xref: /aoo4110/main/sw/source/ui/wrtsh/wrtsh1.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_sw.hxx"

#include <com/sun/star/container/XChild.hpp>
#include <com/sun/star/embed/XVisualObject.hpp>
#include <com/sun/star/embed/EmbedMisc.hpp>
#include <com/sun/star/embed/EmbedStates.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/embed/NoVisualAreaSizeException.hpp>
#include <com/sun/star/chart2/XChartDocument.hpp>
#include <com/sun/star/util/XModifiable.hpp>

#include <math.h>	// prevent conflict between exception and std::exception
#include <hintids.hxx>
#include <svx/svdview.hxx>
#include <sot/factory.hxx>
#include <svl/itemiter.hxx>
#include <vcl/sound.hxx>
#include <tools/bigint.hxx>
#include <sot/storage.hxx>
#include <svtools/insdlg.hxx>
#include <sfx2/frmdescr.hxx>
#include <sfx2/ipclient.hxx>
#include <svtools/ehdl.hxx>
#include <svtools/soerr.hxx>
#include <tools/cachestr.hxx>
#include <unotools/moduleoptions.hxx>
#include <editeng/sizeitem.hxx>
#include <editeng/brkitem.hxx>
#include <editeng/svxacorr.hxx>
#include <vcl/graph.hxx>
#include <sfx2/printer.hxx>
#include <unotools/charclass.hxx>
#include <comphelper/storagehelper.hxx>
#include <svx/svxdlg.hxx>
#include <svx/extrusionbar.hxx>
#include <svx/fontworkbar.hxx>
#include <frmfmt.hxx>
#include <fmtftn.hxx>
#include <fmtpdsc.hxx>
#include <wdocsh.hxx>
#include <basesh.hxx>
#include <swmodule.hxx>
#include <wrtsh.hxx>
#include <view.hxx>
#include <uitool.hxx>
#include <cmdid.h>
#include <cfgitems.hxx>
#include <pagedesc.hxx>
#include <frmmgr.hxx>
#include <shellio.hxx>
#include <uinums.hxx>  // fuer Anwenden einer
#include <swundo.hxx>  // fuer Undo-Ids
#include <swcli.hxx>
#include <poolfmt.hxx>
#include <wview.hxx>
#include <edtwin.hxx>
#include <fmtcol.hxx>
#include <swtable.hxx>
#include <caption.hxx>
#include <viscrs.hxx>
#include <swdtflvr.hxx>
#include <crsskip.hxx>
#include <doc.hxx>
#include <wrtsh.hrc>
#include <SwStyleNameMapper.hxx>
#include <sfx2/request.hxx>
#include <paratr.hxx>
#include <ndtxt.hxx>
#include <editeng/acorrcfg.hxx>
#include <IMark.hxx>
#include <sfx2/bindings.hxx>

// -> #111827#
#include <SwRewriter.hxx>
#include <comcore.hrc>
// <- #111827#

#include <toolkit/helper/vclunohelper.hxx>
#include <sfx2/viewfrm.hxx>

#include <editeng/acorrcfg.hxx>

#include "PostItMgr.hxx"
#include <sfx2/msgpool.hxx>

using namespace sw::mark;
using namespace com::sun::star;

#define COMMON_INI_LIST \
		fnDrag(&SwWrtShell::BeginDrag),\
        fnSetCrsr(&SwWrtShell::SetCrsr),\
		fnEndDrag(&SwWrtShell::EndDrag),\
		fnKillSel(&SwWrtShell::Ignore),\
        pModeStack(0), \
        ePageMove(MV_NO),\
        pCrsrStack(0),  \
        rView(rShell),\
        bDestOnStack(sal_False), \
        fnLeaveSelect(&SwWrtShell::SttLeaveSelect)

#define BITFLD_INI_LIST \
		bClearMark = \
		bIns = sal_True;\
		bAddMode = \
		bBlockMode = \
		bExtMode = \
		bInSelect = \
		bCopy = \
		bLayoutMode = \
		bNoEdit = \
		bSelWrd = \
		bSelLn = \
		bIsInClickToEdit = \
		mbRetainSelection = sal_False;


SvxAutoCorrect* lcl_IsAutoCorr()
{
   	SvxAutoCorrect* pACorr = SvxAutoCorrCfg::Get()->GetAutoCorrect();
    if( pACorr && !pACorr->IsAutoCorrFlag( CptlSttSntnc | CptlSttWrd |
							AddNonBrkSpace | ChgOrdinalNumber |
                            ChgToEnEmDash | SetINetAttr | Autocorrect ))
		pACorr = 0;
	return pACorr;
}

void SwWrtShell::NoEdit(sal_Bool bHideCrsr)
{
	if(bHideCrsr)
		HideCrsr();
	bNoEdit = sal_True;
}



void SwWrtShell::Edit()
{
	if (CanInsert())
	{
		ShowCrsr();
		bNoEdit = sal_False;
	}
}



sal_Bool SwWrtShell::IsEndWrd()
{
	MV_KONTEXT(this);
	if(IsEndPara() && !IsSttPara())
		return sal_True;

	return IsEndWord();
}


/*------------------------------------------------------------------------
 Beschreibung:	Abfrage, ob Einfuegen moeglich ist; gfs. Beep
------------------------------------------------------------------------*/

bool SwWrtShell::_CanInsert()
{
    if(!CanInsert())
    {
        Sound::Beep();
        return false;
    }

    return true;
}

/*------------------------------------------------------------------------
 Beschreibung:	String einfuegen
------------------------------------------------------------------------*/

void SwWrtShell::InsertByWord( const String & rStr)
{
	if( rStr.Len() )
	{
		sal_Bool bDelim = GetAppCharClass().isLetterNumeric( rStr, 0 );
		xub_StrLen nPos = 0, nStt = 0;
		for( ; nPos < rStr.Len(); nPos++ )
   		{
			sal_Bool bTmpDelim = GetAppCharClass().isLetterNumeric( rStr, nPos );
			if( bTmpDelim != bDelim )
			{
				Insert( rStr.Copy( nStt, nPos - nStt ));
				nStt = nPos;
			}
		}
		if( nStt != nPos )
			Insert( rStr.Copy( nStt, nPos - nStt ));
	}
}


void SwWrtShell::Insert( const String &rStr )
{
	ResetCursorStack();
	if( !_CanInsert() )
		return;

	sal_Bool bStarted = sal_False, bHasSel = HasSelection(),
		bCallIns = bIns /*|| bHasSel*/;
    bool bDeleted = false;

    if( bHasSel || ( !bIns && SelectHiddenRange() ) )
	{
			// nur hier klammern, da das normale Insert schon an der
			// Editshell geklammert ist
		StartAllAction();

        // #111827#
        SwRewriter aRewriter;

        aRewriter.AddRule(UNDO_ARG1, GetCrsrDescr());
        aRewriter.AddRule(UNDO_ARG2, String(SW_RES(STR_YIELDS)));
        {
            String aTmpStr;
            aTmpStr += String(SW_RES(STR_START_QUOTE));
            aTmpStr += rStr;
            aTmpStr += String(SW_RES(STR_END_QUOTE));

            aRewriter.AddRule(UNDO_ARG3, rStr);
        }

		StartUndo(UNDO_REPLACE, &aRewriter);
		bStarted = sal_True;
        bDeleted = DelRight() != 0;
	}

    /*
JP 21.01.98: Ueberschreiben ueberschreibt nur die Selektion, nicht das
			naechste Zeichen.
	if( bHasSel && !bIns && 1 < rStr.Len() )
	{
		// falls mehrere Zeichen anstehen, nur das erste einfuegen,
		// der Rest muss dann aber Ueberschrieben werden.
		SwEditShell::Insert( rStr.GetChar( 0 ) );
		SwEditShell::Overwrite( rStr.Copy( 1 ) );
	}
	else
*/
    bCallIns ?
        SwEditShell::Insert2( rStr, bDeleted ) : SwEditShell::Overwrite( rStr );


	if( bStarted )
	{
		EndAllAction();
        EndUndo();
	}
//    delete pChgFlg;
}

/* Begrenzung auf maximale Hoehe geht nicht, da die maximale Hoehe
 * des aktuellen Frames nicht erfragt werden kann. */



void SwWrtShell::Insert( const String &rPath, const String &rFilter,
						 const Graphic &rGrf, SwFlyFrmAttrMgr *pFrmMgr,
						 sal_Bool bRule )
{
	ResetCursorStack();
	if ( !_CanInsert() )
		return;

	StartAllAction();

    SwRewriter aRewriter;
    aRewriter.AddRule(UNDO_ARG1, SW_RES(STR_GRAPHIC));

	StartUndo(UNDO_INSERT, &aRewriter);

	if ( HasSelection() )
		DelRight();
		// eingefuegte Grafik in eigenen Absatz, falls am Ende
		// eines nichtleeren Absatzes
	//For i120928,avoid to split node
	//if ( IsEndPara() && !IsSttPara() )
	//	SwFEShell::SplitNode();

	EnterSelFrmMode();

	sal_Bool bSetGrfSize = sal_True;
	sal_Bool bOwnMgr	 = sal_False;

	if ( !pFrmMgr )
	{
		bOwnMgr = sal_True;
		pFrmMgr = new SwFlyFrmAttrMgr( sal_True, this, FRMMGR_TYPE_GRF );

		// VORSICHT
		// GetAttrSet nimmt einen Abgleich vor
		// Beim Einfuegen ist eine SwFrmSize vorhanden wegen der
		// DEF-Rahmengroesse
		// Diese muss fuer die optimale Groesse explizit entfernt werden
		pFrmMgr->DelAttr(RES_FRM_SIZE);
	}
	else
	{
		Size aSz( pFrmMgr->GetSize() );
		if ( !aSz.Width() || !aSz.Height() )
		{
			aSz.Width() = aSz.Height() = 567;
			pFrmMgr->SetSize( aSz );
		}
		else if ( aSz.Width() != DFLT_WIDTH && aSz.Height() != DFLT_HEIGHT )
			bSetGrfSize = sal_False;

        pFrmMgr->SetHeightSizeType(ATT_FIX_SIZE);

	}

	// Einfuegen der Grafik
	SwFEShell::Insert(rPath, rFilter, &rGrf, &pFrmMgr->GetAttrSet());
	if ( bOwnMgr )
		pFrmMgr->UpdateAttrMgr();

	if( bSetGrfSize && !bRule )
	{
		Size aGrfSize, aBound = GetGraphicDefaultSize();
		GetGrfSize( aGrfSize );

		//Die GrafikSize noch um die Randattribute vergroessern, denn die
		//Zaehlen beim Rahmen mit.
		aGrfSize.Width() += pFrmMgr->CalcWidthBorder();
		aGrfSize.Height()+= pFrmMgr->CalcHeightBorder();

		const BigInt aTempWidth( aGrfSize.Width() );
		const BigInt aTempHeight( aGrfSize.Height());

		// ggf. Breite anpassen, Hoehe dann proportional verkleinern
		if( aGrfSize.Width() > aBound.Width() )
		{
			aGrfSize.Width()  = aBound.Width();
			aGrfSize.Height() = ((BigInt)aBound.Width()) * aTempHeight / aTempWidth;
		}
		// ggf. Hoehe anpassen, Breite dann proportional verkleinern
		if( aGrfSize.Height() > aBound.Height() )
		{
			aGrfSize.Height() = aBound.Height();
			aGrfSize.Width() =  ((BigInt)aBound.Height()) * aTempWidth / aTempHeight;
		}
		pFrmMgr->SetSize( aGrfSize );
		pFrmMgr->UpdateFlyFrm();
	}
	if ( bOwnMgr )
		delete pFrmMgr;

    EndUndo();
	EndAllAction();
}


/*------------------------------------------------------------------------
   Beschreibung: Fuegt ein OLE-Objekt in die CORE ein.
				 Wenn kein Object uebergeben wird, so wird eins erzeugt.
------------------------------------------------------------------------*/


void SwWrtShell::InsertObject( const svt::EmbeddedObjectRef& xRef, SvGlobalName *pName,
                            sal_Bool bActivate, sal_uInt16 nSlotId )
{
	ResetCursorStack();
	if( !_CanInsert() )
		return;

    if( !xRef.is() )
	{
        // temporary storage
        svt::EmbeddedObjectRef xObj;
        uno::Reference < embed::XStorage > xStor = comphelper::OStorageHelper::GetTemporaryStorage();
		sal_Bool bDoVerb = sal_True;
		if ( pName )
		{
            comphelper::EmbeddedObjectContainer aCnt( xStor );
            ::rtl::OUString aName;
            // TODO/LATER: get aspect?
            xObj.Assign( aCnt.CreateEmbeddedObject( pName->GetByteSequence(), aName ), embed::Aspects::MSOLE_CONTENT );
		}
		else
		{
            SvObjectServerList aServerList;
			switch (nSlotId)
			{
				case SID_INSERT_OBJECT:
				{
                    aServerList.FillInsertObjects();
                    aServerList.Remove( SwDocShell::Factory().GetClassId() );
                    // Intentionally no break!
				}

                // TODO/LATER: recording! Convert properties to items
                case SID_INSERT_PLUGIN:
                case SID_INSERT_FLOATINGFRAME:
                {
                    SfxSlotPool* pSlotPool = SW_MOD()->GetSlotPool();
                    const SfxSlot* pSlot = pSlotPool->GetSlot(nSlotId);
                    rtl::OString aCmd(".uno:");
                    aCmd += pSlot->GetUnoName();
                    SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
                    SfxAbstractInsertObjectDialog* pDlg =
                            pFact->CreateInsertObjectDialog( GetWin(), rtl::OStringToOUString( aCmd, RTL_TEXTENCODING_UTF8 ), xStor, &aServerList );
                    if ( pDlg )
                    {
                        pDlg->Execute();
                        bDoVerb = pDlg->IsCreateNew();
						::rtl::OUString aIconMediaType;
						uno::Reference< io::XInputStream > xIconMetaFile = pDlg->GetIconIfIconified( &aIconMediaType );
                        xObj.Assign( pDlg->GetObject(),
									 xIconMetaFile.is() ? embed::Aspects::MSOLE_ICON : embed::Aspects::MSOLE_CONTENT );
						if ( xIconMetaFile.is() )
							xObj.SetGraphicStream( xIconMetaFile, aIconMediaType );

                        DELETEZ( pDlg );
                    }

                    break;
                }

				default:
					break;
			}
		}

        if ( xObj.is() )
		{
            if( InsertOleObject( xObj ) && bActivate && bDoVerb )
			{
                SfxInPlaceClient* pClient = GetView().FindIPClient( xObj.GetObject(), &GetView().GetEditWin() );
                if ( !pClient )
				{
                    pClient = new SwOleClient( &GetView(), &GetView().GetEditWin(), xObj );
					SetCheckForOLEInCaption( sal_True );
				}

				if ( xObj.GetViewAspect() == embed::Aspects::MSOLE_ICON )
				{
					SwRect aArea = GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, 0, xObj.GetObject() );
					aArea.Pos() += GetAnyCurRect( RECT_FLY_EMBEDDED, 0, xObj.GetObject() ).Pos();
					MapMode aMapMode( MAP_TWIP );
					Size aSize = xObj.GetSize( &aMapMode );
					aArea.Width( aSize.Width() );
					aArea.Height( aSize.Height() );
					RequestObjectResize( aArea, xObj.GetObject() );
				}
				else
                	CalcAndSetScale( xObj );

                //#50270# Error brauchen wir nicht handeln, das erledigt das
                //DoVerb in der SfxViewShell
                pClient->DoVerb( SVVERB_SHOW );

                // TODO/LATER: set document name - should be done in Client
                //if ( !ERRCODE_TOERROR( nErr ) )
                //    xIPObj->SetDocumentName( GetView().GetDocShell()->GetTitle() );
			}
		}
	}
	else
	{
		if( HasSelection() )
			DelRight();
        InsertOleObject( xRef );
	}
}

/*------------------------------------------------------------------------
 Beschreibung:	 Object in die Core einfuegen.
				 Vom ClipBoard oder Insert
------------------------------------------------------------------------*/

sal_Bool SwWrtShell::InsertOleObject( const svt::EmbeddedObjectRef& xRef, SwFlyFrmFmt **pFlyFrmFmt )
{
    ResetCursorStack();
	StartAllAction();

	StartUndo(UNDO_INSERT);

	//Some differences between StarMath and any other objects:
	//1. Selections should be deleted. For StarMath the Text should be
	//   passed to the Object
	//2. If the cursor is at the end of an non empty paragraph a paragraph
	//   break should be insertet. StarMath objects are character bound and
	//   no break should be inserted.
	//3. If an selektion is passed to a StarMath object, this object should
	//   not be activated. sal_False should be returned then.
    sal_Bool bStarMath = sal_True;
    sal_Bool bActivate = sal_True;

	// set parent to get correct VisArea(in case of object needing parent printer)
	uno::Reference < container::XChild > xChild( xRef.GetObject(), uno::UNO_QUERY );
	if ( xChild.is() )
		xChild->setParent( pDoc->GetDocShell()->GetModel() );

	SvGlobalName aCLSID( xRef->getClassID() );
	bStarMath = ( SotExchange::IsMath( aCLSID ) != 0 );
	if( IsSelection() )
	{
		if( bStarMath )
		{
			String aMathData;
			GetSelectedText( aMathData, GETSELTXT_PARABRK_TO_ONLYCR );

			if( aMathData.Len() && svt::EmbeddedObjectRef::TryRunningState( xRef.GetObject() ) )
			{
				uno::Reference < beans::XPropertySet > xSet( xRef->getComponent(), uno::UNO_QUERY );
				if ( xSet.is() )
				{
					try
					{
						xSet->setPropertyValue( ::rtl::OUString::createFromAscii("Formula"), uno::makeAny( ::rtl::OUString( aMathData ) ) );
                        bActivate = sal_False;
					}
					catch ( uno::Exception& )
					{
					}
				}
			}
		}
		DelRight();
	}

	if ( !bStarMath )
		SwFEShell::SplitNode( sal_False, sal_False );

	EnterSelFrmMode();

	SwFlyFrmAttrMgr aFrmMgr( sal_True, this, FRMMGR_TYPE_OLE );
	aFrmMgr.SetHeightSizeType(ATT_FIX_SIZE);

	SwRect aBound;
	CalcBoundRect( aBound, aFrmMgr.GetAnchor() );

	//The Size should be suggested by the OLE server
	MapMode aMapMode( MAP_TWIP );
	Size aSz = xRef.GetSize( &aMapMode );

	//Object size can be limited
	if ( aSz.Width() > aBound.Width() )
	{
		//Immer proportional begrenzen.
		aSz.Height() = aSz.Height() * aBound.Width() / aSz.Width();
		aSz.Width() = aBound.Width();
	}
	aFrmMgr.SetSize( aSz );
    SwFlyFrmFmt *pFmt = SwFEShell::InsertObject( xRef, &aFrmMgr.GetAttrSet() );

    // --> #i972#
    if ( bStarMath && pDoc->get( IDocumentSettingAccess::MATH_BASELINE_ALIGNMENT ) )
        AlignFormulaToBaseline( xRef.GetObject() );
    // <--

    if (pFlyFrmFmt)
        *pFlyFrmFmt = pFmt;

    if ( SotExchange::IsChart( aCLSID ) )
    {
        uno::Reference< embed::XEmbeddedObject > xEmbeddedObj( xRef.GetObject(), uno::UNO_QUERY );
        if ( xEmbeddedObj.is() )
        {
            bool bDisableDataTableDialog = false;
            svt::EmbeddedObjectRef::TryRunningState( xEmbeddedObj );
            uno::Reference< beans::XPropertySet > xProps( xEmbeddedObj->getComponent(), uno::UNO_QUERY );
            if ( xProps.is() &&
                 ( xProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DisableDataTableDialog" ) ) ) >>= bDisableDataTableDialog ) &&
                 bDisableDataTableDialog )
            {
                xProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DisableDataTableDialog" ) ),
                    uno::makeAny( sal_False ) );
                xProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "DisableComplexChartTypes" ) ),
                    uno::makeAny( sal_False ) );
                uno::Reference< util::XModifiable > xModifiable( xProps, uno::UNO_QUERY );
                if ( xModifiable.is() )
                {
                    xModifiable->setModified( sal_True );
                }
            }
        }
    }

	EndAllAction();
	GetView().AutoCaption(OLE_CAP, &aCLSID);

    SwRewriter aRewriter;

	if ( bStarMath )
		aRewriter.AddRule(UNDO_ARG1, SW_RES(STR_MATH_FORMULA));
	else if ( SotExchange::IsChart( aCLSID ) )
		aRewriter.AddRule(UNDO_ARG1, SW_RES(STR_CHART));
	else
		aRewriter.AddRule(UNDO_ARG1, SW_RES(STR_OLE));

    EndUndo(UNDO_INSERT, &aRewriter);

    return bActivate;
}

/*------------------------------------------------------------------------
	Beschreibung: Das aktuelle selektierte OLE-Objekt wird mit dem
				  Verb in den Server geladen.
------------------------------------------------------------------------*/



void SwWrtShell::LaunchOLEObj( long nVerb )
{
	if ( GetCntType() == CNT_OLE &&
         !GetView().GetViewFrame()->GetFrame().IsInPlace() )
	{
        svt::EmbeddedObjectRef& xRef = GetOLEObject();
        ASSERT( xRef.is(), "OLE not found" );
        SfxInPlaceClient* pCli=0;

        pCli = GetView().FindIPClient( xRef.GetObject(), &GetView().GetEditWin() );
        if ( !pCli )
            pCli = new SwOleClient( &GetView(), &GetView().GetEditWin(), xRef );

        ((SwOleClient*)pCli)->SetInDoVerb( sal_True );

        CalcAndSetScale( xRef );
        pCli->DoVerb( nVerb );

        ((SwOleClient*)pCli)->SetInDoVerb( sal_False );
        CalcAndSetScale( xRef );
	}
}

void SwWrtShell::MoveObjectIfActive( svt::EmbeddedObjectRef& xObj, const Point& rOffset )
{
    try
    {
        sal_Int32 nState = xObj->getCurrentState();
        if ( nState == ::com::sun::star::embed::EmbedStates::INPLACE_ACTIVE
          || nState == ::com::sun::star::embed::EmbedStates::UI_ACTIVE )
        {
            SfxInPlaceClient* pCli =
				GetView().FindIPClient( xObj.GetObject(), &(GetView().GetEditWin()) );
            if ( pCli )
            {
                Rectangle aArea = pCli->GetObjArea();
                aArea += rOffset;
                pCli->SetObjArea( aArea );
            }
        }
    }
    catch( uno::Exception& )
    {}
}


void SwWrtShell::CalcAndSetScale( svt::EmbeddedObjectRef& xObj,
                                  const SwRect *pFlyPrtRect,
                                  const SwRect *pFlyFrmRect,
                                  const bool bNoTxtFrmPrtAreaChanged )
{
	//Einstellen der Skalierung am Client. Diese ergibt sich aus der Differenz
	//zwischen der VisArea des Objektes und der ObjArea.
    ASSERT( xObj.is(), "ObjectRef not  valid" );

    sal_Int64 nAspect = xObj.GetViewAspect();
    if ( nAspect == embed::Aspects::MSOLE_ICON )
        return; // the replacement image is completely controlled by container in this case

    sal_Int64 nMisc = 0;
    sal_Bool bLinkingChart = sal_False;

    try
    {
        nMisc = xObj->getStatus( nAspect );

        //Das kann ja wohl nur ein nicht aktives Objekt sein. Diese bekommen
        //auf Wunsch die neue Groesse als VisArea gesetzt (StarChart)
        if( embed::EmbedMisc::MS_EMBED_RECOMPOSEONRESIZE & nMisc )
        {
            // TODO/MBA: testing
            SwRect aRect( pFlyPrtRect ? *pFlyPrtRect
                        : GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, 0, xObj.GetObject() ));
            if( !aRect.IsEmpty() )
            {
                // TODO/LEAN: getMapUnit can switch object to running state
                // xObj.TryRunningState();

                MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) );

                // TODO/LATER: needs complete VisArea?!
                Size aSize( OutputDevice::LogicToLogic( aRect.SVRect(), MAP_TWIP, aUnit ).GetSize() );
                awt::Size aSz;
                aSz.Width = aSize.Width();
                aSz.Height = aSize.Height();
                xObj->setVisualAreaSize( nAspect, aSz );
                // --> OD 2005-05-02 #i48419# - action 'UpdateReplacement' doesn't
                // have to change the modified state of the document.
                // This is only a workaround for the defect, that this action
                // modifies a document after load, because unnecessarily the
                // replacement graphic is updated, in spite of the fact that
                // nothing has been changed.
                // If the replacement graphic changes by this action, the document
                // will be already modified via other mechanisms.
                {
                    bool bResetEnableSetModified(false);
                    if ( GetDoc()->GetDocShell()->IsEnableSetModified() )
                    {
                        GetDoc()->GetDocShell()->EnableSetModified( sal_False );
                        bResetEnableSetModified = true;
                    }

                    //#i79576# don't destroy chart replacement images on load
                    //#i79578# don't request a new replacement image for charts to often
                    //a chart sends a modified call to the framework if it was changed
                    //thus the replacement update is already handled elsewhere
                    if ( !SotExchange::IsChart( xObj->getClassID() ) )
                        xObj.UpdateReplacement();

                    if ( bResetEnableSetModified )
                    {
                        GetDoc()->GetDocShell()->EnableSetModified( sal_True );
                    }
                }
                // <--
            }

            // TODO/LATER: this is only a workaround,
            uno::Reference< chart2::XChartDocument > xChartDocument( xObj->getComponent(), uno::UNO_QUERY );
            bLinkingChart = ( xChartDocument.is() && !xChartDocument->hasInternalDataProvider() );
        }
    }
    catch ( uno::Exception& )
    {
        // TODO/LATER: handle the error
        return;
    }

    SfxInPlaceClient* pCli = GetView().FindIPClient( xObj.GetObject(), &GetView().GetEditWin() );
    if ( !pCli )
    {
        if ( (embed::EmbedMisc::EMBED_ACTIVATEIMMEDIATELY & nMisc)
             || bLinkingChart
            // TODO/LATER: ResizeOnPrinterChange
             //|| SVOBJ_MISCSTATUS_RESIZEONPRINTERCHANGE & xObj->GetMiscStatus()
             // --> OD #i117189# - refine condition for non-resizable objects
             // non-resizable objects need to be set the size back by this method
             || ( bNoTxtFrmPrtAreaChanged && nMisc & embed::EmbedMisc::EMBED_NEVERRESIZE ) )
        {
            pCli = new SwOleClient( &GetView(), &GetView().GetEditWin(), xObj );
        }
        else
            return;
    }

    // TODO/LEAN: getMapUnit can switch object to running state
    // xObj.TryRunningState();

    awt::Size aSize;
    try
    {
        aSize = xObj->getVisualAreaSize( nAspect );
    }
    catch( embed::NoVisualAreaSizeException& )
    {
        DBG_ERROR( "Can't get visual area size!\n" );
        // the scaling will not be done
    }
    catch( uno::Exception& )
    {
        // TODO/LATER: handle the error
        DBG_ERROR( "Can't get visual area size!\n" );
        return;
    }

    Size _aVisArea( aSize.Width, aSize.Height );

	Fraction aScaleWidth( 1, 1 );
	Fraction aScaleHeight( 1, 1 );

	sal_Bool bUseObjectSize = sal_False;

	// solange keine vernuenftige Size vom Object kommt, kann nichts
	// skaliert werden
    if( _aVisArea.Width() && _aVisArea.Height() )
	{
		const MapMode aTmp( MAP_TWIP );
        MapUnit aUnit = VCLUnoHelper::UnoEmbed2VCLMapUnit( xObj->getMapUnit( nAspect ) );
        _aVisArea = OutputDevice::LogicToLogic( _aVisArea, aUnit, aTmp);
		Size aObjArea;
		if ( pFlyPrtRect )
			aObjArea = pFlyPrtRect->SSize();
		else
            aObjArea = GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, 0, xObj.GetObject() ).SSize();

        // differ the aObjArea and _aVisArea by 1 Pixel then set new VisArea
		long nX, nY;
		SwSelPaintRects::Get1PixelInLogic( *this, &nX, &nY );
        if( !( _aVisArea.Width() - nX <= aObjArea.Width() &&
               _aVisArea.Width() + nX >= aObjArea.Width() &&
               _aVisArea.Height()- nY <= aObjArea.Height()&&
               _aVisArea.Height()+ nY >= aObjArea.Height() ))
		{
            // TODO/LATER: MISCSTATUS_RESIZEONPRINTERCHANGE
            /*
            if( SVOBJ_MISCSTATUS_RESIZEONPRINTERCHANGE & nMisc )
			{
				//This type of objects should never be resized.
				//If this request comes from the Writer core (inaktive Object
				//ist resized), the Object should be resized too.
				//If this request comes from the Object itself, the Frame
				//in the Writer core should be resized.
				if ( pFlyPrtRect )		//Request from core?
				{
					xObj->SetVisArea( OutputDevice::LogicToLogic(
						pFlyPrtRect->SVRect(), MAP_TWIP, xObj->GetMapUnit() ));
				}
				else
				{
                    SwRect aTmp( Point( LONG_MIN, LONG_MIN ), _aVisArea );
					RequestObjectResize( aTmp, xObj );
				}
				//Der Rest erledigt sich, weil wir eh wiederkommen sollten, evtl.
				//sogar rekursiv.
				return;
			}
            else*/

			if ( nMisc & embed::EmbedMisc::EMBED_NEVERRESIZE )
			{
				// the object must not be scaled, the size stored in object must be used for restoring
				bUseObjectSize = sal_True;
			}
			else
			{
                aScaleWidth = Fraction( aObjArea.Width(),   _aVisArea.Width() );
                aScaleHeight = Fraction( aObjArea.Height(), _aVisArea.Height());
			}
		}
	}

	//Jetzt ist auch der guenstige Zeitpunkt die ObjArea einzustellen.
	//Die Scalierung muss beruecksichtigt werden.
	SwRect aArea;
	if ( pFlyPrtRect )
	{
		aArea = *pFlyPrtRect;
		aArea += pFlyFrmRect->Pos();
	}
	else
	{
        aArea = GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, 0, xObj.GetObject() );
        aArea.Pos() += GetAnyCurRect( RECT_FLY_EMBEDDED, 0, xObj.GetObject() ).Pos();
	}

	if ( bUseObjectSize )
	{
        // --> this moves non-resizable object so that when adding borders the baseline remains the same
        const SwFlyFrmFmt *pFlyFrmFmt = dynamic_cast< const SwFlyFrmFmt * >( GetFlyFrmFmt() );
        ASSERT( pFlyFrmFmt, "Could not find fly frame." );
        if ( pFlyFrmFmt )
        {
            const Point &rPoint = pFlyFrmFmt->GetLastFlyFrmPrtRectPos();
            SwRect aRect( pFlyPrtRect ? *pFlyPrtRect
                        : GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, 0, xObj.GetObject() ));
            aArea += rPoint - aRect.Pos(); // adjust area by diff of printing area position in order to keep baseline alignment correct.
        }
        // <--
        aArea.Width ( _aVisArea.Width() );
        aArea.Height( _aVisArea.Height() );
		RequestObjectResize( aArea, xObj.GetObject() );
	}
	else
	{
		aArea.Width ( Fraction( aArea.Width()  ) / pCli->GetScaleWidth() );
		aArea.Height( Fraction( aArea.Height() ) / pCli->GetScaleHeight());
	}

    pCli->SetObjAreaAndScale( aArea.SVRect(), aScaleWidth, aScaleHeight );
}



void SwWrtShell::ConnectObj( svt::EmbeddedObjectRef& xObj, const SwRect &rPrt,
							const SwRect &rFrm )
{
    SfxInPlaceClient* pCli = GetView().FindIPClient( xObj.GetObject(), &GetView().GetEditWin());
    if ( !pCli )
        pCli = new SwOleClient( &GetView(), &GetView().GetEditWin(), xObj );
    CalcAndSetScale( xObj, &rPrt, &rFrm );
}

/*------------------------------------------------------------------------
 Beschreibung:	Einfuegen harter Seitenumbruch;
				Selektionen werden ueberschrieben
------------------------------------------------------------------------*/



void SwWrtShell::InsertPageBreak(const String *pPageDesc, sal_uInt16 nPgNum )
{
	ResetCursorStack();
	if( _CanInsert() )
	{
		ACT_KONTEXT(this);
        StartUndo(UNDO_UI_INSERT_PAGE_BREAK);

		if ( !IsCrsrInTbl() )
		{
			if(HasSelection())
				DelRight();
			SwFEShell::SplitNode();
		}

		const SwPageDesc *pDesc = pPageDesc
								? FindPageDescByName( *pPageDesc, sal_True ) : 0;
		if( pDesc )
		{
			SwFmtPageDesc aDesc( pDesc );
			aDesc.SetNumOffset( nPgNum );
			SetAttrItem( aDesc );
		}
		else
            SetAttrItem( SvxFmtBreakItem(SVX_BREAK_PAGE_BEFORE, RES_BREAK) );
        EndUndo(UNDO_UI_INSERT_PAGE_BREAK);
	}
}
/*------------------------------------------------------------------------
 Beschreibung:	Einfuegen harter Zeilenumbruch;
				Selektionen werden ueberschrieben
------------------------------------------------------------------------*/


void SwWrtShell::InsertLineBreak()
{
	ResetCursorStack();
	if( _CanInsert() )
	{
		if(HasSelection())
			DelRight();

		const sal_Unicode cIns = 0x0A;
		SvxAutoCorrect* pACorr = lcl_IsAutoCorr();
	    if( pACorr )
			AutoCorrect( *pACorr, cIns );
		else
			SwWrtShell::Insert( String( cIns ) );
	}
}
/*------------------------------------------------------------------------
 Beschreibung:	Einfuegen harter Spaltenumbruch;
				Selektionen werden ueberschrieben
------------------------------------------------------------------------*/


void SwWrtShell::InsertColumnBreak()
{
	ACT_KONTEXT(this);
	ResetCursorStack();
	if( _CanInsert() )
	{
        StartUndo(UNDO_UI_INSERT_COLUMN_BREAK);

		if ( !IsCrsrInTbl() )
		{
			if(HasSelection())
				DelRight();
			SwFEShell::SplitNode( sal_False, sal_False );
		}
        SetAttrItem(SvxFmtBreakItem(SVX_BREAK_COLUMN_BEFORE, RES_BREAK));

        EndUndo(UNDO_UI_INSERT_COLUMN_BREAK);
	}
}

/*------------------------------------------------------------------------
 Beschreibung:	Einfuegen Fussnote
 Parameter: 	rStr -- optionales Fussnotenzeichen
------------------------------------------------------------------------*/


void SwWrtShell::InsertFootnote(const String &rStr, sal_Bool bEndNote, sal_Bool bEdit )
{
	ResetCursorStack();
	if( _CanInsert() )
	{
		if(HasSelection())
        {
            //collapse cursor to the end
            if(!IsCrsrPtAtEnd())
                SwapPam();
            ClearMark();
        }

		SwFmtFtn aFootNote( bEndNote );
		if(rStr.Len())
			aFootNote.SetNumStr( rStr );

		SetAttrItem(aFootNote);

		if( bEdit )
		{
			// zur Bearbeiung des Fussnotentextes
			Left(CRSR_SKIP_CHARS, sal_False, 1, sal_False );
			GotoFtnTxt();
		}
	}
}
/*------------------------------------------------------------------------
 Beschreibung:	SplitNode; hier auch, da
					- selektierter Inhalt geloescht wird;
					- der Cursorstack gfs. zurueckgesetzt wird.
------------------------------------------------------------------------*/


void SwWrtShell::SplitNode( sal_Bool bAutoFmt, sal_Bool bCheckTableStart )
{
	ResetCursorStack();
	if( _CanInsert() )
	{
		ACT_KONTEXT(this);

        rView.GetEditWin().FlushInBuffer();
		sal_Bool bHasSel = HasSelection();
		if( bHasSel )
		{
			StartUndo( UNDO_INSERT );
			DelRight();
		}

		SwFEShell::SplitNode( bAutoFmt, bCheckTableStart );
		if( bHasSel )
			EndUndo( UNDO_INSERT );
	}
}

/*------------------------------------------------------------------------
 Beschreibung:	Numerierung anschalten
 Parameter: 	Optionale Angabe eines Namens fuer die benannte Liste;
				dieser bezeichnet eine Position, wenn er in eine
				Zahl konvertierbar ist und kleiner ist als nMaxRules.
-------------------------------------------------------------------------*/


// zum Testen der CharFormate an der Numerierung
// extern void SetNumChrFmt( SwWrtShell*, SwNumRules& );

// -> #i40041#
// --> OD 2005-10-25 #b6340308#
// Preconditions (as far as OD has figured out):
// - <SwEditShell::HasNumber()> is sal_False, if <bNum> is sal_True
// - <SwEditShell::HasBullet()> is sal_False, if <bNum> is sal_False
// Behavior of method is determined by the current situation at the current
// cursor position in the document.
void SwWrtShell::NumOrBulletOn(sal_Bool bNum)
{
    // determine numbering rule found at current cursor position in the docment.
    const SwNumRule* pCurRule = GetCurNumRule();

    StartUndo(UNDO_NUMORNONUM);

    const SwNumRule * pNumRule = pCurRule;

    // --> OD 2005-10-25 #b6340308#
    // - activate outline rule respectively turning on outline rule for
    //   current text node. But, only for turning on a numbering (<bNum> == sal_True).
    // - overwrite found numbering rule at current cursor position, if
    //   no numbering rule can be retrieved from the paragraph style.
    bool bContinueFoundNumRule( false );
    bool bActivateOutlineRule( false );
    int nActivateOutlineLvl( MAXLEVEL );    // only relevant, if <bActivateOutlineRule> == sal_True
    SwTxtFmtColl * pColl = GetCurTxtFmtColl();
    if ( pColl )
    {
        // --> OD 2005-10-25 #b6340308# - retrieve numbering rule at paragraph
        // style, which is found at current cursor position in the document.
        SwNumRule* pCollRule = pDoc->FindNumRulePtr(pColl->GetNumRule().GetValue());
        // --> OD 2005-10-25 #125993# - The outline numbering rule isn't allowed
        // to be derived from a parent paragraph style to a derived one.
        // Thus check, if the found outline numbering rule is directly
        // set at the paragraph style <pColl>. If not, set <pCollRule> to NULL
        if ( pCollRule && pCollRule == GetDoc()->GetOutlineNumRule() )
        {
            const SwNumRule* pDirectCollRule =
                    pDoc->FindNumRulePtr(pColl->GetNumRule( sal_False ).GetValue());
            if ( !pDirectCollRule )
            {
                pCollRule = 0;
            }
        }
        // --> OD 2006-11-20 #i71764#
        // Document setting OUTLINE_LEVEL_YIELDS_OUTLINE_RULE has no influence
        // any more.
//        if ( pCollRule == NULL &&
//             NO_NUMBERING != pColl->GetOutlineLevel() &&
//             GetDoc()->get(IDocumentSettingAccess::OUTLINE_LEVEL_YIELDS_OUTLINE_RULE) )
//        {
//            pCollRule = GetDoc()->GetOutlineNumRule();
//        }
        // <--

        // <--
        // --> OD 2005-10-25 #b6340308#
        if ( !pCollRule )
        {
            pNumRule = pCollRule;
        }
        // --> OD 2006-06-12 #b6435904#
        // no activation or continuation of outline numbering in Writer/Web document
        else if ( bNum &&
                  !dynamic_cast<SwWebDocShell*>(GetDoc()->GetDocShell()) &&
                  pCollRule == GetDoc()->GetOutlineNumRule() )
        // <--
        {
            if ( pNumRule == pCollRule )
            {
                // check, if text node at current cursor positioned is counted.
                // If not, let it been counted. Then it has to be checked,
                // of the outline numbering has to be activated or continued.
                SwTxtNode* pTxtNode =
                            GetCrsr()->GetPoint()->nNode.GetNode().GetTxtNode();
                if ( pTxtNode && !pTxtNode->IsCountedInList() )
                {
                    // check, if numbering of the outline level of the pararaph
                    // style is active. If not, activate this outline level.
					nActivateOutlineLvl = pColl->GetAssignedOutlineStyleLevel();
                    ASSERT( pColl->IsAssignedToListLevelOfOutlineStyle(),	//<-end,zhaojianwei
                            "<SwWrtShell::NumOrBulletOn(..)> - paragraph style with outline rule, but no outline level" );
                    if ( pColl->IsAssignedToListLevelOfOutlineStyle() &&		//<-end,zhaojianwei
                         pCollRule->Get( static_cast<sal_uInt16>(nActivateOutlineLvl) ).GetNumberingType()
                            == SVX_NUM_NUMBER_NONE )
                    {
                        // activate outline numbering
                        bActivateOutlineRule = true;
                    }
                    else
                    {
                        // turning on outline numbering at current cursor position
                        bContinueFoundNumRule = true;
                    }
                }
                else
                {
                    // --> OD 2009-08-27 #i101234#
                    // activate outline numbering, because from the precondition
                    // it's known, that <SwEdit::HasNumber()> == sal_False
                    bActivateOutlineRule = true;
					nActivateOutlineLvl = pColl->GetAssignedOutlineStyleLevel();//<-end,zhaojianwei
                }
            }
            else if ( !pNumRule )
            {
                // --> OD 2009-08-27 #i101234#
                // Check, if corresponding list level of the outline numbering
                // has already a numbering format set.
                nActivateOutlineLvl = pColl->GetAssignedOutlineStyleLevel();//<-end,zhaojianwei,need further consideration
                if ( pCollRule->Get( static_cast<sal_uInt16>(nActivateOutlineLvl) ).GetNumberingType()
                                == SVX_NUM_NUMBER_NONE )
                {
                    // activate outline numbering, because from the precondition
                    // it's known, that <SwEdit::HasNumber()> == sal_False
                    bActivateOutlineRule = true;
                }
                else
                {
                    // turning on outline numbering at current cursor position
                    bContinueFoundNumRule = true;
                }
                // <--
            }
            else
            {
                // check, if numbering of the outline level of the pararaph
                // style is active. If not, activate this outline level.
				nActivateOutlineLvl = pColl->GetAssignedOutlineStyleLevel();//#outline level,zhaojianwei
                ASSERT( pColl->IsAssignedToListLevelOfOutlineStyle(),//#outline level,zhaojianwei
                        "<SwWrtShell::NumOrBulletOn(..)> - paragraph style with outline rule, but no outline level" );
                if ( pColl->IsAssignedToListLevelOfOutlineStyle() &&//#outline level,zhaojianwei
                     pCollRule->Get( static_cast<sal_uInt16>(nActivateOutlineLvl) ).GetNumberingType()
                        == SVX_NUM_NUMBER_NONE )
                {
                    // activate outline numbering
                    bActivateOutlineRule = true;
                }
                else
                {
                    // turning on outline numbering at current cursor position
                    bContinueFoundNumRule = true;
                }
            }
            pNumRule = pCollRule;
        }
    }

    // --> OD 2005-10-25 #b6340308#
    // Only automatic numbering/bullet rules should be changed.
    // Note: The outline numbering rule is also an automatic one. It's only
    //       changed, if it has to be activated.
    if ( pNumRule )
    {
        if ( !pNumRule->IsAutoRule() )
        {
            pNumRule = 0;
        }
        else if ( pNumRule == GetDoc()->GetOutlineNumRule() &&
                  !bActivateOutlineRule && !bContinueFoundNumRule )
        {
            pNumRule = 0;
        }
    }
    // <--

    // --> OD 2005-10-25 #b6340308#
    // Search for a previous numbering/bullet rule to continue it.
    // --> OD 2008-03-18 #refactorlists#
    String sContinuedListId;
    if ( !pNumRule )
    {
        pNumRule = GetDoc()->SearchNumRule( *GetCrsr()->GetPoint(),
                                            false, bNum, false, 0,
                                            sContinuedListId );
        bContinueFoundNumRule = pNumRule != 0;
    }
    // <--

    if (pNumRule)
    {
        SwNumRule aNumRule(*pNumRule);

        // --> OD 2005-10-25 #b6340308#
        // do not change found numbering/bullet rule, if it should only be continued.
        if ( !bContinueFoundNumRule )
        {
            SwTxtNode * pTxtNode = GetCrsr()->GetPoint()->nNode.GetNode().GetTxtNode();

            if (pTxtNode)
            {
                // --> OD 2005-10-26 #b6340308# - use above retrieve outline
                // level, if outline numbering has to be activated.
                int nLevel = bActivateOutlineRule  ////#outline level,zhaojianwei,need more consideration
                              ? nActivateOutlineLvl
                              : pTxtNode->GetActualListLevel();
                // <--

                if (nLevel < 0)
                    nLevel = 0;

                if (nLevel >= MAXLEVEL)
                    nLevel = MAXLEVEL - 1;

                SwNumFmt aFmt(aNumRule.Get(static_cast<sal_uInt16>(nLevel)));

                if (bNum)
                    aFmt.SetNumberingType(SVX_NUM_ARABIC);
                else
                {
                    // --> OD 2008-06-03 #i63395#
                    // Only apply user defined default bullet font
                    if ( numfunc::IsDefBulletFontUserDefined() )
                    {
                        const Font* pFnt = &numfunc::GetDefBulletFont();
                        aFmt.SetBulletFont( pFnt );
                    }
                    // <--
                    aFmt.SetBulletChar( numfunc::GetBulletChar(static_cast<sal_uInt8>(nLevel)));
                    aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
                    // #i93908# clear suffix for bullet lists
                    aFmt.SetPrefix(::rtl::OUString());
                    aFmt.SetSuffix(::rtl::OUString());
                }
                aNumRule.Set(static_cast<sal_uInt16>(nLevel), aFmt);
            }
        }
        // <--

        // --> OD 2008-02-08 #newlistlevelattrs#
        // reset indent attribute on applying list style
        // --> OD 2008-03-27 #refactorlists#
        SetCurNumRule( aNumRule, false, sContinuedListId, true );
        // <--
    }
    else
    {
        // --> OD 2009-08-27 #i95907#
        const SvxNumberFormat::SvxNumPositionAndSpaceMode ePosAndSpaceMode(
                                    numfunc::GetDefaultPositionAndSpaceMode() );
        // --> OD 2008-02-11 #newlistlevelattrs#
        SwNumRule aNumRule( GetUniqueNumRuleName(), ePosAndSpaceMode );
        // <--
        // <--
        // Zeichenvorlage an die Numerierung haengen
        SwCharFmt* pChrFmt;
        SwDocShell* pDocSh = GetView().GetDocShell();
        // --> OD 2008-06-03 #i63395#
        // Only apply user defined default bullet font
        const Font* pFnt = numfunc::IsDefBulletFontUserDefined()
                           ? &numfunc::GetDefBulletFont()
                           : 0;
        // <--

        if (bNum)
        {
            pChrFmt = GetCharFmtFromPool( RES_POOLCHR_NUM_LEVEL );
        }
        else
        {
            pChrFmt = GetCharFmtFromPool( RES_POOLCHR_BUL_LEVEL );
        }

        const SwTxtNode* pTxtNode = GetCrsr()->GetPoint()->nNode.GetNode().GetTxtNode();
        const SwTwips nWidthOfTabs = pTxtNode
                                     ? pTxtNode->GetWidthOfLeadingTabs()
                                     : 0;
        GetDoc()->RemoveLeadingWhiteSpace( *GetCrsr()->GetPoint() );

        const bool bHtml = 0 != PTR_CAST(SwWebDocShell, pDocSh);
        const bool bRightToLeft = IsInRightToLeftText();
        for( sal_uInt8 nLvl = 0; nLvl < MAXLEVEL; ++nLvl )
        {
            SwNumFmt aFmt( aNumRule.Get( nLvl ) );
            aFmt.SetCharFmt( pChrFmt );

            if (! bNum)
            {
                // --> OD 2008-06-03 #i63395#
                // Only apply user defined default bullet font
                if ( pFnt )
                {
                    aFmt.SetBulletFont( pFnt );
                }
                aFmt.SetBulletChar( numfunc::GetBulletChar(nLvl) );
                aFmt.SetNumberingType(SVX_NUM_CHAR_SPECIAL);
                // #i93908# clear suffix for bullet lists
                aFmt.SetPrefix(::rtl::OUString());
                aFmt.SetSuffix(::rtl::OUString());
            }

            // --> OD 2009-08-26 #i95907#
            if ( ePosAndSpaceMode == SvxNumberFormat::LABEL_WIDTH_AND_POSITION )
            {
                if(bHtml && nLvl)
                {
                    // 1/2" fuer HTML
                    aFmt.SetLSpace(720);
                    aFmt.SetAbsLSpace(nLvl * 720);
                }
                else if ( nWidthOfTabs > 0 )
                {
                    aFmt.SetAbsLSpace(nWidthOfTabs + nLvl * 720);
                }
            }
            // <--

            // --> FME 2005-01-21 #i38904#  Default alignment for
            // numbering/bullet should be rtl in rtl paragraph:
            if ( bRightToLeft )
            {
                aFmt.SetNumAdjust( SVX_ADJUST_RIGHT );
            }
            // <--

            aNumRule.Set( nLvl, aFmt );
        }

        // --> OD 2009-08-26 #i95907#
        if ( pTxtNode &&
             ePosAndSpaceMode == SvxNumberFormat::LABEL_ALIGNMENT )
        {
            // --> OD 2010-01-05 #b6884103#
//            short nTxtNodeFirstLineOffset( 0 );
//            pTxtNode->GetFirstLineOfsWithNum( nTxtNodeFirstLineOffset );
//            const SwTwips nTxtNodeIndent = pTxtNode->GetLeftMarginForTabCalculation() +
//                                           nTxtNodeFirstLineOffset;
            const SwTwips nTxtNodeIndent = pTxtNode->GetAdditionalIndentForStartingNewList();
            // <--
            if ( ( nTxtNodeIndent + nWidthOfTabs ) != 0 )
            {
                // --> OD 2010-05-05 #i111172#
                // If text node is already inside a list, assure that the indents
                // are the same. Thus, adjust the indent change value by subtracting
                // indents of to be applied list style.
                SwTwips nIndentChange = nTxtNodeIndent + nWidthOfTabs;
                if ( pTxtNode->GetNumRule() )
                {
                    const SwNumFmt aFmt( aNumRule.Get( 0 ) );
                    if ( aFmt.GetPositionAndSpaceMode() == SvxNumberFormat::LABEL_ALIGNMENT )
                    {
                        nIndentChange -= aFmt.GetIndentAt() + aFmt.GetFirstLineIndent();
                    }
                }
                // <--
                aNumRule.ChangeIndent( nIndentChange );
            }
        }
        // <--
        // --> OD 2008-02-08 #newlistlevelattrs#
        // reset indent attribute on applying list style
        // --> OD 2008-03-17 #refactorlists#
        // start new list
        SetCurNumRule( aNumRule, true, String(), true );
        // <--
    }

    EndUndo(UNDO_NUMORNONUM);
}
// <- #i40041#

void SwWrtShell::NumOn()
{
    NumOrBulletOn(sal_True);
}

void SwWrtShell::NumOrBulletOff()
{
    const SwNumRule * pCurNumRule = GetCurNumRule();

    if (pCurNumRule)
    {
        if (pCurNumRule->IsOutlineRule())
        {
            SwNumRule aNumRule(*pCurNumRule);

            SwTxtNode * pTxtNode =
                GetCrsr()->GetPoint()->nNode.GetNode().GetTxtNode();

            if (pTxtNode)
            {
                sal_uInt16 nLevel = sal::static_int_cast<sal_uInt16, sal_Int32>(pTxtNode->GetActualListLevel());
                SwNumFmt aFmt(aNumRule.Get(nLevel));

                aFmt.SetNumberingType(SVX_NUM_NUMBER_NONE);
                aNumRule.Set(nLevel, aFmt);

                // --> OD 2008-03-17 #refactorlists#
                // no start or continuation of a list - the outline style is only changed.
                SetCurNumRule( aNumRule, false );
                // <--
            }
        }
        else
        {
            DelNumRules();
        }

        // --> OD 2005-10-24 #126346# - Cursor can not be anymore in front of
        // a label, because numbering/bullet is switched off.
        SetInFrontOfLabel( sal_False );
        // <--
    }
}
// <- #i29560#

/*------------------------------------------------------------------------
 Beschreibung:	Default-Bulletliste erfragen
------------------------------------------------------------------------*/

void SwWrtShell::BulletOn()
{
    NumOrBulletOn(sal_False);
}


/*--------------------------------------------------

--------------------------------------------------*/
SelectionType SwWrtShell::GetSelectionType() const
{
    // ContentType kann nicht ermittelt werden innerhalb einer
    // Start-/Endactionklammerung.
    // Da es keinen ungueltigen Wert gibt, wird TEXT geliefert.
    // Der Wert ist egal, da in EndAction ohnehin aktualisiert wird.

    if ( BasicActionPend() )
        return IsSelFrmMode() ? nsSelectionType::SEL_FRM : nsSelectionType::SEL_TXT;

    SwView &_rView = ((SwView&)GetView());
    if (_rView.GetPostItMgr() && _rView.GetPostItMgr()->HasActiveSidebarWin() )
        return nsSelectionType::SEL_POSTIT;

    int nCnt;
    // Insertion of a text frame is not a DrawMode
    if ( !_rView.GetEditWin().IsFrmAction() &&
        (IsObjSelected() || (_rView.IsDrawMode() && !IsFrmSelected()) ))
    {
        if (GetDrawView()->IsTextEdit())
            nCnt = nsSelectionType::SEL_DRW_TXT;
        else
        {
            if (GetView().IsFormMode())	// Nur Forms selektiert
                nCnt = nsSelectionType::SEL_DRW_FORM;
            else
                nCnt = nsSelectionType::SEL_DRW;            // Irgendein Draw-Objekt

            if (_rView.IsBezierEditMode())
                nCnt |= nsSelectionType::SEL_BEZ;
            else if( GetDrawView()->GetContext() == SDRCONTEXT_MEDIA )
                nCnt |= nsSelectionType::SEL_MEDIA;

            if (svx::checkForSelectedCustomShapes(
                const_cast<SdrView *>(GetDrawView()),
                true /* bOnlyExtruded */ ))
            {
                nCnt |= nsSelectionType::SEL_EXTRUDED_CUSTOMSHAPE;
            }
            sal_uInt32 nCheckStatus = 0;
            if (svx::checkForSelectedFontWork(
                const_cast<SdrView *>(GetDrawView()), nCheckStatus ))
            {
                nCnt |= nsSelectionType::SEL_FONTWORK;
            }
        }

        return nCnt;
    }

    nCnt = GetCntType();

    if ( IsFrmSelected() )
    {
        if (_rView.IsDrawMode())
            _rView.LeaveDrawCreate();   // Aufraeumen (Bug #45639)
        if ( !(nCnt & (CNT_GRF | CNT_OLE)) )
            return nsSelectionType::SEL_FRM;
    }

    if ( IsCrsrInTbl() )
        nCnt |= nsSelectionType::SEL_TBL;

    if ( IsTableMode() )
        nCnt |= (nsSelectionType::SEL_TBL | nsSelectionType::SEL_TBL_CELLS);

    // Do not pop up numbering toolbar, if the text node has a numbering of type SVX_NUM_NUMBER_NONE.
    const SwNumRule* pNumRule = GetCurNumRule();
    if ( pNumRule )
    {
        const SwTxtNode* pTxtNd =
            GetCrsr()->GetPoint()->nNode.GetNode().GetTxtNode();

        if ( pTxtNd && pTxtNd->IsInList() )
        {
            const SwNumFmt& rFmt = pNumRule->Get(sal::static_int_cast< sal_uInt8, sal_Int32>(pTxtNd->GetActualListLevel()));
            if ( SVX_NUM_NUMBER_NONE != rFmt.GetNumberingType() )
                nCnt |= nsSelectionType::SEL_NUM;
        }
    }

    return nCnt;
}

/*------------------------------------------------------------------------
 Beschreibung:	Finden der TextCollection mit dem Name rCollname
 Return:				Pointer auf die Collection oder 0, wenn keine
								TextCollection mit diesem Namen existiert oder
								diese eine Defaultvorlage ist.
------------------------------------------------------------------------*/


SwTxtFmtColl *SwWrtShell::GetParaStyle(const String &rCollName, GetStyle eCreate )
{
	SwTxtFmtColl* pColl = FindTxtFmtCollByName( rCollName );
	if( !pColl && GETSTYLE_NOCREATE != eCreate )
	{
		sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( rCollName, nsSwGetPoolIdFromName::GET_POOLID_TXTCOLL );
		if( USHRT_MAX != nId || GETSTYLE_CREATEANY == eCreate )
			pColl = GetTxtCollFromPool( nId );
	}
	return pColl;
}
/*------------------------------------------------------------------------
 Beschreibung:	Finden der Zeichenvorlage mit dem Name rCollname
 Return:				Pointer auf die Collection oder 0, wenn keine
								Zeichenvorlage mit diesem Namen existiert oder
								diese eine Defaultvorlage oder automatische Vorlage ist.
------------------------------------------------------------------------*/



SwCharFmt *SwWrtShell::GetCharStyle(const String &rFmtName, GetStyle eCreate )
{
	SwCharFmt* pFmt = FindCharFmtByName( rFmtName );
	if( !pFmt && GETSTYLE_NOCREATE != eCreate )
	{
		sal_uInt16 nId = SwStyleNameMapper::GetPoolIdFromUIName( rFmtName, nsSwGetPoolIdFromName::GET_POOLID_CHRFMT );
		if( USHRT_MAX != nId || GETSTYLE_CREATEANY == eCreate )
			pFmt = (SwCharFmt*)GetFmtFromPool( nId );
	}
	return pFmt;
}

/*------------------------------------------------------------------------
 Beschreibung:	Finden des Tabellenformates mit dem Name rFmtname
 Return:				Pointer auf das Format oder 0, wenn kein
								Rahmenformat mit diesem Namen existiert oder
								dieses eine Defaultformat oder automatisches Format ist.
------------------------------------------------------------------------*/



SwFrmFmt *SwWrtShell::GetTblStyle(const String &rFmtName)
{
	SwFrmFmt *pFmt = 0;
	for( sal_uInt16 i = GetTblFrmFmtCount(); i; )
		if( !( pFmt = &GetTblFrmFmt( --i ) )->IsDefault() &&
			pFmt->GetName() == rFmtName && IsUsed( *pFmt ) )
			return pFmt;
	return 0;
}


/*------------------------------------------------------------------------
 Beschreibung:	Anwenden der Vorlagen
------------------------------------------------------------------------*/



void SwWrtShell::SetPageStyle(const String &rCollName)
{
	if( !SwCrsrShell::HasSelection() && !IsSelFrmMode() && !IsObjSelected() )
	{
		SwPageDesc* pDesc = FindPageDescByName( rCollName, sal_True );
		if( pDesc )
			ChgCurPageDesc( *pDesc );
	}
}

/*------------------------------------------------------------------------
 Beschreibung:	Zugriff Vorlagen
------------------------------------------------------------------------*/



String SwWrtShell::GetCurPageStyle( const sal_Bool bCalcFrm ) const
{
	return GetPageDesc(GetCurPageDesc( bCalcFrm )).GetName();
}

/*------------------------------------------------------------------------
 Beschreibung:	Aktuelle Vorlage anhand der geltenden Attribute aendern
------------------------------------------------------------------------*/


void SwWrtShell::QuickUpdateStyle()
{
	SwTxtFmtColl *pColl = GetCurTxtFmtColl();

	// Standard kann nicht geaendert werden
	if(pColl && !pColl->IsDefault())
	{
		FillByEx(pColl);
			// Vorlage auch anwenden, um harte Attributierung
			// zu entfernen
		SetTxtFmtColl(pColl);
	}
}


void SwWrtShell::AutoUpdatePara(SwTxtFmtColl* pColl, const SfxItemSet& rStyleSet)
{
	SfxItemSet aCoreSet( GetAttrPool(),
			RES_CHRATR_BEGIN, 			RES_CHRATR_END - 1,
			RES_PARATR_BEGIN, 			RES_PARATR_END - 1,
			RES_FRMATR_BEGIN, 			RES_FRMATR_END - 1,
			SID_ATTR_TABSTOP_POS, 		SID_ATTR_TABSTOP_POS,
			SID_ATTR_TABSTOP_DEFAULTS, 	SID_ATTR_TABSTOP_DEFAULTS,
			SID_ATTR_TABSTOP_OFFSET, 	SID_ATTR_TABSTOP_OFFSET,
			SID_ATTR_BORDER_INNER,		SID_ATTR_BORDER_INNER,
			SID_ATTR_PARA_MODEL,		SID_ATTR_PARA_KEEP,
			SID_ATTR_PARA_PAGENUM,		SID_ATTR_PARA_PAGENUM,
			0	);
    GetCurAttr( aCoreSet );
	sal_Bool bReset = sal_False;
	SfxItemIter aParaIter( aCoreSet );
	const SfxPoolItem* pParaItem = aParaIter.FirstItem();
	while( pParaItem )
	{
		if(!IsInvalidItem(pParaItem))
		{
			sal_uInt16 nWhich = pParaItem->Which();
			if(SFX_ITEM_SET == aCoreSet.GetItemState(nWhich) &&
			   SFX_ITEM_SET == rStyleSet.GetItemState(nWhich))
			{
				aCoreSet.ClearItem(nWhich);
				bReset = sal_True;
			}
		}
		pParaItem = aParaIter.NextItem();
	}
	StartAction();
	if(bReset)
	{
		ResetAttr();
		SetAttrSet(aCoreSet);
	}
	pDoc->ChgFmt(*pColl, rStyleSet );
	EndAction();
}

/*-----------------12.03.97 12.24-------------------

--------------------------------------------------*/

void SwWrtShell::AutoUpdateFrame( SwFrmFmt* pFmt, const SfxItemSet& rStyleSet )
{
	StartAction();

	ResetFlyFrmAttr( 0, &rStyleSet );
    pFmt->SetFmtAttr( rStyleSet );

	EndAction();
}


void SwWrtShell::AutoCorrect( SvxAutoCorrect& rACorr, sal_Unicode cChar )
{
	ResetCursorStack();
	if(_CanInsert())
	{
		sal_Bool bStarted = sal_False;
		if(HasSelection())
		{
				// nur hier klammern, da das normale Insert schon an der
				// Editshell geklammert ist
			StartAllAction();
			StartUndo(UNDO_INSERT);
			bStarted = sal_True;
			DelRight();
		}
		SwEditShell::AutoCorrect( rACorr, IsInsMode(), cChar );

		if(bStarted)
		{
			EndAllAction();
			EndUndo(UNDO_INSERT);
		}
	}
}


/*
 * eine Art kontrollierter copy ctor
 */

SwWrtShell::SwWrtShell( SwWrtShell& rSh, Window *_pWin, SwView &rShell )
    : SwFEShell( rSh, _pWin ),
	 COMMON_INI_LIST
{
	BITFLD_INI_LIST
	SET_CURR_SHELL( this );

	SetSfxViewShell( (SfxViewShell *)&rShell );
	SetFlyMacroLnk( LINK(this, SwWrtShell, ExecFlyMac) );

	// place the cursor on the first field...
	IFieldmark *pBM = NULL;
	if ( IsFormProtected() && ( pBM = GetFieldmarkAfter( ) ) !=NULL ) {
	    GotoFieldmark(pBM);
	}
}


SwWrtShell::SwWrtShell( SwDoc& rDoc, Window *_pWin, SwView &rShell,
                        const SwViewOption *pViewOpt )
    : SwFEShell( rDoc, _pWin, pViewOpt),
	  COMMON_INI_LIST
{
	BITFLD_INI_LIST
	SET_CURR_SHELL( this );
	SetSfxViewShell( (SfxViewShell *)&rShell );
	SetFlyMacroLnk( LINK(this, SwWrtShell, ExecFlyMac) );
}

/*
 * ctor
 */



SwWrtShell::~SwWrtShell()
{
	SET_CURR_SHELL( this );
	while(IsModePushed())
		PopMode();
	while(PopCrsr(sal_False))
		;
	SwTransferable::ClearSelection( *this );
}

sal_Bool SwWrtShell::Pop( sal_Bool bOldCrsr )
{
	sal_Bool bRet = SwCrsrShell::Pop( bOldCrsr );
	if( bRet && IsSelection() )
	{
		fnSetCrsr = &SwWrtShell::SetCrsrKillSel;
		fnKillSel = &SwWrtShell::ResetSelect;
	}
	return bRet;
}

/*--------------------------------------------------------------------
	Beschreibung:
 --------------------------------------------------------------------*/
bool SwWrtShell::CanInsert()
{
    // #123922# The original expression looks sleek, but it is not. Using the mathematical or ('|')
    // instead of the logical one ('||') forces the compiler to evaluate all conditions to allow or-ing
    // them together (yes, he could do better). Using the logical or allows to return on the first
    // failing statement instead.
    //
    // return (!(IsSelFrmMode() | IsObjSelected() | (GetView().GetDrawFuncPtr() != NULL) | (GetView().GetPostItMgr()->GetActiveSidebarWin()!= NULL)));

    if(IsSelFrmMode())
    {
        return false;
    }

    if(IsObjSelected())
    {
        return false;
    }

    if(GetView().GetDrawFuncPtr())
    {
        return false;
    }

    if(GetView().GetPostItMgr()->GetActiveSidebarWin())
    {
        return false;
    }

    return true;
}


// --------------
void SwWrtShell::ChgDBData(const SwDBData& aDBData)
{
    SwEditShell::ChgDBData(aDBData);
    //notify the db-beamer if available
    GetView().NotifyDBChanged();
}

String SwWrtShell::GetSelDescr() const
{
    String aResult;

    int nSelType = GetSelectionType();
    switch (nSelType)
    {
    case nsSelectionType::SEL_GRF:
        aResult = SW_RES(STR_GRAPHIC);

        break;
    case nsSelectionType::SEL_FRM:
        {
            const SwFrmFmt * pFrmFmt = GetCurFrmFmt();

            if (pFrmFmt)
                aResult = pFrmFmt->GetDescription();
        }
        break;
    case nsSelectionType::SEL_DRW:
        {
            aResult = SW_RES(STR_DRAWING_OBJECTS);
        }
        break;
    default:
        if (0 != pDoc)
            aResult = GetCrsrDescr();
    }

    return aResult;
}

void SwWrtShell::ApplyViewOptions( const SwViewOption &rOpt )
{
	SwFEShell::ApplyViewOptions( rOpt );
    //#i115062# invalidate meta character slot
    GetView().GetViewFrame()->GetBindings().Invalidate( FN_VIEW_META_CHARS );
}