    /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
    /*
     * This file is part of the LibreOffice project.
     *
     * This Source Code Form is subject to the terms of the Mozilla Public
     * License, v. 2.0. If a copy of the MPL was not distributed with this
     * file, You can obtain one at http://mozilla.org/MPL/2.0/.
     *
     * This file incorporates work covered by the following license notice:
     *
     *   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 .
     */

    #include <hintids.hxx>
    #include <uitool.hxx>
    #include <sfx2/app.hxx>
    #include <svx/rulritem.hxx>
    #include <svx/xfillit.hxx>
    #include <svx/xfillit0.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>
    #include <pagedesc.hxx>
    #include <wview.hxx>
    #include <fmtcol.hxx>
    #include <section.hxx>
    #include <swruler.hxx>

    #include <ndtxt.hxx>
    #include <pam.hxx>

    #include <IDocumentSettingAccess.hxx>

    #include <svx/xtable.hxx>

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

    // Pack columns
    static void lcl_FillSvxColumn(const SwFormatCol& rCol,
                              long nTotalWidth,
                              SvxColumnItem& rColItem,
                              long nDistance)
    {
        const SwColumns& rCols = rCol.GetColumns();

        bool bOrtho = rCol.IsOrtho() && rCols.size();
        long nInnerWidth = 0;
        if( bOrtho )
        {
            nInnerWidth = nTotalWidth;
            for (const auto & i : rCols)
            {
                nInnerWidth -= i.GetLeft() + i.GetRight();
            }
            if( nInnerWidth < 0 )
                nInnerWidth = 0;
            else
                nInnerWidth /= rCols.size();
        }

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

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

    // Transfer ColumnItem in ColumnInfo
    static void lcl_ConvertToCols(const SvxColumnItem& rColItem,
                              long nTotalWidth,
                              SwFormatCol& rCols)
    {
        OSL_ENSURE( rCols.GetNumCols() == rColItem.Count(), "Column count mismatch" );
        // 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;  // Sum up all columns and margins

        SwColumns& rArr = rCols.GetColumns();

        // Tabcols sequentially
        for( sal_uInt16 i=0; i < rColItem.Count()-1; ++i )
        {
            OSL_ENSURE(rColItem[i+1].nStart >= rColItem[i].nEnd,"overlapping columns" );
            const long nStart = std::max(rColItem[i+1].nStart, rColItem[i].nEnd);
            const sal_uInt16 nRight = static_cast<sal_uInt16>((nStart - rColItem[i].nEnd) / 2);

            const long nWidth = rColItem[i].nEnd - rColItem[i].nStart + nLeft + nRight;

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

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

        // The difference between the total sum of the desired width and the so far
        // calculated columns and margins should result in the width of the last column.
        rArr[rColItem.Count()-1].SetWishWidth( rCols.GetWishWidth() - static_cast<sal_uInt16>(nSumAll) );

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

    // Delete tabs
    static void lcl_EraseDefTabs(SvxTabStopItem& rTabStops)
    {
        // Delete DefTabs
        for ( sal_uInt16 i = 0; i < rTabStops.Count(); )
        {
            // Here also throw out the DefTab to zero
            if ( SvxTabAdjust::Default == rTabStops[i].GetAdjustment() ||
                rTabStops[i].GetTabPos() == 0 )
            {
                rTabStops.Remove(i);
                continue;
            }
            ++i;
        }
    }

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

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

    // If the frame border is moved, the column separator
    // should stay in the same absolute position.
    static void lcl_Scale(long& nVal, long nScale)
    {
        nVal *= nScale;
        nVal >>= 8;
    }

    void ResizeFrameCols(SwFormatCol& rCol,
                        long nOldWidth,
                        long nNewWidth,
                        long nLeftDelta )
    {
        SwColumns& rArr = rCol.GetColumns();
        long nWishSum = static_cast<long>(rCol.GetWishWidth());
        long nWishDiff = (nWishSum * 100/nOldWidth * nNewWidth) / 100 - nWishSum;
        long nNewWishWidth = nWishSum + nWishDiff;
        if(nNewWishWidth > 0xffffl)
        {
            // If the desired width is getting too large, then all values
            // must be scaled appropriately.
            long nScale = (0xffffl << 8)/ nNewWishWidth;
            for(SwColumn & i : rArr)
            {
                SwColumn* pCol = &i;
                long nVal = pCol->GetWishWidth();
                lcl_Scale(nVal, nScale);
                pCol->SetWishWidth(static_cast<sal_uInt16>(nVal));
                nVal = pCol->GetLeft();
                lcl_Scale(nVal, nScale);
                pCol->SetLeft(static_cast<sal_uInt16>(nVal));
                nVal = pCol->GetRight();
                lcl_Scale(nVal, nScale);
                pCol->SetRight(static_cast<sal_uInt16>(nVal));
            }
            lcl_Scale(nNewWishWidth, nScale);
            lcl_Scale(nWishDiff, nScale);
        }
        rCol.SetWishWidth( static_cast<sal_uInt16>(nNewWishWidth) );

        if( nLeftDelta >= 2 || nLeftDelta <= -2)
            rArr.front().SetWishWidth(rArr.front().GetWishWidth() + static_cast<sal_uInt16>(nWishDiff));
        else
            rArr.back().SetWishWidth(rArr.back().GetWishWidth() + static_cast<sal_uInt16>(nWishDiff));
        // Reset auto width
        rCol.SetOrtho(false, 0, 0 );
    }

    // Here all changes to the tab bar will be shot again into the model.
    void SwView::ExecTabWin( SfxRequest const & rReq )
    {
        SwWrtShell &rSh         = GetWrtShell();
        const FrameTypeFlags nFrameType   = rSh.IsObjSelected() ?
                                        FrameTypeFlags::DRAWOBJ :
                                            rSh.GetFrameType(nullptr,true);
        const bool bFrameSelection = rSh.IsFrameSelected();
        const bool bBrowse = rSh.GetViewOptions()->getBrowseMode();

        const sal_uInt16 nSlot      = rReq.GetSlot();
        const SfxItemSet* pReqArgs = rReq.GetArgs();
        const size_t nDescId    = rSh.GetCurPageDesc();
        const SwPageDesc& rDesc = rSh.GetPageDesc( nDescId );

        const bool bVerticalWriting = rSh.IsInVerticalText();
        const SwFormatHeader& rHeaderFormat = rDesc.GetMaster().GetHeader();
        SwFrameFormat *pHeaderFormat = const_cast<SwFrameFormat*>(rHeaderFormat.GetHeaderFormat());

        const SwFormatFooter& rFooterFormat = rDesc.GetMaster().GetFooter();
        SwFrameFormat *pFooterFormat = const_cast<SwFrameFormat*>(rFooterFormat.GetFooterFormat());

        const SwFormatFrameSize &rFrameSize = rDesc.GetMaster().GetFrameSize();

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

        bool bUnlockView = false;
        rSh.StartAllAction();
        bool bSect = bool(nFrameType & FrameTypeFlags::COLSECT);

        switch  (nSlot)
        {
        case SID_ATTR_LONG_LRSPACE:
            if ( pReqArgs )
            {
                SvxLongLRSpaceItem aLongLR( static_cast<const SvxLongLRSpaceItem&>(pReqArgs->
                                                            Get( SID_ATTR_LONG_LRSPACE )) );
                SvxLRSpaceItem aLR(RES_LR_SPACE);
                if ( !bSect && (bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY) )
                {
                    SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
                    const SwRect &rRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded);

                    bool bVerticalFrame(false);
                    {
                        bool bRTL;
                        bool bVertL2R;
                        bVerticalFrame = ( bFrameSelection &&
                                           rSh.IsFrameVertical(true, bRTL, bVertL2R) ) ||
                                         ( !bFrameSelection && bVerticalWriting);
                    }
                    long nDeltaX = bVerticalFrame ?
                        rRect.Right() - rPageRect.Right() + aLongLR.GetRight() :
                        rPageRect.Left() + aLongLR.GetLeft() - rRect.Left();

                    SfxItemSet aSet( GetPool(), svl::Items<RES_FRM_SIZE, RES_FRM_SIZE,
                                                RES_VERT_ORIENT, RES_HORI_ORIENT,
                                                RES_COL, RES_COL>{} );

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

                    SwFormatFrameSize aSize( pFormat->GetFrameSize() );
                    long nOldWidth = aSize.GetWidth();

                    if(aSize.GetWidthPercent())
                    {
                        SwRect aRect;
                        rSh.CalcBoundRect(aRect, RndStdIds::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( nFrameType & FrameTypeFlags::COLUMN )
                    {
                        SwFormatCol aCol(pFormat->GetCol());

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

                    aSet.Put( aSize );

                    rSh.StartAction();
                    rSh.Push();
                    rSh.SetFlyFrameAttr( aSet );
                    // Cancel the frame selection
                    if(!bFrameSelection && rSh.IsFrameSelected())
                    {
                        rSh.UnSelectFrame();
                        rSh.LeaveSelFrameMode();
                    }
                    rSh.Pop();
                    rSh.EndAction();
                }
                else if ( nFrameType & ( FrameTypeFlags::HEADER | FrameTypeFlags::FOOTER ))
                {
                    // Subtract out page margins
                    long nOld = rDesc.GetMaster().GetLRSpace().GetLeft();
                    aLongLR.SetLeft( nOld > aLongLR.GetLeft() ? 0 : aLongLR.GetLeft() - nOld );

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

                    if ( nFrameType & FrameTypeFlags::HEADER && pHeaderFormat )
                        pHeaderFormat->SetFormatAttr( aLR );
                    else if( nFrameType & FrameTypeFlags::FOOTER && pFooterFormat )
                        pFooterFormat->SetFormatAttr( aLR );
                }
                else if( nFrameType == FrameTypeFlags::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(CurRectType::SectionPrt);
                    const SwRect aTmpRect = rSh.GetAnyCurRect(CurRectType::Section);
                    aSectRect.Pos() += aTmpRect.Pos();
                    long nLeftDiff = aLongLR.GetLeft() - static_cast<long>(aSectRect.Left() - rPageRect.Left() );
                    long nRightDiff = aLongLR.GetRight() - static_cast<long>( rPageRect.Right() - aSectRect.Right());
                    //change the LRSpaceItem of the section accordingly
                    const SwSection* pCurrSect = rSh.GetCurrSection();
                    const SwSectionFormat* pSectFormat = pCurrSect->GetFormat();
                    SvxLRSpaceItem aLRTmp = pSectFormat->GetLRSpace();
                    aLRTmp.SetLeft(aLRTmp.GetLeft() + nLeftDiff);
                    aLRTmp.SetRight(aLRTmp.GetRight() + nRightDiff);
                    SfxItemSet aSet(rSh.GetAttrPool(), svl::Items<RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL>{});
                    aSet.Put(aLRTmp);
                    //change the first/last column
                    if(bSect)
                    {
                        SwFormatCol aCols( pSectFormat->GetCol() );
                        long nDiffWidth = nLeftDiff + nRightDiff;
                        ::ResizeFrameCols(aCols, aSectRect.Width(), aSectRect.Width() - nDiffWidth, nLeftDiff );
                        aSet.Put( aCols );
                    }
                    SwSectionData aData(*pCurrSect);
                    rSh.UpdateSection(rSh.GetSectionFormatPos(*pSectFormat), aData, &aSet);
                }
                else
                {   // Adjust page margins
                    aLR.SetLeft(aLongLR.GetLeft());
                    aLR.SetRight(aLongLR.GetRight());
                    SwapPageMargin( rDesc, aLR );
                    SwPageDesc aDesc( rDesc );
                    aDesc.GetMaster().SetFormatAttr( aLR );
                    rSh.ChgPageDesc( nDescId, aDesc );
                }
            }
            break;

        // apply new left and right margins to current page style
        case SID_ATTR_PAGE_LRSPACE:
            if ( pReqArgs )
            {
                const SvxLongLRSpaceItem aLongLR( pReqArgs->Get( SID_ATTR_PAGE_LRSPACE ) );

                SwPageDesc aDesc( rDesc );
                {
                    SvxLRSpaceItem aLR( RES_LR_SPACE );
                    aLR.SetLeft(aLongLR.GetLeft());
                    aLR.SetRight(aLongLR.GetRight());
                    SwapPageMargin( rDesc, aLR );
                    aDesc.GetMaster().SetFormatAttr( aLR );
                }
                rSh.ChgPageDesc( nDescId, aDesc );
            }
            break;

        case SID_ATTR_LONG_ULSPACE:
            if ( pReqArgs )
            {
                SvxLongULSpaceItem aLongULSpace( static_cast<const SvxLongULSpaceItem&>(pReqArgs->
                                                                Get( SID_ATTR_LONG_ULSPACE )));

                if( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY )
                {
                    SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
                    const SwRect &rRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded);
                    const long nDeltaY = rPageRect.Top() + aLongULSpace.GetUpper() - rRect.Top();
                    const long nHeight = nPageHeight - (aLongULSpace.GetUpper() + aLongULSpace.GetLower());

                    SfxItemSet aSet( GetPool(), svl::Items<RES_FRM_SIZE, RES_FRM_SIZE,
                                                RES_VERT_ORIENT, RES_HORI_ORIENT>{} );
                    //which of the orientation attributes is to be put depends on the frame's environment
                    bool bRTL;
                    bool bVertL2R;
                    if ( ( bFrameSelection &&
                           rSh.IsFrameVertical(true, bRTL, bVertL2R ) ) ||
                         ( !bFrameSelection && bVerticalWriting ) )
                    {
                        SwFormatHoriOrient aHoriOrient(pFormat->GetHoriOrient());
                        aHoriOrient.SetHoriOrient(text::HoriOrientation::NONE);
                        aHoriOrient.SetPos(aHoriOrient.GetPos() + nDeltaY );
                        aSet.Put( aHoriOrient );
                    }
                    else
                    {
                        SwFormatVertOrient aVertOrient(pFormat->GetVertOrient());
                        aVertOrient.SetVertOrient(text::VertOrientation::NONE);
                        aVertOrient.SetPos(aVertOrient.GetPos() + nDeltaY );
                        aSet.Put( aVertOrient );
                    }
                    SwFormatFrameSize aSize(pFormat->GetFrameSize());
                    if(aSize.GetHeightPercent())
                    {
                        SwRect aRect;
                        rSh.CalcBoundRect(aRect, RndStdIds::FLY_AS_CHAR);
                        long nPrtHeight = aRect.Height();
                        aSize.SetHeightPercent(sal_uInt8(nHeight * 100 /nPrtHeight));
                    }
                    else
                        aSize.SetHeight(nHeight );

                    aSet.Put( aSize );
                    rSh.SetFlyFrameAttr( aSet );
                }
                else if( nFrameType == FrameTypeFlags::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(CurRectType::SectionPrt);
                    const SwRect aTmpRect = rSh.GetAnyCurRect(CurRectType::Section);
                    aSectRect.Pos() += aTmpRect.Pos();
                    const long nLeftDiff = aLongULSpace.GetUpper() - static_cast<long>(aSectRect.Top() - rPageRect.Top());
                    const long nRightDiff = aLongULSpace.GetLower() - static_cast<long>(nPageHeight - aSectRect.Bottom() + rPageRect.Top());
                    //change the LRSpaceItem of the section accordingly
                    const SwSection* pCurrSect = rSh.GetCurrSection();
                    const SwSectionFormat* pSectFormat = pCurrSect->GetFormat();
                    SvxLRSpaceItem aLR = pSectFormat->GetLRSpace();
                    aLR.SetLeft(aLR.GetLeft() + nLeftDiff);
                    aLR.SetRight(aLR.GetRight() + nRightDiff);
                    SfxItemSet aSet(rSh.GetAttrPool(), svl::Items<RES_LR_SPACE, RES_LR_SPACE, RES_COL, RES_COL>{});
                    aSet.Put(aLR);
                    //change the first/last column
                    if(bSect)
                    {
                        SwFormatCol aCols( pSectFormat->GetCol() );
                        long nDiffWidth = nLeftDiff + nRightDiff;
                        ::ResizeFrameCols(aCols, aSectRect.Height(), aSectRect.Height() - nDiffWidth, nLeftDiff );
                        aSet.Put( aCols );
                    }
                    SwSectionData aData(*pCurrSect);
                    rSh.UpdateSection(rSh.GetSectionFormatPos(*pSectFormat), aData, &aSet);
                }
                else
                {   SwPageDesc aDesc( rDesc );

                    if ( nFrameType & ( FrameTypeFlags::HEADER | FrameTypeFlags::FOOTER ))
                    {

                        const bool bHead = bool(nFrameType & FrameTypeFlags::HEADER);
                        SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
                        if ( bHead )
                            aUL.SetUpper( static_cast<sal_uInt16>(aLongULSpace.GetUpper()) );
                        else
                            aUL.SetLower( static_cast<sal_uInt16>(aLongULSpace.GetLower()) );
                        aDesc.GetMaster().SetFormatAttr( aUL );

                        if( (bHead && pHeaderFormat) || (!bHead && pFooterFormat) )
                        {
                            SwFormatFrameSize aSz( bHead ? pHeaderFormat->GetFrameSize() :
                                                      pFooterFormat->GetFrameSize() );
                            aSz.SetHeightSizeType( ATT_FIX_SIZE );
                            aSz.SetHeight(nPageHeight - aLongULSpace.GetLower() -
                                                        aLongULSpace.GetUpper() );
                            if ( bHead )
                                pHeaderFormat->SetFormatAttr( aSz );
                            else
                                pFooterFormat->SetFormatAttr( aSz );
                        }
                    }
                    else
                    {
                        SvxULSpaceItem aUL(RES_UL_SPACE);
                        aUL.SetUpper(static_cast<sal_uInt16>(aLongULSpace.GetUpper()));
                        aUL.SetLower(static_cast<sal_uInt16>(aLongULSpace.GetLower()));
                        aDesc.GetMaster().SetFormatAttr(aUL);
                    }

                    rSh.ChgPageDesc( nDescId, aDesc );
                }
            }
            break;

        // apply new top and bottom margins to current page style
        case SID_ATTR_PAGE_ULSPACE:
            if ( pReqArgs )
            {
                SvxLongULSpaceItem aLongULSpace( pReqArgs->Get( SID_ATTR_PAGE_ULSPACE ) );

                SwPageDesc aDesc( rDesc );
                {
                    SvxULSpaceItem aUL(RES_UL_SPACE);
                    aUL.SetUpper(static_cast<sal_uInt16>(aLongULSpace.GetUpper()));
                    aUL.SetLower(static_cast<sal_uInt16>(aLongULSpace.GetLower()));
                    aDesc.GetMaster().SetFormatAttr(aUL);
                }
                rSh.ChgPageDesc( nDescId, aDesc );
            }
            break;

        case SID_ATTR_PAGE_COLUMN:
            if ( pReqArgs )
            {
                const SfxInt16Item aColumnItem( static_cast<const SfxInt16Item&>(pReqArgs->Get(nSlot)) );
                const sal_uInt16 nPageColumnType = aColumnItem.GetValue();

                // nPageColumnType =
                // 1 - single-columned page
                // 2 - two-columned page
                // 3 - three-columned page
                // 4 - two-columned page with left column width of 2/3 of page width
                // 5 - two-columned page with right column width of 2/3 of page width

                sal_uInt16 nCount = 2;
                if ( nPageColumnType == 1 )
                {
                    nCount = 0;
                }
                else if ( nPageColumnType == 3 )
                {
                    nCount = 3;
                }

                const sal_uInt16 nGutterWidth = 0;

                const SvxLRSpaceItem aLR( rDesc.GetMaster().GetLRSpace() );
                const long nLeft = aLR.GetLeft();
                const long nRight = aLR.GetRight();
                const long nWidth = nPageWidth - nLeft - nRight;

                SwFormatCol aCols( rDesc.GetMaster().GetCol() );
                aCols.Init( nCount, nGutterWidth, nWidth );
                aCols.SetWishWidth( nWidth );
                aCols.SetGutterWidth( nGutterWidth, nWidth );
                aCols.SetOrtho( false, nGutterWidth, nWidth );

                long nColumnLeft = 0;
                long nColumnRight = 0;
                if ( nPageColumnType == 4 )
                {
                    nColumnRight = static_cast<long>(nWidth/3);
                    nColumnLeft = nWidth - nColumnRight;
                    aCols.GetColumns()[0].SetWishWidth( nColumnLeft );
                    aCols.GetColumns()[1].SetWishWidth( nColumnRight );
                }
                else if ( nPageColumnType == 5 )
                {
                    nColumnLeft = static_cast<long>(nWidth/3);
                    nColumnRight = nWidth - nColumnLeft;
                    aCols.GetColumns()[0].SetWishWidth( nColumnLeft );
                    aCols.GetColumns()[1].SetWishWidth( nColumnRight );
                }

                SwPageDesc aDesc( rDesc );
                aDesc.GetMaster().SetFormatAttr( aCols );
                rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc );
            }
            break;

        case SID_ATTR_TABSTOP_VERTICAL:
        case SID_ATTR_TABSTOP:
            if (pReqArgs)
            {
                const sal_uInt16 nWhich = GetPool().GetWhich(nSlot);
                SvxTabStopItem aTabStops( static_cast<const SvxTabStopItem&>(pReqArgs->
                                                            Get( nWhich )));
                aTabStops.SetWhich(RES_PARATR_TABSTOP);
                 const SvxTabStopItem& rDefTabs = rSh.GetDefault(RES_PARATR_TABSTOP);

                // Default tab at pos 0
                SfxItemSet aSet( GetPool(), svl::Items<RES_LR_SPACE, RES_LR_SPACE>{} );
                rSh.GetCurAttr( aSet );
                const SvxLRSpaceItem& rLR = aSet.Get(RES_LR_SPACE);

                if ( rLR.GetTextFirstLineOfst() < 0 )
                {
                    SvxTabStop aSwTabStop( 0, SvxTabAdjust::Default );
                    aTabStops.Insert( aSwTabStop );
                }

                // Populate with default tabs.
                ::MakeDefTabs( ::GetTabDist( rDefTabs ), aTabStops );

                SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
                if( pColl && pColl->IsAutoUpdateFormat() )
                {
                    SfxItemSet aTmp(GetPool(), svl::Items<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP>{});
                    aTmp.Put(aTabStops);
                    rSh.AutoUpdatePara( pColl, aTmp );
                }
                else
                    rSh.SetAttrItem( aTabStops );
            }
            break;

        case SID_HANGING_INDENT:
        {
            SfxItemSet aLRSpaceSet( GetPool(), svl::Items<RES_LR_SPACE, RES_LR_SPACE>{} );
            rSh.GetCurAttr( aLRSpaceSet );
            SvxLRSpaceItem aParaMargin( aLRSpaceSet.Get( RES_LR_SPACE ) );

            SvxLRSpaceItem aNewMargin( RES_LR_SPACE );
            aNewMargin.SetTextLeft( aParaMargin.GetTextLeft() + aParaMargin.GetTextFirstLineOfst() );
            aNewMargin.SetRight( aParaMargin.GetRight() );
            aNewMargin.SetTextFirstLineOfst( (aParaMargin.GetTextFirstLineOfst()) * -1 );

            rSh.SetAttrItem( aNewMargin );
            break;
        }

        case SID_ATTR_PARA_LRSPACE_VERTICAL:
        case SID_ATTR_PARA_LRSPACE:
            if ( pReqArgs )
            {
                SvxLRSpaceItem aParaMargin(static_cast<const SvxLRSpaceItem&>(pReqArgs->Get(nSlot)));

                aParaMargin.SetRight( aParaMargin.GetRight() - m_nRightBorderDistance );
                aParaMargin.SetTextLeft(aParaMargin.GetTextLeft() - m_nLeftBorderDistance );

                aParaMargin.SetWhich( RES_LR_SPACE );
                SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();

                // #i23726#
                if (m_pNumRuleNodeFromDoc)
                {
                    // --> #i42922# Mouse move of numbering label
                    // has to consider the left indent of the paragraph
                    SfxItemSet aSet( GetPool(), svl::Items<RES_LR_SPACE, RES_LR_SPACE>{} );
                    rSh.GetCurAttr( aSet );
                    const SvxLRSpaceItem& rLR = aSet.Get(RES_LR_SPACE);

                    SwPosition aPos(*m_pNumRuleNodeFromDoc);
                    // #i90078#
                    rSh.SetIndent( static_cast< short >(aParaMargin.GetTextLeft() - rLR.GetTextLeft()), aPos);
                    // #i42921# invalidate state of indent in order to get a ruler update.
                    aParaMargin.SetWhich( nSlot );
                    GetViewFrame()->GetBindings().SetState( aParaMargin );
                }
                else if( pColl && pColl->IsAutoUpdateFormat() )
                {
                    SfxItemSet aSet(GetPool(), svl::Items<RES_LR_SPACE, RES_LR_SPACE>{});
                    aSet.Put(aParaMargin);
                    rSh.AutoUpdatePara( pColl, aSet);
                }
                else
                    rSh.SetAttrItem( aParaMargin );

                if ( aParaMargin.GetTextFirstLineOfst() < 0 )
                {
                    SfxItemSet aSet( GetPool(), svl::Items<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP>{} );

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

                    // Do we have a tab at position zero?
                    sal_uInt16 i;

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

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

                        ::lcl_EraseDefTabs(aTabStops);

                        SvxTabStop aSwTabStop( 0, SvxTabAdjust::Default );
                        aTabStops.Insert(aSwTabStop);

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

                        if( pColl && pColl->IsAutoUpdateFormat())
                        {
                            SfxItemSet aSetTmp(GetPool(), svl::Items<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP>{});
                            aSetTmp.Put(aTabStops);
                            rSh.AutoUpdatePara( pColl, aSetTmp );
                        }
                        else
                            rSh.SetAttrItem( aTabStops );
                    }
                }
            }
            break;

        case SID_ATTR_PARA_ULSPACE:
            if ( pReqArgs )
            {
                SvxULSpaceItem aParaMargin(static_cast<const SvxULSpaceItem&>(pReqArgs->Get(nSlot)));

                aParaMargin.SetUpper( aParaMargin.GetUpper() );
                aParaMargin.SetLower(aParaMargin.GetLower());

                aParaMargin.SetWhich( RES_UL_SPACE );
                SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
                if( pColl && pColl->IsAutoUpdateFormat() )
                {
                    SfxItemSet aSet(GetPool(), svl::Items<RES_UL_SPACE, RES_UL_SPACE>{});
                    aSet.Put(aParaMargin);
                    rSh.AutoUpdatePara( pColl, aSet);
                }
                else
                    rSh.SetAttrItem( aParaMargin );
            }
            break;
        case SID_PARASPACE_INCREASE:
        case SID_PARASPACE_DECREASE:
            {
                SfxItemSet aULSpaceSet( GetPool(), svl::Items<RES_UL_SPACE, RES_UL_SPACE>{} );
                rSh.GetCurAttr( aULSpaceSet );
                SvxULSpaceItem aULSpace( aULSpaceSet.Get( RES_UL_SPACE ) );
                sal_uInt16 nUpper = aULSpace.GetUpper();
                sal_uInt16 nLower = aULSpace.GetLower();

                if ( nSlot == SID_PARASPACE_INCREASE )
                {
                    nUpper = std::min< sal_uInt16 >( nUpper + 57, 5670 );
                    nLower = std::min< sal_uInt16 >( nLower + 57, 5670 );
                }
                else
                {
                    nUpper = std::max< sal_Int16 >( nUpper - 57, 0 );
                    nLower = std::max< sal_Int16 >( nLower - 57, 0 );
                }

                aULSpace.SetUpper( nUpper );
                aULSpace.SetLower( nLower );

                SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
                if( pColl && pColl->IsAutoUpdateFormat() )
                {
                    aULSpaceSet.Put( aULSpace );
                    rSh.AutoUpdatePara( pColl, aULSpaceSet );
                }
                else
                    rSh.SetAttrItem( aULSpace );
            }
            break;

        case SID_RULER_CHANGE_STATE:
            {
                const SfxPoolItem *pMargin1, *pMargin2;
                if ( pReqArgs &&
                     pReqArgs->GetItemState(SID_RULER_MARGIN1,true,&pMargin1) == SfxItemState::SET )
                {
                    const OUString ratio = static_cast<const SfxStringItem*>(pMargin1)->GetValue();
                    GetHRuler().SetValues(RulerChangeType::MARGIN1, GetHRuler().GetPageWidth() * ratio.toFloat());
                }
                else if ( pReqArgs &&
                     pReqArgs->GetItemState(SID_RULER_MARGIN2,true,&pMargin2) == SfxItemState::SET )
                {
                    const OUString ratio = static_cast<const SfxStringItem*>(pMargin2)->GetValue();
                    GetHRuler().SetValues(RulerChangeType::MARGIN2, GetHRuler().GetPageWidth() * ratio.toFloat());
                }
            }
            break;
        case SID_RULER_BORDERS_VERTICAL:
        case SID_RULER_BORDERS:
            if ( pReqArgs )
            {
                SvxColumnItem aColItem(static_cast<const SvxColumnItem&>(pReqArgs->Get(nSlot)));

                if( m_bSetTabColFromDoc || (!bSect && rSh.GetTableFormat()) )
                {
                    OSL_ENSURE(aColItem.Count(), "ColDesc is empty!!");

                    const bool bSingleLine = rReq.
                                    GetArgs()->Get(SID_RULER_ACT_LINE_ONLY).GetValue();

                    SwTabCols aTabCols;
                    if ( m_bSetTabColFromDoc )
                        rSh.GetMouseTabCols( aTabCols, m_aTabColFromDocPos );
                    else
                        rSh.GetTabCols(aTabCols);

                    // left table border
                    long nBorder = static_cast<long>(aColItem.GetLeft() - aTabCols.GetLeftMin());
                    aTabCols.SetLeft( nBorder );

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

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

                    // Tabcols sequentially
                    // The last column is defined by the edge.
                    // Columns in right-to-left tables need to be mirrored
                    bool bIsTableRTL =
                        IsTabColFromDoc() ?
                              rSh.IsMouseTableRightToLeft(m_aTabColFromDocPos)
                            : rSh.IsTableRightToLeft();
                    const size_t nColCount = aColItem.Count() - 1;
                    if(bIsTableRTL)
                    {
                        for ( size_t i = 0; i < nColCount && i < aTabCols.Count(); ++i )
                        {
                            const SvxColumnDescription& rCol = aColItem[nColCount - i];
                            aTabCols[i] = aTabCols.GetRight() - rCol.nStart;
                            aTabCols.SetHidden( i, !rCol.bVisible );
                        }
                    }
                    else
                    {
                        for ( size_t i = 0; i < nColCount && i < aTabCols.Count(); ++i )
                        {
                            const SvxColumnDescription& rCol = aColItem[i];
                            aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
                            aTabCols.SetHidden( i, !rCol.bVisible );
                        }
                    }

                    if ( m_bSetTabColFromDoc )
                    {
                        if( !rSh.IsViewLocked() )
                        {
                            bUnlockView = true;
                            rSh.LockView( true );
                        }
                        rSh.SetMouseTabCols( aTabCols, bSingleLine,
                                                       m_aTabColFromDocPos );
                    }
                    else
                        rSh.SetTabCols(aTabCols, bSingleLine);

                }
                else
                {
                    if ( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY || bSect)
                    {
                        SwSectionFormat *pSectFormat = nullptr;
                        SfxItemSet aSet( GetPool(), svl::Items<RES_COL, RES_COL>{} );
                        if(bSect)
                        {
                            SwSection *pSect = rSh.GetAnySection();
                            OSL_ENSURE( pSect, "Which section?");
                            pSectFormat = pSect->GetFormat();
                        }
                        else
                        {
                            rSh.GetFlyFrameAttr( aSet );
                        }
                        SwFormatCol aCols(
                            bSect ?
                                pSectFormat->GetCol() :
                                    aSet.Get( RES_COL, false ));
                        SwRect aCurRect = rSh.GetAnyCurRect(bSect ? CurRectType::SectionPrt : CurRectType::FlyEmbeddedPrt);
                        const long lWidth = bVerticalWriting ? aCurRect.Height() : aCurRect.Width();
                        ::lcl_ConvertToCols( aColItem, lWidth, aCols );
                        aSet.Put( aCols );
                        if(bSect)
                            rSh.SetSectionAttr( aSet, pSectFormat );
                        else
                        {
                            rSh.StartAction();
                            rSh.Push();
                            rSh.SetFlyFrameAttr( aSet );
                            // Cancel the frame selection again
                            if(!bFrameSelection && rSh.IsFrameSelected())
                            {
                                rSh.UnSelectFrame();
                                rSh.LeaveSelFrameMode();
                            }
                            rSh.Pop();
                            rSh.EndAction();
                        }
                    }
                    else
                    {
                        SwFormatCol aCols( rDesc.GetMaster().GetCol() );
                        const SwRect aPrtRect = rSh.GetAnyCurRect(CurRectType::PagePrt);
                        ::lcl_ConvertToCols( aColItem,
                                        bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width(),
                                        aCols );
                        SwPageDesc aDesc( rDesc );
                        aDesc.GetMaster().SetFormatAttr( aCols );
                        rSh.ChgPageDesc( rSh.GetCurPageDesc(), aDesc );
                    }
                }
            }
            break;

        case SID_RULER_ROWS :
        case SID_RULER_ROWS_VERTICAL:
            if (pReqArgs)
            {
                SvxColumnItem aColItem(static_cast<const SvxColumnItem&>(pReqArgs->Get(nSlot)));

                if( m_bSetTabColFromDoc || (!bSect && rSh.GetTableFormat()) )
                {
                    OSL_ENSURE(aColItem.Count(), "ColDesc is empty!!");

                    SwTabCols aTabCols;
                    if ( m_bSetTabRowFromDoc )
                        rSh.GetMouseTabRows( aTabCols, m_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 );
                    }

                    const size_t nColItems = aColItem.Count() - 1;
                    if(bVerticalWriting)
                    {
                        for ( size_t i = nColItems; 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 ( size_t i = 0; i < nColItems; ++i )
                        {
                            const SvxColumnDescription& rCol = aColItem[i];
                            aTabCols[i] = rCol.nEnd + aTabCols.GetLeft();
                            aTabCols.SetHidden( i, !rCol.bVisible );
                        }
                    }
                    bool bSingleLine = false;
                    const SfxPoolItem* pSingleLine;
                    if( SfxItemState::SET == rReq.GetArgs()->GetItemState(SID_RULER_ACT_LINE_ONLY, false, &pSingleLine))
                        bSingleLine = static_cast<const SfxBoolItem*>(pSingleLine)->GetValue();
                    if ( m_bSetTabRowFromDoc )
                    {
                        if( !rSh.IsViewLocked() )
                        {
                            bUnlockView = true;
                            rSh.LockView( true );
                        }
                        rSh.SetMouseTabRows( aTabCols, bSingleLine, m_aTabColFromDocPos );
                    }
                    else
                        rSh.SetTabRows(aTabCols, bSingleLine);
                }
            }
            break;

        case SID_ATTR_PAGE_HEADER:
        {
            if ( pReqArgs )
            {
                const bool bHeaderOn =  static_cast<const SfxBoolItem&>(pReqArgs->Get(SID_ATTR_PAGE_HEADER)).GetValue();
                SwPageDesc aDesc(rDesc);
                SwFrameFormat &rMaster = aDesc.GetMaster();
                rMaster.SetFormatAttr( SwFormatHeader( bHeaderOn ));
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;
        case SID_ATTR_PAGE_HEADER_LRMARGIN:
        {
            if ( pReqArgs && rDesc.GetMaster().GetHeader().IsActive() )
            {
                const SvxLongLRSpaceItem& aLongLR = static_cast<const SvxLongLRSpaceItem&>(pReqArgs->Get(SID_ATTR_PAGE_HEADER_LRMARGIN));
                SvxLRSpaceItem aLR(RES_LR_SPACE);
                SwPageDesc aDesc(rDesc);
                aLR.SetLeft(aLongLR.GetLeft());
                aLR.SetRight(aLongLR.GetRight());
                SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(aDesc.GetMaster().GetHeader().GetHeaderFormat());
                pFormat->SetFormatAttr( aLR );
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;
        case SID_ATTR_PAGE_HEADER_SPACING:
        {
            if ( pReqArgs && rDesc.GetMaster().GetHeader().IsActive())
            {
                const SvxLongULSpaceItem& aLongUL = static_cast<const SvxLongULSpaceItem&>(pReqArgs->Get(SID_ATTR_PAGE_HEADER_SPACING));
                SwPageDesc aDesc(rDesc);
                SvxULSpaceItem aUL(0, aLongUL.GetLower(), RES_UL_SPACE );
                SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(aDesc.GetMaster().GetHeader().GetHeaderFormat());
                pFormat->SetFormatAttr( aUL );
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;
        case SID_ATTR_PAGE_HEADER_LAYOUT:
        {
            if ( pReqArgs && rDesc.GetMaster().GetHeader().IsActive())
            {
                const SfxInt16Item& aLayoutItem = static_cast<const SfxInt16Item&>(pReqArgs->Get(SID_ATTR_PAGE_HEADER_LAYOUT));
                sal_uInt16 nLayout = aLayoutItem.GetValue();
                SwPageDesc aDesc(rDesc);
                aDesc.ChgHeaderShare((nLayout>>1) == 0);
                aDesc.ChgFirstShare((nLayout % 2) == 0); // FIXME control changes for both header footer - tdf#100287
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;
        case SID_ATTR_PAGE_FOOTER:
        {
            if ( pReqArgs )
            {
                const bool bFooterOn =  static_cast<const SfxBoolItem&>(pReqArgs->Get(SID_ATTR_PAGE_FOOTER)).GetValue();
                SwPageDesc aDesc(rDesc);
                SwFrameFormat &rMaster = aDesc.GetMaster();
                rMaster.SetFormatAttr( SwFormatFooter( bFooterOn ));
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;
        case SID_ATTR_PAGE_FOOTER_LRMARGIN:
        {
            if ( pReqArgs && rDesc.GetMaster().GetFooter().IsActive() )
            {
                const SvxLongLRSpaceItem& aLongLR = static_cast<const SvxLongLRSpaceItem&>(pReqArgs->Get(SID_ATTR_PAGE_FOOTER_LRMARGIN));
                SvxLRSpaceItem aLR(RES_LR_SPACE);
                SwPageDesc aDesc(rDesc);
                aLR.SetLeft(aLongLR.GetLeft());
                aLR.SetRight(aLongLR.GetRight());
                SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(aDesc.GetMaster().GetFooter().GetFooterFormat());
                pFormat->SetFormatAttr( aLR );
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;
        case SID_ATTR_PAGE_FOOTER_SPACING:
        {
            if ( pReqArgs && rDesc.GetMaster().GetFooter().IsActive())
            {
                const SvxLongULSpaceItem& aLongUL = static_cast<const SvxLongULSpaceItem&>(pReqArgs->Get(SID_ATTR_PAGE_FOOTER_SPACING));
                SwPageDesc aDesc(rDesc);
                SvxULSpaceItem aUL(aLongUL.GetUpper(), 0, RES_UL_SPACE );
                SwFrameFormat* pFormat = const_cast<SwFrameFormat*>(aDesc.GetMaster().GetFooter().GetFooterFormat());
                pFormat->SetFormatAttr( aUL );
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;
        case SID_ATTR_PAGE_FOOTER_LAYOUT:
        {
            if ( pReqArgs && rDesc.GetMaster().GetFooter().IsActive())
            {
                const SfxInt16Item& aLayoutItem = static_cast<const SfxInt16Item&>(pReqArgs->Get(SID_ATTR_PAGE_FOOTER_LAYOUT));
                sal_uInt16 nLayout = aLayoutItem.GetValue();
                SwPageDesc aDesc(rDesc);
                aDesc.ChgFooterShare((nLayout>>1) == 0);
                aDesc.ChgFirstShare((nLayout % 2) == 0); // FIXME control changes for both header footer - tdf#100287
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;

        case SID_ATTR_PAGE_COLOR:
        case SID_ATTR_PAGE_FILLSTYLE:
        case SID_ATTR_PAGE_GRADIENT:
        case SID_ATTR_PAGE_HATCH:
        case SID_ATTR_PAGE_BITMAP:
        {
            if(pReqArgs)
            {
                SwPageDesc aDesc(rDesc);
                SwFrameFormat &rMaster = aDesc.GetMaster();
                switch (nSlot)
                {
                    case SID_ATTR_PAGE_FILLSTYLE:
                    {
                        XFillStyleItem aFSItem( pReqArgs->Get( XATTR_FILLSTYLE ) );
                        drawing::FillStyle eXFS = aFSItem.GetValue();

                        if ( eXFS == drawing::FillStyle_NONE )
                             rMaster.SetFormatAttr( XFillStyleItem( eXFS ) );
                    }
                    break;

                    case SID_ATTR_PAGE_COLOR:
                    {
                        XFillColorItem aColorItem( pReqArgs->Get( XATTR_FILLCOLOR ) );
                        rMaster.SetFormatAttr( XFillStyleItem( drawing::FillStyle_SOLID ) );
                        rMaster.SetFormatAttr( aColorItem );
                    }
                    break;

                    case SID_ATTR_PAGE_GRADIENT:
                    {
                        XFillGradientItem aGradientItem( pReqArgs->Get( XATTR_FILLGRADIENT ) );
                        rMaster.SetFormatAttr( XFillStyleItem( drawing::FillStyle_GRADIENT ) );
                        rMaster.SetFormatAttr( aGradientItem );
                    }
                    break;

                    case SID_ATTR_PAGE_HATCH:
                    {
                        XFillHatchItem aHatchItem( pReqArgs->Get( XATTR_FILLHATCH ) );
                        rMaster.SetFormatAttr( XFillStyleItem( drawing::FillStyle_HATCH ) );
                        rMaster.SetFormatAttr( aHatchItem );
                    }
                    break;

                    case SID_ATTR_PAGE_BITMAP:
                    {
                        XFillBitmapItem aBitmapItem( pReqArgs->Get( XATTR_FILLBITMAP ) );
                        rMaster.SetFormatAttr( XFillStyleItem( drawing::FillStyle_BITMAP ) );
                        rMaster.SetFormatAttr( aBitmapItem );
                    }
                    break;

                    default:
                    break;
                }
                rSh.ChgPageDesc(rSh.GetCurPageDesc(), aDesc);
            }
        }
        break;

        default:
            OSL_ENSURE( false, "wrong SlotId");
        }
        rSh.EndAllAction();

        if( bUnlockView )
            rSh.LockView( false );

        m_bSetTabColFromDoc = m_bSetTabRowFromDoc = m_bTabColFromDoc = m_bTabRowFromDoc = false;
        SetNumRuleNodeFromDoc(nullptr);
    }

    // Here the status of the tab bar will be determined.
    // This means that all relevant attributes at the CursorPos
    // will be submitted to the tab bar.
    void SwView::StateTabWin(SfxItemSet& rSet)
    {
        SwWrtShell &rSh         = GetWrtShell();

        const Point* pPt = IsTabColFromDoc() || IsTabRowFromDoc() ? &m_aTabColFromDocPos : nullptr;
        const FrameTypeFlags nFrameType   = rSh.IsObjSelected()
                    ? FrameTypeFlags::DRAWOBJ
                    : rSh.GetFrameType( pPt, true );

        const bool  bFrameSelection = rSh.IsFrameSelected();
        const bool bBrowse = rSh.GetViewOptions()->getBrowseMode();
        // PageOffset/limiter
        const SwRect& rPageRect = rSh.GetAnyCurRect( CurRectType::Page, pPt );
        const SwRect& rPagePrtRect = rSh.GetAnyCurRect( CurRectType::PagePrt, pPt );
        const long nPageWidth  = rPageRect.Width();
        const long nPageHeight = rPageRect.Height();

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

        const SvxFrameDirectionItem& rFrameDir = rDesc.GetMaster().GetFrameDir();
        const bool bVerticalWriting = rSh.IsInVerticalText();

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

        //#i24363# tab stops relative to indent
        bool bRelative = rSh.getIDocumentSettingAccess().get(DocumentSettingId::TABS_RELATIVE_TO_INDENT);
        m_pHRuler->SetTabsRelativeToIndent( bRelative );
        m_pVRuler->SetTabsRelativeToIndent( bRelative );

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

        SfxItemSet aCoreSet( GetPool(), svl::Items<RES_PARATR_TABSTOP, RES_PARATR_TABSTOP,
                                        RES_LR_SPACE,        RES_UL_SPACE>{} );
        // get also the list level indent values merged as LR-SPACE item, if needed.
        rSh.GetCurAttr( aCoreSet, true );
        const SelectionType nSelType = rSh.GetSelectionType();

        SfxWhichIter aIter( rSet );
        sal_uInt16 nWhich = aIter.FirstWhich();

        while ( nWhich )
        {
            switch ( nWhich )
            {

            case SID_ATTR_PAGE_COLUMN:
            {
                sal_uInt16 nColumnType = 0;

                const SwFrameFormat& rMaster = rDesc.GetMaster();
                const SwFormatCol& aCol(rMaster.GetCol());
                const sal_uInt16 nCols = aCol.GetNumCols();
                if ( nCols == 0 )
                {
                    nColumnType = 1;
                }
                else if ( nCols == 2 )
                {
                    const sal_uInt16 nColLeft = aCol.CalcPrtColWidth(0, aCol.GetWishWidth());
                    const sal_uInt16 nColRight = aCol.CalcPrtColWidth(1, aCol.GetWishWidth());

                    if ( abs(nColLeft - nColRight) <= 10 )
                    {
                        nColumnType = 2;
                    }
                    else if( abs(nColLeft - nColRight*2) < 20 )
                    {
                        nColumnType = 4;
                    }
                    else if( abs(nColLeft*2 - nColRight) < 20 )
                    {
                        nColumnType = 5;
                    }
                }
                else if( nCols == 3 )
                {
                    nColumnType = 3;
                }
                else
                    nColumnType = nCols;

                rSet.Put( SfxInt16Item( SID_ATTR_PAGE_COLUMN, nColumnType ) );
            }
            break;

            case SID_ATTR_LONG_LRSPACE:
            {
                SvxLongLRSpaceItem aLongLR( aPageLRSpace.GetLeft(),
                                            aPageLRSpace.GetRight(),
                                            SID_ATTR_LONG_LRSPACE);
                if(bBrowse)
                {
                    aLongLR.SetLeft(rPagePrtRect.Left());
                    aLongLR.SetRight(nPageWidth - rPagePrtRect.Right());
                }
                if ( ( nFrameType & FrameTypeFlags::HEADER || nFrameType & FrameTypeFlags::FOOTER ) &&
                     !(nFrameType & FrameTypeFlags::COLSECT) )
                {
                    SwFrameFormat *pFormat = const_cast<SwFrameFormat*>((nFrameType & FrameTypeFlags::HEADER) ?
                                    rDesc.GetMaster().GetHeader().GetHeaderFormat() :
                                    rDesc.GetMaster().GetFooter().GetFooterFormat());
                    if( pFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
                    {
                        SwRect aRect( rSh.GetAnyCurRect( CurRectType::HeaderFooter, pPt));
                        aRect.Pos() -= rSh.GetAnyCurRect( CurRectType::Page, pPt ).Pos();
                        const SvxLRSpaceItem& aLR = pFormat->GetLRSpace();
                        aLongLR.SetLeft ( aLR.GetLeft() + aRect.Left() );
                        aLongLR.SetRight( nPageWidth - aRect.Right() + aLR.GetRight() );
                    }
                }
                else
                {
                    SwRect aRect;
                    if( !bFrameSelection && ((nFrameType & FrameTypeFlags::COLSECT) || rSh.IsDirectlyInSection()) )
                    {
                        aRect = rSh.GetAnyCurRect(CurRectType::SectionPrt, pPt);
                        const SwRect aTmpRect = rSh.GetAnyCurRect(CurRectType::Section, pPt);
                        aRect.Pos() += aTmpRect.Pos();
                    }

                    else if ( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY )
                        aRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded, pPt);
                    else if( nFrameType & FrameTypeFlags::DRAWOBJ)
                        aRect = rSh.GetObjRect();

                    if( aRect.Width() )
                    {
                        // make relative to page position:
                        aLongLR.SetLeft(aRect.Left() - rPageRect.Left());
                        aLongLR.SetRight(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;
            }

            // provide left and right margins of current page style
            case SID_ATTR_PAGE_LRSPACE:
            {
                const SvxLRSpaceItem aTmpPageLRSpace( rDesc.GetMaster().GetLRSpace() );
                const SvxLongLRSpaceItem aLongLR(
                    aTmpPageLRSpace.GetLeft(),
                    aTmpPageLRSpace.GetRight(),
                    SID_ATTR_PAGE_LRSPACE );
                rSet.Put( aLongLR );
            }
            break;

            case SID_ATTR_LONG_ULSPACE:
            {
                // Page margin top bottom
                SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
                SvxLongULSpaceItem aLongUL( static_cast<long>(aUL.GetUpper()),
                                            static_cast<long>(aUL.GetLower()),
                                            SID_ATTR_LONG_ULSPACE);

                if ( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY )
                {
                    // Convert document coordinates into page coordinates.
                    const SwRect &rRect = rSh.GetAnyCurRect(CurRectType::FlyEmbedded, pPt);
                    aLongUL.SetUpper(rRect.Top() - rPageRect.Top());
                    aLongUL.SetLower(rPageRect.Bottom() - rRect.Bottom());
                }
                else if ( nFrameType & FrameTypeFlags::HEADER || nFrameType & FrameTypeFlags::FOOTER )
                {
                    SwRect aRect( rSh.GetAnyCurRect( CurRectType::HeaderFooter, pPt));
                    aRect.Pos() -= rSh.GetAnyCurRect( CurRectType::Page, pPt ).Pos();
                    aLongUL.SetUpper( aRect.Top() );
                    aLongUL.SetLower( nPageHeight - aRect.Bottom() );
                }
                else if( nFrameType & FrameTypeFlags::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(static_cast<sal_uInt16>(aLongUL.GetUpper()),
                                          static_cast<sal_uInt16>(aLongUL.GetLower()),
                                          nWhich);
                    rSet.Put(aULTmp);
                }
                break;
            }

            // provide top and bottom margins of current page style
            case SID_ATTR_PAGE_ULSPACE:
            {
                const SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
                SvxLongULSpaceItem aLongUL(
                    static_cast<long>(aUL.GetUpper()),
                    static_cast<long>(aUL.GetLower()),
                    SID_ATTR_PAGE_ULSPACE );

                rSet.Put( aLongUL );
            }
            break;

            case SID_ATTR_TABSTOP_VERTICAL :
            case RES_PARATR_TABSTOP:
            {
                if ( dynamic_cast< const SwWebView *>( this ) !=  nullptr ||
                     IsTabColFromDoc() ||
                     IsTabRowFromDoc() ||
                     ( nSelType & SelectionType::Graphic ) ||
                     ( nSelType & SelectionType::Frame ) ||
                     ( nSelType & SelectionType::Ole ) ||
                     ( SfxItemState::DEFAULT > aCoreSet.GetItemState(RES_LR_SPACE) ) ||
                     (!bVerticalWriting && (SID_ATTR_TABSTOP_VERTICAL == nWhich) ) ||
                     ( bVerticalWriting && (RES_PARATR_TABSTOP == nWhich))
                   )
                    rSet.DisableItem( nWhich );
                else
                {
                    SvxTabStopItem aTabStops(aCoreSet.Get( RES_PARATR_TABSTOP ));

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

                    OSL_ENSURE(m_pHRuler, "why is there no ruler?");
                    const long nDefTabDist = ::GetTabDist(rDefTabs);
                    m_pHRuler->SetDefTabDist( nDefTabDist );
                    m_pVRuler->SetDefTabDist( nDefTabDist );
                    ::lcl_EraseDefTabs(aTabStops);
                    aTabStops.SetWhich(nWhich);
                    rSet.Put(aTabStops);
                }
                break;
            }

            case SID_HANGING_INDENT:
            {
                SfxItemState e = aCoreSet.GetItemState(RES_LR_SPACE);
                if( e == SfxItemState::DISABLED )
                    rSet.DisableItem(nWhich);
                break;
            }

            case SID_ATTR_PARA_LRSPACE_VERTICAL:
            case SID_ATTR_PARA_LRSPACE:
            case SID_ATTR_PARA_LEFTSPACE:
            case SID_ATTR_PARA_RIGHTSPACE:
            case SID_ATTR_PARA_FIRSTLINESPACE:
            {
                if ( nSelType & SelectionType::Graphic ||
                     nSelType & SelectionType::Frame ||
                     nSelType & SelectionType::Ole ||
                     nFrameType == FrameTypeFlags::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 = aCoreSet.Get(RES_LR_SPACE);

                        // #i23726#
                        if (m_pNumRuleNodeFromDoc)
                        {
                            short nOffset = static_cast< short >(aLR.GetTextLeft() +
                                            // #i42922# Mouse move of numbering label
                                            // has to consider the left indent of the paragraph
                                            m_pNumRuleNodeFromDoc->GetLeftMarginWithNum( true ) );

                            short nFLOffset;
                            m_pNumRuleNodeFromDoc->GetFirstLineOfsWithNum( nFLOffset );

                            aLR.SetLeft( nOffset + nFLOffset );
                        }
                    }
                    aLR.SetWhich(nWhich);
                    rSet.Put(aLR);
                }
            break;
            }

            case SID_ATTR_PARA_ULSPACE:
            case SID_ATTR_PARA_ABOVESPACE:
            case SID_ATTR_PARA_BELOWSPACE:
            case SID_PARASPACE_INCREASE:
            case SID_PARASPACE_DECREASE:
            {
                SvxULSpaceItem aUL = aCoreSet.Get(RES_UL_SPACE);
                SfxItemState e = aCoreSet.GetItemState(RES_UL_SPACE);
                if( e >= SfxItemState::DEFAULT )
                {
                    if ( !aUL.GetUpper() && !aUL.GetLower() )
                        rSet.DisableItem( SID_PARASPACE_DECREASE );
                    else if ( aUL.GetUpper() >= 5670 && aUL.GetLower() >= 5670 )
                        rSet.DisableItem( SID_PARASPACE_INCREASE );
                    if ( nWhich == SID_ATTR_PARA_ULSPACE
                        || nWhich == SID_ATTR_PARA_ABOVESPACE
                        || nWhich == SID_ATTR_PARA_BELOWSPACE
                    )
                    {
                        aUL.SetWhich( nWhich );
                        rSet.Put( aUL );
                    }
                }
                else
                {
                    rSet.DisableItem( SID_PARASPACE_INCREASE );
                    rSet.DisableItem( SID_PARASPACE_DECREASE );
                    rSet.InvalidateItem( SID_ATTR_PARA_ULSPACE );
                    rSet.InvalidateItem( SID_ATTR_PARA_ABOVESPACE );
                    rSet.InvalidateItem( SID_ATTR_PARA_BELOWSPACE );
                }
            }
            break;

            case SID_RULER_BORDER_DISTANCE:
            {
                m_nLeftBorderDistance = 0;
                m_nRightBorderDistance = 0;
                if ( nSelType & SelectionType::Graphic ||
                        nSelType & SelectionType::Frame ||
                        nSelType & SelectionType::Ole ||
                        nFrameType == FrameTypeFlags::DRAWOBJ )
                    rSet.DisableItem(SID_RULER_BORDER_DISTANCE);
                else
                {
                    SvxLRSpaceItem aDistLR(SID_RULER_BORDER_DISTANCE);
                    if(nFrameType & FrameTypeFlags::FLY_ANY)
                    {
                        if( IsTabColFromDoc() )
                        {
                            const SwRect& rFlyPrtRect = rSh.GetAnyCurRect( CurRectType::FlyEmbeddedPrt, pPt );
                            aDistLR.SetLeft(rFlyPrtRect.Left());
                            aDistLR.SetRight(rFlyPrtRect.Left());
                        }
                        else
                        {
                            SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
                            aCoreSet.Put( aBoxInfo );
                            rSh.GetFlyFrameAttr( aCoreSet );
                            const SvxBoxItem& rBox = aCoreSet.Get(RES_BOX);
                            aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
                            aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));

                            //add the paragraph border distance
                            SfxItemSet aCoreSet1( GetPool(), svl::Items<RES_BOX, RES_BOX>{} );
                            rSh.GetCurAttr( aCoreSet1 );
                            const SvxBoxItem& rParaBox = aCoreSet1.Get(RES_BOX);
                            aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
                            aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
                        }
                        rSet.Put(aDistLR);
                        m_nLeftBorderDistance  = static_cast< sal_uInt16 >(aDistLR.GetLeft());
                        m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
                    }
                    else if ( IsTabColFromDoc() ||
                        ( rSh.GetTableFormat() && !bFrameSelection &&
                        !(nFrameType & FrameTypeFlags::COLSECT ) ) )
                    {
                        SfxItemSet aCoreSet2( GetPool(),
                                                svl::Items<RES_BOX, RES_BOX,
                                                SID_ATTR_BORDER_INNER, SID_ATTR_BORDER_INNER>{} );
                        SvxBoxInfoItem aBoxInfo( SID_ATTR_BORDER_INNER );
                        aBoxInfo.SetTable(false);
                        aBoxInfo.SetDist(true);
                        aCoreSet2.Put(aBoxInfo);
                        rSh.GetTabBorders( aCoreSet2 );
                        const SvxBoxItem& rBox = aCoreSet2.Get(RES_BOX);
                        aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
                        aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));

                        //add the border distance of the paragraph
                        SfxItemSet aCoreSet1( GetPool(), svl::Items<RES_BOX, RES_BOX>{} );
                        rSh.GetCurAttr( aCoreSet1 );
                        const SvxBoxItem& rParaBox = aCoreSet1.Get(RES_BOX);
                        aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
                        aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
                        rSet.Put(aDistLR);
                        m_nLeftBorderDistance  = static_cast< sal_uInt16 >(aDistLR.GetLeft());
                        m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
                    }
                    else if ( !rSh.IsDirectlyInSection() )
                    {
                        //get the page/header/footer border distance
                        const SwFrameFormat& rMaster = rDesc.GetMaster();
                        const SvxBoxItem& rBox = rMaster.GetAttrSet().Get(RES_BOX);
                        aDistLR.SetLeft(rBox.GetDistance(SvxBoxItemLine::LEFT));
                        aDistLR.SetRight(rBox.GetDistance(SvxBoxItemLine::RIGHT));

                        const SvxBoxItem* pBox = nullptr;
                        if(nFrameType & FrameTypeFlags::HEADER)
                        {
                            rMaster.GetHeader();
                            const SwFormatHeader& rHeaderFormat = rMaster.GetHeader();
                            SwFrameFormat *pHeaderFormat = const_cast<SwFrameFormat*>(rHeaderFormat.GetHeaderFormat());
                            if( pHeaderFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
                                pBox = & pHeaderFormat->GetBox();
                        }
                        else if(nFrameType & FrameTypeFlags::FOOTER )
                        {
                            const SwFormatFooter& rFooterFormat = rMaster.GetFooter();
                            SwFrameFormat *pFooterFormat = const_cast<SwFrameFormat*>(rFooterFormat.GetFooterFormat());
                            if( pFooterFormat )// #i80890# if rDesc is not the one belonging to the current page is might crash
                                pBox = & pFooterFormat->GetBox();
                        }
                        if(pBox)
                        {
                            aDistLR.SetLeft(pBox->GetDistance(SvxBoxItemLine::LEFT));
                            aDistLR.SetRight(pBox->GetDistance(SvxBoxItemLine::RIGHT));
                        }

                        //add the border distance of the paragraph
                        SfxItemSet aCoreSetTmp( GetPool(), svl::Items<RES_BOX, RES_BOX>{} );
                        rSh.GetCurAttr( aCoreSetTmp );
                        const SvxBoxItem& rParaBox = aCoreSetTmp.Get(RES_BOX);
                        aDistLR.SetLeft(aDistLR.GetLeft() + rParaBox.GetDistance(SvxBoxItemLine::LEFT));
                        aDistLR.SetRight(aDistLR.GetRight() + rParaBox.GetDistance(SvxBoxItemLine::RIGHT));
                        rSet.Put(aDistLR);
                        m_nLeftBorderDistance  = static_cast< sal_uInt16 >(aDistLR.GetLeft());
                        m_nRightBorderDistance = static_cast< sal_uInt16 >(aDistLR.GetRight());
                    }
                }
            }
            break;

            case SID_RULER_TEXT_RIGHT_TO_LEFT:
            {
                if ( nSelType & SelectionType::Graphic ||
                        nSelType & SelectionType::Frame ||
                        nSelType & SelectionType::Ole ||
                        nFrameType == FrameTypeFlags::DRAWOBJ)
                    rSet.DisableItem(nWhich);
                else
                {
                    bool bFlag = rSh.IsInRightToLeftText();
                    rSet.Put(SfxBoolItem(nWhich, bFlag));
                }
            }
            break;

            case SID_RULER_BORDERS_VERTICAL:
            case SID_RULER_BORDERS:
            {
                bool bFrameHasVerticalColumns(false);
                {
                    bool bFrameRTL;
                    bool bFrameVertL2R;
                    bFrameHasVerticalColumns = rSh.IsFrameVertical(false, bFrameRTL, bFrameVertL2R) &&
                                               bFrameSelection;
                }
                bool bHasTable = ( IsTabColFromDoc() ||
                        ( rSh.GetTableFormat() && !bFrameSelection &&
                        !(nFrameType & FrameTypeFlags::COLSECT ) ) );

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

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

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

                    const sal_uInt16 nL = static_cast< sal_uInt16 >(std::max(nLft, 0));
                    const sal_uInt16 nR = static_cast< sal_uInt16 >(std::max(nRgt, 0));

                    SvxColumnItem aColItem(nNum, nL, nR);

                    long nStart = 0;
                    long nEnd = 0;

                    //columns in right-to-left tables need to be mirrored
                    bool bIsTableRTL =
                        IsTabColFromDoc() ?
                              rSh.IsMouseTableRightToLeft(m_aTabColFromDocPos)
                            : rSh.IsTableRightToLeft();
                    if(bIsTableRTL)
                    {
                        for ( size_t i = aTabCols.Count(); i; --i )
                        {
                            const SwTabColsEntry& rEntry = aTabCols.GetEntry( i - 1 );
                            nEnd = aTabCols.GetRight() - rEntry.nPos;
                            SvxColumnDescription aColDesc( nStart, nEnd,
                                                        aTabCols.GetRight() - rEntry.nMax,
                                                        aTabCols.GetRight() - rEntry.nMin,
                                                        !aTabCols.IsHidden(i - 1) );
                            aColItem.Append(aColDesc);
                            nStart = nEnd;
                        }
                        SvxColumnDescription aColDesc(nStart,
                                        aTabCols.GetRight() - aTabCols.GetLeft(), true);
                        aColItem.Append(aColDesc);
                    }
                    else
                    {
                        for ( size_t i = 0; i < aTabCols.Count(); ++i )
                        {
                            const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
                            nEnd = 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, true);
                        aColItem.Append(aColDesc);
                    }
                    aColItem.SetWhich(nWhich);
                    rSet.Put(aColItem);
                }
                else if ( bFrameSelection || nFrameType & ( FrameTypeFlags::COLUMN | FrameTypeFlags::COLSECT ) )
                {
                    // Out of frame or page?
                    sal_uInt16 nNum = 0;
                    if(bFrameSelection)
                    {
                        const SwFrameFormat* pFormat = rSh.GetFlyFrameFormat();
                        if(pFormat)
                            nNum = pFormat->GetCol().GetNumCols();
                    }
                    else
                        nNum = rSh.GetCurColNum();

                    if(
                        // For that matter FrameTypeFlags::COLSECT should not be included
                        // if the border is selected!
                        !bFrameSelection &&
                         nFrameType & FrameTypeFlags::COLSECT )
                    {
                        const SwSection *pSect = rSh.GetAnySection(false, pPt);
                        OSL_ENSURE( pSect, "Which section?");
                        if( pSect )
                        {
                            SwSectionFormat const *pFormat = pSect->GetFormat();
                            const SwFormatCol& rCol = pFormat->GetCol();
                            if (rSh.IsColRightToLeft())
                                nNum = rCol.GetColumns().size() - nNum;
                            else
                                --nNum;
                            SvxColumnItem aColItem(nNum);
                            SwRect aRect = rSh.GetAnyCurRect(CurRectType::SectionPrt, pPt);
                            const SwRect aTmpRect = rSh.GetAnyCurRect(CurRectType::Section, pPt);

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

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

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

                            aColItem.SetWhich(nWhich);
                            rSet.Put(aColItem);
                        }
                    }
                    else if( bFrameSelection || nFrameType & FrameTypeFlags::FLY_ANY )
                    {
                        // Columns in frame
                        if ( nNum  )
                        {
                            const SwFrameFormat* pFormat = rSh.GetFlyFrameFormat() ;

                            const SwFormatCol& rCol = pFormat->GetCol();
                            if (rSh.IsColRightToLeft())
                                nNum = rCol.GetColumns().size() - nNum;
                            else
                                nNum--;
                            SvxColumnItem aColItem(nNum);
                            const SwRect &rSizeRect = rSh.GetAnyCurRect(CurRectType::FlyEmbeddedPrt, pPt);

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

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

                            aColItem.SetOrtho(aColItem.CalcOrtho());

                            aColItem.SetWhich(nWhich);
                            rSet.Put(aColItem);
                        }
                        else
                            rSet.DisableItem(nWhich);
                    }
                    else
                    {   // Columns on the page
                        const SwFrameFormat& rMaster = rDesc.GetMaster();
                        SwFormatCol aCol(rMaster.GetCol());
                        if(rFrameDir.GetValue() == SvxFrameDirection::Horizontal_RL_TB)
                            nNum = aCol.GetColumns().size() - nNum;
                        else
                            nNum--;

                        SvxColumnItem aColItem(nNum);
                        const SwRect aPrtRect = rSh.GetAnyCurRect(CurRectType::PagePrt, pPt);
                        const SvxBoxItem& rBox = rMaster.GetFormatAttr(RES_BOX);
                        long nDist = rBox.GetSmallestDistance();

                        lcl_FillSvxColumn(
                            aCol,
                            bVerticalWriting ? aPrtRect.Height() : aPrtRect.Width(),
                            aColItem, nDist);

                        if(bBrowse)
                        {
                            if (bVerticalWriting)
                            {
                                aColItem.SetLeft(static_cast<sal_uInt16>(rPagePrtRect.Top()));
                                aColItem.SetRight(sal_uInt16(nPageHeight - rPagePrtRect.Bottom()));
                            }
                            else
                            {
                                aColItem.SetLeft(static_cast<sal_uInt16>(rPagePrtRect.Left()));
                                aColItem.SetRight(sal_uInt16(nPageWidth - rPagePrtRect.Right()));
                            }
                        }
                        else
                        {
                            if (bVerticalWriting)
                            {
                                SvxULSpaceItem aUL( rDesc.GetMaster().GetULSpace() );
                                aColItem.SetLeft (aUL.GetUpper());
                                aColItem.SetRight(aUL.GetLower());
                            }
                            else
                            {
                                aColItem.SetLeft (aPageLRSpace.GetLeft());
                                aColItem.SetRight(aPageLRSpace.GetRight());
                            }
                        }
                        aColItem.SetOrtho(aColItem.CalcOrtho());

                        aColItem.SetWhich(nWhich);
                        rSet.Put(aColItem);
                    }
                }
                else
                    rSet.DisableItem(nWhich);
                break;
            }

            case SID_RULER_ROWS :
            case SID_RULER_ROWS_VERTICAL:
            {
                bool bFrameHasVerticalColumns(false);
                {
                    bool bFrameRTL;
                    bool bFrameVertL2R;
                    bFrameHasVerticalColumns = rSh.IsFrameVertical(false, bFrameRTL, bFrameVertL2R) &&
                                               bFrameSelection;
                }

                if(((SID_RULER_ROWS == nWhich) &&
                    ((!bVerticalWriting && !bFrameSelection) || (bFrameSelection && !bFrameHasVerticalColumns))) ||
                   ((SID_RULER_ROWS_VERTICAL == nWhich) &&
                    ((bVerticalWriting && !bFrameSelection) || bFrameHasVerticalColumns)))
                    rSet.DisableItem(nWhich);
                else if ( IsTabRowFromDoc() ||
                        ( rSh.GetTableFormat() && !bFrameSelection &&
                        !(nFrameType & FrameTypeFlags::COLSECT ) ) )
                {
                    SwTabCols aTabCols;
                    m_bSetTabRowFromDoc = IsTabRowFromDoc();
                    if ( m_bSetTabRowFromDoc )
                    {
                        rSh.GetMouseTabRows( aTabCols, m_aTabColFromDocPos );
                    }
                    else
                    {
                        rSh.GetTabRows( aTabCols );
                    }

                    const int nLft = aTabCols.GetLeftMin();
                    const int nRgt = (bVerticalWriting ? nPageWidth : nPageHeight) -
                                     (aTabCols.GetLeftMin() + aTabCols.GetRight());

                    const sal_uInt16 nL = static_cast< sal_uInt16 >(std::max(nLft, 0));
                    const sal_uInt16 nR = static_cast< sal_uInt16 >(std::max(nRgt, 0));

                    SvxColumnItem aColItem(0, nL, nR);

                    long nStart = 0;
                    long nEnd = 0;

                    for ( size_t i = 0; i < aTabCols.Count(); ++i )
                    {
                        const SwTabColsEntry& rEntry = aTabCols.GetEntry( i );
                        if(bVerticalWriting)
                        {
                            nEnd = aTabCols.GetRight() - rEntry.nPos;
                            SvxColumnDescription aColDesc( nStart, nEnd,
                                    std::max(0L, aTabCols.GetRight() - rEntry.nMax),
                                    std::max(0L, aTabCols.GetRight() - rEntry.nMin),
                                                        !aTabCols.IsHidden(i) );
                            aColItem.Append(aColDesc);
                        }
                        else
                        {
                            nEnd  = rEntry.nPos - aTabCols.GetLeft();
                            SvxColumnDescription aColDesc( nStart, nEnd,
                                                        rEntry.nMin - aTabCols.GetLeft(),
                                                        rEntry.nMax - aTabCols.GetLeft(),
                                                        !aTabCols.IsHidden(i) );
                            aColItem.Append(aColDesc);
                        }
                        nStart = nEnd;
                    }
                    if(bVerticalWriting)
                        nEnd = aTabCols.GetRight();
                    else
                        nEnd = aTabCols.GetLeft();

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

                    aColItem.SetWhich(nWhich);
                    rSet.Put(aColItem);
                }
                else
                    rSet.DisableItem(nWhich);
            }
            break;

            case SID_RULER_PAGE_POS:
            {
                SvxPagePosSizeItem aPagePosSize(
                        Point( rPageRect.Left(), rPageRect.Top()) , nPageWidth, nPageHeight);

                rSet.Put(aPagePosSize);
                break;
            }

            case SID_RULER_LR_MIN_MAX:
            {
                tools::Rectangle aRectangle;
                if( ( nFrameType & FrameTypeFlags::COLSECT ) && !IsTabColFromDoc() &&
                    ( nFrameType & ( FrameTypeFlags::TABLE|FrameTypeFlags::COLUMN ) ) )
                {
                    if( nFrameType & FrameTypeFlags::TABLE )
                    {
                        const size_t nNum = rSh.GetCurTabColNum();
                        SwTabCols aTabCols;
                        rSh.GetTabCols( aTabCols );

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

                        const sal_uInt16 nL = static_cast< sal_uInt16 >(std::max(nLft, 0));
                        const sal_uInt16 nR = static_cast< sal_uInt16 >(std::max(nRgt, 0));

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

                        if(nNum < aTabCols.Count())
                            aRectangle.AdjustRight(MINLAY );
                    }
                    else
                    {
                        const SwFrameFormat* pFormat =  rSh.GetFlyFrameFormat();
                        const SwFormatCol* pCols = pFormat ? &pFormat->GetCol():
                                                       &rDesc.GetMaster().GetCol();
                        const SwColumns& rCols = pCols->GetColumns();
                        sal_uInt16 nNum = rSh.GetCurOutColNum();
                        const sal_uInt16 nCount = std::min(sal_uInt16(nNum + 1), sal_uInt16(rCols.size()));
                        const SwRect aRect( rSh.GetAnyCurRect( pFormat
                                                        ? CurRectType::FlyEmbeddedPrt
                                                        : CurRectType::PagePrt, pPt ));
                        const SwRect aAbsRect( rSh.GetAnyCurRect( pFormat
                                                        ? CurRectType::FlyEmbedded
                                                        : CurRectType::Page, pPt ));

                        // The width of the frame or within the page margins.
                        const sal_uInt16 nTotalWidth = static_cast<sal_uInt16>(aRect.Width());
                        // The entire frame width - The difference is twice the distance to the edge.
                        const sal_uInt16 nOuterWidth = static_cast<sal_uInt16>(aAbsRect.Width());
                        int nWidth = 0,
                            nEnd = 0;
                        aRectangle.SetLeft( 0 );
                        for ( sal_uInt16 i = 0; i < nCount; ++i )
                        {
                            const SwColumn* pCol = &rCols[i];
                            const int nStart = pCol->GetLeft() + nWidth;
                            if(i == nNum - 2)
                                aRectangle.SetLeft( nStart );
                            nWidth += pCols->CalcColWidth( i, nTotalWidth );
                            nEnd = nWidth - pCol->GetRight();
                        }
                        aRectangle.SetRight( rPageRect.Right() - nEnd );
                        aRectangle.AdjustLeft( -(rPageRect.Left()) );

                        if(nNum > 1)
                        {
                            aRectangle.AdjustLeft(MINLAY );
                            aRectangle.AdjustLeft(aRect.Left() );
                        }
                        if(pFormat) // Range in frame - here you may up to the edge
                        {
                            aRectangle.SetLeft(0);
                            aRectangle.SetRight(0);
                        }
                        else
                        {
                            // Move the rectangle to the correct absolute position.
                            aRectangle.AdjustLeft(aAbsRect.Left() );
                            aRectangle.AdjustRight( -(aAbsRect.Left()) );
                            // Include distance to the border.
                            aRectangle.AdjustRight( -((nOuterWidth - nTotalWidth) / 2) );
                        }

                        if(nNum < rCols.size())
                        {
                            aRectangle.AdjustRight(MINLAY );
                        }
                        else
                            // Right is only the margin now.
                            aRectangle.SetRight( 0 );

                    }
                }
                else if ( ((nFrameType & FrameTypeFlags::TABLE) || IsTabColFromDoc()) &&
                     !bFrameSelection )
                {
                    bool bColumn;
                    if ( IsTabColFromDoc() )
                        bColumn = rSh.GetCurMouseColNum( m_aTabColFromDocPos ) != 0;
                    else
                        bColumn = bool(nFrameType & (FrameTypeFlags::COLUMN|FrameTypeFlags::FLY_ANY|FrameTypeFlags::COLSECTOUTTAB));

                    if ( !bColumn )
                    {
                        if( nFrameType & FrameTypeFlags::FLY_ANY && IsTabColFromDoc() )
                        {
                            SwRect aRect( rSh.GetAnyCurRect(
                                                CurRectType::FlyEmbeddedPrt, pPt ) );
                            aRect.Pos() += rSh.GetAnyCurRect( CurRectType::FlyEmbedded,
                                                                    pPt ).Pos();

                            aRectangle.SetLeft( aRect.Left() - rPageRect.Left() );
                            aRectangle.SetRight( rPageRect.Right() - aRect.Right() );
                        }
                        else if( bBrowse )
                        {
                            aRectangle.SetLeft( rPagePrtRect.Left() );
                            aRectangle.SetRight( nPageWidth - rPagePrtRect.Right() );
                        }
                        else
                        {
                            aRectangle.SetLeft( aPageLRSpace.GetLeft() );
                            aRectangle.SetRight( aPageLRSpace.GetRight() );
                        }
                    }
                    else
                    {   // Here only for table in multi-column pages and borders.
                        bool bSectOutTable = bool(nFrameType & FrameTypeFlags::TABLE);
                        bool bFrame = bool(nFrameType & FrameTypeFlags::FLY_ANY);
                        bool bColSct = bool(nFrameType & ( bSectOutTable
                                                        ? FrameTypeFlags::COLSECTOUTTAB
                                                        : FrameTypeFlags::COLSECT )
                                                    );
                        //So you can also drag with the mouse, without being in the table.
                        CurRectType eRecType = CurRectType::PagePrt;
                        size_t nNum = IsTabColFromDoc() ?
                                    rSh.GetCurMouseColNum( m_aTabColFromDocPos ):
                                    rSh.GetCurOutColNum();
                        const SwFrameFormat* pFormat = nullptr;
                        if( bColSct )
                        {
                            eRecType = bSectOutTable ? CurRectType::SectionOutsideTable
                                                   : CurRectType::Section;
                            const SwSection *pSect = rSh.GetAnySection( bSectOutTable, pPt );
                            OSL_ENSURE( pSect, "Which section?");
                            pFormat = pSect->GetFormat();
                        }
                        else if( bFrame )
                        {
                            pFormat = rSh.GetFlyFrameFormat();
                            eRecType = CurRectType::FlyEmbeddedPrt;
                        }

                        const SwFormatCol* pCols = pFormat ? &pFormat->GetCol():
                                                       &rDesc.GetMaster().GetCol();
                        const SwColumns& rCols = pCols->GetColumns();
                        const sal_uInt16 nBorder = pFormat
                            ? pFormat->GetBox().GetSmallestDistance()
                            : rDesc.GetMaster().GetBox().GetSmallestDistance();

                        // 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(CurRectType::FlyEmbeddedPrt == eRecType)
                            aRect.Pos() += rSh.GetAnyCurRect( CurRectType::FlyEmbedded,
                                                                    pPt ).Pos();

                        const sal_uInt16 nTotalWidth = static_cast<sal_uInt16>(aRect.Width());
                        // Initialize nStart and nEnd for nNum == 0
                        int nWidth = 0,
                            nStart = 0,
                            nEnd = nTotalWidth;

                        if( nNum > rCols.size() )
                        {
                            OSL_ENSURE( false, "wrong FormatCol is being edited!" );
                            nNum = rCols.size();
                        }

                        for( size_t i = 0; i < nNum; ++i )
                        {
                            const SwColumn* pCol = &rCols[i];
                            nStart = pCol->GetLeft() + nWidth;
                            nWidth += pCols->CalcColWidth( static_cast<sal_uInt16>(i), nTotalWidth );
                            nEnd = nWidth - pCol->GetRight();
                        }
                        if( bFrame || bColSct )
                        {
                            aRectangle.SetLeft( aRect.Left() - rPageRect.Left() + nStart );
                            aRectangle.SetRight( nPageWidth - aRectangle.Left() - nEnd + nStart );
                        }
                        else if(!bBrowse)
                        {
                            aRectangle.SetLeft( aPageLRSpace.GetLeft() + nStart );
                            aRectangle.SetRight( nPageWidth - nEnd - aPageLRSpace.GetLeft() );
                        }
                        else
                        {
                            long nLeft = rPagePrtRect.Left();
                            aRectangle.SetLeft( nStart + nLeft );
                            aRectangle.SetRight( nPageWidth - nEnd - nLeft );
                        }
                        if(!bFrame)
                        {
                            aRectangle.AdjustLeft(nBorder );
                            aRectangle.AdjustRight( -nBorder );
                        }
                    }
                }
                else if ( nFrameType & ( FrameTypeFlags::HEADER  | FrameTypeFlags::FOOTER ))
                {
                    aRectangle.SetLeft( aPageLRSpace.GetLeft() );
                    aRectangle.SetRight( aPageLRSpace.GetRight() );
                }
                else
                {
                    aRectangle.SetLeft(0);
                    aRectangle.SetRight(0);
                }

                SfxRectangleItem aLR( SID_RULER_LR_MIN_MAX , aRectangle);
                rSet.Put(aLR);
            }
            break;

            case SID_RULER_PROTECT:
            {
                if(bFrameSelection)
                {
                    FlyProtectFlags nProtect = m_pWrtShell->IsSelObjProtected( FlyProtectFlags::Size|FlyProtectFlags::Pos|FlyProtectFlags::Content );

                    SvxProtectItem aProt(SID_RULER_PROTECT);
                    aProt.SetContentProtect(bool(nProtect & FlyProtectFlags::Content));
                    aProt.SetSizeProtect   (bool(nProtect & FlyProtectFlags::Size));
                    aProt.SetPosProtect    (bool(nProtect & FlyProtectFlags::Pos));
                    rSet.Put(aProt);
                }
                else
                {
                    SvxProtectItem aProtect(SID_RULER_PROTECT);
                    if(bBrowse && !(nFrameType & (FrameTypeFlags::DRAWOBJ|FrameTypeFlags::COLUMN)) && !rSh.GetTableFormat())
                    {
                        aProtect.SetSizeProtect(true);
                        aProtect.SetPosProtect(true);
                    }
                    rSet.Put(aProtect);
                }
            }
            break;

            case SID_ATTR_PAGE_HEADER:
            case SID_ATTR_PAGE_HEADER_LRMARGIN:
            case SID_ATTR_PAGE_HEADER_SPACING:
            case SID_ATTR_PAGE_HEADER_LAYOUT:
            {
                const SwFormatHeader& rHeader = rDesc.GetMaster().GetHeader();
                bool bHeaderOn = rHeader.IsActive();
                rSet.Put( SfxBoolItem(SID_ATTR_PAGE_HEADER, bHeaderOn ) );
                if(bHeaderOn)
                {
                    const SvxLRSpaceItem* rLR = static_cast<const SvxLRSpaceItem*>(
                                                rHeader.GetHeaderFormat()->GetAttrSet().GetItem(SID_ATTR_LRSPACE));
                    const SvxULSpaceItem* rUL = static_cast<const SvxULSpaceItem*>(
                                                rHeader.GetHeaderFormat()->GetAttrSet().GetItem(SID_ATTR_ULSPACE));
                    SvxLongLRSpaceItem aLR(rLR->GetLeft(), rLR->GetRight(), SID_ATTR_PAGE_HEADER_LRMARGIN);
                    rSet.Put(aLR);
                    SvxLongULSpaceItem aUL( rUL->GetUpper(), rUL->GetLower(), SID_ATTR_PAGE_HEADER_SPACING);
                    rSet.Put(aUL);

                    bool bShared = !rDesc.IsHeaderShared();
                    bool bFirst = !rDesc.IsFirstShared(); // FIXME control changes for both header footer - tdf#100287
                    sal_uInt16 nLayout = (static_cast<int>(bShared)<<1) + static_cast<int>(bFirst);
                    SfxInt16Item aLayoutItem(SID_ATTR_PAGE_HEADER_LAYOUT, nLayout);
                    rSet.Put(aLayoutItem);
                }
            }
            break;
            case SID_ATTR_PAGE_FOOTER:
            case SID_ATTR_PAGE_FOOTER_LRMARGIN:
            case SID_ATTR_PAGE_FOOTER_SPACING:
            case SID_ATTR_PAGE_FOOTER_LAYOUT:
            {
                const SwFormatFooter& rFooter = rDesc.GetMaster().GetFooter();
                bool bFooterOn = rFooter.IsActive();
                rSet.Put( SfxBoolItem(SID_ATTR_PAGE_FOOTER, bFooterOn ) );
                if(bFooterOn)
                {
                    const SvxLRSpaceItem* rLR = rFooter.GetFooterFormat()->GetAttrSet().GetItem<SvxLRSpaceItem>(SID_ATTR_LRSPACE);
                    const SvxULSpaceItem* rUL = rFooter.GetFooterFormat()->GetAttrSet().GetItem<SvxULSpaceItem>(SID_ATTR_ULSPACE);
                    SvxLongLRSpaceItem aLR(rLR->GetLeft(), rLR->GetRight(), SID_ATTR_PAGE_FOOTER_LRMARGIN);
                    rSet.Put(aLR);
                    SvxLongULSpaceItem aUL( rUL->GetUpper(), rUL->GetLower(), SID_ATTR_PAGE_FOOTER_SPACING);
                    rSet.Put(aUL);

                    bool bShared = !rDesc.IsFooterShared();
                    bool bFirst = !rDesc.IsFirstShared(); // FIXME control changes for both header footer - tdf#100287
                    sal_uInt16 nLayout = (static_cast<int>(bShared)<<1) + static_cast<int>(bFirst);
                    SfxInt16Item aLayoutItem(SID_ATTR_PAGE_FOOTER_LAYOUT, nLayout);
                    rSet.Put(aLayoutItem);
                }
            }
            break;

            case SID_ATTR_PAGE_COLOR:
            case SID_ATTR_PAGE_FILLSTYLE:
            case SID_ATTR_PAGE_GRADIENT:
            case SID_ATTR_PAGE_HATCH:
            case SID_ATTR_PAGE_BITMAP:
            {
                SfxItemSet aSet = rDesc.GetMaster().GetAttrSet();
                drawing::FillStyle eXFS = aSet.GetItem(XATTR_FILLSTYLE)->GetValue();
                XFillStyleItem aFillStyleItem( eXFS );
                aFillStyleItem.SetWhich( SID_ATTR_PAGE_FILLSTYLE );
                rSet.Put(aFillStyleItem);
                switch(eXFS)
                {
                    case drawing::FillStyle_SOLID:
                    {
                        Color aColor = aSet.GetItem<XFillColorItem>( XATTR_FILLCOLOR, false )->GetColorValue();
                        XFillColorItem aFillColorItem( OUString(), aColor );
                        aFillColorItem.SetWhich( SID_ATTR_PAGE_COLOR );
                        rSet.Put( aFillColorItem );
                    }
                    break;

                    case drawing::FillStyle_GRADIENT:
                    {
                        const XGradient& xGradient = aSet.GetItem<XFillGradientItem>( XATTR_FILLGRADIENT )->GetGradientValue();
                        XFillGradientItem aFillGradientItem( OUString(), xGradient, SID_ATTR_PAGE_GRADIENT  );
                        rSet.Put( aFillGradientItem );
                    }
                    break;

                    case drawing::FillStyle_HATCH:
                    {
                        const XFillHatchItem *pFillHatchItem( aSet.GetItem<XFillHatchItem>( XATTR_FILLHATCH ) );
                        XFillHatchItem aFillHatchItem( pFillHatchItem->GetName(), pFillHatchItem->GetHatchValue());
                        aFillHatchItem.SetWhich( SID_ATTR_PAGE_HATCH );
                        rSet.Put( aFillHatchItem );
                    }
                    break;

                    case drawing::FillStyle_BITMAP:
                    {
                        const XFillBitmapItem *pFillBitmapItem = aSet.GetItem<XFillBitmapItem>( XATTR_FILLBITMAP );
                        XFillBitmapItem aFillBitmapItem( pFillBitmapItem->GetName(), pFillBitmapItem->GetGraphicObject() );
                        aFillBitmapItem.SetWhich( SID_ATTR_PAGE_BITMAP );
                        rSet.Put( aFillBitmapItem );
                    }
                    break;
                    case drawing::FillStyle_NONE:
                    {
                    }
                    break;

                    default:
                    break;
                }
            }
            break;
            }
            nWhich = aIter.NextWhich();
        }
    }

    /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

↑ V547 Expression 'nWhich == (10000 + 284)' is always true.

↑ V547 Expression 'nWhich == (10000 + 285)' is always true.