Adding upstream version 4:24.2.0.upstream/4%24.2.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3582 insertions, 0 deletions

diff --git a/svx/source/dialog/svxruler.cxx b/svx/source/dialog/svxruler.cxx
new file mode 100644
index 0000000000..6323583fd2
--- /dev/null
+++ b/svx/source/dialog/svxruler.cxx
@@ -0,0 +1,3582 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4; fill-column: 100 -*- */
+/*
+ * 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 <cstring>
+#include <climits>
+
+#include <vcl/commandevent.hxx>
+#include <vcl/event.hxx>
+#include <vcl/fieldvalues.hxx>
+#include <vcl/settings.hxx>
+#include <vcl/svapp.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/weldutils.hxx>
+#include <svl/eitem.hxx>
+#include <svl/rectitem.hxx>
+#include <svl/hint.hxx>
+#include <sfx2/dispatch.hxx>
+#include <svx/strings.hrc>
+#include <svx/svxids.hrc>
+#include <svx/dialmgr.hxx>
+#include <svx/ruler.hxx>
+#include <svx/rulritem.hxx>
+#include <editeng/editids.hrc>
+#include <editeng/tstpitem.hxx>
+#include <editeng/lrspitem.hxx>
+#include <editeng/protitem.hxx>
+#include <osl/diagnose.h>
+#include <rtl/math.hxx>
+#include <o3tl/string_view.hxx>
+#include <svl/itemset.hxx>
+
+#include "rlrcitem.hxx"
+#include <memory>
+
+#define CTRL_ITEM_COUNT 14
+#define GAP 10
+#define OBJECT_BORDER_COUNT 4
+#define TAB_GAP 1
+#define INDENT_GAP 2
+#define INDENT_FIRST_LINE   2
+#define INDENT_LEFT_MARGIN  3
+#define INDENT_RIGHT_MARGIN 4
+#define INDENT_COUNT        3 //without the first two old values
+
+struct SvxRuler_Impl {
+    std::unique_ptr<sal_uInt16[]> pPercBuf;
+    std::unique_ptr<sal_uInt16[]> pBlockBuf;
+    sal_uInt16 nPercSize;
+    tools::Long   nTotalDist;
+    tools::Long   lOldWinPos;
+    tools::Long   lMaxLeftLogic;
+    tools::Long   lMaxRightLogic;
+    tools::Long   lLastLMargin;
+    tools::Long   lLastRMargin;
+    std::unique_ptr<SvxProtectItem> aProtectItem;
+    std::unique_ptr<SfxBoolItem> pTextRTLItem;
+    sal_uInt16 nControllerItems;
+    sal_uInt16 nIdx;
+    sal_uInt16 nColLeftPix;
+    sal_uInt16 nColRightPix;    // Pixel values for left / right edge
+                                // For columns; buffered to prevent
+                                // recalculation errors
+                                // May be has to be widen for future values
+    bool bIsTableRows : 1;  // mxColumnItem contains table rows instead of columns
+    //#i24363# tab stops relative to indent
+    bool bIsTabsRelativeToIndent : 1; // Tab stops relative to paragraph indent?
+                                      // false means relative to SvxRuler::GetLeftFrameMargin()
+
+    SvxRuler_Impl() :
+        nPercSize(0), nTotalDist(0),
+        lOldWinPos(0), lMaxLeftLogic(0), lMaxRightLogic(0),
+        lLastLMargin(0), lLastRMargin(0),
+        aProtectItem(std::make_unique<SvxProtectItem>(SID_RULER_PROTECT)),
+        nControllerItems(0), nIdx(0),
+        nColLeftPix(0), nColRightPix(0),
+        bIsTableRows(false),
+        bIsTabsRelativeToIndent(true)
+    {
+    }
+
+    void SetPercSize(sal_uInt16 nSize);
+
+};
+
+static RulerTabData ruler_tab_svx =
+{
+    0, // DPIScaleFactor to be set
+    7, // ruler_tab_width
+    6, // ruler_tab_height
+    0, // ruler_tab_height2
+    0, // ruler_tab_width2
+    0, // ruler_tab_cwidth
+    0, // ruler_tab_cwidth2
+    0, // ruler_tab_cwidth3
+    0, // ruler_tab_cwidth4
+    0, // ruler_tab_dheight
+    0, // ruler_tab_dheight2
+    0, // ruler_tab_dwidth
+    0, // ruler_tab_dwidth2
+    0, // ruler_tab_dwidth3
+    0, // ruler_tab_dwidth4
+    0  // ruler_tab_textoff
+};
+
+void SvxRuler_Impl::SetPercSize(sal_uInt16 nSize)
+{
+    if(nSize > nPercSize)
+    {
+        nPercSize = nSize;
+        pPercBuf.reset( new sal_uInt16[nPercSize] );
+        pBlockBuf.reset( new sal_uInt16[nPercSize] );
+    }
+    size_t nSize2 = sizeof(sal_uInt16) * nPercSize;
+    memset(pPercBuf.get(), 0, nSize2);
+    memset(pBlockBuf.get(), 0, nSize2);
+}
+
+// Constructor of the ruler
+
+// SID_ATTR_ULSPACE, SID_ATTR_LRSPACE
+// expects as parameter SvxULSpaceItem for page edge
+// (either left/right or top/bottom)
+// Ruler: SetMargin1, SetMargin2
+
+// SID_RULER_PAGE_POS
+// expects as parameter the initial value of the page and page width
+// Ruler: SetPagePos
+
+// SID_ATTR_TABSTOP
+// expects: SvxTabStopItem
+// Ruler: SetTabs
+
+// SID_ATTR_PARA_LRSPACE
+// left, right paragraph edge in H-ruler
+// Ruler: SetIndents
+
+// SID_RULER_BORDERS
+// Table borders, columns
+// expects: something like SwTabCols
+// Ruler: SetBorders
+
+constexpr tools::Long glMinFrame = 5;   // minimal frame width in pixels
+
+SvxRuler::SvxRuler(
+            vcl::Window* pParent,        // StarView Parent
+            vcl::Window* pWin,           // Output window: is used for conversion
+                                         // logical units <-> pixels
+            SvxRulerSupportFlags flags,  // Display flags, see ruler.hxx
+            SfxBindings &rBindings,      // associated Bindings
+            WinBits nWinStyle) :         // StarView WinBits
+    Ruler(pParent, nWinStyle),
+    pCtrlItems(CTRL_ITEM_COUNT),
+    pEditWin(pWin),
+    mxRulerImpl(new SvxRuler_Impl),
+    bAppSetNullOffset(false),  // Is the 0-offset of the ruler set by the application?
+    lLogicNullOffset(0),
+    lAppNullOffset(LONG_MAX),
+    lInitialDragPos(0),
+    nFlags(flags),
+    nDragType(SvxRulerDragFlags::NONE),
+    nDefTabType(RULER_TAB_LEFT),
+    nTabCount(0),
+    nTabBufSize(0),
+    lDefTabDist(50),
+    lTabPos(-1),
+    mpBorders(1), // due to one column tables
+    pBindings(&rBindings),
+    nDragOffset(0),
+    nMaxLeft(0),
+    nMaxRight(0),
+    bValid(false),
+    bListening(false),
+    bActive(true),
+    mbCoarseSnapping(false),
+    mbSnapping(true)
+
+{
+    /* Constructor; Initialize data buffer; controller items are created */
+
+    rBindings.EnterRegistrations();
+
+    // Create Supported Items
+    sal_uInt16 i = 0;
+
+    // Page edges
+    pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_LR_MIN_MAX, *this, rBindings));
+    if((nWinStyle & WB_VSCROLL) == WB_VSCROLL)
+    {
+        bHorz = false;
+        pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_LONG_ULSPACE, *this, rBindings));
+    }
+    else
+    {
+        bHorz = true;
+        pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_LONG_LRSPACE, *this, rBindings));
+    }
+
+    // Page Position
+    pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_PAGE_POS, *this, rBindings));
+
+    if(nFlags & SvxRulerSupportFlags::TABS)
+    {
+        sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
+        pCtrlItems[i++].reset(new SvxRulerItem(nTabStopId, *this, rBindings));
+        SetExtraType(RulerExtra::Tab, nDefTabType);
+    }
+
+    if(nFlags & (SvxRulerSupportFlags::PARAGRAPH_MARGINS |SvxRulerSupportFlags::PARAGRAPH_MARGINS_VERTICAL))
+    {
+        if(bHorz)
+            pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_PARA_LRSPACE, *this, rBindings));
+        else
+            pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_PARA_LRSPACE_VERTICAL, *this, rBindings));
+
+        mpIndents.resize(5 + INDENT_GAP);
+
+        for(RulerIndent & rIndent : mpIndents)
+        {
+            rIndent.nPos = 0;
+            rIndent.nStyle = RulerIndentStyle::Top;
+        }
+
+        mpIndents[0].nStyle = RulerIndentStyle::Top;
+        mpIndents[1].nStyle = RulerIndentStyle::Top;
+        mpIndents[INDENT_FIRST_LINE].nStyle = RulerIndentStyle::Top;
+        mpIndents[INDENT_LEFT_MARGIN].nStyle = RulerIndentStyle::Bottom;
+        mpIndents[INDENT_RIGHT_MARGIN].nStyle = RulerIndentStyle::Bottom;
+    }
+
+    if( (nFlags & SvxRulerSupportFlags::BORDERS) ==  SvxRulerSupportFlags::BORDERS )
+    {
+        pCtrlItems[i++].reset(new SvxRulerItem(bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL, *this, rBindings));
+        pCtrlItems[i++].reset(new SvxRulerItem(bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL, *this, rBindings));
+    }
+
+    pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_TEXT_RIGHT_TO_LEFT, *this, rBindings));
+
+    if( (nFlags & SvxRulerSupportFlags::OBJECT) == SvxRulerSupportFlags::OBJECT )
+    {
+        pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_OBJECT, *this, rBindings));
+        mpObjectBorders.resize(OBJECT_BORDER_COUNT);
+        for(sal_uInt16 nBorder = 0; nBorder < OBJECT_BORDER_COUNT; ++nBorder)
+        {
+            mpObjectBorders[nBorder].nPos   = 0;
+            mpObjectBorders[nBorder].nWidth = 0;
+            mpObjectBorders[nBorder].nStyle = RulerBorderStyle::Moveable;
+        }
+    }
+
+    pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_PROTECT, *this, rBindings));
+    pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_BORDER_DISTANCE, *this, rBindings));
+    mxRulerImpl->nControllerItems=i;
+
+    if( (nFlags & SvxRulerSupportFlags::SET_NULLOFFSET) == SvxRulerSupportFlags::SET_NULLOFFSET )
+        SetExtraType(RulerExtra::NullOffset);
+
+    rBindings.LeaveRegistrations();
+
+    ruler_tab_svx.DPIScaleFactor = pParent->GetDPIScaleFactor();
+    ruler_tab_svx.height *= ruler_tab_svx.DPIScaleFactor;
+    ruler_tab_svx.width  *= ruler_tab_svx.DPIScaleFactor;
+
+}
+
+SvxRuler::~SvxRuler()
+{
+    disposeOnce();
+}
+
+void SvxRuler::dispose()
+{
+    /* Destructor ruler; release internal buffer */
+    if(bListening)
+        EndListening(*pBindings);
+
+    pBindings->EnterRegistrations();
+
+    pCtrlItems.clear();
+
+    pBindings->LeaveRegistrations();
+
+    pEditWin.clear();
+    Ruler::dispose();
+}
+
+tools::Long SvxRuler::MakePositionSticky(tools::Long aPosition, tools::Long aPointOfReference, bool aSnapToFrameMargin) const
+{
+    tools::Long aPointOfReferencePixel = ConvertHPosPixel(aPointOfReference);
+    tools::Long aLeftFramePosition     = ConvertHPosPixel(GetLeftFrameMargin());
+    tools::Long aRightFramePosition    = ConvertHPosPixel(GetRightFrameMargin());
+
+    double aTick = GetCurrentRulerUnit().nTick1;
+
+    if (mbCoarseSnapping)
+        aTick = GetCurrentRulerUnit().nTick2;
+
+    tools::Long aTickPixel = pEditWin->LogicToPixel(Size(aTick, 0), GetCurrentMapMode()).Width();
+
+    double aHalfTick = aTick / 2.0;
+    double aHalfTickPixel = aTickPixel / 2.0;
+
+    if (aSnapToFrameMargin)
+    {
+        if (aPosition > aLeftFramePosition - aHalfTickPixel && aPosition < aLeftFramePosition + aHalfTickPixel)
+            return aLeftFramePosition;
+
+        if (aPosition > aRightFramePosition - aHalfTickPixel && aPosition < aRightFramePosition + aHalfTickPixel)
+            return aRightFramePosition;
+    }
+
+    if (!mbSnapping)
+        return aPosition;
+
+    // Move "coordinate system" to frame position so ticks are calculated correctly
+    tools::Long aTranslatedPosition = aPosition - aPointOfReferencePixel;
+    // Convert position to current selected map mode
+    tools::Long aPositionLogic = pEditWin->PixelToLogic(Size(aTranslatedPosition, 0), GetCurrentMapMode()).Width();
+    // Normalize -- snap to nearest tick
+    aPositionLogic = rtl::math::round((aPositionLogic + aHalfTick) / aTick) * aTick;
+    // Convert back to pixels
+    aPosition = pEditWin->LogicToPixel(Size(aPositionLogic, 0), GetCurrentMapMode()).Width();
+    // Move "coordinate system" back to original position
+    return aPosition + aPointOfReferencePixel;
+}
+
+tools::Long SvxRuler::ConvertHPosPixel(tools::Long nVal) const
+{
+    return pEditWin->LogicToPixel(Size(nVal, 0)).Width();
+}
+
+tools::Long SvxRuler::ConvertVPosPixel(tools::Long nVal) const
+{
+    return pEditWin->LogicToPixel(Size(0, nVal)).Height();
+}
+
+tools::Long SvxRuler::ConvertHSizePixel(tools::Long nVal) const
+{
+    return pEditWin->LogicToPixel(Size(nVal, 0)).Width();
+}
+
+tools::Long SvxRuler::ConvertVSizePixel(tools::Long nVal) const
+{
+    return pEditWin->LogicToPixel(Size(0, nVal)).Height();
+}
+
+tools::Long SvxRuler::ConvertPosPixel(tools::Long nVal) const
+{
+    return bHorz ? ConvertHPosPixel(nVal): ConvertVPosPixel(nVal);
+}
+
+tools::Long SvxRuler::ConvertSizePixel(tools::Long nVal) const
+{
+    return bHorz? ConvertHSizePixel(nVal): ConvertVSizePixel(nVal);
+}
+
+inline tools::Long SvxRuler::ConvertHPosLogic(tools::Long nVal) const
+{
+    return pEditWin->PixelToLogic(Size(nVal, 0)).Width();
+}
+
+inline tools::Long SvxRuler::ConvertVPosLogic(tools::Long nVal) const
+{
+    return pEditWin->PixelToLogic(Size(0, nVal)).Height();
+}
+
+inline tools::Long SvxRuler::ConvertHSizeLogic(tools::Long nVal) const
+{
+    return pEditWin->PixelToLogic(Size(nVal, 0)).Width();
+}
+
+inline tools::Long SvxRuler::ConvertVSizeLogic(tools::Long nVal) const
+{
+    return pEditWin->PixelToLogic(Size(0, nVal)).Height();
+}
+
+inline tools::Long SvxRuler::ConvertPosLogic(tools::Long nVal) const
+{
+    return bHorz? ConvertHPosLogic(nVal): ConvertVPosLogic(nVal);
+}
+
+inline tools::Long SvxRuler::ConvertSizeLogic(tools::Long nVal) const
+{
+    return bHorz? ConvertHSizeLogic(nVal): ConvertVSizeLogic(nVal);
+}
+
+tools::Long SvxRuler::PixelHAdjust(tools::Long nVal, tools::Long nValOld) const
+{
+    if(ConvertHSizePixel(nVal) != ConvertHSizePixel(nValOld))
+        return  nVal;
+    else
+        return  nValOld;
+}
+
+tools::Long SvxRuler::PixelVAdjust(tools::Long nVal, tools::Long nValOld) const
+{
+    if(ConvertVSizePixel(nVal) != ConvertVSizePixel(nValOld))
+        return  nVal;
+    else
+        return  nValOld;
+}
+
+tools::Long SvxRuler::PixelAdjust(tools::Long nVal, tools::Long nValOld) const
+{
+    if(ConvertSizePixel(nVal) != ConvertSizePixel(nValOld))
+        return  nVal;
+    else
+        return  nValOld;
+}
+
+inline sal_uInt16 SvxRuler::GetObjectBordersOff(sal_uInt16 nIdx) const
+{
+    return bHorz ? nIdx : nIdx + 2;
+}
+
+/*
+    Update Upper Left edge.
+    Items are translated into the representation of the ruler.
+*/
+void SvxRuler::UpdateFrame()
+{
+    const RulerMarginStyle nMarginStyle =
+        ( mxRulerImpl->aProtectItem->IsSizeProtected() ||
+          mxRulerImpl->aProtectItem->IsPosProtected() ) ?
+        RulerMarginStyle::NONE : RulerMarginStyle::Sizeable;
+
+    if(mxLRSpaceItem && mxPagePosItem)
+    {
+        // if no initialization by default app behavior
+        const tools::Long nOld = lLogicNullOffset;
+        lLogicNullOffset = mxColumnItem ? mxColumnItem->GetLeft() : mxLRSpaceItem->GetLeft();
+
+        if(bAppSetNullOffset)
+        {
+            lAppNullOffset += lLogicNullOffset - nOld;
+        }
+
+        if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX)
+        {
+            Ruler::SetNullOffset(ConvertHPosPixel(lLogicNullOffset));
+            SetMargin1(0, nMarginStyle);
+            lAppNullOffset = 0;
+        }
+        else
+        {
+            SetMargin1(ConvertHPosPixel(lAppNullOffset), nMarginStyle);
+        }
+
+        tools::Long lRight = 0;
+
+        // evaluate the table right edge of the table
+        if(mxColumnItem && mxColumnItem->IsTable())
+            lRight = mxColumnItem->GetRight();
+        else
+            lRight = mxLRSpaceItem->GetRight();
+
+        tools::Long aWidth = mxPagePosItem->GetWidth() - lRight - lLogicNullOffset + lAppNullOffset;
+        tools::Long aWidthPixel = ConvertHPosPixel(aWidth);
+
+        SetMargin2(aWidthPixel, nMarginStyle);
+    }
+    else if(mxULSpaceItem && mxPagePosItem)
+    {
+        // relative the upper edge of the surrounding frame
+        const tools::Long nOld = lLogicNullOffset;
+        lLogicNullOffset = mxColumnItem ? mxColumnItem->GetLeft() : mxULSpaceItem->GetUpper();
+
+        if(bAppSetNullOffset)
+        {
+            lAppNullOffset += lLogicNullOffset - nOld;
+        }
+
+        if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX)
+        {
+            Ruler::SetNullOffset(ConvertVPosPixel(lLogicNullOffset));
+            lAppNullOffset = 0;
+            SetMargin1(0, nMarginStyle);
+        }
+        else
+        {
+            SetMargin1(ConvertVPosPixel(lAppNullOffset), nMarginStyle);
+        }
+
+        tools::Long lLower = mxColumnItem ? mxColumnItem->GetRight() : mxULSpaceItem->GetLower();
+        tools::Long nMargin2 = mxPagePosItem->GetHeight() - lLower - lLogicNullOffset + lAppNullOffset;
+        tools::Long nMargin2Pixel = ConvertVPosPixel(nMargin2);
+
+        SetMargin2(nMargin2Pixel, nMarginStyle);
+    }
+    else
+    {
+        // turns off the view
+        SetMargin1();
+        SetMargin2();
+    }
+
+    if (mxColumnItem)
+    {
+        mxRulerImpl->nColLeftPix = static_cast<sal_uInt16>(ConvertSizePixel(mxColumnItem->GetLeft()));
+        mxRulerImpl->nColRightPix = static_cast<sal_uInt16>(ConvertSizePixel(mxColumnItem->GetRight()));
+    }
+}
+
+void SvxRuler::MouseMove( const MouseEvent& rMEvt )
+{
+    if( bActive )
+    {
+        pBindings->Update( SID_RULER_LR_MIN_MAX );
+        pBindings->Update( SID_ATTR_LONG_ULSPACE );
+        pBindings->Update( SID_ATTR_LONG_LRSPACE );
+        pBindings->Update( SID_RULER_PAGE_POS );
+        pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL);
+        pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL);
+        pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
+        pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL);
+        pBindings->Update( SID_RULER_OBJECT );
+        pBindings->Update( SID_RULER_PROTECT );
+    }
+
+    Ruler::MouseMove( rMEvt );
+
+    RulerSelection aSelection = GetHoverSelection();
+
+    if (aSelection.eType == RulerType::DontKnow)
+    {
+        SetQuickHelpText("");
+        return;
+    }
+
+    RulerUnitData aUnitData = GetCurrentRulerUnit();
+    double aRoundingFactor = aUnitData.nTickUnit / aUnitData.nTick1;
+    sal_Int32 aNoDecimalPlaces = 1 + std::ceil(std::log10(aRoundingFactor));
+    OUString sUnit = OUString::createFromAscii(aUnitData.aUnitStr);
+
+    switch (aSelection.eType)
+    {
+        case RulerType::Indent:
+        {
+            if (!mxParaItem)
+                break;
+
+            tools::Long nIndex = aSelection.nAryPos + INDENT_GAP;
+
+            tools::Long nIndentValue = 0.0;
+            if (nIndex == INDENT_LEFT_MARGIN)
+                nIndentValue = mxParaItem->GetTextLeft();
+            else if (nIndex == INDENT_FIRST_LINE)
+                nIndentValue = mxParaItem->GetTextFirstLineOffset();
+            else if (nIndex == INDENT_RIGHT_MARGIN)
+                nIndentValue = mxParaItem->GetRight();
+
+            double fValue = OutputDevice::LogicToLogic(Size(nIndentValue, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
+            fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces);
+
+            SetQuickHelpText(OUString::number(fValue) + " " + sUnit);
+            break;
+        }
+        case RulerType::Border:
+        {
+            if (mxColumnItem == nullptr)
+                break;
+
+            SvxColumnItem& aColumnItem = *mxColumnItem;
+
+            if (aSelection.nAryPos + 1 >= aColumnItem.Count())
+                break;
+
+            double fStart = OutputDevice::LogicToLogic(Size(aColumnItem[aSelection.nAryPos].nEnd,       0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
+            fStart = rtl::math::round(fStart / aUnitData.nTickUnit, aNoDecimalPlaces);
+            double fEnd   = OutputDevice::LogicToLogic(Size(aColumnItem[aSelection.nAryPos + 1].nStart, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
+            fEnd = rtl::math::round(fEnd / aUnitData.nTickUnit, aNoDecimalPlaces);
+
+            SetQuickHelpText(
+                OUString::number(fStart) + " " + sUnit + " - " +
+                OUString::number(fEnd)   + " " + sUnit );
+            break;
+        }
+        case RulerType::Margin1:
+        {
+            tools::Long nLeft = 0.0;
+            if (mxLRSpaceItem)
+                nLeft = mxLRSpaceItem->GetLeft();
+            else if (mxULSpaceItem)
+                nLeft = mxULSpaceItem->GetUpper();
+            else
+                break;
+
+            double fValue = OutputDevice::LogicToLogic(Size(nLeft, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
+            fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces);
+            SetQuickHelpText(OUString::number(fValue) + " " + sUnit);
+
+            break;
+        }
+        case RulerType::Margin2:
+        {
+            tools::Long nRight = 0.0;
+            if (mxLRSpaceItem)
+                nRight = mxLRSpaceItem->GetRight();
+            else if (mxULSpaceItem)
+                nRight = mxULSpaceItem->GetLower();
+            else
+                break;
+
+            double fValue = OutputDevice::LogicToLogic(Size(nRight, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
+            fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces);
+            SetQuickHelpText(OUString::number(fValue) + " " + sUnit);
+
+            break;
+        }
+        default:
+        {
+            SetQuickHelpText("");
+            break;
+        }
+    }
+}
+
+void SvxRuler::StartListening_Impl()
+{
+    if(!bListening)
+    {
+        bValid = false;
+        StartListening(*pBindings);
+        bListening = true;
+    }
+}
+
+void SvxRuler::UpdateFrame(const SvxLongLRSpaceItem *pItem) // new value LRSpace
+{
+    /* Store new value LRSpace; delete old ones if possible */
+    if(bActive)
+    {
+        if(pItem)
+            mxLRSpaceItem.reset(new SvxLongLRSpaceItem(*pItem));
+        else
+            mxLRSpaceItem.reset();
+        StartListening_Impl();
+    }
+}
+
+void SvxRuler::UpdateFrameMinMax(const SfxRectangleItem *pItem) // value for MinMax
+{
+    /* Set new value for MinMax; delete old ones if possible */
+    if(bActive)
+    {
+        if(pItem)
+            mxMinMaxItem.reset(new SfxRectangleItem(*pItem));
+        else
+            mxMinMaxItem.reset();
+    }
+}
+
+
+void SvxRuler::UpdateFrame(const SvxLongULSpaceItem *pItem) // new value
+{
+    /* Update Right/bottom margin */
+    if(bActive && !bHorz)
+    {
+        if(pItem)
+            mxULSpaceItem.reset(new SvxLongULSpaceItem(*pItem));
+        else
+            mxULSpaceItem.reset();
+        StartListening_Impl();
+    }
+}
+
+void SvxRuler::Update( const SvxProtectItem* pItem )
+{
+    if( pItem )
+        mxRulerImpl->aProtectItem.reset(pItem->Clone());
+}
+
+void SvxRuler::UpdateTextRTL(const SfxBoolItem* pItem)
+{
+    if(bActive && bHorz)
+    {
+        mxRulerImpl->pTextRTLItem.reset();
+        if(pItem)
+            mxRulerImpl->pTextRTLItem.reset(new SfxBoolItem(*pItem));
+        SetTextRTL(mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue());
+        StartListening_Impl();
+    }
+}
+
+void SvxRuler::Update(
+                const SvxColumnItem *pItem,  // new value
+                sal_uInt16 nSID) //Slot Id to identify NULL items
+{
+    /* Set new value for column view */
+    if(!bActive)
+        return;
+
+    if(pItem)
+    {
+        mxColumnItem.reset(new SvxColumnItem(*pItem));
+        mxRulerImpl->bIsTableRows = (pItem->Which() == SID_RULER_ROWS || pItem->Which() == SID_RULER_ROWS_VERTICAL);
+        if(!bHorz && !mxRulerImpl->bIsTableRows)
+            mxColumnItem->SetWhich(SID_RULER_BORDERS_VERTICAL);
+    }
+    else if(mxColumnItem && mxColumnItem->Which() == nSID)
+    //there are two groups of column items table/frame columns and table rows
+    //both can occur in vertical or horizontal mode
+    //the horizontal ruler handles the SID_RULER_BORDERS and SID_RULER_ROWS_VERTICAL
+    //and the vertical handles SID_RULER_BORDERS_VERTICAL and SID_RULER_ROWS
+    //if mxColumnItem is already set with one of the ids then a NULL pItem argument
+    //must not delete it
+    {
+        mxColumnItem.reset();
+        mxRulerImpl->bIsTableRows = false;
+    }
+    StartListening_Impl();
+}
+
+
+void SvxRuler::UpdateColumns()
+{
+    /* Update column view */
+    if(mxColumnItem && mxColumnItem->Count() > 1)
+    {
+        mpBorders.resize(mxColumnItem->Count());
+
+        RulerBorderStyle nStyleFlags = RulerBorderStyle::Variable;
+
+        bool bProtectColumns =
+                    mxRulerImpl->aProtectItem->IsSizeProtected() ||
+                    mxRulerImpl->aProtectItem->IsPosProtected();
+
+        if( !bProtectColumns )
+        {
+            nStyleFlags |= RulerBorderStyle::Moveable;
+            if( !mxColumnItem->IsTable() )
+              nStyleFlags |= RulerBorderStyle::Sizeable;
+        }
+
+        sal_uInt16 nBorders = mxColumnItem->Count();
+
+        if(!mxRulerImpl->bIsTableRows)
+            --nBorders;
+
+        for(sal_uInt16 i = 0; i < nBorders; ++i)
+        {
+            mpBorders[i].nStyle = nStyleFlags;
+            if(!mxColumnItem->At(i).bVisible)
+                mpBorders[i].nStyle |= RulerBorderStyle::Invisible;
+
+            mpBorders[i].nPos = ConvertPosPixel(mxColumnItem->At(i).nEnd + lAppNullOffset);
+
+            if(mxColumnItem->Count() == i + 1)
+            {
+                //with table rows the end of the table is contained in the
+                //column item but it has no width!
+                mpBorders[i].nWidth = 0;
+            }
+            else
+            {
+                mpBorders[i].nWidth = ConvertSizePixel(mxColumnItem->At(i + 1).nStart - mxColumnItem->At(i).nEnd);
+            }
+            mpBorders[i].nMinPos = ConvertPosPixel(mxColumnItem->At(i).nEndMin + lAppNullOffset);
+            mpBorders[i].nMaxPos = ConvertPosPixel(mxColumnItem->At(i).nEndMax + lAppNullOffset);
+        }
+        SetBorders(mxColumnItem->Count() - 1, mpBorders.data());
+    }
+    else
+    {
+        SetBorders();
+    }
+}
+
+void SvxRuler::UpdateObject()
+{
+    /* Update view of object representation */
+    if (mxObjectItem)
+    {
+        DBG_ASSERT(!mpObjectBorders.empty(), "no Buffer");
+        // !! to the page margin
+        tools::Long nMargin = mxLRSpaceItem ? mxLRSpaceItem->GetLeft() : 0;
+        mpObjectBorders[0].nPos =
+            ConvertPosPixel(mxObjectItem->GetStartX() -
+                            nMargin + lAppNullOffset);
+        mpObjectBorders[1].nPos =
+            ConvertPosPixel(mxObjectItem->GetEndX() - nMargin + lAppNullOffset);
+        nMargin = mxULSpaceItem ? mxULSpaceItem->GetUpper() : 0;
+        mpObjectBorders[2].nPos =
+            ConvertPosPixel(mxObjectItem->GetStartY() -
+                            nMargin + lAppNullOffset);
+        mpObjectBorders[3].nPos =
+            ConvertPosPixel(mxObjectItem->GetEndY() - nMargin + lAppNullOffset);
+
+        const sal_uInt16 nOffset = GetObjectBordersOff(0);
+        SetBorders(2, mpObjectBorders.data() + nOffset);
+    }
+    else
+    {
+        SetBorders();
+    }
+}
+
+void SvxRuler::UpdatePara()
+{
+
+    /*  Update the view for paragraph indents:
+        Left margin, first line indent, right margin paragraph update
+        mpIndents[0] = Buffer for old intent
+        mpIndents[1] = Buffer for old intent
+        mpIndents[INDENT_FIRST_LINE]   = first line indent
+        mpIndents[INDENT_LEFT_MARGIN]  = left margin
+        mpIndents[INDENT_RIGHT_MARGIN] = right margin
+    */
+
+    // Dependence on PagePosItem
+    if (mxParaItem && mxPagePosItem && !mxObjectItem)
+    {
+        bool bRTLText = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
+        // First-line indent is negative to the left paragraph margin
+        tools::Long nLeftFrameMargin = GetLeftFrameMargin();
+        tools::Long nRightFrameMargin = GetRightFrameMargin();
+        SetLeftFrameMargin(ConvertHPosPixel(nLeftFrameMargin));
+        SetRightFrameMargin(ConvertHPosPixel(nRightFrameMargin));
+
+        tools::Long leftMargin;
+        tools::Long leftFirstLine;
+        tools::Long rightMargin;
+
+        if(bRTLText)
+        {
+            leftMargin    = nRightFrameMargin - mxParaItem->GetTextLeft() + lAppNullOffset;
+            leftFirstLine = leftMargin - mxParaItem->GetTextFirstLineOffset();
+            rightMargin   = nLeftFrameMargin + mxParaItem->GetRight() + lAppNullOffset;
+        }
+        else
+        {
+            leftMargin    = nLeftFrameMargin + mxParaItem->GetTextLeft() + lAppNullOffset;
+            leftFirstLine = leftMargin + mxParaItem->GetTextFirstLineOffset();
+            rightMargin   = nRightFrameMargin - mxParaItem->GetRight() + lAppNullOffset;
+        }
+
+        mpIndents[INDENT_LEFT_MARGIN].nPos  = ConvertHPosPixel(leftMargin);
+        mpIndents[INDENT_FIRST_LINE].nPos   = ConvertHPosPixel(leftFirstLine);
+        mpIndents[INDENT_RIGHT_MARGIN].nPos = ConvertHPosPixel(rightMargin);
+
+        mpIndents[INDENT_FIRST_LINE].bInvisible = mxParaItem->IsAutoFirst();
+
+        SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+    }
+    else
+    {
+        if(!mpIndents.empty())
+        {
+            mpIndents[INDENT_FIRST_LINE].nPos = 0;
+            mpIndents[INDENT_LEFT_MARGIN].nPos = 0;
+            mpIndents[INDENT_RIGHT_MARGIN].nPos = 0;
+        }
+        SetIndents(); // turn off
+    }
+}
+
+void SvxRuler::UpdatePara(const SvxLRSpaceItem *pItem) // new value of paragraph indents
+{
+    /* Store new value of paragraph indents */
+    if(bActive)
+    {
+        if(pItem)
+            mxParaItem.reset(new SvxLRSpaceItem(*pItem));
+        else
+            mxParaItem.reset();
+        StartListening_Impl();
+    }
+}
+
+void SvxRuler::UpdateBorder(const SvxLRSpaceItem * pItem)
+{
+    /* Border distance */
+    if(bActive)
+    {
+        if (pItem)
+            mxBorderItem.reset(new SvxLRSpaceItem(*pItem));
+        else
+            mxBorderItem.reset();
+
+        StartListening_Impl();
+    }
+}
+
+void SvxRuler::UpdatePage()
+{
+    /* Update view of position and width of page */
+    if (mxPagePosItem)
+    {
+        // all objects are automatically adjusted
+        if(bHorz)
+        {
+            SetPagePos(
+                pEditWin->LogicToPixel(mxPagePosItem->GetPos()).X(),
+                pEditWin->LogicToPixel(Size(mxPagePosItem->GetWidth(), 0)).
+                Width());
+        }
+        else
+        {
+            SetPagePos(
+                pEditWin->LogicToPixel(mxPagePosItem->GetPos()).Y(),
+                pEditWin->LogicToPixel(Size(0, mxPagePosItem->GetHeight())).
+                Height());
+        }
+        if(bAppSetNullOffset)
+            SetNullOffset(ConvertSizePixel(-lAppNullOffset + lLogicNullOffset));
+    }
+    else
+    {
+        SetPagePos();
+    }
+
+    tools::Long lPos = 0;
+    Point aOwnPos = GetPosPixel();
+    Point aEdtWinPos = pEditWin->GetPosPixel();
+    if( AllSettings::GetLayoutRTL() && bHorz )
+    {
+        //#i73321# in RTL the window and the ruler is not mirrored but the
+        // influence of the vertical ruler is inverted
+        Size aOwnSize = GetSizePixel();
+        Size aEdtWinSize = pEditWin->GetSizePixel();
+        lPos = aOwnSize.Width() - aEdtWinSize.Width();
+        lPos -= (aEdtWinPos - aOwnPos).X();
+    }
+    else
+    {
+        Point aPos(aEdtWinPos - aOwnPos);
+        lPos = bHorz ? aPos.X() : aPos.Y();
+    }
+
+    // Unfortunately, we get the offset of the edit window to the ruler never
+    // through a status message. So we set it ourselves if necessary.
+    if(lPos != mxRulerImpl->lOldWinPos)
+    {
+        mxRulerImpl->lOldWinPos=lPos;
+        SetWinPos(lPos);
+    }
+}
+
+void SvxRuler::Update(const SvxPagePosSizeItem *pItem) // new value of page attributes
+{
+    /* Store new value of page attributes */
+    if(bActive)
+    {
+        if(pItem)
+            mxPagePosItem.reset(new SvxPagePosSizeItem(*pItem));
+        else
+            mxPagePosItem.reset();
+        StartListening_Impl();
+    }
+}
+
+void SvxRuler::SetDefTabDist(tools::Long inDefTabDist)  // New distance for DefaultTabs in App-Metrics
+{
+    if (lAppNullOffset == LONG_MAX)
+        UpdateFrame(); // hack: try to get lAppNullOffset initialized
+    /* New distance is set for DefaultTabs */
+    lDefTabDist = inDefTabDist;
+    if( !lDefTabDist )
+        lDefTabDist = 1;
+
+    UpdateTabs();
+}
+
+static sal_uInt16 ToSvTab_Impl(SvxTabAdjust eAdj)
+{
+    /* Internal conversion routine between SV-Tab.-Enum and Svx */
+    switch(eAdj) {
+        case SvxTabAdjust::Left:    return RULER_TAB_LEFT;
+        case SvxTabAdjust::Right:   return RULER_TAB_RIGHT;
+        case SvxTabAdjust::Decimal: return RULER_TAB_DECIMAL;
+        case SvxTabAdjust::Center:  return RULER_TAB_CENTER;
+        case SvxTabAdjust::Default: return RULER_TAB_DEFAULT;
+        default: ; //prevent warning
+    }
+    return 0;
+}
+
+static SvxTabAdjust ToAttrTab_Impl(sal_uInt16 eAdj)
+{
+    switch(eAdj) {
+        case RULER_TAB_LEFT:    return SvxTabAdjust::Left    ;
+        case RULER_TAB_RIGHT:   return SvxTabAdjust::Right   ;
+        case RULER_TAB_DECIMAL: return SvxTabAdjust::Decimal ;
+        case RULER_TAB_CENTER:  return SvxTabAdjust::Center  ;
+        case RULER_TAB_DEFAULT: return SvxTabAdjust::Default ;
+    }
+    return SvxTabAdjust::Left;
+}
+
+void SvxRuler::UpdateTabs()
+{
+    if(IsDrag())
+        return;
+
+    if (mxPagePosItem && mxParaItem && mxTabStopItem && !mxObjectItem)
+    {
+        // buffer for DefaultTabStop
+        // Distance last Tab <-> Right paragraph margin / DefaultTabDist
+        bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
+
+        const tools::Long nLeftFrameMargin = GetLeftFrameMargin();
+        const tools::Long nRightFrameMargin = GetRightFrameMargin();
+
+        //#i24363# tab stops relative to indent
+        const tools::Long nParaItemTxtLeft = mxParaItem->GetTextLeft();
+
+        const tools::Long lParaIndent = nLeftFrameMargin + nParaItemTxtLeft;
+        const tools::Long lRightMargin = nRightFrameMargin - nParaItemTxtLeft;
+
+        const tools::Long lLastTab = mxTabStopItem->Count()
+                                ? ConvertHPosPixel(mxTabStopItem->At(mxTabStopItem->Count() - 1).GetTabPos())
+                                : 0;
+        const tools::Long lPosPixel = ConvertHPosPixel(lParaIndent) + lLastTab;
+        const tools::Long lRightIndent = ConvertHPosPixel(nRightFrameMargin - mxParaItem->GetRight());
+
+        tools::Long lCurrentDefTabDist = lDefTabDist;
+        if(mxTabStopItem->GetDefaultDistance())
+            lCurrentDefTabDist = mxTabStopItem->GetDefaultDistance();
+        tools::Long nDefTabDist = ConvertHPosPixel(lCurrentDefTabDist);
+
+        const sal_uInt16 nDefTabBuf = lPosPixel > lRightIndent || lLastTab > lRightIndent
+                    ? 0
+                    : static_cast<sal_uInt16>( (lRightIndent - lPosPixel) / nDefTabDist );
+
+        if(mxTabStopItem->Count() + TAB_GAP + nDefTabBuf > nTabBufSize)
+        {
+            // 10 (GAP) in stock
+            nTabBufSize = mxTabStopItem->Count() + TAB_GAP + nDefTabBuf + GAP;
+            mpTabs.resize(nTabBufSize);
+        }
+
+        nTabCount = 0;
+        sal_uInt16 j;
+
+        const tools::Long lParaIndentPix = ConvertSizePixel(lParaIndent);
+
+        tools::Long lTabStartLogic = (mxRulerImpl->bIsTabsRelativeToIndent ? lParaIndent : nLeftFrameMargin)
+            + lAppNullOffset;
+        if (bRTL)
+        {
+            lTabStartLogic = lParaIndent + lRightMargin - lTabStartLogic;
+        }
+        tools::Long lLastTabOffsetLogic = 0;
+        for(j = 0; j < mxTabStopItem->Count(); ++j)
+        {
+            const SvxTabStop* pTab = &mxTabStopItem->At(j);
+            lLastTabOffsetLogic = pTab->GetTabPos();
+            tools::Long lPos = lTabStartLogic + (bRTL ? -lLastTabOffsetLogic : lLastTabOffsetLogic);
+            mpTabs[nTabCount + TAB_GAP].nPos = ConvertHPosPixel(lPos);
+            mpTabs[nTabCount + TAB_GAP].nStyle = ToSvTab_Impl(pTab->GetAdjustment());
+            ++nTabCount;
+        }
+
+        // Adjust to previous-to-first default tab stop
+        lLastTabOffsetLogic -= lLastTabOffsetLogic % lCurrentDefTabDist;
+
+        // fill the rest with default Tabs
+        for (j = 0; j < nDefTabBuf; ++j)
+        {
+            //simply add the default distance to the last position
+            lLastTabOffsetLogic += lCurrentDefTabDist;
+            if (bRTL)
+            {
+                mpTabs[nTabCount + TAB_GAP].nPos =
+                    ConvertHPosPixel(lTabStartLogic - lLastTabOffsetLogic);
+                if (mpTabs[nTabCount + TAB_GAP].nPos <= lParaIndentPix)
+                    break;
+            }
+            else
+            {
+                mpTabs[nTabCount + TAB_GAP].nPos =
+                    ConvertHPosPixel(lTabStartLogic + lLastTabOffsetLogic);
+                if (mpTabs[nTabCount + TAB_GAP].nPos >= lRightIndent)
+                    break;
+            }
+
+            mpTabs[nTabCount + TAB_GAP].nStyle = RULER_TAB_DEFAULT;
+            ++nTabCount;
+        }
+        SetTabs(nTabCount, mpTabs.data() + TAB_GAP);
+        DBG_ASSERT(nTabCount + TAB_GAP <= nTabBufSize, "BufferSize too small");
+    }
+    else
+    {
+        SetTabs();
+    }
+}
+
+void SvxRuler::Update(const SvxTabStopItem *pItem) // new value for tabs
+{
+    /* Store new value for tabs; delete old ones if possible */
+    if(!bActive)
+        return;
+
+    if(pItem)
+    {
+        mxTabStopItem.reset(new SvxTabStopItem(*pItem));
+        if(!bHorz)
+            mxTabStopItem->SetWhich(SID_ATTR_TABSTOP_VERTICAL);
+    }
+    else
+    {
+        mxTabStopItem.reset();
+    }
+    StartListening_Impl();
+}
+
+void SvxRuler::Update(const SvxObjectItem *pItem) // new value for objects
+{
+    /* Store new value for objects */
+    if(bActive)
+    {
+        if(pItem)
+            mxObjectItem.reset(new SvxObjectItem(*pItem));
+        else
+            mxObjectItem.reset();
+        StartListening_Impl();
+    }
+}
+
+void SvxRuler::SetNullOffsetLogic(tools::Long lVal) // Setting of the logic NullOffsets
+{
+    lAppNullOffset = lLogicNullOffset - lVal;
+    bAppSetNullOffset = true;
+    Ruler::SetNullOffset(ConvertSizePixel(lVal));
+    Update();
+}
+
+void SvxRuler::Update()
+{
+    /* Perform update of view */
+    if(IsDrag())
+        return;
+
+    UpdatePage();
+    UpdateFrame();
+    if(nFlags & SvxRulerSupportFlags::OBJECT)
+        UpdateObject();
+    else
+        UpdateColumns();
+
+    if(nFlags & (SvxRulerSupportFlags::PARAGRAPH_MARGINS | SvxRulerSupportFlags::PARAGRAPH_MARGINS_VERTICAL))
+      UpdatePara();
+
+    if(nFlags & SvxRulerSupportFlags::TABS)
+      UpdateTabs();
+}
+
+tools::Long SvxRuler::GetPageWidth() const
+{
+    if (!mxPagePosItem)
+        return 0;
+    return bHorz ? mxPagePosItem->GetWidth() : mxPagePosItem->GetHeight();
+}
+
+inline tools::Long SvxRuler::GetFrameLeft() const
+{
+    /* Get Left margin in Pixels */
+    return  bAppSetNullOffset ?
+            GetMargin1() + ConvertSizePixel(lLogicNullOffset) :
+            Ruler::GetNullOffset();
+}
+
+tools::Long SvxRuler::GetFirstLineIndent() const
+{
+    /* Get First-line indent in pixels */
+    return mxParaItem ? mpIndents[INDENT_FIRST_LINE].nPos : GetMargin1();
+}
+
+tools::Long SvxRuler::GetLeftIndent() const
+{
+    /* Get Left paragraph margin in Pixels */
+    return mxParaItem ? mpIndents[INDENT_LEFT_MARGIN].nPos : GetMargin1();
+}
+
+tools::Long SvxRuler::GetRightIndent() const
+{
+    /* Get Right paragraph margin in Pixels */
+    return mxParaItem ? mpIndents[INDENT_RIGHT_MARGIN].nPos : GetMargin2();
+}
+
+tools::Long SvxRuler::GetLogicRightIndent() const
+{
+    /* Get Right paragraph margin in Logic */
+    return mxParaItem ? GetRightFrameMargin() - mxParaItem->GetRight() : GetRightFrameMargin();
+}
+
+// Left margin in App values, is either the margin (= 0)  or the left edge of
+// the column that is set in the column attribute as current column.
+tools::Long SvxRuler::GetLeftFrameMargin() const
+{
+    // #126721# for some unknown reason the current column is set to 0xffff
+    DBG_ASSERT(!mxColumnItem || mxColumnItem->GetActColumn() < mxColumnItem->Count(),
+               "issue #126721# - invalid current column!");
+    tools::Long nLeft = 0;
+    if (mxColumnItem &&
+        mxColumnItem->Count() &&
+        mxColumnItem->IsConsistent())
+    {
+        nLeft = mxColumnItem->GetActiveColumnDescription().nStart;
+    }
+
+    if (mxBorderItem && (!mxColumnItem || mxColumnItem->IsTable()))
+        nLeft += mxBorderItem->GetLeft();
+
+    return nLeft;
+}
+
+inline tools::Long SvxRuler::GetLeftMin() const
+{
+    DBG_ASSERT(mxMinMaxItem, "no MinMax value set");
+    if (mxMinMaxItem)
+    {
+        if (bHorz)
+            return mxMinMaxItem->GetValue().Left();
+        else
+            return mxMinMaxItem->GetValue().Top();
+    }
+    return 0;
+}
+
+inline tools::Long SvxRuler::GetRightMax() const
+{
+    DBG_ASSERT(mxMinMaxItem, "no MinMax value set");
+    if (mxMinMaxItem)
+    {
+        if (bHorz)
+            return mxMinMaxItem->GetValue().Right();
+        else
+            return mxMinMaxItem->GetValue().Bottom();
+    }
+    return 0;
+}
+
+
+tools::Long SvxRuler::GetRightFrameMargin() const
+{
+    /* Get right frame margin (in logical units) */
+    if (mxColumnItem)
+    {
+        if (!IsActLastColumn(true))
+        {
+            return mxColumnItem->At(GetActRightColumn(true)).nEnd;
+        }
+    }
+
+    tools::Long lResult = lLogicNullOffset;
+
+    // If possible deduct right table entry
+    if(mxColumnItem && mxColumnItem->IsTable())
+        lResult += mxColumnItem->GetRight();
+    else if(bHorz && mxLRSpaceItem)
+        lResult += mxLRSpaceItem->GetRight();
+    else if(!bHorz && mxULSpaceItem)
+        lResult += mxULSpaceItem->GetLower();
+
+    if (bHorz && mxBorderItem && (!mxColumnItem || mxColumnItem->IsTable()))
+        lResult += mxBorderItem->GetRight();
+
+    if(bHorz)
+        lResult = mxPagePosItem->GetWidth() - lResult;
+    else
+        lResult = mxPagePosItem->GetHeight() - lResult;
+
+    return lResult;
+}
+
+#define NEG_FLAG ( (nFlags & SvxRulerSupportFlags::NEGATIVE_MARGINS) == \
+                   SvxRulerSupportFlags::NEGATIVE_MARGINS )
+#define TAB_FLAG ( mxColumnItem && mxColumnItem->IsTable() )
+
+tools::Long SvxRuler::GetCorrectedDragPos( bool bLeft, bool bRight )
+{
+    /*
+        Corrects the position within the calculated limits. The limit values are in
+        pixels relative to the page edge.
+    */
+
+    const tools::Long lNullPix = Ruler::GetNullOffset();
+    tools::Long lDragPos = GetDragPos() + lNullPix;
+    bool bHoriRows = bHorz && mxRulerImpl->bIsTableRows;
+    if((bLeft || bHoriRows) && lDragPos < nMaxLeft)
+        lDragPos = nMaxLeft;
+    else if((bRight||bHoriRows) && lDragPos > nMaxRight)
+        lDragPos = nMaxRight;
+    return lDragPos - lNullPix;
+}
+
+static void ModifyTabs_Impl( sal_uInt16 nCount, // Number of Tabs
+                      RulerTab* pTabs,   // Tab buffer
+                      tools::Long lDiff)        // difference to be added
+{
+    /* Helper function, move all the tabs by a fixed value */
+    if( pTabs )
+    {
+        for(sal_uInt16 i = 0; i < nCount; ++i)
+        {
+            pTabs[i].nPos += lDiff;
+        }
+    }
+}
+
+void SvxRuler::DragMargin1()
+{
+    /* Dragging the left edge of frame */
+    tools::Long aDragPosition = GetCorrectedDragPos( !TAB_FLAG || !NEG_FLAG );
+
+    aDragPosition = MakePositionSticky(aDragPosition, GetRightFrameMargin(), false);
+
+    // Check if position changed
+    if (aDragPosition == 0)
+        return;
+
+    DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 3 : 7, bHorz);
+    if (mxColumnItem && (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL))
+        DragBorders();
+    AdjustMargin1(aDragPosition);
+}
+
+void SvxRuler::AdjustMargin1(tools::Long lInputDiff)
+{
+    const tools::Long nOld = bAppSetNullOffset? GetMargin1(): GetNullOffset();
+    const tools::Long lDragPos = lInputDiff;
+
+    bool bProtectColumns =
+        mxRulerImpl->aProtectItem->IsSizeProtected() ||
+        mxRulerImpl->aProtectItem->IsPosProtected();
+
+    const RulerMarginStyle nMarginStyle =
+        bProtectColumns ? RulerMarginStyle::NONE : RulerMarginStyle::Sizeable;
+
+    if(!bAppSetNullOffset)
+    {
+        tools::Long lDiff = lDragPos;
+        SetNullOffset(nOld + lDiff);
+        if (!mxColumnItem || !(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR))
+        {
+            SetMargin2( GetMargin2() - lDiff, nMarginStyle );
+
+            if (!mxColumnItem && !mxObjectItem && mxParaItem)
+            {
+                // Right indent of the old position
+                mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff;
+                SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+            }
+            if (mxObjectItem)
+            {
+                mpObjectBorders[GetObjectBordersOff(0)].nPos -= lDiff;
+                mpObjectBorders[GetObjectBordersOff(1)].nPos -= lDiff;
+                SetBorders(2, mpObjectBorders.data() + GetObjectBordersOff(0));
+            }
+            if (mxColumnItem)
+            {
+                for(sal_uInt16 i = 0; i < mxColumnItem->Count()-1; ++i)
+                    mpBorders[i].nPos -= lDiff;
+                SetBorders(mxColumnItem->Count()-1, mpBorders.data());
+                if(mxColumnItem->IsFirstAct())
+                {
+                    // Right indent of the old position
+                    if (mxParaItem)
+                    {
+                        mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff;
+                        SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+                    }
+                }
+                else
+                {
+                    if (mxParaItem)
+                    {
+                        mpIndents[INDENT_FIRST_LINE].nPos -= lDiff;
+                        mpIndents[INDENT_LEFT_MARGIN].nPos -= lDiff;
+                        mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff;
+                        SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+                    }
+                }
+                if(mxTabStopItem && (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
+                   &&!IsActFirstColumn())
+                {
+                    ModifyTabs_Impl(nTabCount + TAB_GAP, mpTabs.data(), -lDiff);
+                    SetTabs(nTabCount, mpTabs.data() + TAB_GAP);
+                }
+            }
+        }
+    }
+    else
+    {
+        tools::Long lDiff = lDragPos - nOld;
+        SetMargin1(nOld + lDiff, nMarginStyle);
+
+        if (!mxColumnItem
+            || !(nDragType
+                 & (SvxRulerDragFlags::OBJECT_SIZE_LINEAR
+                    | SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)))
+        {
+            if (!mxColumnItem && !mxObjectItem && mxParaItem)
+            {
+                // Left indent of the old position
+                mpIndents[INDENT_FIRST_LINE].nPos += lDiff;
+                mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff;
+                SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+            }
+
+            if (mxColumnItem)
+            {
+                for(sal_uInt16 i = 0; i < mxColumnItem->Count() - 1; ++i)
+                    mpBorders[i].nPos += lDiff;
+                SetBorders(mxColumnItem->Count() - 1, mpBorders.data());
+                if (mxColumnItem->IsFirstAct())
+                {
+                    // Left indent of the old position
+                    if (mxParaItem)
+                    {
+                        mpIndents[INDENT_FIRST_LINE].nPos += lDiff;
+                        mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff;
+                        SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+                    }
+                }
+                else
+                {
+                    if (mxParaItem)
+                    {
+                        mpIndents[INDENT_FIRST_LINE].nPos += lDiff;
+                        mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff;
+                        mpIndents[INDENT_RIGHT_MARGIN].nPos += lDiff;
+                        SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+                    }
+                }
+            }
+            if (mxTabStopItem)
+            {
+                ModifyTabs_Impl(nTabCount + TAB_GAP, mpTabs.data(), lDiff);
+                SetTabs(nTabCount, mpTabs.data() + TAB_GAP);
+            }
+        }
+    }
+}
+
+void SvxRuler::DragMargin2()
+{
+    /* Dragging the right edge of frame */
+    tools::Long aDragPosition = GetCorrectedDragPos( true, !TAB_FLAG || !NEG_FLAG);
+    aDragPosition = MakePositionSticky(aDragPosition, GetLeftFrameMargin(), false);
+    tools::Long lDiff = aDragPosition - GetMargin2();
+
+    // Check if position changed
+    if (lDiff == 0)
+        return;
+
+    if( mxRulerImpl->bIsTableRows &&
+        !bHorz &&
+        mxColumnItem &&
+        (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL))
+    {
+        DragBorders();
+    }
+
+    bool bProtectColumns =
+        mxRulerImpl->aProtectItem->IsSizeProtected() ||
+        mxRulerImpl->aProtectItem->IsPosProtected();
+
+    const RulerMarginStyle nMarginStyle = bProtectColumns ? RulerMarginStyle::NONE : RulerMarginStyle::Sizeable;
+
+    SetMargin2( aDragPosition, nMarginStyle );
+
+    // Right indent of the old position
+    if ((!mxColumnItem || IsActLastColumn()) && mxParaItem)
+    {
+        mpIndents[INDENT_FIRST_LINE].nPos += lDiff;
+        SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+    }
+
+    DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 5 : 7, bHorz);
+}
+
+void SvxRuler::DragIndents()
+{
+    /* Dragging the paragraph indents */
+    tools::Long aDragPosition = NEG_FLAG ? GetDragPos() : GetCorrectedDragPos();
+    const sal_uInt16 nIndex = GetDragAryPos() + INDENT_GAP;
+
+    bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
+
+    if(nIndex == INDENT_RIGHT_MARGIN)
+        aDragPosition = MakePositionSticky(aDragPosition, bRTL ? GetLeftFrameMargin() : GetRightFrameMargin());
+    else
+        aDragPosition = MakePositionSticky(aDragPosition, bRTL ? GetRightFrameMargin() : GetLeftFrameMargin());
+
+    const tools::Long lDiff = mpIndents[nIndex].nPos - aDragPosition;
+
+    // Check if position changed
+    if (lDiff == 0)
+        return;
+
+    if((nIndex == INDENT_FIRST_LINE || nIndex == INDENT_LEFT_MARGIN )  &&
+        !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY))
+    {
+        mpIndents[INDENT_FIRST_LINE].nPos -= lDiff;
+    }
+
+    mpIndents[nIndex].nPos = aDragPosition;
+
+    SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+    DrawLine_Impl(lTabPos, 1, bHorz);
+}
+
+void SvxRuler::DrawLine_Impl(tools::Long& lTabPosition, int nNew, bool bHorizontal)
+{
+    /*
+       Output routine for the ledger line when moving tabs, tables and other
+       columns
+    */
+    if(bHorizontal)
+    {
+        const tools::Long nHeight = pEditWin->GetOutDev()->GetOutputSize().Height();
+        Point aZero = pEditWin->GetMapMode().GetOrigin();
+        if(lTabPosition != -1)
+        {
+            pEditWin->InvertTracking(
+                tools::Rectangle( Point(lTabPosition, -aZero.Y()),
+                           Point(lTabPosition, -aZero.Y() + nHeight)),
+                ShowTrackFlags::Split | ShowTrackFlags::Clip );
+        }
+        if( nNew & 1 )
+        {
+            tools::Long nDrapPosition = GetCorrectedDragPos( ( nNew & 4 ) != 0, ( nNew & 2 ) != 0 );
+            nDrapPosition = MakePositionSticky(nDrapPosition, GetLeftFrameMargin());
+            lTabPosition = ConvertHSizeLogic( nDrapPosition + GetNullOffset() );
+            if (mxPagePosItem)
+                lTabPosition += mxPagePosItem->GetPos().X();
+            pEditWin->InvertTracking(
+                tools::Rectangle( Point(lTabPosition, -aZero.Y()),
+                           Point(lTabPosition, -aZero.Y() + nHeight) ),
+                ShowTrackFlags::Clip | ShowTrackFlags::Split );
+        }
+    }
+    else
+    {
+        const tools::Long nWidth = pEditWin->GetOutDev()->GetOutputSize().Width();
+        Point aZero = pEditWin->GetMapMode().GetOrigin();
+        if(lTabPosition != -1)
+        {
+            pEditWin->InvertTracking(
+                tools::Rectangle( Point(-aZero.X(),          lTabPosition),
+                           Point(-aZero.X() + nWidth, lTabPosition)),
+                ShowTrackFlags::Split | ShowTrackFlags::Clip );
+        }
+
+        if(nNew & 1)
+        {
+            tools::Long nDrapPosition = GetCorrectedDragPos();
+            nDrapPosition = MakePositionSticky(nDrapPosition, GetLeftFrameMargin());
+            lTabPosition = ConvertVSizeLogic(nDrapPosition + GetNullOffset());
+            if (mxPagePosItem)
+                lTabPosition += mxPagePosItem->GetPos().Y();
+            pEditWin->InvertTracking(
+                tools::Rectangle( Point(-aZero.X(),        lTabPosition),
+                           Point(-aZero.X()+nWidth, lTabPosition)),
+                ShowTrackFlags::Clip | ShowTrackFlags::Split );
+        }
+    }
+}
+
+void SvxRuler::DragTabs()
+{
+    /* Dragging of Tabs */
+    tools::Long aDragPosition = GetCorrectedDragPos(true, false);
+    aDragPosition = MakePositionSticky(aDragPosition, GetLeftFrameMargin());
+
+    sal_uInt16 nIdx = GetDragAryPos() + TAB_GAP;
+    tools::Long nDiff = aDragPosition - mpTabs[nIdx].nPos;
+    if (nDiff == 0)
+        return;
+
+    DrawLine_Impl(lTabPos, 7, bHorz);
+
+    if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR)
+    {
+
+        for(sal_uInt16 i = nIdx; i < nTabCount; ++i)
+        {
+            mpTabs[i].nPos += nDiff;
+            // limit on maximum
+            if(mpTabs[i].nPos > GetMargin2())
+                mpTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
+            else
+                mpTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE;
+        }
+    }
+    else if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
+    {
+        mxRulerImpl->nTotalDist -= nDiff;
+        mpTabs[nIdx].nPos = aDragPosition;
+        for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i)
+        {
+            if(mpTabs[i].nStyle & RULER_TAB_DEFAULT)
+                // can be canceled at the DefaultTabs
+                break;
+            tools::Long nDelta = mxRulerImpl->nTotalDist * mxRulerImpl->pPercBuf[i];
+            nDelta /= 1000;
+            mpTabs[i].nPos = mpTabs[nIdx].nPos + nDelta;
+            if(mpTabs[i].nPos + GetNullOffset() > nMaxRight)
+                mpTabs[i].nStyle |= RULER_STYLE_INVISIBLE;
+            else
+                mpTabs[i].nStyle &= ~RULER_STYLE_INVISIBLE;
+        }
+    }
+    else
+    {
+        mpTabs[nIdx].nPos = aDragPosition;
+    }
+
+    if(IsDragDelete())
+        mpTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
+    else
+        mpTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE;
+    SetTabs(nTabCount, mpTabs.data() + TAB_GAP);
+}
+
+void SvxRuler::SetActive(bool bOn)
+{
+    if(bOn)
+    {
+        Activate();
+    }
+    else
+        Deactivate();
+    if(bActive!=bOn)
+    {
+        pBindings->EnterRegistrations();
+        if(bOn)
+            for(sal_uInt16 i=0;i<mxRulerImpl->nControllerItems;i++)
+                pCtrlItems[i]->ReBind();
+        else
+            for(sal_uInt16 j=0;j<mxRulerImpl->nControllerItems;j++)
+                pCtrlItems[j]->UnBind();
+        pBindings->LeaveRegistrations();
+    }
+    bActive = bOn;
+}
+
+void SvxRuler::UpdateParaContents_Impl(
+                            tools::Long lDifference,
+                            UpdateType eType)  // Art (all, left or right)
+{
+    /* Helper function; carry Tabs and Paragraph Margins */
+    switch(eType)
+    {
+        case UpdateType::MoveRight:
+            mpIndents[INDENT_RIGHT_MARGIN].nPos += lDifference;
+            break;
+        case UpdateType::MoveLeft:
+        {
+            mpIndents[INDENT_FIRST_LINE].nPos += lDifference;
+            mpIndents[INDENT_LEFT_MARGIN].nPos += lDifference;
+            if (!mpTabs.empty())
+            {
+                for(sal_uInt16 i = 0; i < nTabCount+TAB_GAP; ++i)
+                {
+                    mpTabs[i].nPos += lDifference;
+                }
+                SetTabs(nTabCount, mpTabs.data() + TAB_GAP);
+            }
+            break;
+        }
+    }
+    SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+}
+
+void SvxRuler::DragBorders()
+{
+    /* Dragging of Borders (Tables and other columns) */
+    bool bLeftIndentsCorrected  = false;
+    bool bRightIndentsCorrected = false;
+    int nIndex;
+
+    if(GetDragType() == RulerType::Border)
+    {
+        DrawLine_Impl(lTabPos, 7, bHorz);
+        nIndex = GetDragAryPos();
+    }
+    else
+    {
+        nIndex = 0;
+    }
+
+    RulerDragSize nDragSize = GetDragSize();
+    tools::Long lDiff = 0;
+
+    // the drag position has to be corrected to be able to prevent borders from passing each other
+    tools::Long lPos = MakePositionSticky(GetCorrectedDragPos(), GetLeftFrameMargin());
+
+    switch(nDragSize)
+    {
+        case RulerDragSize::Move:
+        {
+            if(GetDragType() == RulerType::Border)
+                lDiff = lPos - nDragOffset - mpBorders[nIndex].nPos;
+            else
+                lDiff = GetDragType() == RulerType::Margin1 ? lPos - mxRulerImpl->lLastLMargin : lPos - mxRulerImpl->lLastRMargin;
+
+            if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR)
+            {
+                tools::Long nRight = GetMargin2() - glMinFrame; // Right limiters
+                for(int i = mpBorders.size() - 2; i >= nIndex; --i)
+                {
+                    tools::Long l = mpBorders[i].nPos;
+                    mpBorders[i].nPos += lDiff;
+                    mpBorders[i].nPos = std::min(mpBorders[i].nPos, nRight - mpBorders[i].nWidth);
+                    nRight = mpBorders[i].nPos - glMinFrame;
+                    // RR update the column
+                    if(i == GetActRightColumn())
+                    {
+                        UpdateParaContents_Impl(mpBorders[i].nPos - l, UpdateType::MoveRight);
+                        bRightIndentsCorrected = true;
+                    }
+                    // LAR, EZE update the column
+                    else if(i == GetActLeftColumn())
+                    {
+                        UpdateParaContents_Impl(mpBorders[i].nPos - l, UpdateType::MoveLeft);
+                        bLeftIndentsCorrected = true;
+                    }
+                }
+            }
+            else if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
+            {
+                int nLimit;
+                tools::Long lLeft;
+                int nStartLimit = mpBorders.size() - 2;
+                switch(GetDragType())
+                {
+                default: ;//prevent warning
+                    OSL_FAIL("svx::SvxRuler::DragBorders(), unknown drag type!" );
+                    [[fallthrough]];
+                case RulerType::Border:
+                    if(mxRulerImpl->bIsTableRows)
+                    {
+                        mpBorders[nIndex].nPos += lDiff;
+                        if(bHorz)
+                        {
+                            lLeft = mpBorders[nIndex].nPos;
+                            mxRulerImpl->nTotalDist -= lDiff;
+                            nLimit = nIndex + 1;
+                        }
+                        else
+                        {
+                            lLeft = 0;
+                            nStartLimit = nIndex - 1;
+                            mxRulerImpl->nTotalDist += lDiff;
+                            nLimit = 0;
+                        }
+                    }
+                    else
+                    {
+                        nLimit = nIndex + 1;
+                        mpBorders[nIndex].nPos += lDiff;
+                        lLeft = mpBorders[nIndex].nPos;
+                        mxRulerImpl->nTotalDist -= lDiff;
+                    }
+                break;
+                case RulerType::Margin1:
+                    nLimit = 0;
+                    lLeft = mxRulerImpl->lLastLMargin + lDiff;
+                    mxRulerImpl->nTotalDist -= lDiff;
+                break;
+                case RulerType::Margin2:
+                    nLimit = 0;
+                    lLeft= 0;
+                    nStartLimit = mpBorders.size() - 2;
+                    mxRulerImpl->nTotalDist += lDiff;
+                break;
+                }
+
+                for(int i  = nStartLimit; i >= nLimit; --i)
+                {
+
+                    tools::Long l = mpBorders[i].nPos;
+                    mpBorders[i].nPos =
+                        lLeft +
+                        (mxRulerImpl->nTotalDist * mxRulerImpl->pPercBuf[i]) / 1000 +
+                        mxRulerImpl->pBlockBuf[i];
+
+                    // RR update the column
+                    if(!mxRulerImpl->bIsTableRows)
+                    {
+                        if(i == GetActRightColumn())
+                        {
+                            UpdateParaContents_Impl(mpBorders[i].nPos - l, UpdateType::MoveRight);
+                            bRightIndentsCorrected = true;
+                        }
+                        // LAR, EZE update the column
+                        else if(i == GetActLeftColumn())
+                        {
+                            UpdateParaContents_Impl(mpBorders[i].nPos - l, UpdateType::MoveLeft);
+                            bLeftIndentsCorrected = true;
+                        }
+                    }
+                }
+                if(mxRulerImpl->bIsTableRows)
+                {
+                    //in vertical tables the left borders have to be moved
+                    if(bHorz)
+                    {
+                        for(int i  = 0; i < nIndex; ++i)
+                            mpBorders[i].nPos += lDiff;
+                        AdjustMargin1(lDiff);
+                    }
+                    else
+                    {
+                        //otherwise the right borders are moved
+                        for(int i  = mxColumnItem->Count() - 1; i > nIndex; --i)
+                            mpBorders[i].nPos += lDiff;
+                        SetMargin2( GetMargin2() + lDiff, RulerMarginStyle::NONE );
+                    }
+                }
+            }
+            else if(mxRulerImpl->bIsTableRows)
+            {
+                //moving rows: if a row is resized all following rows
+                //have to be moved by the same amount.
+                //This includes the left border when the table is not limited
+                //to a lower frame border.
+                int nLimit;
+                if(GetDragType()==RulerType::Border)
+                {
+                    nLimit = nIndex + 1;
+                    mpBorders[nIndex].nPos += lDiff;
+                }
+                else
+                {
+                    nLimit=0;
+                }
+                //in vertical tables the left borders have to be moved
+                if(bHorz)
+                {
+                    for(int i  = 0; i < nIndex; ++i)
+                    {
+                        mpBorders[i].nPos += lDiff;
+                    }
+                    AdjustMargin1(lDiff);
+                }
+                else
+                {
+                    //otherwise the right borders are moved
+                    for(int i  = mpBorders.size() - 2; i >= nLimit; --i)
+                    {
+                        mpBorders[i].nPos += lDiff;
+                    }
+                    SetMargin2( GetMargin2() + lDiff, RulerMarginStyle::NONE );
+                }
+            }
+            else
+                mpBorders[nIndex].nPos += lDiff;
+            break;
+        }
+      case RulerDragSize::N1:
+        {
+            lDiff = lPos - mpBorders[nIndex].nPos;
+            mpBorders[nIndex].nWidth += mpBorders[nIndex].nPos - lPos;
+            mpBorders[nIndex].nPos = lPos;
+            break;
+        }
+      case RulerDragSize::N2:
+        {
+            const tools::Long nOld = mpBorders[nIndex].nWidth;
+            mpBorders[nIndex].nWidth = lPos - mpBorders[nIndex].nPos;
+            lDiff = mpBorders[nIndex].nWidth - nOld;
+            break;
+        }
+    }
+    if(!bRightIndentsCorrected &&
+       GetActRightColumn() == nIndex &&
+       nDragSize != RulerDragSize::N2 &&
+       !mpIndents.empty() &&
+       !mxRulerImpl->bIsTableRows)
+    {
+        UpdateParaContents_Impl(lDiff, UpdateType::MoveRight);
+    }
+    else if(!bLeftIndentsCorrected &&
+            GetActLeftColumn() == nIndex &&
+            nDragSize != RulerDragSize::N1 &&
+            !mpIndents.empty())
+    {
+        UpdateParaContents_Impl(lDiff, UpdateType::MoveLeft);
+    }
+    SetBorders(mxColumnItem->Count() - 1, mpBorders.data());
+}
+
+void SvxRuler::DragObjectBorder()
+{
+    /* Dragging of object edges */
+    if(RulerDragSize::Move == GetDragSize())
+    {
+        const tools::Long lPosition = MakePositionSticky(GetCorrectedDragPos(), GetLeftFrameMargin());
+
+        const sal_uInt16 nIdx = GetDragAryPos();
+        mpObjectBorders[GetObjectBordersOff(nIdx)].nPos = lPosition;
+        SetBorders(2, mpObjectBorders.data() + GetObjectBordersOff(0));
+        DrawLine_Impl(lTabPos, 7, bHorz);
+
+    }
+}
+
+void SvxRuler::ApplyMargins()
+{
+    /* Applying margins; changed by dragging. */
+    const SfxPoolItem* pItem = nullptr;
+    sal_uInt16 nId = SID_ATTR_LONG_LRSPACE;
+
+    if(bHorz)
+    {
+        const tools::Long lOldNull = lLogicNullOffset;
+        if(mxRulerImpl->lMaxLeftLogic != -1 && nMaxLeft == GetMargin1() + Ruler::GetNullOffset())
+        {
+            lLogicNullOffset = mxRulerImpl->lMaxLeftLogic;
+            mxLRSpaceItem->SetLeft(lLogicNullOffset);
+        }
+        else
+        {
+            lLogicNullOffset = ConvertHPosLogic(GetFrameLeft()) - lAppNullOffset;
+            mxLRSpaceItem->SetLeft(PixelHAdjust(lLogicNullOffset, mxLRSpaceItem->GetLeft()));
+        }
+
+        if(bAppSetNullOffset)
+        {
+            lAppNullOffset += lLogicNullOffset - lOldNull;
+        }
+
+        tools::Long nRight;
+        if(mxRulerImpl->lMaxRightLogic != -1
+           && nMaxRight == GetMargin2() + Ruler::GetNullOffset())
+        {
+            nRight = GetPageWidth() - mxRulerImpl->lMaxRightLogic;
+        }
+        else
+        {
+            nRight = std::max(tools::Long(0),
+                            mxPagePosItem->GetWidth() - mxLRSpaceItem->GetLeft() -
+                                (ConvertHPosLogic(GetMargin2()) - lAppNullOffset));
+
+            nRight = PixelHAdjust( nRight, mxLRSpaceItem->GetRight());
+        }
+        mxLRSpaceItem->SetRight(nRight);
+
+        pItem = mxLRSpaceItem.get();
+
+#ifdef DEBUGLIN
+        Debug_Impl(pEditWin, *mxLRSpaceItem);
+#endif // DEBUGLIN
+
+    }
+    else
+    {
+        const tools::Long lOldNull = lLogicNullOffset;
+        lLogicNullOffset =
+                ConvertVPosLogic(GetFrameLeft()) -
+                lAppNullOffset;
+        mxULSpaceItem->SetUpper(
+            PixelVAdjust(lLogicNullOffset, mxULSpaceItem->GetUpper()));
+        if(bAppSetNullOffset)
+        {
+            lAppNullOffset += lLogicNullOffset - lOldNull;
+        }
+        mxULSpaceItem->SetLower(
+            PixelVAdjust(
+                std::max(tools::Long(0), mxPagePosItem->GetHeight() -
+                    mxULSpaceItem->GetUpper() -
+                    (ConvertVPosLogic(GetMargin2()) -
+                     lAppNullOffset)), mxULSpaceItem->GetLower()));
+        pItem = mxULSpaceItem.get();
+        nId = SID_ATTR_LONG_ULSPACE;
+
+#ifdef DEBUGLIN
+        Debug_Impl(pEditWin,*mxULSpaceItem);
+#endif // DEBUGLIN
+
+    }
+    pBindings->GetDispatcher()->ExecuteList(nId, SfxCallMode::RECORD, { pItem });
+    if (mxTabStopItem)
+        UpdateTabs();
+}
+
+tools::Long SvxRuler::RoundToCurrentMapMode(tools::Long lValue) const
+{
+    RulerUnitData aUnitData = GetCurrentRulerUnit();
+    double aRoundingFactor = aUnitData.nTickUnit / aUnitData.nTick1;
+
+    tools::Long lNewValue = OutputDevice::LogicToLogic(Size(lValue, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
+    lNewValue = (rtl::math::round(lNewValue / static_cast<double>(aUnitData.nTickUnit) * aRoundingFactor) / aRoundingFactor) * aUnitData.nTickUnit;
+    return OutputDevice::LogicToLogic(Size(lNewValue, 0), GetCurrentMapMode(), pEditWin->GetMapMode()).Width();
+}
+
+void SvxRuler::ApplyIndents()
+{
+    /* Applying paragraph settings; changed by dragging. */
+
+    tools::Long nLeftFrameMargin  = GetLeftFrameMargin();
+
+    bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
+
+    tools::Long nNewTxtLeft;
+    tools::Long nNewFirstLineOffset;
+    tools::Long nNewRight;
+
+    tools::Long nFirstLine    = ConvertPosLogic(mpIndents[INDENT_FIRST_LINE].nPos);
+    tools::Long nLeftMargin   = ConvertPosLogic(mpIndents[INDENT_LEFT_MARGIN].nPos);
+    tools::Long nRightMargin  = ConvertPosLogic(mpIndents[INDENT_RIGHT_MARGIN].nPos);
+
+    if(mxColumnItem && ((bRTL && !IsActLastColumn(true)) || (!bRTL && !IsActFirstColumn(true))))
+    {
+        if(bRTL)
+        {
+            tools::Long nRightColumn  = GetActRightColumn(true);
+            tools::Long nRightBorder  = ConvertPosLogic(mpBorders[nRightColumn].nPos);
+            nNewTxtLeft = nRightBorder - nLeftMargin - lAppNullOffset;
+        }
+        else
+        {
+            tools::Long nLeftColumn = GetActLeftColumn(true);
+            tools::Long nLeftBorder = ConvertPosLogic(mpBorders[nLeftColumn].nPos + mpBorders[nLeftColumn].nWidth);
+            nNewTxtLeft = nLeftMargin - nLeftBorder - lAppNullOffset;
+        }
+    }
+    else
+    {
+        if(bRTL)
+        {
+            tools::Long nRightBorder = ConvertPosLogic(GetMargin2());
+            nNewTxtLeft = nRightBorder - nLeftMargin - lAppNullOffset;
+        }
+        else
+        {
+            tools::Long nLeftBorder = ConvertPosLogic(GetMargin1());
+            nNewTxtLeft = nLeftBorder + nLeftMargin - nLeftFrameMargin - lAppNullOffset;
+        }
+    }
+
+    if(bRTL)
+        nNewFirstLineOffset = nLeftMargin - nFirstLine - lAppNullOffset;
+    else
+        nNewFirstLineOffset = nFirstLine - nLeftMargin - lAppNullOffset;
+
+    if(mxColumnItem && ((!bRTL && !IsActLastColumn(true)) || (bRTL && !IsActFirstColumn(true))))
+    {
+        if(bRTL)
+        {
+            tools::Long nLeftColumn = GetActLeftColumn(true);
+            tools::Long nLeftBorder = ConvertPosLogic(mpBorders[nLeftColumn].nPos + mpBorders[nLeftColumn].nWidth);
+            nNewRight = nRightMargin - nLeftBorder - lAppNullOffset;
+        }
+        else
+        {
+            tools::Long nRightColumn  = GetActRightColumn(true);
+            tools::Long nRightBorder  = ConvertPosLogic(mpBorders[nRightColumn].nPos);
+            nNewRight = nRightBorder - nRightMargin - lAppNullOffset;
+        }
+    }
+    else
+    {
+        if(bRTL)
+        {
+            tools::Long nLeftBorder = ConvertPosLogic(GetMargin1());
+            nNewRight = nLeftBorder + nRightMargin - nLeftFrameMargin - lAppNullOffset;
+        }
+        else
+        {
+            tools::Long nRightBorder = ConvertPosLogic(GetMargin2());
+            nNewRight = nRightBorder - nRightMargin - lAppNullOffset;
+        }
+    }
+
+    if (mbSnapping)
+    {
+        nNewTxtLeft         = RoundToCurrentMapMode(nNewTxtLeft);
+        nNewFirstLineOffset = RoundToCurrentMapMode(nNewFirstLineOffset);
+        nNewRight           = RoundToCurrentMapMode(nNewRight);
+    }
+
+    mxParaItem->SetTextFirstLineOffset(sal::static_int_cast<short>(nNewFirstLineOffset));
+    mxParaItem->SetTextLeft(nNewTxtLeft);
+    mxParaItem->SetRight(nNewRight);
+
+    sal_uInt16 nParagraphId  = bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL;
+    pBindings->GetDispatcher()->ExecuteList(nParagraphId, SfxCallMode::RECORD,
+            { mxParaItem.get() });
+    UpdateTabs();
+}
+
+void SvxRuler::ApplyTabs()
+{
+    /* Apply tab settings, changed by dragging. */
+    bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
+    const sal_uInt16 nCoreIdx = GetDragAryPos();
+    if(IsDragDelete())
+    {
+        mxTabStopItem->Remove(nCoreIdx);
+    }
+    else if(SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType ||
+            SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType)
+    {
+        SvxTabStopItem *pItem = new SvxTabStopItem(mxTabStopItem->Which());
+        //remove default tab stops
+        for ( sal_uInt16 i = 0; i < pItem->Count(); )
+        {
+            if ( SvxTabAdjust::Default == (*pItem)[i].GetAdjustment() )
+            {
+                pItem->Remove(i);
+                continue;
+            }
+            ++i;
+        }
+
+        sal_uInt16 j;
+        for(j = 0; j < nCoreIdx; ++j)
+        {
+            pItem->Insert(mxTabStopItem->At(j));
+        }
+        for(; j < mxTabStopItem->Count(); ++j)
+        {
+            SvxTabStop aTabStop = mxTabStopItem->At(j);
+            aTabStop.GetTabPos() = PixelHAdjust(
+                ConvertHPosLogic(
+                    mpTabs[j + TAB_GAP].nPos - GetLeftIndent()) - lAppNullOffset,
+                aTabStop.GetTabPos());
+            pItem->Insert(aTabStop);
+        }
+        mxTabStopItem.reset(pItem);
+    }
+    else if( mxTabStopItem->Count() == 0 )
+        return;
+    else
+    {
+        SvxTabStop aTabStop = mxTabStopItem->At(nCoreIdx);
+        if( mxRulerImpl->lMaxRightLogic != -1 &&
+            mpTabs[nCoreIdx + TAB_GAP].nPos + Ruler::GetNullOffset() == nMaxRight )
+        {
+            // Set tab pos exactly at the right indent
+            tools::Long nTmpLeftIndentLogic
+                = lAppNullOffset + (bRTL ? GetRightFrameMargin() : GetLeftFrameMargin());
+            if (mxRulerImpl->bIsTabsRelativeToIndent && mxParaItem)
+            {
+                nTmpLeftIndentLogic += bRTL ? mxParaItem->GetRight() : mxParaItem->GetTextLeft();
+            }
+            aTabStop.GetTabPos()
+                = mxRulerImpl->lMaxRightLogic - lLogicNullOffset - nTmpLeftIndentLogic;
+        }
+        else
+        {
+            if(bRTL)
+            {
+                //#i24363# tab stops relative to indent
+                const tools::Long nTmpLeftIndent = mxRulerImpl->bIsTabsRelativeToIndent ?
+                                            GetLeftIndent() :
+                                            ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset );
+
+                tools::Long nNewPosition = ConvertHPosLogic(nTmpLeftIndent - mpTabs[nCoreIdx + TAB_GAP].nPos);
+                aTabStop.GetTabPos() = PixelHAdjust(nNewPosition - lAppNullOffset, aTabStop.GetTabPos());
+            }
+            else
+            {
+                //#i24363# tab stops relative to indent
+                const tools::Long nTmpLeftIndent = mxRulerImpl->bIsTabsRelativeToIndent ?
+                                            GetLeftIndent() :
+                                            ConvertHPosPixel( GetLeftFrameMargin() + lAppNullOffset );
+
+                tools::Long nNewPosition = ConvertHPosLogic(mpTabs[nCoreIdx + TAB_GAP].nPos - nTmpLeftIndent);
+                aTabStop.GetTabPos() = PixelHAdjust(nNewPosition - lAppNullOffset, aTabStop.GetTabPos());
+            }
+        }
+        mxTabStopItem->Remove(nCoreIdx);
+        mxTabStopItem->Insert(aTabStop);
+    }
+    sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
+    pBindings->GetDispatcher()->ExecuteList(nTabStopId, SfxCallMode::RECORD,
+            { mxTabStopItem.get() });
+    UpdateTabs();
+}
+
+void SvxRuler::ApplyBorders()
+{
+    /* Applying (table) column settings; changed by dragging. */
+    if(mxColumnItem->IsTable())
+    {
+        tools::Long lValue = GetFrameLeft();
+        if(lValue != mxRulerImpl->nColLeftPix)
+        {
+            tools::Long nLeft = PixelHAdjust(
+                            ConvertHPosLogic(lValue) -
+                                lAppNullOffset,
+                            mxColumnItem->GetLeft());
+            mxColumnItem->SetLeft(nLeft);
+        }
+
+        lValue = GetMargin2();
+
+        if(lValue != mxRulerImpl->nColRightPix)
+        {
+            tools::Long nWidthOrHeight = bHorz ? mxPagePosItem->GetWidth() : mxPagePosItem->GetHeight();
+            tools::Long nRight = PixelHAdjust(
+                            nWidthOrHeight -
+                                mxColumnItem->GetLeft() -
+                                ConvertHPosLogic(lValue) -
+                                lAppNullOffset,
+                            mxColumnItem->GetRight() );
+            mxColumnItem->SetRight(nRight);
+        }
+    }
+
+    for(sal_uInt16 i = 0; i < mxColumnItem->Count() - 1; ++i)
+    {
+        tools::Long& nEnd = mxColumnItem->At(i).nEnd;
+        nEnd = PixelHAdjust(
+                ConvertPosLogic(mpBorders[i].nPos),
+                mxColumnItem->At(i).nEnd);
+        tools::Long& nStart = mxColumnItem->At(i + 1).nStart;
+        nStart = PixelHAdjust(
+                    ConvertSizeLogic(mpBorders[i].nPos +
+                        mpBorders[i].nWidth) -
+                        lAppNullOffset,
+                    mxColumnItem->At(i + 1).nStart);
+        // It may be that, due to the PixelHAdjust readjustment to old values,
+        // the width becomes  < 0. This we readjust.
+        if( nEnd > nStart )
+            nStart = nEnd;
+    }
+
+#ifdef DEBUGLIN
+        Debug_Impl(pEditWin,*mxColumnItem);
+#endif // DEBUGLIN
+
+    SfxBoolItem aFlag(SID_RULER_ACT_LINE_ONLY,
+                      bool(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY));
+
+    sal_uInt16 nColId = mxRulerImpl->bIsTableRows ? (bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL) :
+                            (bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
+
+    pBindings->GetDispatcher()->ExecuteList(nColId, SfxCallMode::RECORD,
+            { mxColumnItem.get(), &aFlag });
+}
+
+void SvxRuler::ApplyObject()
+{
+    /* Applying object settings, changed by dragging. */
+
+    // to the page margin
+    tools::Long nMargin = mxLRSpaceItem ? mxLRSpaceItem->GetLeft() : 0;
+    tools::Long nStartX = PixelAdjust(
+                    ConvertPosLogic(mpObjectBorders[0].nPos) +
+                        nMargin -
+                        lAppNullOffset,
+                    mxObjectItem->GetStartX());
+    mxObjectItem->SetStartX(nStartX);
+
+    tools::Long nEndX = PixelAdjust(
+                    ConvertPosLogic(mpObjectBorders[1].nPos) +
+                        nMargin -
+                        lAppNullOffset,
+                    mxObjectItem->GetEndX());
+    mxObjectItem->SetEndX(nEndX);
+
+    nMargin = mxULSpaceItem ? mxULSpaceItem->GetUpper() : 0;
+    tools::Long nStartY = PixelAdjust(
+                    ConvertPosLogic(mpObjectBorders[2].nPos) +
+                        nMargin -
+                        lAppNullOffset,
+                    mxObjectItem->GetStartY());
+    mxObjectItem->SetStartY(nStartY);
+
+    tools::Long nEndY = PixelAdjust(
+                    ConvertPosLogic(mpObjectBorders[3].nPos) +
+                        nMargin -
+                        lAppNullOffset,
+                    mxObjectItem->GetEndY());
+    mxObjectItem->SetEndY(nEndY);
+
+    pBindings->GetDispatcher()->ExecuteList(SID_RULER_OBJECT,
+            SfxCallMode::RECORD, { mxObjectItem.get() });
+}
+
+void SvxRuler::PrepareProportional_Impl(RulerType eType)
+{
+    /*
+       Preparation proportional dragging, and it is calculated based on the
+       proportional share of the total width in parts per thousand.
+    */
+    mxRulerImpl->nTotalDist = GetMargin2();
+    switch(eType)
+    {
+      case RulerType::Margin2:
+      case RulerType::Margin1:
+      case RulerType::Border:
+        {
+            DBG_ASSERT(mxColumnItem, "no ColumnItem");
+
+            mxRulerImpl->SetPercSize(mxColumnItem->Count());
+
+            tools::Long lPos;
+            tools::Long lWidth=0;
+            sal_uInt16 nStart;
+            sal_uInt16 nIdx=GetDragAryPos();
+            tools::Long lActWidth=0;
+            tools::Long lActBorderSum;
+            tools::Long lOrigLPos;
+
+            if(eType != RulerType::Border)
+            {
+                lOrigLPos = GetMargin1();
+                nStart = 0;
+                lActBorderSum = 0;
+            }
+            else
+            {
+                if(mxRulerImpl->bIsTableRows &&!bHorz)
+                {
+                    lOrigLPos = GetMargin1();
+                    nStart = 0;
+                }
+                else
+                {
+                    lOrigLPos = mpBorders[nIdx].nPos + mpBorders[nIdx].nWidth;
+                    nStart = 1;
+                }
+                lActBorderSum = mpBorders[nIdx].nWidth;
+            }
+
+            //in horizontal mode the percentage value has to be
+            //calculated on a "current change" position base
+            //because the height of the table changes while dragging
+            if(mxRulerImpl->bIsTableRows && RulerType::Border == eType)
+            {
+                sal_uInt16 nStartBorder;
+                sal_uInt16 nEndBorder;
+                if(bHorz)
+                {
+                    nStartBorder = nIdx + 1;
+                    nEndBorder = mxColumnItem->Count() - 1;
+                }
+                else
+                {
+                    nStartBorder = 0;
+                    nEndBorder = nIdx;
+                }
+
+                lWidth = mpBorders[nIdx].nPos;
+                if(bHorz)
+                    lWidth = GetMargin2() - lWidth;
+                mxRulerImpl->nTotalDist = lWidth;
+                lPos = mpBorders[nIdx].nPos;
+
+                for(sal_uInt16 i = nStartBorder; i < nEndBorder; ++i)
+                {
+                    if(bHorz)
+                    {
+                        lActWidth += mpBorders[i].nPos - lPos;
+                        lPos = mpBorders[i].nPos + mpBorders[i].nWidth;
+                    }
+                    else
+                        lActWidth = mpBorders[i].nPos;
+                    mxRulerImpl->pPercBuf[i] = static_cast<sal_uInt16>((lActWidth * 1000)
+                                                    / mxRulerImpl->nTotalDist);
+                    mxRulerImpl->pBlockBuf[i] = static_cast<sal_uInt16>(lActBorderSum);
+                    lActBorderSum += mpBorders[i].nWidth;
+                }
+            }
+            else
+            {
+                lPos = lOrigLPos;
+                for(sal_uInt16 ii = nStart; ii < mxColumnItem->Count() - 1; ++ii)
+                {
+                    lWidth += mpBorders[ii].nPos - lPos;
+                    lPos = mpBorders[ii].nPos + mpBorders[ii].nWidth;
+                }
+
+                lWidth += GetMargin2() - lPos;
+                mxRulerImpl->nTotalDist = lWidth;
+                lPos = lOrigLPos;
+
+                for(sal_uInt16 i = nStart; i < mxColumnItem->Count() - 1; ++i)
+                {
+                    lActWidth += mpBorders[i].nPos - lPos;
+                    lPos = mpBorders[i].nPos + mpBorders[i].nWidth;
+                    mxRulerImpl->pPercBuf[i] = static_cast<sal_uInt16>((lActWidth * 1000)
+                                                    / mxRulerImpl->nTotalDist);
+                    mxRulerImpl->pBlockBuf[i] = static_cast<sal_uInt16>(lActBorderSum);
+                    lActBorderSum += mpBorders[i].nWidth;
+                }
+            }
+        }
+        break;
+        case RulerType::Tab:
+        {
+            const sal_uInt16 nIdx = GetDragAryPos()+TAB_GAP;
+            mxRulerImpl->nTotalDist -= mpTabs[nIdx].nPos;
+            mxRulerImpl->SetPercSize(nTabCount);
+            for(sal_uInt16 n=0;n<=nIdx;mxRulerImpl->pPercBuf[n++]=0) ;
+            for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i)
+            {
+                const tools::Long nDelta = mpTabs[i].nPos - mpTabs[nIdx].nPos;
+                mxRulerImpl->pPercBuf[i] = static_cast<sal_uInt16>((nDelta * 1000) / mxRulerImpl->nTotalDist);
+            }
+            break;
+        }
+        default: break;
+    }
+}
+
+void SvxRuler::EvalModifier()
+{
+    /*
+    Eval Drag Modifier
+    Shift: move linear
+    Control: move proportional
+    Shift + Control: Table: only current line
+    Alt: disable snapping
+    Alt + Shift: coarse snapping
+    */
+
+    sal_uInt16 nModifier = GetDragModifier();
+    if(mxRulerImpl->bIsTableRows)
+    {
+        //rows can only be moved in one way, additionally current column is possible
+        if(nModifier == KEY_SHIFT)
+            nModifier = 0;
+    }
+
+    switch(nModifier)
+    {
+        case KEY_SHIFT:
+            nDragType = SvxRulerDragFlags::OBJECT_SIZE_LINEAR;
+        break;
+        case KEY_MOD2 | KEY_SHIFT:
+            mbCoarseSnapping = true;
+        break;
+        case KEY_MOD2:
+            mbSnapping = false;
+        break;
+        case KEY_MOD1:
+        {
+            const RulerType eType = GetDragType();
+            nDragType = SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL;
+            if( RulerType::Tab == eType ||
+                ( ( RulerType::Border == eType  ||
+                    RulerType::Margin1 == eType ||
+                    RulerType::Margin2 == eType ) &&
+                mxColumnItem ) )
+            {
+                PrepareProportional_Impl(eType);
+            }
+        }
+        break;
+        case KEY_MOD1 | KEY_SHIFT:
+            if( GetDragType() != RulerType::Margin1 &&
+                GetDragType() != RulerType::Margin2 )
+            {
+                nDragType = SvxRulerDragFlags::OBJECT_ACTLINE_ONLY;
+            }
+        break;
+    }
+}
+
+void SvxRuler::Click()
+{
+    /* Override handler SV; sets Tab per dispatcher call */
+    Ruler::Click();
+    if( bActive )
+    {
+        pBindings->Update( SID_RULER_LR_MIN_MAX );
+        pBindings->Update( SID_ATTR_LONG_ULSPACE );
+        pBindings->Update( SID_ATTR_LONG_LRSPACE );
+        pBindings->Update( SID_RULER_PAGE_POS );
+        pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL);
+        pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL);
+        pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
+        pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL);
+        pBindings->Update( SID_RULER_OBJECT );
+        pBindings->Update( SID_RULER_PROTECT );
+        pBindings->Update( SID_ATTR_PARA_LRSPACE_VERTICAL );
+    }
+    bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
+    if(!(mxTabStopItem &&
+       (nFlags & SvxRulerSupportFlags::TABS) == SvxRulerSupportFlags::TABS))
+        return;
+
+    bool bContentProtected = mxRulerImpl->aProtectItem->IsContentProtected();
+    if( bContentProtected ) return;
+    const tools::Long lPos = GetClickPos();
+    if(!((bRTL && lPos < std::min(GetFirstLineIndent(), GetLeftIndent()) && lPos > GetRightIndent()) ||
+        (!bRTL && lPos > std::min(GetFirstLineIndent(), GetLeftIndent()) && lPos < GetRightIndent())))
+        return;
+
+    //convert position in left-to-right text
+    tools::Long nTabPos;
+//#i24363# tab stops relative to indent
+    if(bRTL)
+        nTabPos = ( mxRulerImpl->bIsTabsRelativeToIndent ?
+                    GetLeftIndent() :
+                    ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset ) ) -
+                  lPos;
+    else
+        nTabPos = lPos -
+                  ( mxRulerImpl->bIsTabsRelativeToIndent ?
+                    GetLeftIndent() :
+                    ConvertHPosPixel( GetLeftFrameMargin() + lAppNullOffset ));
+
+    SvxTabStop aTabStop(ConvertHPosLogic(nTabPos),
+                        ToAttrTab_Impl(nDefTabType));
+    mxTabStopItem->Insert(aTabStop);
+    UpdateTabs();
+}
+
+void SvxRuler::CalcMinMax()
+{
+    /*
+       Calculates the limits for dragging; which are in pixels relative to the
+       page edge
+    */
+    bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
+    const tools::Long lNullPix = ConvertPosPixel(lLogicNullOffset);
+    mxRulerImpl->lMaxLeftLogic=mxRulerImpl->lMaxRightLogic=-1;
+    switch(GetDragType())
+    {
+        case RulerType::Margin1:
+        {        // left edge of the surrounding Frame
+            // DragPos - NOf between left - right
+            mxRulerImpl->lMaxLeftLogic = GetLeftMin();
+            nMaxLeft=ConvertSizePixel(mxRulerImpl->lMaxLeftLogic);
+
+            if (!mxColumnItem || mxColumnItem->Count() == 1)
+            {
+                if(bRTL)
+                {
+                    nMaxRight = lNullPix - GetRightIndent() +
+                        std::max(GetFirstLineIndent(), GetLeftIndent()) -
+                        glMinFrame;
+                }
+                else
+                {
+                    nMaxRight = lNullPix + GetRightIndent() -
+                        std::max(GetFirstLineIndent(), GetLeftIndent()) -
+                        glMinFrame;
+                }
+            }
+            else if(mxRulerImpl->bIsTableRows)
+            {
+                //top border is not moveable when table rows are displayed
+                // protection of content means the margin is not moveable
+                if(bHorz && !mxRulerImpl->aProtectItem->IsContentProtected())
+                {
+                    nMaxLeft = mpBorders[0].nMinPos + lNullPix;
+                    if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
+                        nMaxRight = GetRightIndent() + lNullPix -
+                                (mxColumnItem->Count() - 1 ) * glMinFrame;
+                    else
+                        nMaxRight = mpBorders[0].nPos - glMinFrame + lNullPix;
+                }
+                else
+                    nMaxLeft = nMaxRight = lNullPix;
+            }
+            else
+            {
+                if (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
+                {
+                    nMaxRight=lNullPix+CalcPropMaxRight();
+                }
+                else if (nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR)
+                {
+                    nMaxRight = ConvertPosPixel(
+                        GetPageWidth() - (
+                            (mxColumnItem->IsTable() && mxLRSpaceItem)
+                            ? mxLRSpaceItem->GetRight() : 0))
+                            - GetMargin2() + GetMargin1();
+                }
+                else
+                {
+                    nMaxRight = lNullPix - glMinFrame;
+                    if (mxColumnItem->IsFirstAct())
+                    {
+                        if(bRTL)
+                        {
+                            nMaxRight += std::min(
+                                mpBorders[0].nPos,
+                                std::max(GetFirstLineIndent(), GetLeftIndent()) - GetRightIndent());
+                        }
+                        else
+                        {
+                            nMaxRight += std::min(
+                                mpBorders[0].nPos, GetRightIndent() -
+                                std::max(GetFirstLineIndent(), GetLeftIndent()));
+                        }
+                    }
+                    else if ( mxColumnItem->Count() > 1 )
+                    {
+                        nMaxRight += mpBorders[0].nPos;
+                    }
+                    else
+                    {
+                        nMaxRight += GetRightIndent() - std::max(GetFirstLineIndent(), GetLeftIndent());
+                    }
+                    // Do not drag the left table edge over the edge of the page
+                    if(mxLRSpaceItem && mxColumnItem->IsTable())
+                    {
+                        tools::Long nTmp=ConvertSizePixel(mxLRSpaceItem->GetLeft());
+                        if(nTmp>nMaxLeft)
+                            nMaxLeft=nTmp;
+                    }
+                }
+            }
+            break;
+        }
+        case RulerType::Margin2:
+        {        // right edge of the surrounding Frame
+            mxRulerImpl->lMaxRightLogic
+                = mxMinMaxItem ? GetPageWidth() - GetRightMax() : GetPageWidth();
+            nMaxRight = ConvertSizePixel(mxRulerImpl->lMaxRightLogic);
+
+            if (!mxColumnItem)
+            {
+                if(bRTL)
+                {
+                    nMaxLeft =  GetMargin2() + GetRightIndent() -
+                        std::max(GetFirstLineIndent(),GetLeftIndent())  - GetMargin1()+
+                            glMinFrame + lNullPix;
+                }
+                else
+                {
+                    nMaxLeft =  GetMargin2() - GetRightIndent() +
+                        std::max(GetFirstLineIndent(),GetLeftIndent())  - GetMargin1()+
+                            glMinFrame + lNullPix;
+                }
+            }
+            else if(mxRulerImpl->bIsTableRows)
+            {
+                // get the bottom move range from the last border position - only available for rows!
+                // protection of content means the margin is not moveable
+                if(bHorz || mxRulerImpl->aProtectItem->IsContentProtected())
+                {
+                    nMaxLeft = nMaxRight = mpBorders[mxColumnItem->Count() - 1].nMaxPos + lNullPix;
+                }
+                else
+                {
+                    if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
+                    {
+                        nMaxLeft = (mxColumnItem->Count()) * glMinFrame + lNullPix;
+                    }
+                    else
+                    {
+                        if(mxColumnItem->Count() > 1)
+                            nMaxLeft = mpBorders[mxColumnItem->Count() - 2].nPos + glMinFrame + lNullPix;
+                        else
+                            nMaxLeft = glMinFrame + lNullPix;
+                    }
+                    if(mxColumnItem->Count() > 1)
+                        nMaxRight = mpBorders[mxColumnItem->Count() - 2].nMaxPos + lNullPix;
+                    else
+                        nMaxRight -= GetRightIndent() - lNullPix;
+                }
+            }
+            else
+            {
+                nMaxLeft = glMinFrame + lNullPix;
+                if(IsActLastColumn() || mxColumnItem->Count() < 2 ) //If last active column
+                {
+                    if(bRTL)
+                    {
+                        nMaxLeft = glMinFrame + lNullPix + GetMargin2() +
+                            GetRightIndent() - std::max(GetFirstLineIndent(),
+                                                   GetLeftIndent());
+                    }
+                    else
+                    {
+                        nMaxLeft = glMinFrame + lNullPix + GetMargin2() -
+                            GetRightIndent() + std::max(GetFirstLineIndent(),
+                                                   GetLeftIndent());
+                    }
+                }
+                if( mxColumnItem->Count() >= 2 )
+                {
+                    tools::Long nNewMaxLeft =
+                        glMinFrame + lNullPix +
+                        mpBorders[mxColumnItem->Count() - 2].nPos +
+                        mpBorders[mxColumnItem->Count() - 2].nWidth;
+                    nMaxLeft = std::max(nMaxLeft, nNewMaxLeft);
+                }
+
+            }
+            break;
+        }
+        case RulerType::Border:
+        {                // Table, column (Modifier)
+        const sal_uInt16 nIdx = GetDragAryPos();
+        switch(GetDragSize())
+        {
+          case RulerDragSize::N1 :
+            {
+                nMaxRight = mpBorders[nIdx].nPos +
+                    mpBorders[nIdx].nWidth + lNullPix;
+
+                if(0 == nIdx)
+                    nMaxLeft = lNullPix;
+                else
+                    nMaxLeft = mpBorders[nIdx - 1].nPos + mpBorders[nIdx - 1].nWidth + lNullPix;
+                if (mxColumnItem && nIdx == mxColumnItem->GetActColumn())
+                {
+                    if(bRTL)
+                    {
+                        nMaxLeft += mpBorders[nIdx].nPos +
+                            GetRightIndent() - std::max(GetFirstLineIndent(),
+                                                   GetLeftIndent());
+                    }
+                    else
+                    {
+                        nMaxLeft += mpBorders[nIdx].nPos -
+                            GetRightIndent() + std::max(GetFirstLineIndent(),
+                                                   GetLeftIndent());
+                    }
+                    if(0 != nIdx)
+                        nMaxLeft -= mpBorders[nIdx-1].nPos +
+                            mpBorders[nIdx-1].nWidth;
+                }
+                nMaxLeft += glMinFrame;
+                nMaxLeft += nDragOffset;
+                break;
+            }
+          case RulerDragSize::Move:
+            {
+                if (mxColumnItem)
+                {
+                    //nIdx contains the position of the currently moved item
+                    //next visible separator on the left
+                    sal_uInt16 nLeftCol=GetActLeftColumn(false, nIdx);
+                    //next visible separator on the right
+                    sal_uInt16 nRightCol=GetActRightColumn(false, nIdx);
+                    //next separator on the left - regardless if visible or not
+                    sal_uInt16 nActLeftCol=GetActLeftColumn();
+                    //next separator on the right - regardless if visible or not
+                    sal_uInt16 nActRightCol=GetActRightColumn();
+                    if(mxColumnItem->IsTable())
+                    {
+                        if(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY)
+                        {
+                            //the current row/column should be modified only
+                            //then the next/previous visible border position
+                            //marks the min/max positions
+                            nMaxLeft = nLeftCol == USHRT_MAX ?
+                                0 :
+                                mpBorders[nLeftCol].nPos;
+                            //rows can always be increased without a limit
+                            if(mxRulerImpl->bIsTableRows)
+                                nMaxRight = mpBorders[nIdx].nMaxPos;
+                            else
+                                nMaxRight = nRightCol == USHRT_MAX ?
+                                    GetMargin2():
+                                    mpBorders[nRightCol].nPos;
+                            nMaxLeft += lNullPix;
+                            nMaxRight += lNullPix;
+                        }
+                        else
+                        {
+                            if(SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType && !bHorz && mxRulerImpl->bIsTableRows)
+                                nMaxLeft = (nIdx + 1) * glMinFrame + lNullPix;
+                            else
+                                nMaxLeft = mpBorders[nIdx].nMinPos + lNullPix;
+                            if((SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType) ||
+                               (SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType) )
+                            {
+                                if(mxRulerImpl->bIsTableRows)
+                                {
+                                    if(bHorz)
+                                        nMaxRight = GetRightIndent() + lNullPix -
+                                                (mxColumnItem->Count() - nIdx - 1) * glMinFrame;
+                                    else
+                                        nMaxRight = mpBorders[nIdx].nMaxPos + lNullPix;
+                                }
+                                else
+                                    nMaxRight=lNullPix+CalcPropMaxRight(nIdx);
+                            }
+                            else
+                                nMaxRight = mpBorders[nIdx].nMaxPos + lNullPix;
+                        }
+                        nMaxLeft += glMinFrame;
+                        nMaxRight -= glMinFrame;
+
+                    }
+                    else
+                    {
+                        if(nLeftCol==USHRT_MAX)
+                            nMaxLeft=lNullPix;
+                        else
+                            nMaxLeft = mpBorders[nLeftCol].nPos +
+                                mpBorders[nLeftCol].nWidth + lNullPix;
+
+                        if(nActRightCol == nIdx)
+                        {
+                            if(bRTL)
+                            {
+                                nMaxLeft += mpBorders[nIdx].nPos +
+                                    GetRightIndent() - std::max(GetFirstLineIndent(),
+                                                           GetLeftIndent());
+                                if(nActLeftCol!=USHRT_MAX)
+                                    nMaxLeft -= mpBorders[nActLeftCol].nPos +
+                                        mpBorders[nActLeftCol].nWidth;
+                            }
+                            else
+                            {
+                                nMaxLeft += mpBorders[nIdx].nPos -
+                                    GetRightIndent() + std::max(GetFirstLineIndent(),
+                                                           GetLeftIndent());
+                                if(nActLeftCol!=USHRT_MAX)
+                                    nMaxLeft -= mpBorders[nActLeftCol].nPos +
+                                        mpBorders[nActLeftCol].nWidth;
+                            }
+                        }
+                        nMaxLeft += glMinFrame;
+                        nMaxLeft += nDragOffset;
+
+                        // nMaxRight
+                        // linear / proportional move
+                        if((SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType) ||
+                           (SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType) )
+                        {
+                            nMaxRight=lNullPix+CalcPropMaxRight(nIdx);
+                        }
+                        else if(SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType)
+                        {
+                            nMaxRight = lNullPix + GetMargin2() - GetMargin1() +
+                                (mpBorders.size() - nIdx - 1) * glMinFrame;
+                        }
+                        else
+                        {
+                            if(nRightCol==USHRT_MAX)
+                            { // last column
+                                nMaxRight = GetMargin2() + lNullPix;
+                                if(IsActLastColumn())
+                                {
+                                    if(bRTL)
+                                    {
+                                        nMaxRight -=
+                                            GetMargin2() + GetRightIndent() -
+                                                std::max(GetFirstLineIndent(),
+                                                    GetLeftIndent());
+                                    }
+                                    else
+                                    {
+                                        nMaxRight -=
+                                            GetMargin2() - GetRightIndent() +
+                                                std::max(GetFirstLineIndent(),
+                                                    GetLeftIndent());
+                                    }
+                                    nMaxRight += mpBorders[nIdx].nPos +
+                                        mpBorders[nIdx].nWidth;
+                                }
+                            }
+                            else
+                            {
+                                nMaxRight = lNullPix + mpBorders[nRightCol].nPos;
+                                sal_uInt16 nNotHiddenRightCol =
+                                    GetActRightColumn(true, nIdx);
+
+                                if( nActLeftCol == nIdx )
+                                {
+                                    tools::Long nBorder = nNotHiddenRightCol ==
+                                        USHRT_MAX ?
+                                        GetMargin2() :
+                                        mpBorders[nNotHiddenRightCol].nPos;
+                                    if(bRTL)
+                                    {
+                                        nMaxRight -= nBorder + GetRightIndent() -
+                                            std::max(GetFirstLineIndent(),
+                                                GetLeftIndent());
+                                    }
+                                    else
+                                    {
+                                        nMaxRight -= nBorder - GetRightIndent() +
+                                            std::max(GetFirstLineIndent(),
+                                                GetLeftIndent());
+                                    }
+                                    nMaxRight += mpBorders[nIdx].nPos +
+                                        mpBorders[nIdx].nWidth;
+                                }
+                            }
+                            nMaxRight -= glMinFrame;
+                            nMaxRight -= mpBorders[nIdx].nWidth;
+                        }
+                    }
+                }
+                // ObjectItem
+                else
+                {
+                    nMaxLeft = LONG_MIN;
+                    nMaxRight = LONG_MAX;
+                }
+                break;
+            }
+          case RulerDragSize::N2:
+            if (mxColumnItem)
+            {
+                nMaxLeft = lNullPix + mpBorders[nIdx].nPos;
+                if(nIdx == mxColumnItem->Count()-2) { // last column
+                    nMaxRight = GetMargin2() + lNullPix;
+                    if(mxColumnItem->IsLastAct()) {
+                        nMaxRight -=
+                            GetMargin2() - GetRightIndent() +
+                                std::max(GetFirstLineIndent(),
+                                    GetLeftIndent());
+                        nMaxRight += mpBorders[nIdx].nPos +
+                            mpBorders[nIdx].nWidth;
+                    }
+                }
+                else {
+                    nMaxRight = lNullPix + mpBorders[nIdx+1].nPos;
+                    if(mxColumnItem->GetActColumn()-1 == nIdx) {
+                        nMaxRight -= mpBorders[nIdx+1].nPos  - GetRightIndent() +
+                            std::max(GetFirstLineIndent(),
+                                GetLeftIndent());
+                        nMaxRight += mpBorders[nIdx].nPos +
+                            mpBorders[nIdx].nWidth;
+                    }
+                }
+                nMaxRight -= glMinFrame;
+                nMaxRight -= mpBorders[nIdx].nWidth;
+                break;
+            }
+        }
+        nMaxRight += nDragOffset;
+        break;
+    }
+      case RulerType::Indent:
+        {
+        const sal_uInt16 nIdx = GetDragAryPos();
+        switch(nIdx) {
+        case INDENT_FIRST_LINE - INDENT_GAP:
+        case INDENT_LEFT_MARGIN - INDENT_GAP:
+            {
+                if(bRTL)
+                {
+                    nMaxLeft = lNullPix + GetRightIndent();
+
+                    if(mxColumnItem && !mxColumnItem->IsFirstAct())
+                        nMaxLeft += mpBorders[mxColumnItem->GetActColumn()-1].nPos +
+                            mpBorders[mxColumnItem->GetActColumn()-1].nWidth;
+                    nMaxRight = lNullPix + GetMargin2();
+
+                    // Dragging along
+                    if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
+                       !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY))
+                    {
+                        if(GetLeftIndent() > GetFirstLineIndent())
+                            nMaxLeft += GetLeftIndent() - GetFirstLineIndent();
+                        else
+                            nMaxRight -= GetFirstLineIndent() - GetLeftIndent();
+                    }
+                }
+                else
+                {
+                    nMaxLeft = lNullPix;
+
+                    if(mxColumnItem && !mxColumnItem->IsFirstAct())
+                        nMaxLeft += mpBorders[mxColumnItem->GetActColumn()-1].nPos +
+                            mpBorders[mxColumnItem->GetActColumn()-1].nWidth;
+                    nMaxRight = lNullPix + GetRightIndent() - glMinFrame;
+
+                    // Dragging along
+                    if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
+                       !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY))
+                    {
+                        if(GetLeftIndent() > GetFirstLineIndent())
+                            nMaxLeft += GetLeftIndent() - GetFirstLineIndent();
+                        else
+                            nMaxRight -= GetFirstLineIndent() - GetLeftIndent();
+                    }
+                }
+            }
+          break;
+          case INDENT_RIGHT_MARGIN - INDENT_GAP:
+            {
+                if(bRTL)
+                {
+                    nMaxLeft = lNullPix;
+                    nMaxRight = lNullPix + std::min(GetFirstLineIndent(), GetLeftIndent()) - glMinFrame;
+                    if (mxColumnItem)
+                    {
+                        sal_uInt16 nRightCol=GetActRightColumn( true );
+                        if(!IsActLastColumn( true ))
+                            nMaxRight += mpBorders[nRightCol].nPos;
+                        else
+                            nMaxRight += GetMargin2();
+                    }
+                    else
+                    {
+                        nMaxLeft += GetMargin1();
+                    }
+                    nMaxLeft += glMinFrame;
+                }
+                else
+                {
+                    nMaxLeft = lNullPix +
+                        std::max(GetFirstLineIndent(), GetLeftIndent());
+                    nMaxRight = lNullPix;
+                    if (mxColumnItem)
+                    {
+                        sal_uInt16 nRightCol=GetActRightColumn( true );
+                        if(!IsActLastColumn( true ))
+                            nMaxRight += mpBorders[nRightCol].nPos;
+                        else
+                            nMaxRight += GetMargin2();
+                    }
+                    else
+                        nMaxRight += GetMargin2();
+                    nMaxLeft += glMinFrame;
+                }
+            }
+            break;
+        }
+        break;
+    }
+    case RulerType::Tab:                // Tabs (Modifier)
+        /* left = NOf + Max(LAR, EZ)
+           right = NOf + RAR */
+
+        if (bRTL)
+            nMaxLeft = lNullPix + GetRightIndent();
+        else
+            nMaxLeft = lNullPix + std::min(GetFirstLineIndent(), GetLeftIndent());
+
+        mxRulerImpl->lMaxRightLogic = GetLogicRightIndent() + lLogicNullOffset;
+        nMaxRight = ConvertSizePixel(mxRulerImpl->lMaxRightLogic);
+        break;
+    default: ; //prevent warning
+    }
+}
+
+bool SvxRuler::StartDrag()
+{
+    /*
+       Beginning of a drag operation (SV-handler) evaluates modifier and
+       calculated values
+
+       [Cross-reference]
+
+       <SvxRuler::EvalModifier()>
+       <SvxRuler::CalcMinMax()>
+       <SvxRuler::EndDrag()>
+    */
+    bool bContentProtected = mxRulerImpl->aProtectItem->IsContentProtected();
+
+    if(!bValid)
+        return false;
+
+    mxRulerImpl->lLastLMargin = GetMargin1();
+    mxRulerImpl->lLastRMargin = GetMargin2();
+
+    bool bOk = true;
+
+    lInitialDragPos = GetDragPos();
+    switch(GetDragType())
+    {
+        case RulerType::Margin1:        // left edge of the surrounding Frame
+        case RulerType::Margin2:        // right edge of the surrounding Frame
+            if((bHorz && mxLRSpaceItem) || (!bHorz && mxULSpaceItem))
+            {
+                if (!mxColumnItem)
+                    EvalModifier();
+                else
+                    nDragType = SvxRulerDragFlags::OBJECT;
+            }
+            else
+            {
+                bOk = false;
+            }
+            break;
+        case RulerType::Border: // Table, column (Modifier)
+            if (mxColumnItem)
+            {
+                nDragOffset = 0;
+                if (!mxColumnItem->IsTable())
+                    nDragOffset = GetDragPos() - mpBorders[GetDragAryPos()].nPos;
+                EvalModifier();
+            }
+            else
+                nDragOffset = 0;
+            break;
+        case RulerType::Indent: // Paragraph indents (Modifier)
+        {
+            if( bContentProtected )
+                return false;
+            if(INDENT_LEFT_MARGIN == GetDragAryPos() + INDENT_GAP) {  // Left paragraph indent
+                mpIndents[0] = mpIndents[INDENT_FIRST_LINE];
+                EvalModifier();
+            }
+            else
+            {
+                nDragType = SvxRulerDragFlags::OBJECT;
+            }
+            mpIndents[1] = mpIndents[GetDragAryPos() + INDENT_GAP];
+            break;
+        }
+        case RulerType::Tab: // Tabs (Modifier)
+            if( bContentProtected )
+                return false;
+            EvalModifier();
+            mpTabs[0] = mpTabs[GetDragAryPos() + 1];
+            mpTabs[0].nStyle |= RULER_STYLE_DONTKNOW;
+            break;
+        default:
+            nDragType = SvxRulerDragFlags::NONE;
+    }
+
+    if(bOk)
+        CalcMinMax();
+
+    return bOk;
+}
+
+void  SvxRuler::Drag()
+{
+    /* SV-Draghandler */
+    if(IsDragCanceled())
+    {
+        Ruler::Drag();
+        return;
+    }
+    switch(GetDragType()) {
+        case RulerType::Margin1: // left edge of the surrounding Frame
+            DragMargin1();
+            mxRulerImpl->lLastLMargin = GetMargin1();
+            break;
+        case RulerType::Margin2: // right edge of the surrounding Frame
+            DragMargin2();
+            mxRulerImpl->lLastRMargin = GetMargin2();
+            break;
+        case RulerType::Indent: // Paragraph indents
+            DragIndents();
+            break;
+        case RulerType::Border: // Table, columns
+            if (mxColumnItem)
+                DragBorders();
+            else if (mxObjectItem)
+                DragObjectBorder();
+            break;
+        case RulerType::Tab: // Tabs
+            DragTabs();
+            break;
+        default:
+            break; //prevent warning
+    }
+    Ruler::Drag();
+}
+
+void SvxRuler::EndDrag()
+{
+    /*
+       SV-handler; is called when ending the dragging. Triggers the updating of data
+       on the application, by calling the respective Apply...() methods to send the
+       data to the application.
+    */
+    const bool bUndo = IsDragCanceled();
+    const tools::Long lPos = GetDragPos();
+    DrawLine_Impl(lTabPos, 6, bHorz);
+    lTabPos = -1;
+
+    if(!bUndo)
+    {
+        switch(GetDragType())
+        {
+            case RulerType::Margin1: // upper left edge of the surrounding Frame
+            case RulerType::Margin2: // lower right edge of the surrounding Frame
+                {
+                    if (!mxColumnItem || !mxColumnItem->IsTable())
+                        ApplyMargins();
+
+                    if(mxColumnItem &&
+                       (mxColumnItem->IsTable() ||
+                        (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)))
+                        ApplyBorders();
+
+                }
+                break;
+            case RulerType::Border: // Table, columns
+                if(lInitialDragPos != lPos ||
+                    (mxRulerImpl->bIsTableRows && bHorz)) //special case - the null offset is changed here
+                {
+                    if (mxColumnItem)
+                    {
+                        ApplyBorders();
+                        if(bHorz)
+                            UpdateTabs();
+                    }
+                    else if (mxObjectItem)
+                        ApplyObject();
+                }
+                break;
+            case RulerType::Indent: // Paragraph indents
+                if(lInitialDragPos != lPos)
+                    ApplyIndents();
+                SetIndents(INDENT_COUNT, mpIndents.data() + INDENT_GAP);
+                break;
+            case RulerType::Tab: // Tabs
+                {
+                    ApplyTabs();
+                    mpTabs[GetDragAryPos()].nStyle &= ~RULER_STYLE_INVISIBLE;
+                    SetTabs(nTabCount, mpTabs.data() + TAB_GAP);
+                }
+                break;
+            default:
+                break; //prevent warning
+        }
+    }
+    nDragType = SvxRulerDragFlags::NONE;
+
+    mbCoarseSnapping = false;
+    mbSnapping = true;
+
+    Ruler::EndDrag();
+    if(bUndo)
+    {
+        for(sal_uInt16 i = 0; i < mxRulerImpl->nControllerItems; i++)
+        {
+            pCtrlItems[i]->ClearCache();
+            pCtrlItems[i]->GetBindings().Invalidate(pCtrlItems[i]->GetId());
+        }
+    }
+}
+
+void SvxRuler::ExtraDown()
+{
+    /* Override SV method, sets the new type for the Default tab. */
+
+    // Switch Tab Type
+    if(mxTabStopItem &&
+        (nFlags & SvxRulerSupportFlags::TABS) == SvxRulerSupportFlags::TABS)
+    {
+        ++nDefTabType;
+        if(RULER_TAB_DEFAULT == nDefTabType)
+            nDefTabType = RULER_TAB_LEFT;
+        SetExtraType(RulerExtra::Tab, nDefTabType);
+    }
+    Ruler::ExtraDown();
+}
+
+void SvxRuler::Notify(SfxBroadcaster&, const SfxHint& rHint)
+{
+    /*
+       Report through the bindings that the status update is completed. The ruler
+       updates its appearance and gets registered again in the bindings.
+    */
+
+    // start update
+    if (bActive && rHint.GetId() == SfxHintId::UpdateDone)
+    {
+        Update();
+        EndListening(*pBindings);
+        bValid = true;
+        bListening = false;
+    }
+}
+
+void SvxRuler::MenuSelect(std::u16string_view ident)
+{
+    if (ident.empty())
+        return;
+    /* Handler of the context menus for switching the unit of measurement */
+    SetUnit(vcl::EnglishStringToMetric(ident));
+}
+
+void SvxRuler::TabMenuSelect(std::u16string_view rIdent)
+{
+    if (rIdent.empty())
+        return;
+    sal_Int32 nId = o3tl::toInt32(rIdent);
+    /* Handler of the tab menu for setting the type */
+    if (mxTabStopItem && mxTabStopItem->Count() > mxRulerImpl->nIdx)
+    {
+        SvxTabStop aTabStop = mxTabStopItem->At(mxRulerImpl->nIdx);
+        aTabStop.GetAdjustment() = ToAttrTab_Impl(nId - 1);
+        mxTabStopItem->Remove(mxRulerImpl->nIdx);
+        mxTabStopItem->Insert(aTabStop);
+        sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
+        pBindings->GetDispatcher()->ExecuteList(nTabStopId,
+                SfxCallMode::RECORD, { mxTabStopItem.get() });
+        UpdateTabs();
+        mxRulerImpl->nIdx = 0;
+    }
+}
+
+const TranslateId RID_SVXSTR_RULER_TAB[] =
+{
+    RID_SVXSTR_RULER_TAB_LEFT,
+    RID_SVXSTR_RULER_TAB_RIGHT,
+    RID_SVXSTR_RULER_TAB_CENTER,
+    RID_SVXSTR_RULER_TAB_DECIMAL
+};
+
+void SvxRuler::Command( const CommandEvent& rCommandEvent )
+{
+    /* Mouse context menu for switching the unit of measurement */
+    if ( CommandEventId::ContextMenu == rCommandEvent.GetCommand() )
+    {
+        CancelDrag();
+
+        tools::Rectangle aRect(rCommandEvent.GetMousePosPixel(), Size(1, 1));
+        weld::Window* pPopupParent = weld::GetPopupParent(*this, aRect);
+        std::unique_ptr<weld::Builder> xBuilder(Application::CreateBuilder(pPopupParent, "svx/ui/rulermenu.ui"));
+        std::unique_ptr<weld::Menu> xMenu(xBuilder->weld_menu("menu"));
+
+        bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
+        if ( !mpTabs.empty() &&
+             RulerType::Tab ==
+             GetRulerType( rCommandEvent.GetMousePosPixel(), &mxRulerImpl->nIdx ) &&
+             mpTabs[mxRulerImpl->nIdx + TAB_GAP].nStyle < RULER_TAB_DEFAULT )
+        {
+            xMenu->clear();
+
+            const Size aSz(ruler_tab_svx.width + 2, ruler_tab_svx.height + 2);
+            const Point aPt(aSz.Width() / 2, aSz.Height() / 2);
+
+            for ( sal_uInt16 i = RULER_TAB_LEFT; i < RULER_TAB_DEFAULT; ++i )
+            {
+                ScopedVclPtr<VirtualDevice> xDev(pPopupParent->create_virtual_device());
+                xDev->SetOutputSize(aSz);
+
+                sal_uInt16 nStyle = bRTL ? i|RULER_TAB_RTL : i;
+                nStyle |= static_cast<sal_uInt16>(bHorz ? WB_HORZ : WB_VERT);
+
+                Color aFillColor(xDev->GetSettings().GetStyleSettings().GetShadowColor());
+                DrawTab(*xDev, aFillColor, aPt, nStyle);
+
+                OUString sId(OUString::number(i + 1));
+                xMenu->insert(-1, sId, SvxResId(RID_SVXSTR_RULER_TAB[i]),
+                              nullptr, xDev.get(), nullptr, TRISTATE_TRUE);
+                xMenu->set_active(sId, i == mpTabs[mxRulerImpl->nIdx + TAB_GAP].nStyle);
+            }
+            TabMenuSelect(xMenu->popup_at_rect(pPopupParent, aRect));
+        }
+        else
+        {
+            FieldUnit eUnit = GetUnit();
+            const int nCount = xMenu->n_children();
+
+            bool bReduceMetric = bool(nFlags & SvxRulerSupportFlags::REDUCED_METRIC);
+            for ( sal_uInt16 i = nCount; i; --i )
+            {
+                OUString sIdent = xMenu->get_id(i - 1);
+                FieldUnit eMenuUnit = vcl::EnglishStringToMetric(sIdent);
+                xMenu->set_active(sIdent, eMenuUnit == eUnit);
+                if( bReduceMetric )
+                {
+                    if (eMenuUnit == FieldUnit::M    ||
+                        eMenuUnit == FieldUnit::KM   ||
+                        eMenuUnit == FieldUnit::FOOT ||
+                        eMenuUnit == FieldUnit::MILE)
+                    {
+                        xMenu->remove(sIdent);
+                    }
+                    else if (( eMenuUnit == FieldUnit::CHAR ) && !bHorz )
+                    {
+                        xMenu->remove(sIdent);
+                    }
+                    else if (( eMenuUnit == FieldUnit::LINE ) && bHorz )
+                    {
+                        xMenu->remove(sIdent);
+                    }
+                }
+            }
+            MenuSelect(xMenu->popup_at_rect(pPopupParent, aRect));
+        }
+    }
+    else
+    {
+        Ruler::Command( rCommandEvent );
+    }
+}
+
+sal_uInt16 SvxRuler::GetActRightColumn(
+                        bool bForceDontConsiderHidden,
+                        sal_uInt16 nAct ) const
+{
+    if( nAct == USHRT_MAX )
+        nAct = mxColumnItem->GetActColumn();
+    else
+        nAct++; //To be able to pass on the ActDrag
+
+    bool bConsiderHidden = !bForceDontConsiderHidden &&
+                               !(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY);
+
+    while( nAct < mxColumnItem->Count() - 1 )
+    {
+        if (mxColumnItem->At(nAct).bVisible || bConsiderHidden)
+            return nAct;
+        else
+            nAct++;
+    }
+    return USHRT_MAX;
+}
+
+sal_uInt16 SvxRuler::GetActLeftColumn(
+                        bool bForceDontConsiderHidden,
+                        sal_uInt16 nAct ) const
+{
+    if(nAct == USHRT_MAX)
+        nAct = mxColumnItem->GetActColumn();
+
+    sal_uInt16 nLeftOffset = 1;
+
+    bool bConsiderHidden = !bForceDontConsiderHidden &&
+                               !(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY);
+
+    while(nAct >= nLeftOffset)
+    {
+        if (mxColumnItem->At(nAct - nLeftOffset).bVisible || bConsiderHidden)
+            return nAct - nLeftOffset;
+        else
+            nLeftOffset++;
+    }
+    return USHRT_MAX;
+}
+
+bool SvxRuler::IsActLastColumn(
+                        bool bForceDontConsiderHidden,
+                        sal_uInt16 nAct) const
+{
+    return GetActRightColumn(bForceDontConsiderHidden, nAct) == USHRT_MAX;
+}
+
+bool SvxRuler::IsActFirstColumn(
+                        bool bForceDontConsiderHidden,
+                        sal_uInt16 nAct) const
+{
+    return GetActLeftColumn(bForceDontConsiderHidden, nAct) == USHRT_MAX;
+}
+
+tools::Long SvxRuler::CalcPropMaxRight(sal_uInt16 nCol) const
+{
+
+    if(!(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR))
+    {
+        // Remove the minimum width for all affected columns
+        // starting from the right edge
+        tools::Long _nMaxRight = GetMargin2() - GetMargin1();
+
+        tools::Long lFences = 0;
+        tools::Long lMinSpace = USHRT_MAX;
+        tools::Long lOldPos;
+        tools::Long lColumns = 0;
+
+        sal_uInt16 nStart;
+        if(!mxColumnItem->IsTable())
+        {
+            if(nCol == USHRT_MAX)
+            {
+                lOldPos = GetMargin1();
+                nStart = 0;
+            }
+            else
+            {
+                lOldPos = mpBorders[nCol].nPos + mpBorders[nCol].nWidth;
+                nStart = nCol + 1;
+                lFences = mpBorders[nCol].nWidth;
+            }
+
+            for(size_t i = nStart; i < mpBorders.size() - 1; ++i)
+            {
+                tools::Long lWidth = mpBorders[i].nPos - lOldPos;
+                lColumns += lWidth;
+                if(lWidth < lMinSpace)
+                    lMinSpace = lWidth;
+                lOldPos = mpBorders[i].nPos + mpBorders[i].nWidth;
+                lFences += mpBorders[i].nWidth;
+            }
+            tools::Long lWidth = GetMargin2() - lOldPos;
+            lColumns += lWidth;
+            if(lWidth < lMinSpace)
+                lMinSpace = lWidth;
+        }
+        else
+        {
+            sal_uInt16 nActCol;
+            if(nCol == USHRT_MAX) //CalcMinMax for LeftMargin
+            {
+                lOldPos = GetMargin1();
+            }
+            else
+            {
+                lOldPos = mpBorders[nCol].nPos;
+            }
+            lColumns = GetMargin2()-lOldPos;
+            nActCol = nCol;
+            lFences = 0;
+            while(nActCol < mpBorders.size() || nActCol == USHRT_MAX)
+            {
+                sal_uInt16 nRight;
+                if(nActCol == USHRT_MAX)
+                {
+                    nRight = 0;
+                    while (!(*mxColumnItem)[nRight].bVisible)
+                    {
+                        nRight++;
+                    }
+                }
+                else
+                {
+                    nRight = GetActRightColumn(false, nActCol);
+                }
+
+                tools::Long lWidth;
+                if(nRight != USHRT_MAX)
+                {
+                    lWidth = mpBorders[nRight].nPos - lOldPos;
+                    lOldPos = mpBorders[nRight].nPos;
+                }
+                else
+                {
+                    lWidth=GetMargin2() - lOldPos;
+                }
+                nActCol = nRight;
+                if(lWidth < lMinSpace)
+                    lMinSpace = lWidth;
+                if(nActCol == USHRT_MAX)
+                    break;
+            }
+        }
+
+        _nMaxRight -= static_cast<tools::Long>(lFences + glMinFrame / static_cast<float>(lMinSpace) * lColumns);
+        return _nMaxRight;
+    }
+    else
+    {
+        if(mxColumnItem->IsTable())
+        {
+            sal_uInt16 nVisCols = 0;
+            for(size_t i = GetActRightColumn(false, nCol); i < mpBorders.size();)
+            {
+                if ((*mxColumnItem)[i].bVisible)
+                    nVisCols++;
+                i = GetActRightColumn(false, i);
+            }
+            return GetMargin2() - GetMargin1() - (nVisCols + 1) * glMinFrame;
+        }
+        else
+        {
+            tools::Long lWidth = 0;
+            for(size_t i = nCol; i < mpBorders.size() - 1; i++)
+            {
+                lWidth += glMinFrame + mpBorders[i].nWidth;
+            }
+            return GetMargin2() - GetMargin1() - lWidth;
+        }
+    }
+}
+
+// Tab stops relative to indent (#i24363#)
+void SvxRuler::SetTabsRelativeToIndent( bool bRel )
+{
+    mxRulerImpl->bIsTabsRelativeToIndent = bRel;
+}
+
+void SvxRuler::SetValues(RulerChangeType type, tools::Long diffValue)
+{
+    if (diffValue == 0)
+        return;
+
+    if (type == RulerChangeType::MARGIN1)
+        AdjustMargin1(diffValue);
+    else if (type == RulerChangeType::MARGIN2)
+        SetMargin2( GetMargin2() - diffValue);
+    ApplyMargins();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab cinoptions=b1,g0,N-s cinkeys+=0=break: */