xref: /aoo41x/main/sw/source/ui/uiview/viewtab.cxx (revision efeef26f)

/**************************************************************
 *
 * 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 <tools/list.hxx>

#include <hintids.hxx>
#include "uitool.hxx"
#include <sfx2/app.hxx>
#include <svx/rulritem.hxx>
#include <editeng/tstpitem.hxx>
#include <sfx2/request.hxx>
#include <editeng/lrspitem.hxx>
#include <editeng/ulspitem.hxx>
#include <editeng/boxitem.hxx>
#include <editeng/frmdiritem.hxx>
#include <svl/eitem.hxx>
#include <svl/whiter.hxx>
#include <svx/ruler.hxx>
#include <editeng/protitem.hxx>
#include <svl/rectitem.hxx>
#include <sfx2/bindings.hxx>
#include <fmtfsize.hxx>
#include <fmthdft.hxx>
#include <fmtclds.hxx>
#include <fmtornt.hxx>
#include <frmatr.hxx>
#include <edtwin.hxx>
#include "view.hxx"
#include "wrtsh.hxx"
#include "basesh.hxx"
#include "cmdid.h"
#include "viewopt.hxx"
#include "tabcol.hxx"
#include "frmfmt.hxx"		// FrameFormat
#include "pagedesc.hxx"		// Aktuelles Seitenformat
#include "wview.hxx"
#include "fmtcol.hxx"
#include "section.hxx"

// -> #i23726#
#include "ndtxt.hxx"
#include "pam.hxx"
// <- #i23726#

#include <IDocumentSettingAccess.hxx>

using namespace ::com::sun::star;


/*--------------------------------------------------------------------
	Beschreibung:	Debug-Methode
 --------------------------------------------------------------------*/


/*--------------------------------------------------------------------
	Beschreibung:	Columns eintueten
 --------------------------------------------------------------------*/


void lcl_FillSvxColumn(const SwFmtCol& rCol,
						  sal_uInt16 nTotalWidth,
						  SvxColumnItem& rColItem,
						  long nDistance)
{
	const SwColumns& rCols = rCol.GetColumns();
	sal_uInt16 nWidth = 0;

    sal_Bool bOrtho = rCol.IsOrtho() && rCols.Count();
    long nInnerWidth = 0;
    if( bOrtho )
    {
        nInnerWidth = nTotalWidth;
        for ( sal_uInt16 i = 0; i < rCols.Count(); ++i )
        {
            SwColumn* pCol = rCols[i];
            nInnerWidth -= pCol->GetLeft() + pCol->GetRight();
        }
        if( nInnerWidth < 0 )
            nInnerWidth = 0;
        else
            nInnerWidth /= rCols.Count();
    }
    for ( sal_uInt16 i = 0; i < rCols.Count(); ++i )
    {
        SwColumn* pCol = rCols[i];
        const sal_uInt16 nStart = sal_uInt16(pCol->GetLeft() + nWidth + nDistance);
        if( bOrtho )
            nWidth = static_cast< sal_uInt16 >(nWidth + nInnerWidth + pCol->GetLeft() + pCol->GetRight());
        else
            nWidth = static_cast< sal_uInt16 >(nWidth + rCol.CalcColWidth(i, nTotalWidth));
        const sal_uInt16 nEnd = sal_uInt16(nWidth - pCol->GetRight() + nDistance);

        SvxColumnDescription aColDesc(nStart, nEnd, sal_True);
        rColItem.Append(aColDesc);
    }
}

/*--------------------------------------------------------------------
	Beschreibung:	ColumnItem in ColumnInfo ueberfuehren
 --------------------------------------------------------------------*/


void lcl_ConvertToCols(const SvxColumnItem& rColItem,
						  sal_uInt16 nTotalWidth,
						  SwFmtCol& rCols)
{
	ASSERT( rCols.GetNumCols() == rColItem.Count(), "Column count mismatch" );
    // #126939# ruler executes that change the columns shortly after the selection has changed
    // can result in a crash
    if(rCols.GetNumCols() != rColItem.Count())
        return;

	sal_uInt16 nLeft 	= 0;
	SwTwips nSumAll= 0;  // Summiere alle Spalten und Raender auf

	SwColumns& rArr = rCols.GetColumns();

	// Tabcols der Reihe nach
	for( sal_uInt16 i=0; i < rColItem.Count()-1; ++i )
	{
		DBG_ASSERT(rColItem[i+1].nStart >= rColItem[i].nEnd,"\201berlappende Spalten" );
        sal_uInt16 nStart = static_cast< sal_uInt16 >(rColItem[i+1].nStart);
        sal_uInt16 nEnd = static_cast< sal_uInt16 >(rColItem[i].nEnd);
		if(nStart < nEnd)
			nStart = nEnd;
		const sal_uInt16 nDiff	= nStart - nEnd;
		const sal_uInt16 nRight = nDiff / 2;

        sal_uInt16 nWidth = static_cast< sal_uInt16 >(rColItem[i].nEnd - rColItem[i].nStart);
		nWidth += nLeft + nRight;

		SwColumn* pCol = rArr[i];
		pCol->SetWishWidth( sal_uInt16(long(rCols.GetWishWidth()) * long(nWidth) /
															long(nTotalWidth) ));
		pCol->SetLeft( nLeft );
		pCol->SetRight( nRight );
		nSumAll += pCol->GetWishWidth();

		nLeft = nRight;
	}
	rArr[rColItem.Count()-1]->SetLeft( nLeft );

	//Die Differenz aus der Gesamtwunschbreite und der Summe der bisher berechneten
	// Spalten und Raender sollte die Breite der letzten Spalte ergeben.
	rArr[rColItem.Count()-1]->SetWishWidth( rCols.GetWishWidth() - (sal_uInt16)nSumAll );

	rCols.SetOrtho(sal_False, 0, 0 );
}

/*--------------------------------------------------------------------
	Beschreibung:	Tabs loeschen
 --------------------------------------------------------------------*/


void lcl_EraseDefTabs(SvxTabStopItem& rTabStops)
{
	// Def Tabs loeschen
	for ( sal_uInt16 i = 0; i < rTabStops.Count(); )
	{
		// Hier auch den DefTab auf Null rausschmeissen
		if ( SVX_TAB_ADJUST_DEFAULT == rTabStops[i].GetAdjustment() ||
			rTabStops[i].GetTabPos() == 0 )
		{
			rTabStops.Remove(i);
			continue;
		}
		++i;
	}
}

/*--------------------------------------------------------------------
	Beschreibung:	Seitenrand umdrehen
 --------------------------------------------------------------------*/


void SwView::SwapPageMargin(const SwPageDesc& rDesc, SvxLRSpaceItem& rLRSpace)
{
	sal_uInt16 nPhyPage, nVirPage;
	GetWrtShell().GetPageNum( nPhyPage, nVirPage );

	if ( rDesc.GetUseOn() == nsUseOnPage::PD_MIRROR && (nPhyPage % 2) == 0 )
	{
        long nTmp = rLRSpace.GetRight();
		rLRSpace.SetRight( rLRSpace.GetLeft() );
		rLRSpace.SetLeft( nTmp );
	}
}

/*--------------------------------------------------------------------
	Beschreibung:	Wenn der Rahmenrand verschoben wird, sollen die
					Spaltentrenner an der gleichen absoluten Position bleiben
 --------------------------------------------------------------------*/


void lcl_Scale(long& nVal, long nScale)
{
	nVal *= nScale;
	nVal >>= 8;
}

void ResizeFrameCols(SwFmtCol& rCol,
					long nOldWidth,
					long nNewWidth,
					long nLeftDelta )
{
	SwColumns& rArr = rCol.GetColumns();
	long nWishSum = (long)rCol.GetWishWidth();
	long nWishDiff = (nWishSum * 100/nOldWidth * nNewWidth) / 100 - nWishSum;
	long nNewWishWidth = nWishSum + nWishDiff;
	if(nNewWishWidth > 0xffffl)
	{
		// wenn die Wunschbreite zu gross wird, dann muessen alle Werte passend skaliert werden
		long nScale = (0xffffl << 8)/ nNewWishWidth;
		for(sal_uInt16 i = 0; i < rArr.Count(); i++)
		{
			SwColumn* pCol = rArr.GetObject(i);
			long nVal = pCol->GetWishWidth();
			lcl_Scale(nVal, nScale);
			pCol->SetWishWidth((sal_uInt16) nVal);
			nVal = pCol->GetLeft();
			lcl_Scale(nVal, nScale);
			pCol->SetLeft((sal_uInt16) nVal);
			nVal = pCol->GetRight();
			lcl_Scale(nVal, nScale);
			pCol->SetRight((sal_uInt16) nVal);
		}
		lcl_Scale(nNewWishWidth, nScale);
		lcl_Scale(nWishDiff, nScale);
	}
	rCol.SetWishWidth( (sal_uInt16) (nNewWishWidth) );

	if( nLeftDelta >= 2 || nLeftDelta <= -2)
		rArr[0]->SetWishWidth(rArr[0]->GetWishWidth() + (sal_uInt16)nWishDiff);
	else
		rArr[rArr.Count()-1]->SetWishWidth(rArr[rArr.Count()-1]->GetWishWidth() + (sal_uInt16)nWishDiff);
    //reset auto width
    rCol.SetOrtho(sal_False, 0, 0 );
}
/*--------------------------------------------------------------------
	Beschreibung:	Hier werden alle Aenderungen der Tableiste
					wieder in das Modell geschossen
 --------------------------------------------------------------------*/


void SwView::ExecTabWin( SfxRequest& rReq )
{
	SwWrtShell &rSh 		= GetWrtShell();
	const sal_uInt16 nFrmType	= rSh.IsObjSelected() ?
									FRMTYPE_DRAWOBJ :
										rSh.GetFrmType(0,sal_True);
	const sal_Bool bFrmSelection = rSh.IsFrmSelected();
	const sal_Bool bBrowse = rSh.GetViewOptions()->getBrowseMode();

	const sal_uInt16 nSlot 	  	= rReq.GetSlot();
	const sal_uInt16 nDescId  	= rSh.GetCurPageDesc();
	const SwPageDesc& rDesc = rSh.GetPageDesc( nDescId );

    const sal_Bool bVerticalWriting = rSh.IsInVerticalText();
    const SwFmtHeader& rHeaderFmt = rDesc.GetMaster().GetHeader();
	SwFrmFmt *pHeaderFmt = (SwFrmFmt*)rHeaderFmt.GetHeaderFmt();

	const SwFmtFooter& rFooterFmt = rDesc.GetMaster().GetFooter();
	SwFrmFmt *pFooterFmt = (SwFrmFmt*)rFooterFmt.GetFooterFmt();

	const SwFmtFrmSize &rFrmSize = rDesc.GetMaster().GetFrmSize();

    const SwRect& rPageRect = rSh.GetAnyCurRect(RECT_PAGE);
    const long nPageWidth  = bBrowse ? rPageRect.Width() : rFrmSize.GetWidth();
    const long nPageHeight = bBrowse ? rPageRect.Height() : rFrmSize.GetHeight();

	sal_Bool bUnlockView = sal_False;
	rSh.StartAllAction();
	sal_Bool bSect = 0 != (nFrmType & FRMTYPE_COLSECT);

	switch	( nSlot )
	{
    case SID_ATTR_LONG_LRSPACE:
	{
		SvxLongLRSpaceItem aLongLR( (const SvxLongLRSpaceItem&)rReq.GetArgs()->
													Get( SID_ATTR_LONG_LRSPACE ) );
        SvxLRSpaceItem aLR(RES_LR_SPACE);
        if ( !bSect && (bFrmSelection || nFrmType & FRMTYPE_FLY_ANY) )
		{
            SwFrmFmt* pFmt = ((SwFrmFmt*)rSh.GetFlyFrmFmt());
			const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED);

            sal_Bool bVerticalFrame(sal_False);
            {
                sal_Bool bRTL;
                sal_Bool bVertL2R;
                bVerticalFrame = ( bFrmSelection &&
                                   rSh.IsFrmVertical(sal_True, bRTL, bVertL2R) ) ||
                                 ( !bFrmSelection && bVerticalWriting);
            }
            long nDeltaX = bVerticalFrame ?
                rRect.Right() - rPageRect.Right() + aLongLR.GetRight() :
				rPageRect.Left() + aLongLR.GetLeft() - rRect.Left();

            SfxItemSet aSet( GetPool(), RES_FRM_SIZE, RES_FRM_SIZE,
                                        RES_VERT_ORIENT, RES_HORI_ORIENT,
										RES_COL, RES_COL, 0 );

            if(bVerticalFrame)
            {
                SwFmtVertOrient aVertOrient(pFmt->GetVertOrient());
                aVertOrient.SetVertOrient(text::VertOrientation::NONE);
                aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaX );
                aSet.Put( aVertOrient );
            }
            else
            {
                SwFmtHoriOrient aHoriOrient( pFmt->GetHoriOrient() );
                aHoriOrient.SetHoriOrient( text::HoriOrientation::NONE );
                aHoriOrient.SetPos( aHoriOrient.GetPos() + nDeltaX );
                aSet.Put( aHoriOrient );
            }

			SwFmtFrmSize aSize( pFmt->GetFrmSize() );
			long nOldWidth = (long) aSize.GetWidth();

			if(aSize.GetWidthPercent())
			{
				SwRect aRect;
                rSh.CalcBoundRect(aRect, FLY_AS_CHAR);
				long nPrtWidth = aRect.Width();
				aSize.SetWidthPercent(sal_uInt8((nPageWidth - aLongLR.GetLeft() - aLongLR.GetRight()) * 100 /nPrtWidth));
			}
			else
				aSize.SetWidth( nPageWidth -
						(aLongLR.GetLeft() + aLongLR.GetRight()));

			if( nFrmType & FRMTYPE_COLUMN )
			{
				SwFmtCol aCol(pFmt->GetCol());

				::ResizeFrameCols(aCol, nOldWidth, (long)aSize.GetWidth(), nDeltaX );
				aSet.Put(aCol);
			}

			aSet.Put( aSize );

			rSh.StartAction();
			rSh.Push();
			rSh.SetFlyFrmAttr( aSet );
			//die Rahmenselektion wieder aufheben
			if(!bFrmSelection && rSh.IsFrmSelected())
			{
				rSh.UnSelectFrm();
				rSh.LeaveSelFrmMode();
			}
			rSh.Pop();
			rSh.EndAction();
		}
		else if ( nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER ))
		{
			// Seitenraender rausrechnen
            long nOld = rDesc.GetMaster().GetLRSpace().GetLeft();
            aLongLR.SetLeft( nOld > aLongLR.GetLeft() ? 0 : aLongLR.GetLeft() - nOld );

			nOld = rDesc.GetMaster().GetLRSpace().GetRight();
			aLongLR.SetRight( nOld > (sal_uInt16)aLongLR.GetRight() ? 0 : aLongLR.GetRight() - nOld );
			aLR.SetLeft((sal_uInt16)aLongLR.GetLeft());
			aLR.SetRight((sal_uInt16)aLongLR.GetRight());

			if ( nFrmType & FRMTYPE_HEADER && pHeaderFmt )
                pHeaderFmt->SetFmtAttr( aLR );
			else if( nFrmType & FRMTYPE_FOOTER && pFooterFmt )
                pFooterFmt->SetFmtAttr( aLR );
		}
		else if( nFrmType == FRMTYPE_DRAWOBJ)
		{
			SwRect aRect( rSh.GetObjRect() );
			aRect.Left( aLongLR.GetLeft() + rPageRect.Left() );
			aRect.Right( rPageRect.Right() - aLongLR.GetRight());
			rSh.SetObjRect( aRect );
		}
        else if(bSect || rSh.IsDirectlyInSection())
		{
			//change the section indents and the columns if available
			//at first determine the changes
            SwRect aSectRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, 0);
            const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, 0);
            aSectRect.Pos() += aTmpRect.Pos();
            long nLeftDiff = aLongLR.GetLeft() - (long)(aSectRect.Left() - rPageRect.Left() );
            long nRightDiff = aLongLR.GetRight() - (long)( rPageRect.Right() - aSectRect.Right());
			//change the LRSpaceItem of the section accordingly
            const SwSection* pCurrSect = rSh.GetCurrSection();
            const SwSectionFmt* pSectFmt = pCurrSect->GetFmt();
            SvxLRSpaceItem aLRTmp = pSectFmt->GetLRSpace();
            aLRTmp.SetLeft(aLRTmp.GetLeft() + nLeftDiff);
            aLRTmp.SetRight(aLRTmp.GetRight() + nRightDiff);
            SfxItemSet aSet(rSh.GetAttrPool(), RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL, 0L);
            aSet.Put(aLRTmp);
			//change the first/last column
			if(bSect)
			{
                SwFmtCol aCols( pSectFmt->GetCol() );
                long nDiffWidth = nLeftDiff + nRightDiff;
                ::ResizeFrameCols(aCols, aSectRect.Width(), aSectRect.Width() - nDiffWidth, nLeftDiff );
                aSet.Put( aCols );
			}
            SwSectionData aData(*pCurrSect);
            rSh.UpdateSection(rSh.GetSectionFmtPos(*pSectFmt), aData, &aSet);
        }
		else
		{	// Seitenraender einstellen
			aLR.SetLeft((sal_uInt16)aLongLR.GetLeft());
			aLR.SetRight((sal_uInt16)aLongLR.GetRight());
			SwapPageMargin( rDesc, aLR );
			SwPageDesc aDesc( rDesc );
            aDesc.GetMaster().SetFmtAttr( aLR );
			rSh.ChgPageDesc( nDescId, aDesc );
		}
	}
	break;
    case SID_ATTR_LONG_ULSPACE:
	{
		SvxLongULSpaceItem aLongULSpace( (const SvxLongULSpaceItem&)rReq.GetArgs()->
														Get( SID_ATTR_LONG_ULSPACE ));

		if( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY )
		{
            SwFrmFmt* pFmt = ((SwFrmFmt*)rSh.GetFlyFrmFmt());
			const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED);
            const long nDeltaY = rPageRect.Top() + aLongULSpace.GetUpper() - rRect.Top();
			const long nHeight = nPageHeight - (aLongULSpace.GetUpper() + aLongULSpace.GetLower());

            SfxItemSet aSet( GetPool(), RES_FRM_SIZE, RES_FRM_SIZE,
                                        RES_VERT_ORIENT, RES_HORI_ORIENT, 0 );
            //which of the orientation attributes is to be put depends on the frame's environment
            sal_Bool bRTL;
            sal_Bool bVertL2R;
            if ( ( bFrmSelection &&
                   rSh.IsFrmVertical(sal_True, bRTL, bVertL2R ) ) ||
                 ( !bFrmSelection && bVerticalWriting ) )
            {
                SwFmtHoriOrient aHoriOrient(pFmt->GetHoriOrient());
                aHoriOrient.SetHoriOrient(text::HoriOrientation::NONE);
                aHoriOrient.SetPos(aHoriOrient.GetPos() + nDeltaY );
                aSet.Put( aHoriOrient );
            }
            else
            {
                SwFmtVertOrient aVertOrient(pFmt->GetVertOrient());
                aVertOrient.SetVertOrient(text::VertOrientation::NONE);
                aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaY );
                aSet.Put( aVertOrient );
            }
			SwFmtFrmSize aSize(pFmt->GetFrmSize());
			if(aSize.GetHeightPercent())
			{
				SwRect aRect;
                rSh.CalcBoundRect(aRect, FLY_AS_CHAR);
				long nPrtHeight = aRect.Height();
				aSize.SetHeightPercent(sal_uInt8(nHeight * 100 /nPrtHeight));
			}
			else
				aSize.SetHeight(nHeight );

            aSet.Put( aSize );
            rSh.SetFlyFrmAttr( aSet );
		}
		else if( nFrmType == FRMTYPE_DRAWOBJ )
		{
			SwRect aRect( rSh.GetObjRect() );
            aRect.Top( aLongULSpace.GetUpper() + rPageRect.Top() );
			aRect.Bottom( rPageRect.Bottom() - aLongULSpace.GetLower() );
			rSh.SetObjRect( aRect ) ;
		}
        else if(bVerticalWriting && (bSect || rSh.IsDirectlyInSection()))
		{
			//change the section indents and the columns if available
			//at first determine the changes
            SwRect aSectRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, 0);
            const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, 0);
            aSectRect.Pos() += aTmpRect.Pos();
            const long nLeftDiff = aLongULSpace.GetUpper() - (long)(aSectRect.Top() - rPageRect.Top());
            const long nRightDiff = aLongULSpace.GetLower() - (long)(nPageHeight - aSectRect.Bottom() + rPageRect.Top());
			//change the LRSpaceItem of the section accordingly
            const SwSection* pCurrSect = rSh.GetCurrSection();
            const SwSectionFmt* pSectFmt = pCurrSect->GetFmt();
            SvxLRSpaceItem aLR = pSectFmt->GetLRSpace();
            aLR.SetLeft(aLR.GetLeft() + nLeftDiff);
            aLR.SetRight(aLR.GetRight() + nRightDiff);
            SfxItemSet aSet(rSh.GetAttrPool(), RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL, 0L);
            aSet.Put(aLR);
			//change the first/last column
			if(bSect)
			{
                SwFmtCol aCols( pSectFmt->GetCol() );
                long nDiffWidth = nLeftDiff + nRightDiff;
                ::ResizeFrameCols(aCols, aSectRect.Height(), aSectRect.Height() - nDiffWidth, nLeftDiff );
                aSet.Put( aCols );
			}
            SwSectionData aData(*pCurrSect);
            rSh.UpdateSection(rSh.GetSectionFmtPos(*pSectFmt), aData, &aSet);
        }
		else
		{	SwPageDesc aDesc( rDesc );

			if ( nFrmType & ( FRMTYPE_HEADER | FRMTYPE_FOOTER ))
			{

				const sal_Bool bHead = nFrmType & FRMTYPE_HEADER ? sal_True : sal_False;
				SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
				if ( bHead )
					aUL.SetUpper( (sal_uInt16)aLongULSpace.GetUpper() );
				else
					aUL.SetLower( (sal_uInt16)aLongULSpace.GetLower() );
                aDesc.GetMaster().SetFmtAttr( aUL );

				if( (bHead && pHeaderFmt) || (!bHead && pFooterFmt) )
                {
                    SwFmtFrmSize aSz( bHead ? pHeaderFmt->GetFrmSize() :
										      pFooterFmt->GetFrmSize() );
                    aSz.SetHeightSizeType( ATT_FIX_SIZE );
				    aSz.SetHeight(nPageHeight - aLongULSpace.GetLower() -
											    aLongULSpace.GetUpper() );
				    if ( bHead )
                        pHeaderFmt->SetFmtAttr( aSz );
				    else
                        pFooterFmt->SetFmtAttr( aSz );
                }
			}
			else
			{
                SvxULSpaceItem aUL(RES_UL_SPACE);
				aUL.SetUpper((sal_uInt16)aLongULSpace.GetUpper());
				aUL.SetLower((sal_uInt16)aLongULSpace.GetLower());
                aDesc.GetMaster().SetFmtAttr(aUL);
			}

			rSh.ChgPageDesc( nDescId, aDesc );
		}
	}
	break;
    case SID_ATTR_TABSTOP_VERTICAL:
    case SID_ATTR_TABSTOP:
    {
		sal_uInt16 nWhich = GetPool().GetWhich(nSlot);
		SvxTabStopItem aTabStops( (const SvxTabStopItem&)rReq.GetArgs()->
                                                    Get( nWhich ));
		aTabStops.SetWhich(RES_PARATR_TABSTOP);
 		const SvxTabStopItem& rDefTabs =
					(const SvxTabStopItem&)rSh.GetDefault(RES_PARATR_TABSTOP);

		// Default-Tab an Pos 0
		SfxItemSet aSet( GetPool(), RES_LR_SPACE, RES_LR_SPACE );
        rSh.GetCurAttr( aSet );
		const SvxLRSpaceItem& rLR = (const SvxLRSpaceItem&)aSet.Get(RES_LR_SPACE);

		if ( rLR.GetTxtFirstLineOfst() < 0 )
		{
			SvxTabStop aSwTabStop( 0, SVX_TAB_ADJUST_DEFAULT );
			aTabStops.Insert( aSwTabStop );
		}

		// auffuellen mit Default-Tabs
		sal_uInt16 nDef = ::GetTabDist( rDefTabs );
		::MakeDefTabs( nDef, aTabStops );

		SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
		if(	pColl && pColl->IsAutoUpdateFmt() )
		{
			SfxItemSet aTmp(GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP);
			aTmp.Put(aTabStops);
			rSh.AutoUpdatePara( pColl, aTmp );
		}
		else
			rSh.SetAttr( aTabStops );
		break;
	}
    case SID_ATTR_PARA_LRSPACE_VERTICAL:
    case SID_ATTR_PARA_LRSPACE:
	{
		SvxLRSpaceItem aParaMargin((const SvxLRSpaceItem&)rReq.
										GetArgs()->Get(nSlot));
		if(nFrmType & FRMTYPE_FLY_ANY)
		{
            sal_Bool bFirstColumn = sal_True;
            sal_Bool bLastColumn = sal_True;
            if(nFrmType & FRMTYPE_COLUMN)
            {
                sal_uInt16 nCurFrameCol = rSh.GetCurColNum() - 1;
                bFirstColumn = !nCurFrameCol;
                const SwFrmFmt* pFmt =  rSh.GetFlyFrmFmt();
                const SwFmtCol* pCols = &pFmt->GetCol();
                const SwColumns& rCols = pCols->GetColumns();
                sal_uInt16 nColumnCount = rCols.Count();
                bLastColumn = nColumnCount == nCurFrameCol + 1;
            }
		}
        aParaMargin.SetRight( aParaMargin.GetRight() - nRightBorderDistance );
        aParaMargin.SetTxtLeft(aParaMargin.GetTxtLeft() - nLeftBorderDistance );

		aParaMargin.SetWhich( RES_LR_SPACE );
		SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();

        // #i23726#
        if (pNumRuleNodeFromDoc)
        {
            // --> FME 2005-02-22 #i42922# Mouse move of numbering label
            // has to consider the left indent of the paragraph
	        SfxItemSet aSet( GetPool(), RES_LR_SPACE, RES_LR_SPACE );
            rSh.GetCurAttr( aSet );
            const SvxLRSpaceItem& rLR =
                    static_cast<const SvxLRSpaceItem&>(aSet.Get(RES_LR_SPACE));
            // <--

            SwPosition aPos(*pNumRuleNodeFromDoc);
            // --> OD 2008-06-09 #i90078#
            rSh.SetIndent( static_cast< short >(aParaMargin.GetTxtLeft() - rLR.GetTxtLeft()), aPos);
            // <--
            // --> OD 2005-02-18 #i42921# - invalidate state of indent in order
            // to get a ruler update.
            aParaMargin.SetWhich( nSlot );
            GetViewFrame()->GetBindings().SetState( aParaMargin );
            // <--
        }
		else if( pColl && pColl->IsAutoUpdateFmt() )
		{
			SfxItemSet aSet(GetPool(), RES_LR_SPACE, RES_LR_SPACE);
			aSet.Put(aParaMargin);
			rSh.AutoUpdatePara( pColl, aSet);
		}
		else
			rSh.SetAttr( aParaMargin );

		if ( aParaMargin.GetTxtFirstLineOfst() < 0 )
		{
			SfxItemSet aSet( GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP );

            rSh.GetCurAttr( aSet );
			const SvxTabStopItem&  rTabStops = (const SvxTabStopItem&)aSet.Get(RES_PARATR_TABSTOP);

			// Haben wir einen Tab an Stelle Null
			sal_uInt16 i;

			for ( i = 0; i < rTabStops.Count(); ++i )
				if ( rTabStops[i].GetTabPos() == 0 )
					break;

			if ( i >= rTabStops.Count() )
			{
				// Kein DefTab
                SvxTabStopItem aTabStops( RES_PARATR_TABSTOP );
				aTabStops = rTabStops;

				::lcl_EraseDefTabs(aTabStops);

				SvxTabStop aSwTabStop( 0, SVX_TAB_ADJUST_DEFAULT );
				aTabStops.Insert(aSwTabStop);

				const SvxTabStopItem& rDefTabs =
					(const SvxTabStopItem&)rSh.GetDefault(RES_PARATR_TABSTOP);
				sal_uInt16 nDef = ::GetTabDist(rDefTabs);
				::MakeDefTabs( nDef, aTabStops );

				if(	pColl && pColl->IsAutoUpdateFmt())
				{
					SfxItemSet aSetTmp(GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP);
					aSetTmp.Put(aTabStops);
					rSh.AutoUpdatePara( pColl, aSetTmp );
				}
				else
					rSh.SetAttr( aTabStops );
			}
		}
	}
	break;
    case SID_RULER_BORDERS_VERTICAL:
    case SID_RULER_BORDERS:
	{
		SvxColumnItem aColItem((const SvxColumnItem&)rReq.
                                            GetArgs()->Get(nSlot));

		if( bSetTabColFromDoc || (!bSect && rSh.GetTableFmt()) )
		{
			ASSERT(aColItem.Count(), "ColDesc ist leer!!");

			const sal_Bool bSingleLine = ((const SfxBoolItem&)rReq.
							GetArgs()->Get(SID_RULER_ACT_LINE_ONLY)).GetValue();

			SwTabCols aTabCols;
			if ( bSetTabColFromDoc )
				rSh.GetMouseTabCols( aTabCols, aTabColFromDocPos );
			else
				rSh.GetTabCols(aTabCols);

			// linker Tabellenrand
			long nBorder = (long)(aColItem.GetLeft() - aTabCols.GetLeftMin());
			aTabCols.SetLeft( nBorder );

            nBorder = (bVerticalWriting ? nPageHeight : nPageWidth) - aTabCols.GetLeftMin() - aColItem.GetRight();

#ifdef DEBUG
            long nTmp1 = nPageWidth;
            long nTmp2 = aTabCols.GetLeftMin() + nBorder;
            (void)nTmp1;
            (void)nTmp2;
#endif

            if ( aColItem.GetRight() > 0 )
        		aTabCols.SetRight( nBorder );

			// Tabcols der Reihe nach
			// Die letzte Col wird durch den Rand definiert
            //columns in right-to-left tables need to be mirrored
            sal_Bool bIsTableRTL =
                IsTabColFromDoc() ?
                      rSh.IsMouseTableRightToLeft(aTabColFromDocPos)
                    : rSh.IsTableRightToLeft();
            if(bIsTableRTL)
			{
				sal_uInt16 nColCount = aColItem.Count() - 1;
				for ( sal_uInt16 i = 0; i < nColCount; ++i )
				{
					const SvxColumnDescription& rCol = aColItem[nColCount - i];
					aTabCols[i] = aTabCols.GetRight() - rCol.nStart;
					aTabCols.SetHidden( i, !rCol.bVisible );
				}
			}
			else
			{
				for ( sal_uInt16 i = 0; i < aColItem.Count()-1; ++i )
				{
					const SvxColumnDescription& rCol = aColItem[i];
					aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
					aTabCols.SetHidden( i, !rCol.bVisible );
				}
			}

            if ( bSetTabColFromDoc )
			{
				if( !rSh.IsViewLocked() )
				{
					bUnlockView = sal_True;
					rSh.LockView( sal_True );
				}
				rSh.SetMouseTabCols( aTabCols, bSingleLine,
											   aTabColFromDocPos );
			}
			else
				rSh.SetTabCols(aTabCols, bSingleLine);

		}
		else
		{
			if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY || bSect)
			{
				SwSectionFmt *pSectFmt = 0;
				SfxItemSet aSet( GetPool(), RES_COL, RES_COL );
				if(bSect)
				{
					const SwSection *pSect = rSh.GetAnySection();
					ASSERT( pSect, "Welcher Bereich?");
					pSectFmt = pSect->GetFmt();
				}
				else
				{
					rSh.GetFlyFrmAttr( aSet );
				}
				SwFmtCol aCols(
					bSect ?
						pSectFmt->GetCol() :
							(const SwFmtCol&)aSet.Get( RES_COL, sal_False ));
				SwRect aCurRect = rSh.GetAnyCurRect(bSect ? RECT_SECTION_PRT : RECT_FLY_PRT_EMBEDDED);
				const long lWidth = bVerticalWriting ? aCurRect.Height() : aCurRect.Width();
				::lcl_ConvertToCols( aColItem, sal_uInt16(lWidth), aCols );
				aSet.Put( aCols );
				if(bSect)
					rSh.SetSectionAttr( aSet, pSectFmt );
				else
				{
					rSh.StartAction();
					rSh.Push();
					rSh.SetFlyFrmAttr( aSet );
					//die Rahmenselektion wieder aufheben
					if(!bFrmSelection && rSh.IsFrmSelected())
					{
						rSh.UnSelectFrm();
						rSh.LeaveSelFrmMode();
					}
					rSh.Pop();
					rSh.EndAction();
				}
			}
			else
			{
				SwFmtCol aCols( rDesc.GetMaster().GetCol() );
                const SwRect aPrtRect = rSh.GetAnyCurRect(RECT_PAGE_PRT);
				::lcl_ConvertToCols( aColItem,
					sal_uInt16(bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width()),
								aCols );
				SwPageDesc aDesc( rDesc );
                aDesc.GetMaster().SetFmtAttr( aCols );
				rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc );
			}
		}
	}
	break;

	case SID_RULER_ROWS :
	case SID_RULER_ROWS_VERTICAL:
	{
		SvxColumnItem aColItem((const SvxColumnItem&)rReq.
											GetArgs()->Get(nSlot));

		if( bSetTabColFromDoc || (!bSect && rSh.GetTableFmt()) )
		{
			ASSERT(aColItem.Count(), "ColDesc ist leer!!");

			SwTabCols aTabCols;
			if ( bSetTabRowFromDoc )
				rSh.GetMouseTabRows( aTabCols, aTabColFromDocPos );
			else
				rSh.GetTabRows(aTabCols);

			if ( bVerticalWriting )
			{
				aTabCols.SetRight(nPageWidth - aColItem.GetRight() - aColItem.GetLeft());
                aTabCols.SetLeftMin(aColItem.GetLeft());
			}
			else
			{
                long nBorder = nPageHeight - aTabCols.GetLeftMin() - aColItem.GetRight();
				aTabCols.SetRight( nBorder );
			}

			if(bVerticalWriting)
			{
				for ( sal_uInt16 i = aColItem.Count() - 1; i; --i )
				{
					const SvxColumnDescription& rCol = aColItem[i - 1];
					long nColumnPos = aTabCols.GetRight() - rCol.nEnd ;
					aTabCols[i - 1] = nColumnPos;
					aTabCols.SetHidden( i - 1, !rCol.bVisible );
				}
			}
			else
			{
				for ( sal_uInt16 i = 0; i < aColItem.Count()-1; ++i )
				{
					const SvxColumnDescription& rCol = aColItem[i];
					aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
					aTabCols.SetHidden( i, !rCol.bVisible );
				}
			}
			sal_Bool bSingleLine = sal_False;
			const SfxPoolItem* pSingleLine;
			if( SFX_ITEM_SET == rReq.GetArgs()->GetItemState(SID_RULER_ACT_LINE_ONLY, sal_False, &pSingleLine))
				bSingleLine = ((const SfxBoolItem*)pSingleLine)->GetValue();
			if ( bSetTabRowFromDoc )
			{
				if( !rSh.IsViewLocked() )
				{
					bUnlockView = sal_True;
					rSh.LockView( sal_True );
				}
				rSh.SetMouseTabRows( aTabCols, bSingleLine, aTabColFromDocPos );
			}
			else
				rSh.SetTabRows(aTabCols, bSingleLine);
		}
	}
	break;

    default:
		ASSERT( !this, "Falsche SlotId");
	}
	rSh.EndAllAction();

	if( bUnlockView )
		rSh.LockView( sal_False );

    bSetTabColFromDoc = bSetTabRowFromDoc = bTabColFromDoc = bTabRowFromDoc = sal_False;
    SetNumRuleNodeFromDoc(NULL);
}

/*--------------------------------------------------------------------
	Beschreibung:	Hier wird der Status der Tableiste ermittelt
					sprich alle relevanten Attribute an der CursorPos
					werden der Tableiste uebermittelt
 --------------------------------------------------------------------*/


void SwView::StateTabWin(SfxItemSet& rSet)
{
	SwWrtShell &rSh 		= GetWrtShell();

    const Point* pPt = IsTabColFromDoc() || IsTabRowFromDoc() ? &aTabColFromDocPos : 0;
	const sal_uInt16 nFrmType	= rSh.IsObjSelected()
				? FRMTYPE_DRAWOBJ
				: rSh.GetFrmType( pPt, sal_True );

	const sal_Bool 	bFrmSelection = rSh.IsFrmSelected();
	const sal_Bool bBrowse = rSh.GetViewOptions()->getBrowseMode();
	// PageOffset/Begrenzer
	const SwRect& rPageRect = rSh.GetAnyCurRect( RECT_PAGE, pPt );
	const SwRect& rPagePrtRect = rSh.GetAnyCurRect( RECT_PAGE_PRT, pPt );
	const long nPageWidth  = rPageRect.Width();
	const long nPageHeight = rPageRect.Height();

    const SwPageDesc& rDesc = rSh.GetPageDesc(
                IsTabColFromDoc() || bTabRowFromDoc ?
                    rSh.GetMousePageDesc(aTabColFromDocPos) : rSh.GetCurPageDesc() );

    const SvxFrameDirectionItem& rFrameDir = rDesc.GetMaster().GetFrmDir();
    const sal_Bool bVerticalWriting = rSh.IsInVerticalText();

    //enable tab stop display on the rulers depending on the writing direction
    WinBits nRulerStyle = pHRuler->GetStyle() & ~WB_EXTRAFIELD;
    pHRuler->SetStyle(bVerticalWriting||bBrowse ? nRulerStyle : nRulerStyle|WB_EXTRAFIELD);
    nRulerStyle = pVRuler->GetStyle() & ~WB_EXTRAFIELD;
    pVRuler->SetStyle(bVerticalWriting ? nRulerStyle|WB_EXTRAFIELD : nRulerStyle);

    //#i24363# tab stops relative to indent
    bool bRelative = rSh.getIDocumentSettingAccess()->get(IDocumentSettingAccess::TABS_RELATIVE_TO_INDENT);
    pHRuler->SetTabsRelativeToIndent( bRelative );
    pVRuler->SetTabsRelativeToIndent( bRelative );

    SvxLRSpaceItem aPageLRSpace( rDesc.GetMaster().GetLRSpace() );
	SwapPageMargin( rDesc, aPageLRSpace );

	SfxItemSet aCoreSet( GetPool(), RES_PARATR_TABSTOP, RES_PARATR_TABSTOP,
									RES_LR_SPACE, 		 RES_UL_SPACE, 0 );
    // --> OD 2008-01-17 #newlistlevelattrs#
    // get also the list level indent values merged as LR-SPACE item, if needed.
    rSh.GetCurAttr( aCoreSet, true );
    // <--
    SelectionType nSelType = rSh.GetSelectionType();

	SfxWhichIter aIter( rSet );
	sal_uInt16 nWhich = aIter.FirstWhich();
    sal_Bool bPutContentProtection = sal_False;

	while ( nWhich )
	{
		switch ( nWhich )
		{
//        case RES_LR_SPACE:
//        case SID_ATTR_LRSPACE:
		case SID_ATTR_LONG_LRSPACE:
        {
			SvxLongLRSpaceItem aLongLR( (long)aPageLRSpace.GetLeft(),
										(long)aPageLRSpace.GetRight(),
										SID_ATTR_LONG_LRSPACE);
			if(bBrowse)
			{
				aLongLR.SetLeft(rPagePrtRect.Left());
				aLongLR.SetRight(nPageWidth - rPagePrtRect.Right());
			}
			if ( ( nFrmType & FRMTYPE_HEADER || nFrmType & FRMTYPE_FOOTER ) &&
				 !(nFrmType & FRMTYPE_COLSECT) )
			{
				SwFrmFmt *pFmt = (SwFrmFmt*) (nFrmType & FRMTYPE_HEADER ?
								rDesc.GetMaster().GetHeader().GetHeaderFmt() :
								rDesc.GetMaster().GetFooter().GetFooterFmt());
                if( pFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash
                {
                    SwRect aRect( rSh.GetAnyCurRect( RECT_HEADERFOOTER, pPt));
                    aRect.Pos() -= rSh.GetAnyCurRect( RECT_PAGE, pPt ).Pos();
                    const SvxLRSpaceItem& aLR = pFmt->GetLRSpace();
                    aLongLR.SetLeft ( (long)aLR.GetLeft() + (long)aRect.Left() );
                    aLongLR.SetRight( (nPageWidth -
                                        (long)aRect.Right() + (long)aLR.GetRight()));
                }
			}
			else
			{
				SwRect aRect;
				if( !bFrmSelection && ((nFrmType & FRMTYPE_COLSECT) || rSh.IsDirectlyInSection()) )
                {
                    aRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, pPt);
                    const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, pPt);
                    aRect.Pos() += aTmpRect.Pos();
                }

				else if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY )
					aRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
				else if( nFrmType & FRMTYPE_DRAWOBJ)
					aRect = rSh.GetObjRect();

				if( aRect.Width() )
				{
                    // PAGES01
                    // make relative to page position:
					aLongLR.SetLeft ((long)( aRect.Left() - rPageRect.Left() ));
					aLongLR.SetRight((long)( rPageRect.Right() - aRect.Right()));
				}
			}
			if( nWhich == SID_ATTR_LONG_LRSPACE )
				rSet.Put( aLongLR );
            else
			{
				SvxLRSpaceItem aLR( aLongLR.GetLeft(),
								    aLongLR.GetRight(),
                                    0, 0,
									nWhich);
				rSet.Put(aLR);
			}
			break;
		}
		case SID_ATTR_LONG_ULSPACE:
//        case SID_ATTR_ULSPACE:
//        case RES_UL_SPACE:
		{
			// Rand Seite Oben Unten
			SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
			SvxLongULSpaceItem aLongUL( (long)aUL.GetUpper(),
										(long)aUL.GetLower(),
										SID_ATTR_LONG_ULSPACE);

			if ( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY )
			{
				// Dokumentkoordinaten Frame auf Seitenkoordinaten umbrechen
				const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
				aLongUL.SetUpper((sal_uInt16)(rRect.Top() - rPageRect.Top() ));
				aLongUL.SetLower((sal_uInt16)(rPageRect.Bottom() - rRect.Bottom() ));
			}
			else if ( nFrmType & FRMTYPE_HEADER || nFrmType & FRMTYPE_FOOTER )
			{
				SwRect aRect( rSh.GetAnyCurRect( RECT_HEADERFOOTER, pPt));
				aRect.Pos() -= rSh.GetAnyCurRect( RECT_PAGE, pPt ).Pos();
				aLongUL.SetUpper( (sal_uInt16)aRect.Top() );
				aLongUL.SetLower( (sal_uInt16)(nPageHeight - aRect.Bottom()) );
			}
			else if( nFrmType & FRMTYPE_DRAWOBJ)
			{
				const SwRect &rRect = rSh.GetObjRect();
				aLongUL.SetUpper((rRect.Top() - rPageRect.Top()));
				aLongUL.SetLower((rPageRect.Bottom() - rRect.Bottom()));
			}
			else if(bBrowse)
			{
				aLongUL.SetUpper(rPagePrtRect.Top());
				aLongUL.SetLower(nPageHeight - rPagePrtRect.Bottom());
			}
			if( nWhich == SID_ATTR_LONG_ULSPACE )
				rSet.Put( aLongUL );
			else
			{
				SvxULSpaceItem aULTmp((sal_uInt16)aLongUL.GetUpper(),
									  (sal_uInt16)aLongUL.GetLower(),
									  nWhich);
				rSet.Put(aULTmp);
			}
			break;
		}
        case SID_ATTR_TABSTOP_VERTICAL :
        case RES_PARATR_TABSTOP:
		{
			if ( ISA( SwWebView ) ||
				 IsTabColFromDoc() ||
                 IsTabRowFromDoc() ||
				 ( nSelType & nsSelectionType::SEL_GRF) ||
					(nSelType & nsSelectionType::SEL_FRM) ||
					(nSelType & nsSelectionType::SEL_OLE) ||
                    SFX_ITEM_AVAILABLE > aCoreSet.GetItemState(RES_LR_SPACE)||
                    (!bVerticalWriting && (SID_ATTR_TABSTOP_VERTICAL == nWhich))||
                    (bVerticalWriting && (RES_PARATR_TABSTOP == nWhich))
                 )
                rSet.DisableItem( nWhich );
			else
            {
                SvxTabStopItem aTabStops((const SvxTabStopItem&)
											aCoreSet.Get( RES_PARATR_TABSTOP ));

				const SvxTabStopItem& rDefTabs = (const SvxTabStopItem&)
											rSh.GetDefault(RES_PARATR_TABSTOP);

                DBG_ASSERT(pHRuler, "warum ist das Lineal nicht da?");
				long nDefTabDist = ::GetTabDist(rDefTabs);
                pHRuler->SetDefTabDist( nDefTabDist );
                pVRuler->SetDefTabDist( nDefTabDist );
				::lcl_EraseDefTabs(aTabStops);
                rSet.Put(aTabStops, nWhich);
			}
			break;
		}
        case SID_ATTR_PARA_LRSPACE_VERTICAL:
        case SID_ATTR_PARA_LRSPACE:
		{
			if ( nSelType & nsSelectionType::SEL_GRF ||
					nSelType & nsSelectionType::SEL_FRM ||
					nSelType & nsSelectionType::SEL_OLE ||
                    nFrmType == FRMTYPE_DRAWOBJ ||
                    (!bVerticalWriting && (SID_ATTR_PARA_LRSPACE_VERTICAL == nWhich))||
                    (bVerticalWriting && (SID_ATTR_PARA_LRSPACE == nWhich))
                    )
            {
                rSet.DisableItem(nWhich);
            }
			else
			{
                SvxLRSpaceItem aLR( RES_LR_SPACE );
				if ( !IsTabColFromDoc() )
                {
					aLR = (const SvxLRSpaceItem&)aCoreSet.Get(RES_LR_SPACE);

                    // #i23726#
                    if (pNumRuleNodeFromDoc)
                    {
                        short nOffset = static_cast< short >(aLR.GetTxtLeft() +
                                        // --> FME 2005-02-22 #i42922# Mouse move of numbering label
                                        // has to consider the left indent of the paragraph
                                        pNumRuleNodeFromDoc->GetLeftMarginWithNum( sal_True ) );
                                       // <--

                        short nFLOffset;
                        pNumRuleNodeFromDoc->GetFirstLineOfsWithNum( nFLOffset );

                        aLR.SetLeft( nOffset + nFLOffset );
                    }
                }
				aLR.SetWhich(nWhich);
				rSet.Put(aLR);
			}
        break;
		}
        case SID_RULER_BORDER_DISTANCE:
        {
            nLeftBorderDistance = 0;
            nRightBorderDistance = 0;
            if ( nSelType & nsSelectionType::SEL_GRF ||
					nSelType & nsSelectionType::SEL_FRM ||
					nSelType & nsSelectionType::SEL_OLE ||
					nFrmType == FRMTYPE_DRAWOBJ )
                rSet.DisableItem(SID_RULER_BORDER_DISTANCE);
			else
			{
                SvxLRSpaceItem aDistLR(SID_RULER_BORDER_DISTANCE);
                if(nFrmType & FRMTYPE_FLY_ANY)
				{
					if( IsTabColFromDoc() )
					{
                        const SwRect& rFlyPrtRect = rSh.GetAnyCurRect( RECT_FLY_PRT_EMBEDDED, pPt );
                        aDistLR.SetLeft(rFlyPrtRect.Left());
                        aDistLR.SetRight(rFlyPrtRect.Left());
					}
					else
					{
						SfxItemSet aCoreSet2( GetPool(),
												RES_BOX, RES_BOX,
												SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
                        SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
						aCoreSet.Put( aBoxInfo );
						rSh.GetFlyFrmAttr( aCoreSet );
						const SvxBoxItem& rBox = (const SvxBoxItem&)aCoreSet.Get(RES_BOX);
                        aDistLR.SetLeft((sal_uInt16)rBox.GetDistance(BOX_LINE_LEFT ));
                        aDistLR.SetRight((sal_uInt16)rBox.GetDistance(BOX_LINE_RIGHT));

						//add the paragraph border distance
                        SfxItemSet aCoreSet1( GetPool(),
                                                RES_BOX, RES_BOX,
                                                0 );
                        rSh.GetCurAttr( aCoreSet1 );
                        const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSet1.Get(RES_BOX);
						aDistLR.SetLeft(aDistLR.GetLeft() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_LEFT ));
						aDistLR.SetRight(aDistLR.GetRight() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_RIGHT));
					}
                    rSet.Put(aDistLR);
                    nLeftBorderDistance  = static_cast< sal_uInt16 >(aDistLR.GetLeft());
                    nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
                }
                else if ( IsTabColFromDoc() ||
					( rSh.GetTableFmt() && !bFrmSelection &&
					!(nFrmType & FRMTYPE_COLSECT ) ) )
                {
                    SfxItemSet aCoreSet2( GetPool(),
                                            RES_BOX, RES_BOX,
                                            SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
                    SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
                    aBoxInfo.SetTable(sal_False);
                    aBoxInfo.SetDist((sal_Bool) sal_True);
                    aCoreSet2.Put(aBoxInfo);
                    rSh.GetTabBorders( aCoreSet2 );
                    const SvxBoxItem& rBox = (const SvxBoxItem&)aCoreSet2.Get(RES_BOX);
                    aDistLR.SetLeft((sal_uInt16)rBox.GetDistance(BOX_LINE_LEFT ));
                    aDistLR.SetRight((sal_uInt16)rBox.GetDistance(BOX_LINE_RIGHT));

                    //add the border distance of the paragraph
                    SfxItemSet aCoreSet1( GetPool(),
                                            RES_BOX, RES_BOX,
                                            0 );
                    rSh.GetCurAttr( aCoreSet1 );
                    const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSet1.Get(RES_BOX);
                    aDistLR.SetLeft(aDistLR.GetLeft() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_LEFT ));
                    aDistLR.SetRight(aDistLR.GetRight() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_RIGHT));
                    rSet.Put(aDistLR);
                    nLeftBorderDistance  = static_cast< sal_uInt16 >(aDistLR.GetLeft());
                    nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
                }
                else if ( !rSh.IsDirectlyInSection() )
                {
                    //get the page/header/footer border distance
                    const SwFrmFmt& rMaster = rDesc.GetMaster();
                    const SvxBoxItem& rBox = (const SvxBoxItem&)rMaster.GetAttrSet().Get(RES_BOX);
                    aDistLR.SetLeft((sal_uInt16)rBox.GetDistance(BOX_LINE_LEFT ));
                    aDistLR.SetRight((sal_uInt16)rBox.GetDistance(BOX_LINE_RIGHT));

                    const SvxBoxItem* pBox = 0;
                    if(nFrmType & FRMTYPE_HEADER)
                    {
                        rMaster.GetHeader();
                        const SwFmtHeader& rHeaderFmt = rMaster.GetHeader();
                        SwFrmFmt *pHeaderFmt = (SwFrmFmt*)rHeaderFmt.GetHeaderFmt();
                        if( pHeaderFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash
                            pBox = & (const SvxBoxItem&)pHeaderFmt->GetBox();
                    }
                    else if(nFrmType & FRMTYPE_FOOTER )
                    {
                        const SwFmtFooter& rFooterFmt = rMaster.GetFooter();
                        SwFrmFmt *pFooterFmt = (SwFrmFmt*)rFooterFmt.GetFooterFmt();
                        if( pFooterFmt )// #i80890# if rDesc is not the one belonging to the current page is might crash
                            pBox = & (const SvxBoxItem&)pFooterFmt->GetBox();
                    }
                    if(pBox)
                    {
                        aDistLR.SetLeft((sal_uInt16)pBox->GetDistance(BOX_LINE_LEFT ));
                        aDistLR.SetRight((sal_uInt16)pBox->GetDistance(BOX_LINE_RIGHT));
                    }

                    //add the border distance of the paragraph
                    SfxItemSet aCoreSetTmp( GetPool(),
                                            RES_BOX, RES_BOX,
                                            SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER, 0 );
                    rSh.GetCurAttr( aCoreSetTmp );
                    const SvxBoxItem& rParaBox = (const SvxBoxItem&)aCoreSetTmp.Get(RES_BOX);
                    aDistLR.SetLeft(aDistLR.GetLeft() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_LEFT ));
                    aDistLR.SetRight(aDistLR.GetRight() + (sal_uInt16)rParaBox.GetDistance(BOX_LINE_RIGHT));
                    rSet.Put(aDistLR);
                    nLeftBorderDistance  = static_cast< sal_uInt16 >(aDistLR.GetLeft());
                    nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
                }
            }
        }
        break;
        case SID_RULER_TEXT_RIGHT_TO_LEFT:
        {
            if ( nSelType & nsSelectionType::SEL_GRF ||
					nSelType & nsSelectionType::SEL_FRM ||
					nSelType & nsSelectionType::SEL_OLE ||
                    nFrmType == FRMTYPE_DRAWOBJ)
                rSet.DisableItem(nWhich);
            else
            {
                sal_Bool bFlag = rSh.IsInRightToLeftText();
                rSet.Put(SfxBoolItem(nWhich, bFlag));
            }
        }
        break;
        case SID_RULER_BORDERS_VERTICAL:
        case SID_RULER_BORDERS:
		{
            sal_Bool bFrameHasVerticalColumns(sal_False);
            {
                sal_Bool bFrameRTL;
                sal_Bool bFrameVertL2R;
                bFrameHasVerticalColumns = rSh.IsFrmVertical(sal_False, bFrameRTL, bFrameVertL2R) &&
                                           bFrmSelection;
            }
            sal_Bool bHasTable = ( IsTabColFromDoc() ||
                    ( rSh.GetTableFmt() && !bFrmSelection &&
                    !(nFrmType & FRMTYPE_COLSECT ) ) );

            sal_Bool bTableVertical = bHasTable && rSh.IsTableVertical();

            if( ( (SID_RULER_BORDERS_VERTICAL == nWhich) &&
                    ((bHasTable && !bTableVertical)||
                        (!bVerticalWriting && !bFrmSelection && !bHasTable ) || (bFrmSelection && !bFrameHasVerticalColumns)) ) ||
                ((SID_RULER_BORDERS == nWhich) &&
                    ((bHasTable && bTableVertical)||
                        (bVerticalWriting && !bFrmSelection&& !bHasTable) || bFrameHasVerticalColumns)))
                rSet.DisableItem(nWhich);
            else if ( bHasTable )
			{
				SwTabCols aTabCols;
				sal_uInt16	  nNum;
				if ( 0 != ( bSetTabColFromDoc = IsTabColFromDoc() ) )
				{
					rSh.GetMouseTabCols( aTabCols, aTabColFromDocPos );
					nNum = rSh.GetCurMouseTabColNum( aTabColFromDocPos );
				}
				else
				{
					rSh.GetTabCols( aTabCols );
					nNum = rSh.GetCurTabColNum();
                    if(rSh.IsTableRightToLeft())
                        nNum = aTabCols.Count() - nNum;
				}

				ASSERT(nNum <= aTabCols.Count(), "TabCol not found");
				const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft();
                const int nRgt = (sal_uInt16)(bTableVertical ? nPageHeight : nPageWidth) -
								  (aTabCols.GetLeftMin() +
								  aTabCols.GetRight());

                const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
                const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);

				SvxColumnItem aColItem(nNum, nL, nR);

				sal_uInt16 nStart = 0,
					   nEnd;

                //columns in right-to-left tables need to be mirrored
                sal_Bool bIsTableRTL =
                    IsTabColFromDoc() ?
                          rSh.IsMouseTableRightToLeft(aTabColFromDocPos)
                        : rSh.IsTableRightToLeft();
                if(bIsTableRTL)
                {
                    for ( sal_uInt16 i = aTabCols.Count(); i ; --i )
                    {
                        const SwTabColsEntry& rEntry = aTabCols.GetEntry( i - 1 );
                        nEnd  = (sal_uInt16)aTabCols.GetRight();
                        nEnd  = nEnd - (sal_uInt16)rEntry.nPos;
                        SvxColumnDescription aColDesc( nStart, nEnd,
                                    (sal_uInt16(aTabCols.GetRight() - rEntry.nMax)),
                                    (sal_uInt16(aTabCols.GetRight() - rEntry.nMin)),
                                                    !aTabCols.IsHidden(i - 1) );
                        aColItem.Append(aColDesc);
                        nStart = nEnd;
                    }
                    SvxColumnDescription aColDesc(nStart,
                                    aTabCols.GetRight() - aTabCols.GetLeft(), sal_True);
                    aColItem.Append(aColDesc);
                }
                else
                {
                    for ( sal_uInt16 i = 0; i < aTabCols.Count(); ++i )
                    {
                        const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
                        nEnd  = static_cast< sal_uInt16 >(rEntry.nPos - aTabCols.GetLeft());
                        SvxColumnDescription aColDesc( nStart, nEnd,
                                rEntry.nMin - aTabCols.GetLeft(), rEntry.nMax - aTabCols.GetLeft(),
                                                    !aTabCols.IsHidden(i) );
                        aColItem.Append(aColDesc);
                        nStart = nEnd;
                    }
                    SvxColumnDescription aColDesc(nStart, aTabCols.GetRight() - aTabCols.GetLeft(),
                                0, 0,
                                    sal_True);
                    aColItem.Append(aColDesc);
                }
				rSet.Put(aColItem, nWhich);
			}
			else if ( bFrmSelection || nFrmType & ( FRMTYPE_COLUMN | FRMTYPE_COLSECT ) )
			{
				// Aus Rahmen oder Seite ?
				sal_uInt16 nNum = 0;
				if(bFrmSelection)
				{
					const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt();
					if(pFmt)
						nNum = pFmt->GetCol().GetNumCols();
				}
				else
					nNum = rSh.GetCurColNum();

				if(
					//eigentlich sollte FRMTYPE_COLSECT nicht enthalten sein, wenn der Rahmen selektiert ist!
					!bFrmSelection &&
 					nFrmType & FRMTYPE_COLSECT )
				{
					const SwSection *pSect = rSh.GetAnySection(sal_False, pPt);
					ASSERT( pSect, "Welcher Bereich?");
					if( pSect )
					{
						SwSectionFmt *pFmt = pSect->GetFmt();
                        const SwFmtCol& rCol = pFmt->GetCol();
						if(rSh.IsInRightToLeftText())
							nNum = rCol.GetColumns().Count() - nNum;
						else
							--nNum;
						SvxColumnItem aColItem(nNum);
						SwRect aRect = rSh.GetAnyCurRect(RECT_SECTION_PRT, pPt);
                        const SwRect aTmpRect = rSh.GetAnyCurRect(RECT_SECTION, pPt);

						::lcl_FillSvxColumn(rCol, sal_uInt16(bVerticalWriting ? aRect.Height() : aRect.Width()), aColItem, 0);

						if(bVerticalWriting)
						{
							aRect.Pos() += Point(aTmpRect.Left(), aTmpRect.Top());
							aRect.Pos().Y() -= rPageRect.Top();
							aColItem.SetLeft ((sal_uInt16)(aRect.Top()));
                            aColItem.SetRight((sal_uInt16)(nPageHeight   - aRect.Bottom() ));
						}
						else
						{
							aRect.Pos() += aTmpRect.Pos();

                            // PAGES01
                            // make relative to page position:
					        aColItem.SetLeft ((sal_uInt16)( aRect.Left() - rPageRect.Left() ));
					        aColItem.SetRight((sal_uInt16)( rPageRect.Right() - aRect.Right()));
						}
						aColItem.SetOrtho(aColItem.CalcOrtho());

						rSet.Put(aColItem, nWhich);
					}
				}
				else if( bFrmSelection || nFrmType & FRMTYPE_FLY_ANY )
				{
					// Spalten in Rahmen
					if ( nNum  )
					{
						const SwFrmFmt* pFmt = rSh.GetFlyFrmFmt() ;

						const SwFmtCol& rCol = pFmt->GetCol();
						if(rSh.IsInRightToLeftText())
							nNum = rCol.GetColumns().Count() - nNum;
						else
							nNum--;
						SvxColumnItem aColItem(nNum);
						const SwRect &rSizeRect = rSh.GetAnyCurRect(RECT_FLY_PRT_EMBEDDED, pPt);

                        sal_Bool bUseVertical = bFrameHasVerticalColumns || (!bFrmSelection && bVerticalWriting);
                        const long lWidth = bUseVertical ? rSizeRect.Height() : rSizeRect.Width();
						const SwRect &rRect = rSh.GetAnyCurRect(RECT_FLY_EMBEDDED, pPt);
                        long nDist2 = ((bUseVertical ? rRect.Height() : rRect.Width()) - lWidth) /2;
						::lcl_FillSvxColumn(rCol, sal_uInt16(lWidth), aColItem, nDist2);

						SfxItemSet aFrameSet(GetPool(), RES_LR_SPACE, RES_LR_SPACE);
						rSh.GetFlyFrmAttr( aFrameSet );

                        if(bUseVertical)
						{
                            aColItem.SetLeft ((sal_uInt16)(rRect.Top()- rPageRect.Top()));
                            aColItem.SetRight((sal_uInt16)(nPageHeight + rPageRect.Top() - rRect.Bottom() ));
						}
						else
						{
							aColItem.SetLeft ((sal_uInt16)(rRect.Left() - rPageRect.Left()   ));
							aColItem.SetRight((sal_uInt16)(rPageRect.Right() - rRect.Right() ));
						}

						aColItem.SetOrtho(aColItem.CalcOrtho());

						rSet.Put(aColItem, nWhich);
					}
					else
                        rSet.DisableItem(nWhich);
				}
				else
				{	// Spalten auf der Seite
					const SwFrmFmt& rMaster = rDesc.GetMaster();
					SwFmtCol aCol(rMaster.GetCol());
					if(rFrameDir.GetValue() == FRMDIR_HORI_RIGHT_TOP)
						nNum = aCol.GetColumns().Count() - nNum;
					else
						nNum--;

					SvxColumnItem aColItem(nNum);
                    const SwRect aPrtRect = rSh.GetAnyCurRect(RECT_PAGE_PRT, pPt);
                    const SvxBoxItem& rBox = (const SvxBoxItem&)rMaster.GetFmtAttr(RES_BOX);
					long nDist = rBox.GetDistance();
                    ::lcl_FillSvxColumn(aCol,
                        sal_uInt16(bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width() ),
                        aColItem, nDist);

					if(bBrowse)
					{
						aColItem.SetLeft((sal_uInt16)rPagePrtRect.Left());
						aColItem.SetRight(sal_uInt16(nPageWidth - rPagePrtRect.Right()));
					}
					else
					{
						aColItem.SetLeft (aPageLRSpace.GetLeft());
						aColItem.SetRight(aPageLRSpace.GetRight());
					}
					aColItem.SetOrtho(aColItem.CalcOrtho());

					rSet.Put(aColItem, nWhich);
				}
			}
			else
                rSet.DisableItem(nWhich);
			break;
		}
        case SID_RULER_ROWS :
        case SID_RULER_ROWS_VERTICAL:
        {
            sal_Bool bFrameHasVerticalColumns(sal_False);
            {
                sal_Bool bFrameRTL;
                sal_Bool bFrameVertL2R;
                bFrameHasVerticalColumns = rSh.IsFrmVertical(sal_False, bFrameRTL, bFrameVertL2R) &&
                                           bFrmSelection;
            }

            if( ( (SID_RULER_ROWS == nWhich) &&
                    ((!bVerticalWriting && !bFrmSelection) || (bFrmSelection && !bFrameHasVerticalColumns)) ) ||
                ((SID_RULER_ROWS_VERTICAL == nWhich) &&
                    ((bVerticalWriting && !bFrmSelection) || bFrameHasVerticalColumns)))
                rSet.DisableItem(nWhich);
            else if ( IsTabRowFromDoc() ||
                    ( rSh.GetTableFmt() && !bFrmSelection &&
                    !(nFrmType & FRMTYPE_COLSECT ) ) )
            {
                SwTabCols aTabCols;
                //no current value necessary
                sal_uInt16    nNum = 0;
                if ( 0 != ( bSetTabRowFromDoc = IsTabRowFromDoc() ) )
                {
                    rSh.GetMouseTabRows( aTabCols, aTabColFromDocPos );
                }
                else
                {
                    rSh.GetTabRows( aTabCols );
                }

//                ASSERT(nNum <= aTabCols.Count(), "TabCol not found");
                const int nLft = aTabCols.GetLeftMin();
                const int nRgt = (sal_uInt16)(bVerticalWriting ? nPageWidth : nPageHeight) -
                                  (aTabCols.GetLeftMin() +
                                  aTabCols.GetRight());

                const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
                const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);

                SvxColumnItem aColItem(nNum, nL, nR);

                sal_uInt16 nStart = 0,
                       nEnd;

                for ( sal_uInt16 i = 0; i < aTabCols.Count(); ++i )
                {
                    const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
                    if(bVerticalWriting)
					{
                        nEnd  = sal_uInt16(aTabCols.GetRight() - rEntry.nPos);
                        SvxColumnDescription aColDesc( nStart, nEnd,
                            aTabCols.GetRight() - rEntry.nMax, aTabCols.GetRight() - rEntry.nMin,
													!aTabCols.IsHidden(i) );
						aColItem.Append(aColDesc);
					}
					else
					{
                        nEnd  = sal_uInt16(rEntry.nPos - aTabCols.GetLeft());
						SvxColumnDescription aColDesc( nStart, nEnd,
                                sal_uInt16(rEntry.nMin - aTabCols.GetLeft()), sal_uInt16(rEntry.nMax - aTabCols.GetLeft()),
													!aTabCols.IsHidden(i) );
						aColItem.Append(aColDesc);
					}
                    nStart = nEnd;
                }
                if(bVerticalWriting)
                    nEnd = static_cast< sal_uInt16 >(aTabCols.GetRight());
                else
                    nEnd = static_cast< sal_uInt16 >(aTabCols.GetLeft());
                // put a position protection when the last row cannot be moved
                // due to a page break inside of a row
                if(!aTabCols.IsLastRowAllowedToChange())
					bPutContentProtection = sal_True;

                SvxColumnDescription aColDesc( nStart, nEnd,
                    aTabCols.GetRight(), aTabCols.GetRight(),
                                            sal_False );
                aColItem.Append(aColDesc);

                rSet.Put(aColItem, nWhich);
            }
            else
                rSet.DisableItem(nWhich);
        }
        break;
		case SID_RULER_PAGE_POS:
		{
            // PAGES01
            SvxPagePosSizeItem aPagePosSize(
					Point( rPageRect.Left(), rPageRect.Top()) ,	nPageWidth, nPageHeight);

			rSet.Put(aPagePosSize);
			break;
		}
		case SID_RULER_LR_MIN_MAX:
		{
			Rectangle aRectangle;
			if( ( nFrmType & FRMTYPE_COLSECT ) && !IsTabColFromDoc() &&
				( nFrmType & ( FRMTYPE_TABLE|FRMTYPE_COLUMN ) ) )
			{
				if( nFrmType & FRMTYPE_TABLE )
				{
					const sal_uInt16 nNum = rSh.GetCurTabColNum();
					SwTabCols aTabCols;
					rSh.GetTabCols( aTabCols );

                    const int nLft = aTabCols.GetLeftMin() + aTabCols.GetLeft();
					const int nRgt = (sal_uInt16)nPageWidth -(aTabCols.GetLeftMin() + aTabCols.GetRight());

                    const sal_uInt16 nL = static_cast< sal_uInt16 >(nLft > 0 ? nLft : 0);
                    const sal_uInt16 nR = static_cast< sal_uInt16 >(nRgt > 0 ? nRgt : 0);

					aRectangle.Left() = nL;
					if(nNum > 1)
						aRectangle.Left() += aTabCols[nNum - 2];
					if(nNum)
						aRectangle.Left() += MINLAY;
					if(aTabCols.Count() <= nNum + 1 )
						aRectangle.Right() = nR;
					else
						aRectangle.Right() = nPageWidth - (nL + aTabCols[nNum + 1]);

					if(nNum < aTabCols.Count())
						aRectangle.Right() += MINLAY;
				}
				else
				{
					const SwFrmFmt* pFmt =  rSh.GetFlyFrmFmt();
					const SwFmtCol* pCols = pFmt ? &pFmt->GetCol():
												   &rDesc.GetMaster().GetCol();
					const SwColumns& rCols = pCols->GetColumns();
					sal_uInt16 nNum = rSh.GetCurOutColNum();
					sal_uInt16 nCount = Min(sal_uInt16(nNum + 1), rCols.Count());
					const SwRect aRect( rSh.GetAnyCurRect( pFmt
													? RECT_FLY_PRT_EMBEDDED
													: RECT_PAGE_PRT, pPt ));
					const SwRect aAbsRect( rSh.GetAnyCurRect( pFmt
													? RECT_FLY_EMBEDDED
													: RECT_PAGE, pPt ));

					//die Breite im Rahmen bzw. innerhalbe der Seitenraender
					const sal_uInt16 nTotalWidth = (sal_uInt16)aRect.Width();
					//die gesamte Rahmenbreite - die Differenz ist der doppelte Abstand zum Rand
					const sal_uInt16 nOuterWidth = (sal_uInt16)aAbsRect.Width();
					int nWidth = 0,
						nStart = 0,
						nEnd = 0;
					aRectangle.Left() = 0;
                    for ( sal_uInt16 i = 0; i < nCount; ++i )
					{
						SwColumn* pCol = rCols[i];
						nStart = pCol->GetLeft() + nWidth;
						if(i == nNum - 2)
							aRectangle.Left() = nStart;
						nWidth += pCols->CalcColWidth( i, nTotalWidth );
						nEnd = nWidth - pCol->GetRight();
					}
					aRectangle.Right() = rPageRect.Right() - nEnd;
					aRectangle.Left() -= rPageRect.Left();

                    if(nNum > 1)
					{
						aRectangle.Left() += MINLAY;
						aRectangle.Left() += aRect.Left();
					}
					if(pFmt) //Bereich in Rahmen - hier darf man bis zum Rand
						aRectangle.Left()  = aRectangle.Right() = 0;
					else
					{
						// das Rechteck an die richtige absolute Position verschieben
						aRectangle.Left() += aAbsRect.Left();
						aRectangle.Right() -= aAbsRect.Left();
						// Abstand zur Umrandung mit einbeziehen
						aRectangle.Right() -= (nOuterWidth - nTotalWidth) / 2;
					}

					if(nNum < rCols.Count())
					{
						aRectangle.Right() += MINLAY;
					}
					else
						// rechts ist jetzt nur noch der Seitenrand
						aRectangle.Right() = 0;


				}
			}
			else if ( ((nFrmType & FRMTYPE_TABLE) || IsTabColFromDoc()) &&
				 !bFrmSelection )
			{
				sal_Bool bColumn;
				if ( IsTabColFromDoc() )
					bColumn = rSh.GetCurMouseColNum( aTabColFromDocPos ) != 0;
				else
					bColumn = (nFrmType & (FRMTYPE_COLUMN|FRMTYPE_FLY_ANY|
											FRMTYPE_COLSECTOUTTAB)) ?
											sal_True : sal_False;
				if ( !bColumn )
				{
					if( nFrmType & FRMTYPE_FLY_ANY && IsTabColFromDoc() )
					{
						SwRect aRect( rSh.GetAnyCurRect(
											RECT_FLY_PRT_EMBEDDED, pPt ) );
						aRect.Pos() += rSh.GetAnyCurRect( RECT_FLY_EMBEDDED,
																pPt ).Pos();

						aRectangle.Left()  = aRect.Left() - rPageRect.Left();
						aRectangle.Right() = rPageRect.Right() - aRect.Right();
					}
					else if( bBrowse )
					{
						aRectangle.Left()  = rPagePrtRect.Left();
						aRectangle.Right() = nPageWidth - rPagePrtRect.Right();
					}
					else
					{
						aRectangle.Left()  = aPageLRSpace.GetLeft();
						aRectangle.Right() = aPageLRSpace.GetRight();
					}
				}
				else
				{	//hier nur fuer Tabelle in mehrspaltigen Seiten und Rahmen
					sal_Bool bSectOutTbl = (nFrmType & FRMTYPE_TABLE) ? sal_True : sal_False;
					sal_Bool bFrame = (nFrmType & FRMTYPE_FLY_ANY) ? sal_True : sal_False;
					sal_Bool bColSct = 	(nFrmType & ( bSectOutTbl
													? FRMTYPE_COLSECTOUTTAB
													: FRMTYPE_COLSECT )
												) ? sal_True : sal_False;
					//Damit man auch mit der Mouse ziehen kann,
					//ohne in der Tabelle zu stehen
					CurRectType eRecType = RECT_PAGE_PRT;
                    sal_uInt16 nNum = IsTabColFromDoc() ?
								rSh.GetCurMouseColNum( aTabColFromDocPos ):
								rSh.GetCurOutColNum();
					const SwFrmFmt* pFmt = NULL;
					if( bColSct )
					{
						eRecType = bSectOutTbl ? RECT_OUTTABSECTION
											   : RECT_SECTION;
						const SwSection *pSect = rSh.GetAnySection( bSectOutTbl, pPt );
						ASSERT( pSect, "Welcher Bereich?");
						pFmt = pSect->GetFmt();
					}
					else if( bFrame )
					{
						pFmt = rSh.GetFlyFrmFmt();
						eRecType = RECT_FLY_PRT_EMBEDDED;
					}

					const SwFmtCol* pCols = pFmt ? &pFmt->GetCol():
												   &rDesc.GetMaster().GetCol();
					const SwColumns& rCols = pCols->GetColumns();
					const sal_uInt16 nBorder = pFmt ? pFmt->GetBox().GetDistance() :
												  rDesc.GetMaster().GetBox().GetDistance();

					/* RECT_FLY_PRT_EMBEDDED returns the relative position to
						RECT_FLY_EMBEDDED
						the absolute position must be added here
					*/
					SwRect aRect( rSh.GetAnyCurRect( eRecType, pPt ) );
					if(RECT_FLY_PRT_EMBEDDED == eRecType)
						aRect.Pos() += rSh.GetAnyCurRect( RECT_FLY_EMBEDDED,
																pPt ).Pos();

					const sal_uInt16 nTotalWidth = (sal_uInt16)aRect.Width();
					//nStart und nEnd initialisieren fuer nNum == 0
					int nWidth = 0,
						nStart = 0,
						nEnd = nTotalWidth;

					if( nNum > rCols.Count() )
					{
						ASSERT( !this, "es wird auf dem falschen FmtCol gearbeitet!" );
						nNum = rCols.Count();
					}

                    for( sal_uInt16 i = 0; i < nNum; ++i )
					{
						SwColumn* pCol = rCols[i];
						nStart = pCol->GetLeft() + nWidth;
						nWidth += pCols->CalcColWidth( i, nTotalWidth );
						nEnd = nWidth - pCol->GetRight();
					}
					if( bFrame | bColSct )
					{
						aRectangle.Left()  = aRect.Left() - rPageRect.Left() + nStart;
						aRectangle.Right() = nPageWidth	- aRectangle.Left() - nEnd + nStart;
					}
					else if(!bBrowse)
					{
						aRectangle.Left()  = aPageLRSpace.GetLeft() + nStart;
						aRectangle.Right() = nPageWidth - nEnd - aPageLRSpace.GetLeft();
					}
					else
					{
						long nLeft = rPagePrtRect.Left();
						aRectangle.Left()  = nStart + nLeft;
						aRectangle.Right() = nPageWidth - nEnd - nLeft;
					}
					if(!bFrame)
					{
						aRectangle.Left() += nBorder;
						aRectangle.Right() -= nBorder;
					}
				}
			}
			else if ( nFrmType & ( FRMTYPE_HEADER  | FRMTYPE_FOOTER ))
			{
				aRectangle.Left()  = aPageLRSpace.GetLeft();
				aRectangle.Right() = aPageLRSpace.GetRight();
			}
			else
				aRectangle.Left()  = aRectangle.Right() = 0;

			SfxRectangleItem aLR( SID_RULER_LR_MIN_MAX , aRectangle);
			rSet.Put(aLR);
		}
		break;
		case SID_RULER_PROTECT:
		{
			if(bFrmSelection)
			{
				sal_uInt8 nProtect = pWrtShell->IsSelObjProtected( FLYPROTECT_SIZE|FLYPROTECT_POS|FLYPROTECT_CONTENT );

				SvxProtectItem aProt(SID_RULER_PROTECT);
				aProt.SetCntntProtect((nProtect & FLYPROTECT_CONTENT)	!= 0);
				aProt.SetSizeProtect ((nProtect & FLYPROTECT_SIZE)		!= 0);
				aProt.SetPosProtect  ((nProtect & FLYPROTECT_POS)		!= 0);
				rSet.Put(aProt);
			}
			else
			{
				SvxProtectItem aProtect(SID_RULER_PROTECT);
				if(bBrowse && !(nFrmType & (FRMTYPE_DRAWOBJ|FRMTYPE_COLUMN)) && !rSh.GetTableFmt())
				{
					aProtect.SetSizeProtect(sal_True);
					aProtect.SetPosProtect(sal_True);
				}
				rSet.Put(aProtect);
			}
		}
		break;
		}
		nWhich = aIter.NextWhich();
	}
    if(bPutContentProtection)
    {
        SvxProtectItem aProtect(SID_RULER_PROTECT);
        aProtect.SetCntntProtect(sal_True);
        rSet.Put(aProtect);
    }
}