LCOV - code coverage report
Current view: top level - svx/source/dialog - svxruler.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 408 1772 23.0 %
Date: 2015-06-13 12:38:46 Functions: 43 99 43.4 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <cstring>
      21             : #include <climits>
      22             : 
      23             : #include <vcl/image.hxx>
      24             : #include <vcl/svapp.hxx>
      25             : #include <vcl/settings.hxx>
      26             : #include <svl/eitem.hxx>
      27             : #include <svl/rectitem.hxx>
      28             : #include <svl/smplhint.hxx>
      29             : #include <sfx2/dispatch.hxx>
      30             : #include <svx/dialogs.hrc>
      31             : #include <svx/dialmgr.hxx>
      32             : #include <svx/ruler.hxx>
      33             : #include <svx/rulritem.hxx>
      34             : #include <editeng/tstpitem.hxx>
      35             : #include <editeng/lrspitem.hxx>
      36             : #include <editeng/protitem.hxx>
      37             : 
      38             : #include <svx/svdtrans.hxx>
      39             : 
      40             : #include "rlrcitem.hxx"
      41             : 
      42             : #ifndef RULER_TAB_RTL
      43             : #define RULER_TAB_RTL           ((sal_uInt16)0x0010)
      44             : #endif
      45             : 
      46             : #define CTRL_ITEM_COUNT 14
      47             : #define GAP 10
      48             : #define OBJECT_BORDER_COUNT 4
      49             : #define TAB_GAP 1
      50             : #define INDENT_GAP 2
      51             : #define INDENT_FIRST_LINE   2
      52             : #define INDENT_LEFT_MARGIN  3
      53             : #define INDENT_RIGHT_MARGIN 4
      54             : #define INDENT_COUNT        3 //without the first two old values
      55             : 
      56             : #ifdef DEBUG_RULER
      57             : #include <vcl/lstbox.hxx>
      58             : class RulerDebugWindow : public vcl::Window
      59             : {
      60             :     ListBox aBox;
      61             : public:
      62             :         explicit RulerDebugWindow(vcl::Window* pParent) :
      63             :             Window(pParent, WB_BORDER|WB_SIZEMOVE|WB_DIALOGCONTROL|WB_CLIPCHILDREN|WB_SYSTEMWINDOW),
      64             :             aBox(this, WB_BORDER)
      65             :             {
      66             :                 Size aOutput(200, 400);
      67             :                 SetOutputSizePixel(aOutput);
      68             :                 aBox.SetSizePixel(aOutput);
      69             :                 aBox.Show();
      70             :                 Show();
      71             :                 Size aParentSize(pParent->GetOutputSizePixel());
      72             :                 Size aOwnSize(GetSizePixel());
      73             :                 aParentSize.Width() -= aOwnSize.Width();
      74             :                 aParentSize.Height() -= aOwnSize.Height();
      75             :                 SetPosPixel(Point(aParentSize.Width(), aParentSize.Height()));
      76             :             }
      77             :         ~RulerDebugWindow();
      78             : 
      79             :         ListBox& GetLBox() {return aBox;}
      80             :         static void     AddDebugText(const sal_Char* pDescription, const OUString& rText );
      81             : };
      82             : static RulerDebugWindow* pDebugWindow = 0;
      83             : 
      84             : RulerDebugWindow::~RulerDebugWindow()
      85             : {
      86             :     pDebugWindow = 0;
      87             : }
      88             : void     RulerDebugWindow::AddDebugText(const sal_Char* pDescription, const OUString& rText )
      89             : {
      90             :     if(!pDebugWindow)
      91             :     {
      92             :         vcl::Window* pParent = Application::GetFocusWindow();
      93             :         while(pParent->GetParent())
      94             :             pParent = pParent->GetParent();
      95             :         pDebugWindow = new RulerDebugWindow(pParent);
      96             :     }
      97             :     OUString sContent( OUString::createFromAscii(pDescription) );
      98             :     sContent += rText;
      99             :     sal_uInt16 nPos = pDebugWindow->GetLBox().InsertEntry(sContent);
     100             :     pDebugWindow->GetLBox().SelectEntryPos(nPos);
     101             :     pDebugWindow->GrabFocus();
     102             : }
     103             : 
     104             : #define ADD_DEBUG_TEXT(cDescription, sValue) \
     105             :     RulerDebugWindow::AddDebugText(cDescription, sValue);
     106             : 
     107             : #define REMOVE_DEBUG_WINDOW \
     108             :     delete pDebugWindow;    \
     109             :     pDebugWindow = 0;
     110             : 
     111             : #else
     112             : #define ADD_DEBUG_TEXT(cDescription, sValue)
     113             : #define REMOVE_DEBUG_WINDOW
     114             : #endif
     115             : 
     116             : struct SvxRuler_Impl {
     117             :     sal_uInt16 *pPercBuf;
     118             :     sal_uInt16 *pBlockBuf;
     119             :     sal_uInt16 nPercSize;
     120             :     long   nTotalDist;
     121             :     long   lOldWinPos;
     122             :     long   lMaxLeftLogic;
     123             :     long   lMaxRightLogic;
     124             :     long   lLastLMargin;
     125             :     long   lLastRMargin;
     126             :     SvxProtectItem aProtectItem;
     127             :     SfxBoolItem* pTextRTLItem;
     128             :     sal_uInt16 nControlerItems;
     129             :     sal_uInt16 nIdx;
     130             :     sal_uInt16 nColLeftPix;
     131             :     sal_uInt16 nColRightPix;    // Pixel values for left / right edge
     132             :                                 // For columns; buffered to prevent
     133             :                                 // recalculation errors
     134             :                                 // May be has to be widen for future values
     135             :     bool bIsTableRows : 1;  // mxColumnItem contains table rows instead of columns
     136             :     //#i24363# tab stops relative to indent
     137             :     bool bIsTabsRelativeToIndent : 1; // Tab stops relative to paragraph indent?
     138             : 
     139        5694 :     SvxRuler_Impl() :
     140             :         pPercBuf(0), pBlockBuf(0), nPercSize(0), nTotalDist(0),
     141             :         lOldWinPos(0), lMaxLeftLogic(0), lMaxRightLogic(0),
     142             :         lLastLMargin(0), lLastRMargin(0), aProtectItem(SID_RULER_PROTECT),
     143             :         pTextRTLItem(0), nControlerItems(0), nIdx(0),
     144             :         nColLeftPix(0), nColRightPix(0),
     145             :         bIsTableRows(false),
     146        5694 :         bIsTabsRelativeToIndent(true)
     147             :     {
     148        5694 :     }
     149             : 
     150        5686 :     ~SvxRuler_Impl()
     151        5686 :     {
     152        5686 :         nPercSize = 0; nTotalDist = 0;
     153        5686 :         delete[] pPercBuf; delete[] pBlockBuf; pPercBuf = 0;
     154        5686 :         delete pTextRTLItem;
     155        5686 :     }
     156             :     void SetPercSize(sal_uInt16 nSize);
     157             : 
     158             : };
     159             : 
     160             : static RulerTabData ruler_tab_svx =
     161             : {
     162             :     0, // DPIScaleFactor to be set
     163             :     7, // ruler_tab_width
     164             :     6, // ruler_tab_height
     165             :     0, // ruler_tab_height2
     166             :     0, // ruler_tab_width2
     167             :     0, // ruler_tab_cwidth
     168             :     0, // ruler_tab_cwidth2
     169             :     0, // ruler_tab_cwidth3
     170             :     0, // ruler_tab_cwidth4
     171             :     0, // ruler_tab_dheight
     172             :     0, // ruler_tab_dheight2
     173             :     0, // ruler_tab_dwidth
     174             :     0, // ruler_tab_dwidth2
     175             :     0, // ruler_tab_dwidth3
     176             :     0, // ruler_tab_dwidth4
     177             :     0  // ruler_tab_textoff
     178             : };
     179             : 
     180           0 : void SvxRuler_Impl::SetPercSize(sal_uInt16 nSize)
     181             : {
     182           0 :     if(nSize > nPercSize)
     183             :     {
     184           0 :         delete[] pPercBuf;
     185           0 :         delete[] pBlockBuf;
     186           0 :         pPercBuf = new sal_uInt16[nPercSize = nSize];
     187           0 :         pBlockBuf = new sal_uInt16[nPercSize = nSize];
     188             :     }
     189           0 :     size_t nSize2 = sizeof(sal_uInt16) * nPercSize;
     190           0 :     memset(pPercBuf, 0, nSize2);
     191           0 :     memset(pBlockBuf, 0, nSize2);
     192           0 : }
     193             : 
     194             : // Constructor of the ruler
     195             : 
     196             : // SID_ATTR_ULSPACE, SID_ATTR_LRSPACE
     197             : // expects as parameter SvxULSpaceItem for page edge
     198             : // (either left/right or top/bottom)
     199             : // Ruler: SetMargin1, SetMargin2
     200             : 
     201             : // SID_RULER_PAGE_POS
     202             : // expectes as parameter the initial value of the page and page width
     203             : // Ruler: SetPagePos
     204             : 
     205             : // SID_ATTR_TABSTOP
     206             : // expects: SvxTabStopItem
     207             : // Ruler: SetTabs
     208             : 
     209             : // SID_ATTR_PARA_LRSPACE
     210             : // left, right paragraph edge in H-ruler
     211             : // Ruler: SetIndents
     212             : 
     213             : // SID_RULER_BORDERS
     214             : // Table borders, columns
     215             : // expects: something like SwTabCols
     216             : // Ruler: SetBorders
     217             : 
     218        5694 : SvxRuler::SvxRuler(
     219             :             vcl::Window* pParent,        // StarView Parent
     220             :             vcl::Window* pWin,           // Output window: is used for conversion
     221             :                                          // logical units <-> pixels
     222             :             SvxRulerSupportFlags flags,  // Display flags, see ruler.hxx
     223             :             SfxBindings &rBindings,      // associated Bindings
     224             :             WinBits nWinStyle) :         // StarView WinBits
     225             :     Ruler(pParent, nWinStyle),
     226             :     pCtrlItems(CTRL_ITEM_COUNT),
     227             :     pEditWin(pWin),
     228        5694 :     mxRulerImpl(new SvxRuler_Impl),
     229             :     bAppSetNullOffset(false),  // Is the 0-offset of the ruler set by the application?
     230             :     lLogicNullOffset(0),
     231             :     lAppNullOffset(LONG_MAX),
     232             :     lMinFrame(5),
     233             :     lInitialDragPos(0),
     234             :     nFlags(flags),
     235             :     nDragType(SvxRulerDragFlags::NONE),
     236             :     nDefTabType(RULER_TAB_LEFT),
     237             :     nTabCount(0),
     238             :     nTabBufSize(0),
     239             :     lDefTabDist(50),
     240             :     lTabPos(-1),
     241             :     mpBorders(1), // due to one column tables
     242             :     pBindings(&rBindings),
     243             :     nDragOffset(0),
     244             :     nMaxLeft(0),
     245             :     nMaxRight(0),
     246             :     bValid(false),
     247             :     bListening(false),
     248             :     bActive(true),
     249             :     mbCoarseSnapping(false),
     250       11388 :     mbSnapping(true)
     251             : 
     252             : {
     253             :     /* Constructor; Initialize data buffer; controller items are created */
     254             : 
     255        5694 :     rBindings.EnterRegistrations();
     256             : 
     257             :     // Create Supported Items
     258        5694 :     sal_uInt16 i = 0;
     259             : 
     260             :     // Page edges
     261        5694 :     pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_LR_MIN_MAX, *this, rBindings));
     262        5694 :     if((nWinStyle & WB_VSCROLL) == WB_VSCROLL)
     263             :     {
     264        2847 :         bHorz = false;
     265        2847 :         pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_LONG_ULSPACE, *this, rBindings));
     266             :     }
     267             :     else
     268             :     {
     269        2847 :         bHorz = true;
     270        2847 :         pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_LONG_LRSPACE, *this, rBindings));
     271             :     }
     272             : 
     273             :     // Page Position
     274        5694 :     pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_PAGE_POS, *this, rBindings));
     275             : 
     276        5694 :     if(nFlags & SvxRulerSupportFlags::TABS)
     277             :     {
     278        5608 :         sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
     279        5608 :         pCtrlItems[i++].reset(new SvxRulerItem(nTabStopId, *this, rBindings));
     280        5608 :         SetExtraType(RULER_EXTRA_TAB, nDefTabType);
     281             :     }
     282             : 
     283        5694 :     if(nFlags & (SvxRulerSupportFlags::PARAGRAPH_MARGINS |SvxRulerSupportFlags::PARAGRAPH_MARGINS_VERTICAL))
     284             :     {
     285        5608 :         if(bHorz)
     286        2847 :             pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_PARA_LRSPACE, *this, rBindings));
     287             :         else
     288        2761 :             pCtrlItems[i++].reset(new SvxRulerItem(SID_ATTR_PARA_LRSPACE_VERTICAL, *this, rBindings));
     289             : 
     290        5608 :         mpIndents.resize(5 + INDENT_GAP);
     291             : 
     292       44864 :         for(size_t nIn = 0; nIn < mpIndents.size(); nIn++)
     293             :         {
     294       39256 :             mpIndents[nIn].nPos = 0;
     295       39256 :             mpIndents[nIn].nStyle = RULER_STYLE_DONTKNOW;
     296             :         }
     297             : 
     298        5608 :         mpIndents[0].nStyle = RULER_STYLE_DONTKNOW;
     299        5608 :         mpIndents[1].nStyle = RULER_STYLE_DONTKNOW;
     300        5608 :         mpIndents[INDENT_FIRST_LINE].nStyle = RULER_INDENT_TOP;
     301        5608 :         mpIndents[INDENT_LEFT_MARGIN].nStyle = RULER_INDENT_BOTTOM;
     302        5608 :         mpIndents[INDENT_RIGHT_MARGIN].nStyle = RULER_INDENT_BOTTOM;
     303             :     }
     304             : 
     305        5694 :     if( (nFlags & SvxRulerSupportFlags::BORDERS) ==  SvxRulerSupportFlags::BORDERS )
     306             :     {
     307        5522 :         pCtrlItems[i++].reset(new SvxRulerItem(bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL, *this, rBindings));
     308        5522 :         pCtrlItems[i++].reset(new SvxRulerItem(bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL, *this, rBindings));
     309             :     }
     310             : 
     311        5694 :     pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_TEXT_RIGHT_TO_LEFT, *this, rBindings));
     312             : 
     313        5694 :     if( (nFlags & SvxRulerSupportFlags::OBJECT) == SvxRulerSupportFlags::OBJECT )
     314             :     {
     315         172 :         pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_OBJECT, *this, rBindings));
     316         172 :         mpObjectBorders.resize(OBJECT_BORDER_COUNT);
     317         860 :         for(sal_uInt16 nBorder = 0; nBorder < OBJECT_BORDER_COUNT; ++nBorder)
     318             :         {
     319         688 :             mpObjectBorders[nBorder].nPos   = 0;
     320         688 :             mpObjectBorders[nBorder].nWidth = 0;
     321         688 :             mpObjectBorders[nBorder].nStyle = RULER_BORDER_MOVEABLE;
     322             :         }
     323             :     }
     324             : 
     325        5694 :     pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_PROTECT, *this, rBindings));
     326        5694 :     pCtrlItems[i++].reset(new SvxRulerItem(SID_RULER_BORDER_DISTANCE, *this, rBindings));
     327        5694 :     mxRulerImpl->nControlerItems=i;
     328             : 
     329        5694 :     if( (nFlags & SvxRulerSupportFlags::SET_NULLOFFSET) == SvxRulerSupportFlags::SET_NULLOFFSET )
     330          86 :         SetExtraType(RULER_EXTRA_NULLOFFSET, 0);
     331             : 
     332        5694 :     rBindings.LeaveRegistrations();
     333             : 
     334        5694 :     ruler_tab_svx.DPIScaleFactor = pParent->GetDPIScaleFactor();
     335        5694 :     ruler_tab_svx.height *= ruler_tab_svx.DPIScaleFactor;
     336        5694 :     ruler_tab_svx.width  *= ruler_tab_svx.DPIScaleFactor;
     337             : 
     338        5694 : }
     339             : 
     340       14129 : SvxRuler::~SvxRuler()
     341             : {
     342        5686 :     disposeOnce();
     343        8443 : }
     344             : 
     345        5686 : void SvxRuler::dispose()
     346             : {
     347             :     /* Destructor ruler; release internal buffer */
     348             :     REMOVE_DEBUG_WINDOW
     349        5686 :     if(bListening)
     350           8 :         EndListening(*pBindings);
     351             : 
     352        5686 :     pBindings->EnterRegistrations();
     353             : 
     354        5686 :     pCtrlItems.clear();
     355             : 
     356        5686 :     pBindings->LeaveRegistrations();
     357             : 
     358        5686 :     pEditWin.clear();
     359        5686 :     Ruler::dispose();
     360        5686 : }
     361             : 
     362           0 : long SvxRuler::MakePositionSticky(long aPosition, long aPointOfReference, bool aSnapToFrameMargin) const
     363             : {
     364           0 :     long aPointOfReferencePixel = ConvertHPosPixel(aPointOfReference);
     365           0 :     long aLeftFramePosition     = ConvertHPosPixel(GetLeftFrameMargin());
     366           0 :     long aRightFramePosition    = ConvertHPosPixel(GetRightFrameMargin());
     367             : 
     368           0 :     double aTick = GetCurrentRulerUnit().nTick1;
     369             : 
     370           0 :     if (mbCoarseSnapping)
     371           0 :         aTick = GetCurrentRulerUnit().nTick2;
     372             : 
     373           0 :     long aTickPixel = pEditWin->LogicToPixel(Size(aTick, 0), GetCurrentMapMode()).Width();
     374             : 
     375           0 :     double aHalfTick = aTick / 2.0;
     376           0 :     double aHalfTickPixel = aTickPixel / 2.0;
     377             : 
     378           0 :     if (aSnapToFrameMargin)
     379             :     {
     380           0 :         if (aPosition > aLeftFramePosition - aHalfTickPixel && aPosition < aLeftFramePosition + aHalfTickPixel)
     381           0 :             return aLeftFramePosition;
     382             : 
     383           0 :         if (aPosition > aRightFramePosition - aHalfTickPixel && aPosition < aRightFramePosition + aHalfTickPixel)
     384           0 :             return aRightFramePosition;
     385             :     }
     386             : 
     387           0 :     if (!mbSnapping)
     388           0 :         return aPosition;
     389             : 
     390             :     // Move "coordinate system" to frame position so ticks are calculated correctly
     391           0 :     long aTranslatedPosition = aPosition - aPointOfReferencePixel;
     392             :     // Convert position to current selected map mode
     393           0 :     long aPositionLogic = pEditWin->PixelToLogic(Size(aTranslatedPosition, 0), GetCurrentMapMode()).Width();
     394             :     // Normalize -- snap to nearest tick
     395           0 :     aPositionLogic = rtl::math::round((aPositionLogic + aHalfTick) / aTick) * aTick;
     396             :     // Convert back to pixels
     397           0 :     aPosition = pEditWin->LogicToPixel(Size(aPositionLogic, 0), GetCurrentMapMode()).Width();
     398             :     // Move "coordinate system" back to original position
     399           0 :     return aPosition + aPointOfReferencePixel;
     400             : }
     401             : 
     402       15647 : long SvxRuler::ConvertHPosPixel(long nVal) const
     403             : {
     404       15647 :     return pEditWin->LogicToPixel(Size(nVal, 0)).Width();
     405             : }
     406             : 
     407        1198 : long SvxRuler::ConvertVPosPixel(long nVal) const
     408             : {
     409        1198 :     return pEditWin->LogicToPixel(Size(0, nVal)).Height();
     410             : }
     411             : 
     412        1640 : long SvxRuler::ConvertHSizePixel(long nVal) const
     413             : {
     414        1640 :     return pEditWin->LogicToPixel(Size(nVal, 0)).Width();
     415             : }
     416             : 
     417         105 : long SvxRuler::ConvertVSizePixel(long nVal) const
     418             : {
     419         105 :     return pEditWin->LogicToPixel(Size(0, nVal)).Height();
     420             : }
     421             : 
     422          18 : long SvxRuler::ConvertPosPixel(long nVal) const
     423             : {
     424          18 :     return bHorz ? ConvertHPosPixel(nVal): ConvertVPosPixel(nVal);
     425             : }
     426             : 
     427        1745 : long SvxRuler::ConvertSizePixel(long nVal) const
     428             : {
     429        1745 :     return bHorz? ConvertHSizePixel(nVal): ConvertVSizePixel(nVal);
     430             : }
     431             : 
     432           0 : inline long SvxRuler::ConvertHPosLogic(long nVal) const
     433             : {
     434           0 :     return pEditWin->PixelToLogic(Size(nVal, 0)).Width();
     435             : }
     436             : 
     437           0 : inline long SvxRuler::ConvertVPosLogic(long nVal) const
     438             : {
     439           0 :     return pEditWin->PixelToLogic(Size(0, nVal)).Height();
     440             : }
     441             : 
     442           0 : inline long SvxRuler::ConvertHSizeLogic(long nVal) const
     443             : {
     444           0 :     return pEditWin->PixelToLogic(Size(nVal, 0)).Width();
     445             : }
     446             : 
     447           0 : inline long SvxRuler::ConvertVSizeLogic(long nVal) const
     448             : {
     449           0 :     return pEditWin->PixelToLogic(Size(0, nVal)).Height();
     450             : }
     451             : 
     452           0 : inline long SvxRuler::ConvertPosLogic(long nVal) const
     453             : {
     454           0 :     return bHorz? ConvertHPosLogic(nVal): ConvertVPosLogic(nVal);
     455             : }
     456             : 
     457           0 : inline long SvxRuler::ConvertSizeLogic(long nVal) const
     458             : {
     459           0 :     return bHorz? ConvertHSizeLogic(nVal): ConvertVSizeLogic(nVal);
     460             : }
     461             : 
     462           0 : long SvxRuler::PixelHAdjust(long nVal, long nValOld) const
     463             : {
     464           0 :     if(ConvertHSizePixel(nVal) != ConvertHSizePixel(nValOld))
     465           0 :         return  nVal;
     466             :     else
     467           0 :         return  nValOld;
     468             : }
     469             : 
     470           0 : long SvxRuler::PixelVAdjust(long nVal, long nValOld) const
     471             : {
     472           0 :     if(ConvertVSizePixel(nVal) != ConvertVSizePixel(nValOld))
     473           0 :         return  nVal;
     474             :     else
     475           0 :         return  nValOld;
     476             : }
     477             : 
     478           0 : long SvxRuler::PixelAdjust(long nVal, long nValOld) const
     479             : {
     480           0 :     if(ConvertSizePixel(nVal) != ConvertSizePixel(nValOld))
     481           0 :         return  nVal;
     482             :     else
     483           0 :         return  nValOld;
     484             : }
     485             : 
     486           0 : inline sal_uInt16 SvxRuler::GetObjectBordersOff(sal_uInt16 nIdx) const
     487             : {
     488           0 :     return bHorz ? nIdx : nIdx + 2;
     489             : }
     490             : 
     491             : /*
     492             :     Update Upper Left edge.
     493             :     Items are translated into the representation of the ruler.
     494             : */
     495       57549 : void SvxRuler::UpdateFrame()
     496             : {
     497             :     const sal_uInt16 nMarginStyle =
     498       57549 :         ( mxRulerImpl->aProtectItem.IsSizeProtected() ||
     499       57389 :           mxRulerImpl->aProtectItem.IsPosProtected() ) ?
     500      114938 :         0 : RULER_MARGIN_SIZEABLE;
     501             : 
     502       57549 :     if(mxLRSpaceItem.get() && mxPagePosItem.get())
     503             :     {
     504             :         // if no initialization by default app behavior
     505         573 :         const long nOld = lLogicNullOffset;
     506         573 :         lLogicNullOffset = mxColumnItem.get() ? mxColumnItem->GetLeft(): mxLRSpaceItem->GetLeft();
     507             : 
     508         573 :         if(bAppSetNullOffset)
     509             :         {
     510          61 :             lAppNullOffset += lLogicNullOffset - nOld;
     511             :         }
     512             : 
     513         573 :         if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX)
     514             :         {
     515         512 :             Ruler::SetNullOffset(ConvertHPosPixel(lLogicNullOffset));
     516         512 :             SetMargin1(0, nMarginStyle);
     517         512 :             lAppNullOffset = 0;
     518             :         }
     519             :         else
     520             :         {
     521          61 :             SetMargin1(ConvertHPosPixel(lAppNullOffset), nMarginStyle);
     522             :         }
     523             : 
     524         573 :         long lRight = 0;
     525             : 
     526             :         // evaluate the table right edge of the table
     527         573 :         if(mxColumnItem.get() && mxColumnItem->IsTable())
     528           2 :             lRight = mxColumnItem->GetRight();
     529             :         else
     530         571 :             lRight = mxLRSpaceItem->GetRight();
     531             : 
     532         573 :         long aWidth = mxPagePosItem->GetWidth() - lRight - lLogicNullOffset + lAppNullOffset;
     533         573 :         long aWidthPixel = ConvertHPosPixel(aWidth);
     534             : 
     535         573 :         SetMargin2(aWidthPixel, nMarginStyle);
     536             :     }
     537       56976 :     else if(mxULSpaceItem.get() && mxPagePosItem.get())
     538             :     {
     539             :         // relative the upper edge of the surrounding frame
     540         593 :         const long nOld = lLogicNullOffset;
     541         593 :         lLogicNullOffset = mxColumnItem.get() ? mxColumnItem->GetLeft() : mxULSpaceItem->GetUpper();
     542             : 
     543         593 :         if(bAppSetNullOffset)
     544             :         {
     545          60 :             lAppNullOffset += lLogicNullOffset - nOld;
     546             :         }
     547             : 
     548         593 :         if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX)
     549             :         {
     550         533 :             Ruler::SetNullOffset(ConvertVPosPixel(lLogicNullOffset));
     551         533 :             lAppNullOffset = 0;
     552         533 :             SetMargin1(0, nMarginStyle);
     553             :         }
     554             :         else
     555             :         {
     556          60 :             SetMargin1(ConvertVPosPixel(lAppNullOffset), nMarginStyle);
     557             :         }
     558             : 
     559         593 :         long lLower = mxColumnItem.get() ? mxColumnItem->GetRight() : mxULSpaceItem->GetLower();
     560         593 :         long nMargin2 = mxPagePosItem->GetHeight() - lLower - lLogicNullOffset + lAppNullOffset;
     561         593 :         long nMargin2Pixel = ConvertVPosPixel(nMargin2);
     562             : 
     563         593 :         SetMargin2(nMargin2Pixel, nMarginStyle);
     564             :     }
     565             :     else
     566             :     {
     567             :         // turns off the view
     568       56383 :         SetMargin1();
     569       56383 :         SetMargin2();
     570             :     }
     571             : 
     572       57549 :     if(mxColumnItem.get())
     573             :     {
     574           4 :         mxRulerImpl->nColLeftPix = (sal_uInt16) ConvertSizePixel(mxColumnItem->GetLeft());
     575           4 :         mxRulerImpl->nColRightPix = (sal_uInt16) ConvertSizePixel(mxColumnItem->GetRight());
     576             :     }
     577       57549 : }
     578             : 
     579           0 : void SvxRuler::MouseMove( const MouseEvent& rMEvt )
     580             : {
     581           0 :     if( bActive )
     582             :     {
     583           0 :         pBindings->Update( SID_RULER_LR_MIN_MAX );
     584           0 :         pBindings->Update( SID_ATTR_LONG_ULSPACE );
     585           0 :         pBindings->Update( SID_ATTR_LONG_LRSPACE );
     586           0 :         pBindings->Update( SID_RULER_PAGE_POS );
     587           0 :         pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL);
     588           0 :         pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL);
     589           0 :         pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
     590           0 :         pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL);
     591           0 :         pBindings->Update( SID_RULER_OBJECT );
     592           0 :         pBindings->Update( SID_RULER_PROTECT );
     593             :     }
     594             : 
     595           0 :     Ruler::MouseMove( rMEvt );
     596             : 
     597           0 :     RulerSelection aSelection = GetHoverSelection();
     598             : 
     599           0 :     if (aSelection.eType == RULER_TYPE_DONTKNOW)
     600             :     {
     601           0 :         SetQuickHelpText("");
     602           0 :         return;
     603             :     }
     604             : 
     605           0 :     RulerUnitData aUnitData = GetCurrentRulerUnit();
     606           0 :     double aRoundingFactor = aUnitData.nTickUnit / aUnitData.nTick1;
     607           0 :     sal_Int32 aNoDecimalPlaces = 1 + std::ceil(std::log10(aRoundingFactor));
     608           0 :     OUString sUnit = OUString::createFromAscii(aUnitData.aUnitStr);
     609             : 
     610           0 :     switch (aSelection.eType)
     611             :     {
     612             :         case RULER_TYPE_INDENT:
     613             :         {
     614           0 :             if (!mxParaItem.get())
     615           0 :                 break;
     616             : 
     617           0 :             long nIndex = aSelection.nAryPos + INDENT_GAP;
     618             : 
     619           0 :             long nIndentValue = 0.0;
     620           0 :             if (nIndex == INDENT_LEFT_MARGIN)
     621           0 :                 nIndentValue = mxParaItem->GetTextLeft();
     622           0 :             else if (nIndex == INDENT_FIRST_LINE)
     623           0 :                 nIndentValue = mxParaItem->GetTextFirstLineOfst();
     624           0 :             else if (nIndex == INDENT_RIGHT_MARGIN)
     625           0 :                 nIndentValue = mxParaItem->GetRight();
     626             : 
     627           0 :             double fValue = OutputDevice::LogicToLogic(Size(nIndentValue, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
     628           0 :             fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces);
     629             : 
     630           0 :             SetQuickHelpText(OUString::number(fValue) + " " + sUnit);
     631           0 :             break;
     632             :         }
     633             :         case RULER_TYPE_BORDER:
     634             :         {
     635           0 :             if (mxColumnItem.get() == NULL)
     636           0 :                 break;
     637             : 
     638           0 :             SvxColumnItem& aColumnItem = *mxColumnItem.get();
     639             : 
     640           0 :             if (aSelection.nAryPos + 1 >= aColumnItem.Count())
     641           0 :                 break;
     642             : 
     643           0 :             double fStart = OutputDevice::LogicToLogic(Size(aColumnItem[aSelection.nAryPos].nEnd,       0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
     644           0 :             fStart = rtl::math::round(fStart / aUnitData.nTickUnit, aNoDecimalPlaces);
     645           0 :             double fEnd   = OutputDevice::LogicToLogic(Size(aColumnItem[aSelection.nAryPos + 1].nStart, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
     646           0 :             fEnd = rtl::math::round(fEnd / aUnitData.nTickUnit, aNoDecimalPlaces);
     647             : 
     648             :             SetQuickHelpText(
     649           0 :                 OUString::number(fStart) + " " + sUnit + " - " +
     650           0 :                 OUString::number(fEnd)   + " " + sUnit );
     651           0 :             break;
     652             :         }
     653             :         case RULER_TYPE_MARGIN1:
     654             :         {
     655           0 :             long nLeft = 0.0;
     656           0 :             if (mxLRSpaceItem.get())
     657           0 :                 nLeft = mxLRSpaceItem->GetLeft();
     658           0 :             else if (mxULSpaceItem.get())
     659           0 :                 nLeft = mxULSpaceItem->GetUpper();
     660             :             else
     661           0 :                 break;
     662             : 
     663           0 :             double fValue = OutputDevice::LogicToLogic(Size(nLeft, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
     664           0 :             fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces);
     665           0 :             SetQuickHelpText(OUString::number(fValue) + " " + sUnit);
     666             : 
     667           0 :             break;
     668             :         }
     669             :         case RULER_TYPE_MARGIN2:
     670             :         {
     671           0 :             long nRight = 0.0;
     672           0 :             if (mxLRSpaceItem.get())
     673           0 :                 nRight = mxLRSpaceItem->GetRight();
     674           0 :             else if (mxULSpaceItem.get())
     675           0 :                 nRight = mxULSpaceItem->GetLower();
     676             :             else
     677           0 :                 break;
     678             : 
     679           0 :             double fValue = OutputDevice::LogicToLogic(Size(nRight, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
     680           0 :             fValue = rtl::math::round(fValue / aUnitData.nTickUnit, aNoDecimalPlaces);
     681           0 :             SetQuickHelpText(OUString::number(fValue) + " " + sUnit);
     682             : 
     683           0 :             break;
     684             :         }
     685             :         default:
     686             :         {
     687           0 :             SetQuickHelpText("");
     688           0 :             break;
     689             :         }
     690           0 :     }
     691             : }
     692             : 
     693        4663 : void SvxRuler::StartListening_Impl()
     694             : {
     695        4663 :     if(!bListening)
     696             :     {
     697         667 :         bValid = false;
     698         667 :         StartListening(*pBindings);
     699         667 :         bListening = true;
     700             :     }
     701        4663 : }
     702             : 
     703         316 : void SvxRuler::UpdateFrame(const SvxLongLRSpaceItem *pItem) // new value LRSpace
     704             : {
     705             :     /* Store new value LRSpace; delete old ones if possible */
     706         316 :     if(bActive)
     707             :     {
     708         316 :         if(pItem)
     709         315 :             mxLRSpaceItem.reset(new SvxLongLRSpaceItem(*pItem));
     710             :         else
     711           1 :             mxLRSpaceItem.reset();
     712         316 :         StartListening_Impl();
     713             :     }
     714         316 : }
     715             : 
     716         641 : void SvxRuler::UpdateFrameMinMax(const SfxRectangleItem *pItem) // value for MinMax
     717             : {
     718             :     /* Set new value for MinMax; delete old ones if possible */
     719         641 :     if(bActive)
     720             :     {
     721         641 :         if(pItem)
     722         641 :             mxMinMaxItem.reset(new SfxRectangleItem(*pItem));
     723             :         else
     724           0 :             mxMinMaxItem.reset();
     725             :     }
     726         641 : }
     727             : 
     728             : 
     729         330 : void SvxRuler::UpdateFrame(const SvxLongULSpaceItem *pItem) // new value
     730             : {
     731             :     /* Update Right/bottom margin */
     732         330 :     if(bActive && !bHorz)
     733             :     {
     734         330 :         if(pItem)
     735         329 :             mxULSpaceItem.reset(new SvxLongULSpaceItem(*pItem));
     736             :         else
     737           1 :             mxULSpaceItem.reset();
     738         330 :         StartListening_Impl();
     739             :     }
     740         330 : }
     741             : 
     742         639 : void SvxRuler::Update( const SvxProtectItem* pItem )
     743             : {
     744         639 :     if( pItem )
     745         565 :         mxRulerImpl->aProtectItem = *pItem;
     746         639 : }
     747             : 
     748         637 : void SvxRuler::UpdateTextRTL(const SfxBoolItem* pItem)
     749             : {
     750         637 :     if(bActive && bHorz)
     751             :     {
     752         311 :         delete mxRulerImpl->pTextRTLItem;
     753         311 :         mxRulerImpl->pTextRTLItem = 0;
     754         311 :         if(pItem)
     755         310 :             mxRulerImpl->pTextRTLItem = new SfxBoolItem(*pItem);
     756         311 :         SetTextRTL(mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue());
     757         311 :         StartListening_Impl();
     758             :     }
     759         637 : }
     760             : 
     761        1126 : void SvxRuler::Update(
     762             :                 const SvxColumnItem *pItem,  // new value
     763             :                 sal_uInt16 nSID) //Slot Id to identify NULL items
     764             : {
     765             :     /* Set new value for column view */
     766        1126 :     if(bActive)
     767             :     {
     768        1126 :         if(pItem)
     769             :         {
     770           2 :             mxColumnItem.reset(new SvxColumnItem(*pItem));
     771           2 :             mxRulerImpl->bIsTableRows = (pItem->Which() == SID_RULER_ROWS || pItem->Which() == SID_RULER_ROWS_VERTICAL);
     772           2 :             if(!bHorz && !mxRulerImpl->bIsTableRows)
     773           0 :                 mxColumnItem->SetWhich(SID_RULER_BORDERS_VERTICAL);
     774             :         }
     775        1124 :         else if(mxColumnItem.get() && mxColumnItem->Which() == nSID)
     776             :         //there are two groups of column items table/frame columns and table rows
     777             :         //both can occur in vertical or horizontal mode
     778             :         //the horizontal ruler handles the SID_RULER_BORDERS and SID_RULER_ROWS_VERTICAL
     779             :         //and the vertical handles SID_RULER_BORDERS_VERTICAL and SID_RULER_ROWS
     780             :         //if mxColumnItem is already set with one of the ids then a NULL pItem argument
     781             :         //must not delete it
     782             :         {
     783           0 :             mxColumnItem.reset();
     784           0 :             mxRulerImpl->bIsTableRows = false;
     785             :         }
     786        1126 :         StartListening_Impl();
     787             :     }
     788        1126 : }
     789             : 
     790             : 
     791       55741 : void SvxRuler::UpdateColumns()
     792             : {
     793             :     /* Update column view */
     794       55741 :     if(mxColumnItem.get() && mxColumnItem->Count() > 1)
     795             :     {
     796           4 :         mpBorders.resize(mxColumnItem->Count());
     797             : 
     798           4 :         sal_uInt16 nStyleFlags = RULER_BORDER_VARIABLE;
     799             : 
     800             :         bool bProtectColumns =
     801           8 :                     mxRulerImpl->aProtectItem.IsSizeProtected() ||
     802           8 :                     mxRulerImpl->aProtectItem.IsPosProtected();
     803             : 
     804           4 :         if( !bProtectColumns )
     805           4 :             nStyleFlags |= RULER_BORDER_MOVEABLE;
     806             : 
     807           4 :         if( mxColumnItem->IsTable() )
     808           4 :             nStyleFlags |= RULER_BORDER_TABLE;
     809           0 :         else if ( !bProtectColumns )
     810           0 :             nStyleFlags |= RULER_BORDER_SIZEABLE;
     811             : 
     812           4 :         sal_uInt16 nBorders = mxColumnItem->Count();
     813             : 
     814           4 :         if(!mxRulerImpl->bIsTableRows)
     815           2 :             --nBorders;
     816             : 
     817          10 :         for(sal_uInt16 i = 0; i < nBorders; ++i)
     818             :         {
     819           6 :             mpBorders[i].nStyle = nStyleFlags;
     820           6 :             if(!mxColumnItem->At(i).bVisible)
     821           2 :                 mpBorders[i].nStyle |= RULER_STYLE_INVISIBLE;
     822             : 
     823           6 :             mpBorders[i].nPos = ConvertPosPixel(mxColumnItem->At(i).nEnd + lAppNullOffset);
     824             : 
     825           6 :             if(mxColumnItem->Count() == i + 1)
     826             :             {
     827             :                 //with table rows the end of the table is contained in the
     828             :                 //column item but it has no width!
     829           2 :                 mpBorders[i].nWidth = 0;
     830             :             }
     831             :             else
     832             :             {
     833           4 :                 mpBorders[i].nWidth = ConvertSizePixel(mxColumnItem->At(i + 1).nStart - mxColumnItem->At(i).nEnd);
     834             :             }
     835           6 :             mpBorders[i].nMinPos = ConvertPosPixel(mxColumnItem->At(i).nEndMin + lAppNullOffset);
     836           6 :             mpBorders[i].nMaxPos = ConvertPosPixel(mxColumnItem->At(i).nEndMax + lAppNullOffset);
     837             :         }
     838           4 :         SetBorders(mxColumnItem->Count() - 1, &mpBorders[0]);
     839             :     }
     840             :     else
     841             :     {
     842       55737 :         SetBorders();
     843             :     }
     844       55741 : }
     845             : 
     846        1148 : void SvxRuler::UpdateObject()
     847             : {
     848             :     /* Update view of object representation */
     849        1148 :     if(mxObjectItem.get())
     850             :     {
     851             :         DBG_ASSERT(!mpObjectBorders.empty(), "no Buffer");
     852             :         // !! to the page margin
     853           0 :         long nMargin = mxLRSpaceItem.get() ? mxLRSpaceItem->GetLeft() : 0;
     854           0 :         mpObjectBorders[0].nPos =
     855           0 :             ConvertPosPixel(mxObjectItem->GetStartX() -
     856           0 :                             nMargin + lAppNullOffset);
     857           0 :         mpObjectBorders[1].nPos =
     858           0 :             ConvertPosPixel(mxObjectItem->GetEndX() - nMargin + lAppNullOffset);
     859           0 :         nMargin = mxULSpaceItem.get() ? mxULSpaceItem->GetUpper() : 0;
     860           0 :         mpObjectBorders[2].nPos =
     861           0 :             ConvertPosPixel(mxObjectItem->GetStartY() -
     862           0 :                             nMargin + lAppNullOffset);
     863           0 :         mpObjectBorders[3].nPos =
     864           0 :             ConvertPosPixel(mxObjectItem->GetEndY() - nMargin + lAppNullOffset);
     865             : 
     866           0 :         const sal_uInt16 nOffset = GetObjectBordersOff(0);
     867           0 :         SetBorders(2, &mpObjectBorders[0] + nOffset);
     868             :     }
     869             :     else
     870             :     {
     871        1148 :         SetBorders();
     872             :     }
     873        1148 : }
     874             : 
     875       56316 : void SvxRuler::UpdatePara()
     876             : {
     877             : 
     878             :     /*  Update the view for paragraph indents:
     879             :         Left margin, first line indent, right margin paragraph update
     880             :         mpIndents[0] = Buffer for old intent
     881             :         mpIndents[1] = Buffer for old intent
     882             :         mpIndents[INDENT_FIRST_LINE]   = first line indent
     883             :         mpIndents[INDENT_LEFT_MARGIN]  = left margin
     884             :         mpIndents[INDENT_RIGHT_MARGIN] = right margin
     885             :     */
     886             : 
     887             :     // Dependence on PagePosItem
     888       56316 :     if(mxParaItem.get() && mxPagePosItem.get() && !mxObjectItem.get())
     889             :     {
     890         570 :         bool bRTLText = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
     891             :         // First-line indent is negative to the left paragraph margin
     892         570 :         long nLeftFrameMargin = GetLeftFrameMargin();
     893         570 :         long nRightFrameMargin = GetRightFrameMargin();
     894         570 :         SetLeftFrameMargin(ConvertHPosPixel(nLeftFrameMargin));
     895         570 :         SetRightFrameMargin(ConvertHPosPixel(nRightFrameMargin));
     896             : 
     897             :         long leftMargin;
     898             :         long leftFirstLine;
     899             :         long rightMargin;
     900             : 
     901         570 :         if(bRTLText)
     902             :         {
     903           0 :             leftMargin    = nRightFrameMargin - mxParaItem->GetTextLeft() + lAppNullOffset;
     904           0 :             leftFirstLine = leftMargin - mxParaItem->GetTextFirstLineOfst();
     905           0 :             rightMargin   = nLeftFrameMargin + mxParaItem->GetRight() + lAppNullOffset;
     906             :         }
     907             :         else
     908             :         {
     909         570 :             leftMargin    = nLeftFrameMargin + mxParaItem->GetTextLeft() + lAppNullOffset;
     910         570 :             leftFirstLine = leftMargin + mxParaItem->GetTextFirstLineOfst();
     911         570 :             rightMargin   = nRightFrameMargin - mxParaItem->GetRight() + lAppNullOffset;
     912             :         }
     913             : 
     914         570 :         mpIndents[INDENT_LEFT_MARGIN].nPos  = ConvertHPosPixel(leftMargin);
     915         570 :         mpIndents[INDENT_FIRST_LINE].nPos   = ConvertHPosPixel(leftFirstLine);
     916         570 :         mpIndents[INDENT_RIGHT_MARGIN].nPos = ConvertHPosPixel(rightMargin);
     917             : 
     918         570 :         if( mxParaItem->IsAutoFirst() )
     919           0 :             mpIndents[INDENT_FIRST_LINE].nStyle |= RULER_STYLE_INVISIBLE;
     920             :         else
     921         570 :             mpIndents[INDENT_FIRST_LINE].nStyle &= ~RULER_STYLE_INVISIBLE;
     922             : 
     923         570 :         SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
     924             :     }
     925             :     else
     926             :     {
     927       55746 :         if(!mpIndents.empty())
     928             :         {
     929       55746 :             mpIndents[INDENT_FIRST_LINE].nPos = 0;
     930       55746 :             mpIndents[INDENT_LEFT_MARGIN].nPos = 0;
     931       55746 :             mpIndents[INDENT_RIGHT_MARGIN].nPos = 0;
     932             :         }
     933       55746 :         SetIndents(); // turn off
     934             :     }
     935       56316 : }
     936             : 
     937         601 : void SvxRuler::UpdatePara(const SvxLRSpaceItem *pItem) // new value of paragraph indents
     938             : {
     939             :     /* Store new value of paragraph indents */
     940         601 :     if(bActive)
     941             :     {
     942         601 :         if(pItem)
     943         311 :             mxParaItem.reset(new SvxLRSpaceItem(*pItem));
     944             :         else
     945         290 :             mxParaItem.reset();
     946         601 :         StartListening_Impl();
     947             :     }
     948         601 : }
     949             : 
     950         635 : void SvxRuler::UpdateParaBorder(const SvxLRSpaceItem * pItem )
     951             : {
     952             :     /* Border distance */
     953         635 :     if(bActive)
     954             :     {
     955         635 :         if(pItem)
     956         557 :             mxParaBorderItem.reset(new SvxLRSpaceItem(*pItem));
     957             :         else
     958          78 :             mxParaBorderItem.reset();
     959         635 :         StartListening_Impl();
     960             :     }
     961         635 : }
     962             : 
     963       56889 : void SvxRuler::UpdatePage()
     964             : {
     965             :     /* Update view of position and width of page */
     966       56889 :     if(mxPagePosItem.get())
     967             :     {
     968             :         // all objects are automatically adjusted
     969        1162 :         if(bHorz)
     970             :         {
     971             :             SetPagePos(
     972        1142 :                 pEditWin->LogicToPixel(mxPagePosItem->GetPos()).X(),
     973        1142 :                 pEditWin->LogicToPixel(Size(mxPagePosItem->GetWidth(), 0)).
     974        1713 :                 Width());
     975             :         }
     976             :         else
     977             :         {
     978             :             SetPagePos(
     979        1182 :                 pEditWin->LogicToPixel(mxPagePosItem->GetPos()).Y(),
     980        1182 :                 pEditWin->LogicToPixel(Size(0, mxPagePosItem->GetHeight())).
     981        1773 :                 Height());
     982             :         }
     983        1162 :         if(bAppSetNullOffset)
     984         121 :             SetNullOffset(ConvertSizePixel(-lAppNullOffset + lLogicNullOffset));
     985             :     }
     986             :     else
     987             :     {
     988       55727 :         SetPagePos();
     989             :     }
     990             : 
     991       56889 :     long lPos = 0;
     992       56889 :     Point aOwnPos = GetPosPixel();
     993       56889 :     Point aEdtWinPos = pEditWin->GetPosPixel();
     994       56889 :     if( AllSettings::GetLayoutRTL() && bHorz )
     995             :     {
     996             :         //#i73321# in RTL the window and the ruler is not mirrored but the
     997             :         // influence of the vertical ruler is inverted
     998           0 :         Size aOwnSize = GetSizePixel();
     999           0 :         Size aEdtWinSize = pEditWin->GetSizePixel();
    1000           0 :         lPos = aOwnSize.Width() - aEdtWinSize.Width();
    1001           0 :         lPos -= (aEdtWinPos - aOwnPos).X();
    1002             :     }
    1003             :     else
    1004             :     {
    1005       56889 :         Point aPos(aEdtWinPos - aOwnPos);
    1006       56889 :         lPos = bHorz ? aPos.X() : aPos.Y();
    1007             :     }
    1008             : 
    1009             :     // Unfortunately, we get the offset of the edit window to the ruler never
    1010             :     // through a status message. So we set it ourselves if necessary.
    1011       56889 :     if(lPos != mxRulerImpl->lOldWinPos)
    1012             :     {
    1013          88 :         mxRulerImpl->lOldWinPos=lPos;
    1014          88 :         SetWinPos(lPos);
    1015             :     }
    1016       56889 : }
    1017             : 
    1018         670 : void SvxRuler::Update(const SvxPagePosSizeItem *pItem) // new value of page attributes
    1019             : {
    1020             :     /* Store new value of page attributes */
    1021         670 :     if(bActive)
    1022             :     {
    1023         670 :         if(pItem)
    1024         670 :             mxPagePosItem.reset(new SvxPagePosSizeItem(*pItem));
    1025             :         else
    1026           0 :             mxPagePosItem.reset();
    1027         670 :         StartListening_Impl();
    1028             :     }
    1029         670 : }
    1030             : 
    1031        1170 : void SvxRuler::SetDefTabDist(long inDefTabDist)  // New distance for DefaultTabs in App-Metrics
    1032             : {
    1033        1170 :     if (lAppNullOffset == LONG_MAX)
    1034         660 :         UpdateFrame(); // hack: try to get lAppNullOffset initialized
    1035             :     /* New distance is set for DefaultTabs */
    1036        1170 :     lDefTabDist = inDefTabDist;
    1037        1170 :     UpdateTabs();
    1038        1170 : }
    1039             : 
    1040           0 : sal_uInt16 ToSvTab_Impl(SvxTabAdjust eAdj)
    1041             : {
    1042             :     /* Internal conversion routine between SV-Tab.-Enum and Svx */
    1043           0 :     switch(eAdj) {
    1044           0 :         case SVX_TAB_ADJUST_LEFT:    return RULER_TAB_LEFT;
    1045           0 :         case SVX_TAB_ADJUST_RIGHT:   return RULER_TAB_RIGHT;
    1046           0 :         case SVX_TAB_ADJUST_DECIMAL: return RULER_TAB_DECIMAL;
    1047           0 :         case SVX_TAB_ADJUST_CENTER:  return RULER_TAB_CENTER;
    1048           0 :         case SVX_TAB_ADJUST_DEFAULT: return RULER_TAB_DEFAULT;
    1049             :         default: ; //prevent warning
    1050             :     }
    1051           0 :     return 0;
    1052             : }
    1053             : 
    1054           0 : SvxTabAdjust ToAttrTab_Impl(sal_uInt16 eAdj)
    1055             : {
    1056           0 :     switch(eAdj) {
    1057           0 :         case RULER_TAB_LEFT:    return SVX_TAB_ADJUST_LEFT    ;
    1058           0 :         case RULER_TAB_RIGHT:   return SVX_TAB_ADJUST_RIGHT   ;
    1059           0 :         case RULER_TAB_DECIMAL: return SVX_TAB_ADJUST_DECIMAL ;
    1060           0 :         case RULER_TAB_CENTER:  return SVX_TAB_ADJUST_CENTER  ;
    1061           0 :         case RULER_TAB_DEFAULT: return SVX_TAB_ADJUST_DEFAULT ;
    1062             :     }
    1063           0 :     return SVX_TAB_ADJUST_LEFT;
    1064             : }
    1065             : 
    1066       57486 : void SvxRuler::UpdateTabs()
    1067             : {
    1068       57486 :     if(IsDrag())
    1069       57486 :         return;
    1070             : 
    1071      116590 :     if( mxPagePosItem.get() &&
    1072        2446 :         mxParaItem.get()    &&
    1073       59081 :         mxTabStopItem.get() &&
    1074         767 :         !mxObjectItem.get() )
    1075             :     {
    1076             :         // buffer for DefaultTabStop
    1077             :         // Distance last Tab <-> Right paragraph margin / DefaultTabDist
    1078         767 :         bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
    1079             : 
    1080         767 :         long nLeftFrameMargin = GetLeftFrameMargin();
    1081         767 :         long nRightFrameMargin = GetRightFrameMargin();
    1082             : 
    1083             :         //#i24363# tab stops relative to indent
    1084         767 :         const long nParaItemTxtLeft = mxParaItem->GetTextLeft();
    1085             : 
    1086         767 :         const long lParaIndent = nLeftFrameMargin + nParaItemTxtLeft;
    1087             : 
    1088         767 :         const long lLastTab = mxTabStopItem->Count()
    1089           0 :                                 ? ConvertHPosPixel(mxTabStopItem->At(mxTabStopItem->Count() - 1).GetTabPos())
    1090         767 :                                 : 0;
    1091         767 :         const long lPosPixel = ConvertHPosPixel(lParaIndent) + lLastTab;
    1092         767 :         const long lRightIndent = ConvertHPosPixel(nRightFrameMargin - mxParaItem->GetRight());
    1093             : 
    1094         767 :         long nDefTabDist = ConvertHPosPixel(lDefTabDist);
    1095             : 
    1096         767 :         if( !nDefTabDist )
    1097           0 :             nDefTabDist = 1;
    1098             : 
    1099         767 :         const sal_uInt16 nDefTabBuf = lPosPixel > lRightIndent || lLastTab > lRightIndent
    1100             :                     ? 0
    1101        1534 :                     : (sal_uInt16)( (lRightIndent - lPosPixel) / nDefTabDist );
    1102             : 
    1103         767 :         if(mxTabStopItem->Count() + TAB_GAP + nDefTabBuf > nTabBufSize)
    1104             :         {
    1105             :             // 10 (GAP) in stock
    1106         272 :             nTabBufSize = mxTabStopItem->Count() + TAB_GAP + nDefTabBuf + GAP;
    1107         272 :             mpTabs.resize(nTabBufSize);
    1108             :         }
    1109             : 
    1110         767 :         nTabCount = 0;
    1111             :         sal_uInt16 j;
    1112             : 
    1113             :         //#i24363# tab stops relative to indent
    1114         767 :         const long lRightPixMargin = ConvertSizePixel(nRightFrameMargin - nParaItemTxtLeft );
    1115         767 :         const long lParaIndentPix = ConvertSizePixel(lParaIndent);
    1116             : 
    1117         767 :         for(j = 0; j < mxTabStopItem->Count(); ++j)
    1118             :         {
    1119           0 :             const SvxTabStop* pTab = &mxTabStopItem->At(j);
    1120           0 :             if (mxRulerImpl->bIsTabsRelativeToIndent)
    1121             :             {
    1122           0 :                 long nTabPosition = ConvertHPosPixel(lParaIndent + pTab->GetTabPos() + lAppNullOffset);
    1123           0 :                 mpTabs[nTabCount + TAB_GAP].nPos = nTabPosition;
    1124             :             }
    1125             :             else
    1126             :             {
    1127           0 :                 long nTabPosition = ConvertHPosPixel(0 + pTab->GetTabPos() + lAppNullOffset);
    1128           0 :                 mpTabs[nTabCount + TAB_GAP].nPos = nTabPosition;
    1129             :             }
    1130             : 
    1131           0 :             if(bRTL)
    1132             :             {
    1133           0 :                 mpTabs[nTabCount + TAB_GAP].nPos = lParaIndentPix + lRightPixMargin - mpTabs[nTabCount + TAB_GAP].nPos;
    1134             :             }
    1135           0 :             mpTabs[nTabCount + TAB_GAP].nStyle = ToSvTab_Impl(pTab->GetAdjustment());
    1136           0 :             ++nTabCount;
    1137             :         }
    1138             : 
    1139         767 :         if(!mxTabStopItem->Count())
    1140         767 :             mpTabs[0].nPos = bRTL ? lRightPixMargin : lParaIndentPix;
    1141             : 
    1142             :         // fill the rest with default Tabs
    1143         767 :         if(bRTL)
    1144             :         {
    1145           0 :             sal_Int32 aFirst = mpTabs[nTabCount].nPos;
    1146           0 :             for(j = 0; j < nDefTabBuf; ++j)
    1147             :             {
    1148           0 :                 mpTabs[nTabCount + TAB_GAP].nPos =
    1149           0 :                     aFirst - ConvertHPosPixel(j * lDefTabDist);
    1150             : 
    1151           0 :                 if(j == 0 )
    1152             :                 {
    1153           0 :                     mpTabs[nTabCount + TAB_GAP].nPos -=
    1154           0 :                         ((mpTabs[nTabCount + TAB_GAP].nPos - lRightPixMargin)
    1155           0 :                          % nDefTabDist );
    1156             :                 }
    1157             : 
    1158           0 :                 if(mpTabs[nTabCount + TAB_GAP].nPos <= lParaIndentPix)
    1159           0 :                     break;
    1160           0 :                 mpTabs[nTabCount + TAB_GAP].nStyle = RULER_TAB_DEFAULT;
    1161           0 :                 ++nTabCount;
    1162             :             }
    1163             :         }
    1164             :         else
    1165             :         {
    1166         767 :             sal_Int32 aFirst = 0;
    1167       10854 :             for(j = 0; j < nDefTabBuf; ++j)
    1168             :             {
    1169       10111 :                 if( j == 0 )
    1170             :                 {
    1171             :                     //set the first default tab stop
    1172         767 :                     if(mxRulerImpl->bIsTabsRelativeToIndent)
    1173             :                     {
    1174         767 :                         mpTabs[nTabCount + TAB_GAP].nPos = (mpTabs[nTabCount].nPos + nDefTabDist);
    1175             : 
    1176         767 :                         mpTabs[nTabCount + TAB_GAP].nPos -=
    1177        1534 :                             (mpTabs[nTabCount + TAB_GAP].nPos - lParaIndentPix) % nDefTabDist;
    1178         767 :                         aFirst = mpTabs[nTabCount + TAB_GAP].nPos;
    1179             :                     }
    1180             :                     else
    1181             :                     {
    1182           0 :                         if( mpTabs[nTabCount].nPos < 0 )
    1183           0 :                             aFirst = ( mpTabs[nTabCount].nPos / nDefTabDist ) * nDefTabDist;
    1184             :                         else
    1185           0 :                             aFirst = ( mpTabs[nTabCount].nPos / nDefTabDist + 1 ) * nDefTabDist;
    1186           0 :                         mpTabs[nTabCount + TAB_GAP].nPos = aFirst;
    1187             :                     }
    1188             :                 }
    1189             :                 else
    1190             :                 {
    1191             :                     //simply add the default distance to the last position
    1192             : 
    1193        9344 :                     mpTabs[nTabCount + TAB_GAP].nPos = aFirst + ConvertHPosPixel(j * lDefTabDist);
    1194             :                 }
    1195             : 
    1196       10111 :                 if(mpTabs[nTabCount + TAB_GAP].nPos >= lRightIndent)
    1197          24 :                     break;
    1198       10087 :                 mpTabs[nTabCount + TAB_GAP].nStyle = RULER_TAB_DEFAULT;
    1199       10087 :                 ++nTabCount;
    1200             :             }
    1201             :         }
    1202         767 :         SetTabs(nTabCount, &mpTabs[0] + TAB_GAP);
    1203             :         DBG_ASSERT(nTabCount + TAB_GAP <= nTabBufSize, "BufferSize too small");
    1204             :     }
    1205             :     else
    1206             :     {
    1207       56719 :         SetTabs();
    1208             :     }
    1209             : }
    1210             : 
    1211         600 : void SvxRuler::Update(const SvxTabStopItem *pItem) // new value for tabs
    1212             : {
    1213             :     /* Store new value for tabs; delete old ones if possible */
    1214         600 :     if(bActive)
    1215             :     {
    1216         600 :         if(pItem)
    1217             :         {
    1218         273 :             mxTabStopItem.reset(new SvxTabStopItem(*pItem));
    1219         273 :             if(!bHorz)
    1220           0 :                 mxTabStopItem->SetWhich(SID_ATTR_TABSTOP_VERTICAL);
    1221             :         }
    1222             :         else
    1223             :         {
    1224         327 :             mxTabStopItem.reset();
    1225             :         }
    1226         600 :         StartListening_Impl();
    1227             :     }
    1228         600 : }
    1229             : 
    1230          74 : void SvxRuler::Update(const SvxObjectItem *pItem) // new value for objects
    1231             : {
    1232             :     /* Store new value for objects */
    1233          74 :     if(bActive)
    1234             :     {
    1235          74 :         if(pItem)
    1236           0 :             mxObjectItem.reset(new SvxObjectItem(*pItem));
    1237             :         else
    1238          74 :             mxObjectItem.reset();
    1239          74 :         StartListening_Impl();
    1240             :     }
    1241          74 : }
    1242             : 
    1243          78 : void SvxRuler::SetNullOffsetLogic(long lVal) // Setting of the logic NullOffsets
    1244             : {
    1245          78 :     lAppNullOffset = lLogicNullOffset - lVal;
    1246          78 :     bAppSetNullOffset = true;
    1247          78 :     Ruler::SetNullOffset(ConvertSizePixel(lVal));
    1248          78 :     Update();
    1249          78 : }
    1250             : 
    1251       56889 : void SvxRuler::Update()
    1252             : {
    1253             :     /* Perform update of view */
    1254       56889 :     if(IsDrag())
    1255       56889 :         return;
    1256             : 
    1257       56889 :     UpdatePage();
    1258       56889 :     UpdateFrame();
    1259       56889 :     if(nFlags & SvxRulerSupportFlags::OBJECT)
    1260        1148 :         UpdateObject();
    1261             :     else
    1262       55741 :         UpdateColumns();
    1263             : 
    1264       56889 :     if(nFlags & (SvxRulerSupportFlags::PARAGRAPH_MARGINS | SvxRulerSupportFlags::PARAGRAPH_MARGINS_VERTICAL))
    1265       56316 :       UpdatePara();
    1266             : 
    1267       56889 :     if(nFlags & SvxRulerSupportFlags::TABS)
    1268       56316 :       UpdateTabs();
    1269             : }
    1270             : 
    1271       55915 : long SvxRuler::GetPageWidth() const
    1272             : {
    1273       55915 :     if (!mxPagePosItem.get())
    1274       54894 :         return 0;
    1275        1021 :     return bHorz ? mxPagePosItem->GetWidth() : mxPagePosItem->GetHeight();
    1276             : }
    1277             : 
    1278           0 : inline long SvxRuler::GetFrameLeft() const
    1279             : {
    1280             :     /* Get Left margin in Pixels */
    1281             :     return  bAppSetNullOffset ?
    1282           0 :             GetMargin1() + ConvertSizePixel(lLogicNullOffset) :
    1283           0 :             Ruler::GetNullOffset();
    1284             : }
    1285             : 
    1286             : inline void SvxRuler::SetFrameLeft(long lFrameLeft)
    1287             : {
    1288             :     /* Set Left margin in Pixels */
    1289             :     bool bProtectColumns =
    1290             :                 mxRulerImpl->aProtectItem.IsSizeProtected() ||
    1291             :                 mxRulerImpl->aProtectItem.IsPosProtected();
    1292             :     if(bAppSetNullOffset)
    1293             :     {
    1294             :         SetMargin1(lFrameLeft - ConvertSizePixel(lLogicNullOffset),
    1295             :                    bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE);
    1296             :     }
    1297             :     else
    1298             :     {
    1299             :         Ruler::SetNullOffset(lFrameLeft);
    1300             :     }
    1301             : }
    1302             : 
    1303           0 : long SvxRuler::GetFirstLineIndent() const
    1304             : {
    1305             :     /* Get First-line indent in pixels */
    1306           0 :     return mxParaItem.get() ? mpIndents[INDENT_FIRST_LINE].nPos : GetMargin1();
    1307             : }
    1308             : 
    1309           0 : long SvxRuler::GetLeftIndent() const
    1310             : {
    1311             :     /* Get Left paragraph margin in Pixels */
    1312           0 :     return mxParaItem.get() ? mpIndents[INDENT_LEFT_MARGIN].nPos : GetMargin1();
    1313             : }
    1314             : 
    1315           0 : long SvxRuler::GetRightIndent() const
    1316             : {
    1317             :     /* Get Right paragraph margin in Pixels */
    1318           0 :     return mxParaItem.get() ? mpIndents[INDENT_RIGHT_MARGIN].nPos : GetMargin2();
    1319             : }
    1320             : 
    1321           0 : long SvxRuler::GetLogicRightIndent() const
    1322             : {
    1323             :     /* Get Right paragraph margin in Logic */
    1324           0 :     return mxParaItem.get() ? GetRightFrameMargin() - mxParaItem->GetRight() : GetRightFrameMargin();
    1325             : }
    1326             : 
    1327             : // Left margin in App values, is either the margin (= 0)  or the left edge of
    1328             : // the column that is set in the column attribute as current column.
    1329        1337 : long SvxRuler::GetLeftFrameMargin() const
    1330             : {
    1331             :     // #126721# for some unknown reason the current column is set to 0xffff
    1332             :     DBG_ASSERT(!mxColumnItem.get() || mxColumnItem->GetActColumn() < mxColumnItem->Count(),
    1333             :                     "issue #126721# - invalid current column!");
    1334        1337 :     long nLeft = 0;
    1335        2680 :     if (mxColumnItem.get() &&
    1336        1343 :         mxColumnItem->Count() &&
    1337           6 :         mxColumnItem->IsConsistent())
    1338             :     {
    1339           6 :         nLeft = mxColumnItem->GetActiveColumnDescription().nStart;
    1340             :     }
    1341             : 
    1342        1337 :     return nLeft;
    1343             : }
    1344             : 
    1345           0 : inline long SvxRuler::GetLeftMin() const
    1346             : {
    1347             :     DBG_ASSERT(mxMinMaxItem.get(), "no MinMax value set");
    1348           0 :     if (mxMinMaxItem.get())
    1349             :     {
    1350           0 :         if (bHorz)
    1351           0 :             return mxMinMaxItem->GetValue().Left();
    1352             :         else
    1353           0 :             return mxMinMaxItem->GetValue().Top();
    1354             :     }
    1355           0 :     return 0;
    1356             : }
    1357             : 
    1358           0 : inline long SvxRuler::GetRightMax() const
    1359             : {
    1360             :     DBG_ASSERT(mxMinMaxItem.get(), "no MinMax value set");
    1361           0 :     if (mxMinMaxItem.get())
    1362             :     {
    1363           0 :         if (bHorz)
    1364           0 :             return mxMinMaxItem->GetValue().Right();
    1365             :         else
    1366           0 :             return mxMinMaxItem->GetValue().Bottom();
    1367             :     }
    1368           0 :     return 0;
    1369             : }
    1370             : 
    1371             : 
    1372        1337 : long SvxRuler::GetRightFrameMargin() const
    1373             : {
    1374             :     /* Get right frame margin (in logical units) */
    1375        1337 :     if (mxColumnItem.get())
    1376             :     {
    1377           6 :         if (!IsActLastColumn(true))
    1378             :         {
    1379           6 :             return mxColumnItem->At(GetActRightColumn(true)).nEnd;
    1380             :         }
    1381             :     }
    1382             : 
    1383        1331 :     long lResult = lLogicNullOffset;
    1384             : 
    1385             :     // If possible deduct right table entry
    1386        1331 :     if(mxColumnItem.get() && mxColumnItem->IsTable())
    1387           0 :         lResult += mxColumnItem->GetRight();
    1388        1331 :     else if(bHorz && mxLRSpaceItem.get())
    1389        1331 :         lResult += mxLRSpaceItem->GetRight();
    1390           0 :     else if(!bHorz && mxULSpaceItem.get())
    1391           0 :         lResult += mxULSpaceItem->GetLower();
    1392             : 
    1393        1331 :     if(bHorz)
    1394        1331 :         lResult = mxPagePosItem->GetWidth() - lResult;
    1395             :     else
    1396           0 :         lResult = mxPagePosItem->GetHeight() - lResult;
    1397             : 
    1398        1331 :     return lResult;
    1399             : }
    1400             : 
    1401             : #define NEG_FLAG ( (nFlags & SvxRulerSupportFlags::NEGATIVE_MARGINS) == \
    1402             :                    SvxRulerSupportFlags::NEGATIVE_MARGINS )
    1403             : #define TAB_FLAG ( mxColumnItem.get() && mxColumnItem->IsTable() )
    1404             : 
    1405           0 : long SvxRuler::GetCorrectedDragPos( bool bLeft, bool bRight )
    1406             : {
    1407             :     /*
    1408             :         Corrects the position within the calculated limits. The limit values are in
    1409             :         pixels relative to the page edge.
    1410             :     */
    1411             : 
    1412           0 :     const long lNullPix = Ruler::GetNullOffset();
    1413           0 :     long lDragPos = GetDragPos() + lNullPix;
    1414             : ADD_DEBUG_TEXT("lDragPos: ", OUString::number(lDragPos))
    1415           0 :      bool bHoriRows = bHorz && mxRulerImpl->bIsTableRows;
    1416           0 :     if((bLeft || (bHoriRows)) && lDragPos < nMaxLeft)
    1417           0 :         lDragPos = nMaxLeft;
    1418           0 :     else if((bRight||bHoriRows) && lDragPos > nMaxRight)
    1419           0 :         lDragPos = nMaxRight;
    1420           0 :     return lDragPos - lNullPix;
    1421             : }
    1422             : 
    1423           0 : void ModifyTabs_Impl( sal_uInt16 nCount, // Number of Tabs
    1424             :                       RulerTab* pTabs,   // Tab buffer
    1425             :                       long lDiff)        // difference to be added
    1426             : {
    1427             :     /* Helper function, move all the tabs by a fixed value */
    1428           0 :     if( pTabs )
    1429             :     {
    1430           0 :         for(sal_uInt16 i = 0; i < nCount; ++i)
    1431             :         {
    1432           0 :             pTabs[i].nPos += lDiff;
    1433             :         }
    1434             :     }
    1435           0 : }
    1436             : 
    1437           0 : void SvxRuler::DragMargin1()
    1438             : {
    1439             :     /* Dragging the left edge of frame */
    1440           0 :     long aDragPosition = GetCorrectedDragPos( !TAB_FLAG || !NEG_FLAG, true );
    1441             : 
    1442           0 :     aDragPosition = MakePositionSticky(aDragPosition, GetRightFrameMargin(), false);
    1443             : 
    1444             :     // Check if position changed
    1445           0 :     if (aDragPosition == 0)
    1446           0 :         return;
    1447             : 
    1448           0 :     DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 3 : 7, bHorz);
    1449           0 :     if (mxColumnItem.get() && (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL))
    1450           0 :         DragBorders();
    1451           0 :     AdjustMargin1(aDragPosition);
    1452             : }
    1453             : 
    1454           0 : void SvxRuler::AdjustMargin1(long lInputDiff)
    1455             : {
    1456           0 :     const long nOld = bAppSetNullOffset? GetMargin1(): GetNullOffset();
    1457           0 :     const long lDragPos = lInputDiff;
    1458             : 
    1459             :     bool bProtectColumns =
    1460           0 :         mxRulerImpl->aProtectItem.IsSizeProtected() ||
    1461           0 :         mxRulerImpl->aProtectItem.IsPosProtected();
    1462             : 
    1463             :     const sal_uInt16 nMarginStyle =
    1464           0 :         bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE;
    1465             : 
    1466           0 :     if(!bAppSetNullOffset)
    1467             :     {
    1468           0 :         long lDiff = lDragPos;
    1469           0 :         SetNullOffset(nOld + lDiff);
    1470           0 :         if (!mxColumnItem.get() || !(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR))
    1471             :         {
    1472           0 :             SetMargin2( GetMargin2() - lDiff, nMarginStyle );
    1473             : 
    1474           0 :             if (!mxColumnItem.get() && !mxObjectItem.get() && mxParaItem.get())
    1475             :             {
    1476             :                 // Right indent of the old position
    1477           0 :                 mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff;
    1478           0 :                 SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1479             :             }
    1480           0 :             if(mxObjectItem.get())
    1481             :             {
    1482           0 :                 mpObjectBorders[GetObjectBordersOff(0)].nPos -= lDiff;
    1483           0 :                 mpObjectBorders[GetObjectBordersOff(1)].nPos -= lDiff;
    1484           0 :                 SetBorders(2, &mpObjectBorders[0] + GetObjectBordersOff(0));
    1485             :             }
    1486           0 :             if(mxColumnItem.get())
    1487             :             {
    1488           0 :                 for(sal_uInt16 i = 0; i < mxColumnItem->Count()-1; ++i)
    1489           0 :                     mpBorders[i].nPos -= lDiff;
    1490           0 :                 SetBorders(mxColumnItem->Count()-1, &mpBorders[0]);
    1491           0 :                 if(mxColumnItem->IsFirstAct())
    1492             :                 {
    1493             :                     // Right indent of the old position
    1494           0 :                     if(mxParaItem.get())
    1495             :                     {
    1496           0 :                         mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff;
    1497           0 :                         SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1498             :                     }
    1499             :                 }
    1500             :                 else
    1501             :                 {
    1502           0 :                     if(mxParaItem.get())
    1503             :                     {
    1504           0 :                         mpIndents[INDENT_FIRST_LINE].nPos -= lDiff;
    1505           0 :                         mpIndents[INDENT_LEFT_MARGIN].nPos -= lDiff;
    1506           0 :                         mpIndents[INDENT_RIGHT_MARGIN].nPos -= lDiff;
    1507           0 :                         SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1508             :                     }
    1509             :                 }
    1510           0 :                 if(mxTabStopItem.get() && (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
    1511           0 :                    &&!IsActFirstColumn())
    1512             :                 {
    1513           0 :                     ModifyTabs_Impl(nTabCount + TAB_GAP, &mpTabs[0], -lDiff);
    1514           0 :                     SetTabs(nTabCount, &mpTabs[0] + TAB_GAP);
    1515             :                 }
    1516             :             }
    1517             :         }
    1518             :     }
    1519             :     else
    1520             :     {
    1521           0 :         long lDiff = lDragPos - nOld;
    1522           0 :         SetMargin1(nOld + lDiff, nMarginStyle);
    1523             : 
    1524           0 :         if (!mxColumnItem.get() || !(nDragType & (SvxRulerDragFlags::OBJECT_SIZE_LINEAR | SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)))
    1525             :         {
    1526           0 :             if (!mxColumnItem.get() && !mxObjectItem.get() && mxParaItem.get())
    1527             :             {
    1528             :                 // Left indent of the old position
    1529           0 :                 mpIndents[INDENT_FIRST_LINE].nPos += lDiff;
    1530           0 :                 mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff;
    1531           0 :                 SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1532             :             }
    1533             : 
    1534           0 :             if (mxColumnItem.get())
    1535             :             {
    1536           0 :                 for(sal_uInt16 i = 0; i < mxColumnItem->Count() - 1; ++i)
    1537           0 :                     mpBorders[i].nPos += lDiff;
    1538           0 :                 SetBorders(mxColumnItem->Count() - 1, &mpBorders[0]);
    1539           0 :                 if (mxColumnItem->IsFirstAct())
    1540             :                 {
    1541             :                     // Left indent of the old position
    1542           0 :                     if(mxParaItem.get())
    1543             :                     {
    1544           0 :                         mpIndents[INDENT_FIRST_LINE].nPos += lDiff;
    1545           0 :                         mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff;
    1546           0 :                         SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1547             :                     }
    1548             :                 }
    1549             :                 else
    1550             :                 {
    1551           0 :                     if(mxParaItem.get())
    1552             :                     {
    1553           0 :                         mpIndents[INDENT_FIRST_LINE].nPos += lDiff;
    1554           0 :                         mpIndents[INDENT_LEFT_MARGIN].nPos += lDiff;
    1555           0 :                         mpIndents[INDENT_RIGHT_MARGIN].nPos += lDiff;
    1556           0 :                         SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1557             :                     }
    1558             :                 }
    1559             :             }
    1560           0 :             if(mxTabStopItem.get())
    1561             :             {
    1562           0 :                 ModifyTabs_Impl(nTabCount + TAB_GAP, &mpTabs[0], lDiff);
    1563           0 :                 SetTabs(nTabCount, &mpTabs[0] + TAB_GAP);
    1564             :             }
    1565             :         }
    1566             :     }
    1567           0 : }
    1568             : 
    1569           0 : void SvxRuler::DragMargin2()
    1570             : {
    1571             :     /* Dragging the right edge of frame */
    1572           0 :     long aDragPosition = GetCorrectedDragPos( true, !TAB_FLAG || !NEG_FLAG);
    1573           0 :     aDragPosition = MakePositionSticky(aDragPosition, GetLeftFrameMargin(), false);
    1574           0 :     long lDiff = aDragPosition - GetMargin2();
    1575             : 
    1576             :     // Check if position changed
    1577           0 :     if (lDiff == 0)
    1578           0 :         return;
    1579             : 
    1580           0 :     if( mxRulerImpl->bIsTableRows &&
    1581           0 :         !bHorz &&
    1582           0 :         mxColumnItem.get() &&
    1583           0 :         (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL))
    1584             :     {
    1585           0 :         DragBorders();
    1586             :     }
    1587             : 
    1588             :     bool bProtectColumns =
    1589           0 :         mxRulerImpl->aProtectItem.IsSizeProtected() ||
    1590           0 :         mxRulerImpl->aProtectItem.IsPosProtected();
    1591             : 
    1592           0 :     const sal_uInt16 nMarginStyle = bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE;
    1593             : 
    1594           0 :     SetMargin2( aDragPosition, nMarginStyle );
    1595             : 
    1596             :     // Right indent of the old position
    1597           0 :     if((!mxColumnItem.get() || IsActLastColumn()) && mxParaItem.get())
    1598             :     {
    1599           0 :         mpIndents[INDENT_FIRST_LINE].nPos += lDiff;
    1600           0 :         SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1601             :     }
    1602             : 
    1603           0 :     DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 5 : 7, bHorz);
    1604             : }
    1605             : 
    1606           0 : void SvxRuler::DragIndents()
    1607             : {
    1608             :     /* Dragging the paragraph indents */
    1609           0 :     long aDragPosition = NEG_FLAG ? GetDragPos() : GetCorrectedDragPos();
    1610           0 :     const sal_uInt16 nIndex = GetDragAryPos() + INDENT_GAP;
    1611             : 
    1612           0 :     bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
    1613             : 
    1614           0 :     if(nIndex == INDENT_RIGHT_MARGIN)
    1615           0 :         aDragPosition = MakePositionSticky(aDragPosition, bRTL ? GetLeftFrameMargin() : GetRightFrameMargin());
    1616             :     else
    1617           0 :         aDragPosition = MakePositionSticky(aDragPosition, bRTL ? GetRightFrameMargin() : GetLeftFrameMargin());
    1618             : 
    1619           0 :     const long lDiff = mpIndents[nIndex].nPos - aDragPosition;
    1620             : 
    1621             :     // Check if position changed
    1622           0 :     if (lDiff == 0)
    1623           0 :         return;
    1624             : 
    1625           0 :     if((nIndex == INDENT_FIRST_LINE || nIndex == INDENT_LEFT_MARGIN )  &&
    1626           0 :         !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY))
    1627             :     {
    1628           0 :         mpIndents[INDENT_FIRST_LINE].nPos -= lDiff;
    1629             :     }
    1630             : 
    1631           0 :     mpIndents[nIndex].nPos = aDragPosition;
    1632             : 
    1633           0 :     SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1634           0 :     DrawLine_Impl(lTabPos, 1, bHorz);
    1635             : }
    1636             : 
    1637           0 : void SvxRuler::DrawLine_Impl(long& lTabPosition, int nNew, bool bHorizontal)
    1638             : {
    1639             :     /*
    1640             :        Output routine for the ledger line when moving tabs, tables and other
    1641             :        columns
    1642             :     */
    1643           0 :     if(bHorizontal)
    1644             :     {
    1645           0 :         const long nHeight = pEditWin->GetOutputSize().Height();
    1646           0 :         Point aZero = pEditWin->GetMapMode().GetOrigin();
    1647           0 :         if(lTabPosition != -1)
    1648             :         {
    1649             :             pEditWin->InvertTracking(
    1650           0 :                 Rectangle( Point(lTabPosition, -aZero.Y()),
    1651           0 :                            Point(lTabPosition, -aZero.Y() + nHeight)),
    1652           0 :                 SHOWTRACK_SPLIT | SHOWTRACK_CLIP );
    1653             :         }
    1654           0 :         if( nNew & 1 )
    1655             :         {
    1656           0 :             long nDrapPosition = GetCorrectedDragPos( ( nNew & 4 ) != 0, ( nNew & 2 ) != 0 );
    1657           0 :             nDrapPosition = MakePositionSticky(nDrapPosition, GetLeftFrameMargin());
    1658           0 :             lTabPosition = ConvertHSizeLogic( nDrapPosition + GetNullOffset() );
    1659           0 :             if(mxPagePosItem.get())
    1660           0 :                 lTabPosition += mxPagePosItem->GetPos().X();
    1661             :             pEditWin->InvertTracking(
    1662           0 :                 Rectangle( Point(lTabPosition, -aZero.Y()),
    1663           0 :                            Point(lTabPosition, -aZero.Y() + nHeight) ),
    1664           0 :                 SHOWTRACK_CLIP | SHOWTRACK_SPLIT );
    1665             :         }
    1666             :     }
    1667             :     else
    1668             :     {
    1669           0 :         const long nWidth = pEditWin->GetOutputSize().Width();
    1670           0 :         Point aZero = pEditWin->GetMapMode().GetOrigin();
    1671           0 :         if(lTabPosition != -1)
    1672             :         {
    1673             :             pEditWin->InvertTracking(
    1674           0 :                 Rectangle( Point(-aZero.X(),          lTabPosition),
    1675           0 :                            Point(-aZero.X() + nWidth, lTabPosition)),
    1676           0 :                 SHOWTRACK_SPLIT | SHOWTRACK_CLIP );
    1677             :         }
    1678             : 
    1679           0 :         if(nNew & 1)
    1680             :         {
    1681           0 :             long nDrapPosition = GetCorrectedDragPos();
    1682           0 :             nDrapPosition = MakePositionSticky(nDrapPosition, GetLeftFrameMargin());
    1683           0 :             lTabPosition = ConvertVSizeLogic(nDrapPosition + GetNullOffset());
    1684           0 :             if(mxPagePosItem.get())
    1685           0 :                 lTabPosition += mxPagePosItem->GetPos().Y();
    1686             :             pEditWin->InvertTracking(
    1687           0 :                 Rectangle( Point(-aZero.X(),        lTabPosition),
    1688           0 :                            Point(-aZero.X()+nWidth, lTabPosition)),
    1689           0 :                 SHOWTRACK_CLIP | SHOWTRACK_SPLIT );
    1690             :         }
    1691             :     }
    1692           0 : }
    1693             : 
    1694           0 : void SvxRuler::DragTabs()
    1695             : {
    1696             :     /* Dragging of Tabs */
    1697           0 :     long aDragPosition = GetCorrectedDragPos(true, false);
    1698           0 :     aDragPosition = MakePositionSticky(aDragPosition, GetLeftFrameMargin());
    1699             : 
    1700           0 :     sal_uInt16 nIdx = GetDragAryPos() + TAB_GAP;
    1701           0 :     long nDiff = aDragPosition - mpTabs[nIdx].nPos;
    1702           0 :     if (nDiff == 0)
    1703           0 :         return;
    1704             : 
    1705           0 :     DrawLine_Impl(lTabPos, 7, bHorz);
    1706             : 
    1707           0 :     if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR)
    1708             :     {
    1709             : 
    1710           0 :         for(sal_uInt16 i = nIdx; i < nTabCount; ++i)
    1711             :         {
    1712           0 :             mpTabs[i].nPos += nDiff;
    1713             :             // limit on maximum
    1714           0 :             if(mpTabs[i].nPos > GetMargin2())
    1715           0 :                 mpTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
    1716             :             else
    1717           0 :                 mpTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE;
    1718             :         }
    1719             :     }
    1720           0 :     else if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
    1721             :     {
    1722           0 :         mxRulerImpl->nTotalDist -= nDiff;
    1723           0 :         mpTabs[nIdx].nPos = aDragPosition;
    1724           0 :         for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i)
    1725             :         {
    1726           0 :             if(mpTabs[i].nStyle & RULER_TAB_DEFAULT)
    1727             :                 // can be canceled at the DefaultTabs
    1728           0 :                 break;
    1729           0 :             long nDelta = mxRulerImpl->nTotalDist * mxRulerImpl->pPercBuf[i];
    1730           0 :             nDelta /= 1000;
    1731           0 :             mpTabs[i].nPos = mpTabs[nIdx].nPos + nDelta;
    1732           0 :             if(mpTabs[i].nPos + GetNullOffset() > nMaxRight)
    1733           0 :                 mpTabs[i].nStyle |= RULER_STYLE_INVISIBLE;
    1734             :             else
    1735           0 :                 mpTabs[i].nStyle &= ~RULER_STYLE_INVISIBLE;
    1736             :         }
    1737             :     }
    1738             :     else
    1739             :     {
    1740           0 :         mpTabs[nIdx].nPos = aDragPosition;
    1741             :     }
    1742             : 
    1743           0 :     if(IsDragDelete())
    1744           0 :         mpTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
    1745             :     else
    1746           0 :         mpTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE;
    1747           0 :     SetTabs(nTabCount, &mpTabs[0] + TAB_GAP);
    1748             : }
    1749             : 
    1750       20256 : void SvxRuler::SetActive(bool bOn)
    1751             : {
    1752       20256 :     if(bOn)
    1753             :     {
    1754       11432 :         Activate();
    1755             :     }
    1756             :     else
    1757        8824 :         Deactivate();
    1758       20256 :     if(bActive!=bOn)
    1759             :     {
    1760       11163 :         pBindings->EnterRegistrations();
    1761       11163 :         if(bOn)
    1762       30431 :             for(sal_uInt16 i=0;i<mxRulerImpl->nControlerItems;i++)
    1763       27646 :                 pCtrlItems[i]->ReBind();
    1764             :         else
    1765       91610 :             for(sal_uInt16 j=0;j<mxRulerImpl->nControlerItems;j++)
    1766       83232 :                 pCtrlItems[j]->UnBind();
    1767       11163 :         pBindings->LeaveRegistrations();
    1768             :     }
    1769       20256 :     bActive = bOn;
    1770       20256 : }
    1771             : 
    1772           0 : void SvxRuler::UpdateParaContents_Impl(
    1773             :                             long lDifference,
    1774             :                             UpdateType eType)  // Art (all, left or right)
    1775             : {
    1776             :     /* Helper function; carry Tabs and Paragraph Margins */
    1777           0 :     switch(eType)
    1778             :     {
    1779             :         case MOVE_RIGHT:
    1780           0 :             mpIndents[INDENT_RIGHT_MARGIN].nPos += lDifference;
    1781           0 :             break;
    1782             :         case MOVE_ALL:
    1783           0 :             mpIndents[INDENT_RIGHT_MARGIN].nPos += lDifference;
    1784             :             // no break
    1785             :         case MOVE_LEFT:
    1786             :         {
    1787           0 :             mpIndents[INDENT_FIRST_LINE].nPos += lDifference;
    1788           0 :             mpIndents[INDENT_LEFT_MARGIN].nPos += lDifference;
    1789           0 :             if (!mpTabs.empty())
    1790             :             {
    1791           0 :                 for(sal_uInt16 i = 0; i < nTabCount+TAB_GAP; ++i)
    1792             :                 {
    1793           0 :                     mpTabs[i].nPos += lDifference;
    1794             :                 }
    1795           0 :                 SetTabs(nTabCount, &mpTabs[0] + TAB_GAP);
    1796             :             }
    1797           0 :             break;
    1798             :         }
    1799             :     }
    1800           0 :     SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    1801           0 : }
    1802             : 
    1803           0 : void SvxRuler::DragBorders()
    1804             : {
    1805             :     /* Dragging of Borders (Tables and other columns) */
    1806           0 :     bool bLeftIndentsCorrected  = false;
    1807           0 :     bool bRightIndentsCorrected = false;
    1808             :     int nIndex;
    1809             : 
    1810           0 :     if(GetDragType() == RULER_TYPE_BORDER)
    1811             :     {
    1812           0 :         DrawLine_Impl(lTabPos, 7, bHorz);
    1813           0 :         nIndex = GetDragAryPos();
    1814             :     }
    1815             :     else
    1816             :     {
    1817           0 :         nIndex = 0;
    1818             :     }
    1819             : 
    1820           0 :     sal_uInt16 nDragSize = GetDragSize();
    1821           0 :     long lDiff = 0;
    1822             : 
    1823             :     // the drag position has to be corrected to be able to prevent borders from passing each other
    1824           0 :     long lPos = MakePositionSticky(GetCorrectedDragPos(), GetLeftFrameMargin());
    1825             : 
    1826           0 :     switch(nDragSize)
    1827             :     {
    1828             :         case RULER_DRAGSIZE_MOVE:
    1829             :         {
    1830             : ADD_DEBUG_TEXT("lLastLMargin: ", OUString::number(mxRulerImpl->lLastLMargin))
    1831           0 :             if(GetDragType() == RULER_TYPE_BORDER)
    1832           0 :                 lDiff = lPos - nDragOffset - mpBorders[nIndex].nPos;
    1833             :             else
    1834           0 :                 lDiff = GetDragType() == RULER_TYPE_MARGIN1 ? lPos - mxRulerImpl->lLastLMargin : lPos - mxRulerImpl->lLastRMargin;
    1835             : 
    1836           0 :             if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR)
    1837             :             {
    1838           0 :                 long nRight = GetMargin2() - lMinFrame; // Right limiters
    1839           0 :                 for(int i = mpBorders.size() - 2; i >= nIndex; --i)
    1840             :                 {
    1841           0 :                     long l = mpBorders[i].nPos;
    1842           0 :                     mpBorders[i].nPos += lDiff;
    1843           0 :                     mpBorders[i].nPos = std::min(mpBorders[i].nPos, nRight - mpBorders[i].nWidth);
    1844           0 :                     nRight = mpBorders[i].nPos - lMinFrame;
    1845             :                     // RR update the column
    1846           0 :                     if(i == GetActRightColumn())
    1847             :                     {
    1848           0 :                         UpdateParaContents_Impl(mpBorders[i].nPos - l, MOVE_RIGHT);
    1849           0 :                         bRightIndentsCorrected = true;
    1850             :                     }
    1851             :                     // LAR, EZE update the column
    1852           0 :                     else if(i == GetActLeftColumn())
    1853             :                     {
    1854           0 :                         UpdateParaContents_Impl(mpBorders[i].nPos - l, MOVE_LEFT);
    1855           0 :                         bLeftIndentsCorrected = true;
    1856             :                     }
    1857             :                 }
    1858             :             }
    1859           0 :             else if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
    1860             :             {
    1861             :                 int nLimit;
    1862             :                 long lLeft;
    1863           0 :                 int nStartLimit = mpBorders.size() - 2;
    1864           0 :                 switch(GetDragType())
    1865             :                 {
    1866             :                 default: ;//prevent warning
    1867             :                     OSL_FAIL("svx::SvxRuler::DragBorders(), unknown drag type!" );
    1868             :                     //fall-through
    1869             :                 case RULER_TYPE_BORDER:
    1870           0 :                     if(mxRulerImpl->bIsTableRows)
    1871             :                     {
    1872           0 :                         mpBorders[nIndex].nPos += lDiff;
    1873           0 :                         if(bHorz)
    1874             :                         {
    1875           0 :                             lLeft = mpBorders[nIndex].nPos;
    1876           0 :                             mxRulerImpl->nTotalDist -= lDiff;
    1877           0 :                             nLimit = nIndex + 1;
    1878             :                         }
    1879             :                         else
    1880             :                         {
    1881           0 :                             lLeft = 0;
    1882           0 :                             nStartLimit = nIndex - 1;
    1883           0 :                             mxRulerImpl->nTotalDist += lDiff;
    1884           0 :                             nLimit = 0;
    1885             :                         }
    1886             :                     }
    1887             :                     else
    1888             :                     {
    1889           0 :                         nLimit = nIndex + 1;
    1890           0 :                         mpBorders[nIndex].nPos += lDiff;
    1891           0 :                         lLeft = mpBorders[nIndex].nPos;
    1892           0 :                         mxRulerImpl->nTotalDist -= lDiff;
    1893             :                     }
    1894           0 :                 break;
    1895             :                 case RULER_TYPE_MARGIN1:
    1896           0 :                     nLimit = 0;
    1897           0 :                     lLeft = mxRulerImpl->lLastLMargin + lDiff;
    1898           0 :                     mxRulerImpl->nTotalDist -= lDiff;
    1899           0 :                 break;
    1900             :                 case RULER_TYPE_MARGIN2:
    1901           0 :                     nLimit = 0;
    1902           0 :                     lLeft= 0;
    1903           0 :                     nStartLimit = mpBorders.size() - 2;
    1904           0 :                     mxRulerImpl->nTotalDist += lDiff;
    1905           0 :                 break;
    1906             :                 }
    1907             : 
    1908           0 :                 for(int i  = nStartLimit; i >= nLimit; --i)
    1909             :                 {
    1910             : 
    1911           0 :                     long l = mpBorders[i].nPos;
    1912           0 :                     mpBorders[i].nPos =
    1913           0 :                         lLeft +
    1914           0 :                         (mxRulerImpl->nTotalDist * mxRulerImpl->pPercBuf[i]) / 1000 +
    1915           0 :                         mxRulerImpl->pBlockBuf[i];
    1916             : 
    1917             :                     // RR update the column
    1918           0 :                     if(!mxRulerImpl->bIsTableRows)
    1919             :                     {
    1920           0 :                         if(i == GetActRightColumn())
    1921             :                         {
    1922           0 :                             UpdateParaContents_Impl(mpBorders[i].nPos - l, MOVE_RIGHT);
    1923           0 :                             bRightIndentsCorrected = true;
    1924             :                         }
    1925             :                         // LAR, EZE update the column
    1926           0 :                         else if(i == GetActLeftColumn())
    1927             :                         {
    1928           0 :                             UpdateParaContents_Impl(mpBorders[i].nPos - l, MOVE_LEFT);
    1929           0 :                             bLeftIndentsCorrected = true;
    1930             :                         }
    1931             :                     }
    1932             :                 }
    1933           0 :                 if(mxRulerImpl->bIsTableRows)
    1934             :                 {
    1935             :                     //in vertical tables the left borders have to be moved
    1936           0 :                     if(bHorz)
    1937             :                     {
    1938           0 :                         for(int i  = 0; i < nIndex; ++i)
    1939           0 :                             mpBorders[i].nPos += lDiff;
    1940           0 :                         AdjustMargin1(lDiff);
    1941             :                     }
    1942             :                     else
    1943             :                     {
    1944             :                         //otherwise the right borders are moved
    1945           0 :                         for(int i  = mxColumnItem->Count() - 1; i > nIndex; --i)
    1946           0 :                             mpBorders[i].nPos += lDiff;
    1947           0 :                         SetMargin2( GetMargin2() + lDiff, 0 );
    1948             :                     }
    1949             :                 }
    1950             :             }
    1951           0 :             else if(mxRulerImpl->bIsTableRows)
    1952             :             {
    1953             :                 //moving rows: if a row is resized all following rows
    1954             :                 //have to be moved by the same amount.
    1955             :                 //This includes the left border when the table is not limited
    1956             :                 //to a lower frame border.
    1957             :                 int nLimit;
    1958           0 :                 if(GetDragType()==RULER_TYPE_BORDER)
    1959             :                 {
    1960           0 :                     nLimit = nIndex + 1;
    1961           0 :                     mpBorders[nIndex].nPos += lDiff;
    1962             :                 }
    1963             :                 else
    1964             :                 {
    1965           0 :                     nLimit=0;
    1966             :                 }
    1967             :                 //in vertical tables the left borders have to be moved
    1968           0 :                 if(bHorz)
    1969             :                 {
    1970           0 :                     for(int i  = 0; i < nIndex; ++i)
    1971             :                     {
    1972           0 :                         mpBorders[i].nPos += lDiff;
    1973             :                     }
    1974           0 :                     AdjustMargin1(lDiff);
    1975             :                 }
    1976             :                 else
    1977             :                 {
    1978             :                     //otherwise the right borders are moved
    1979           0 :                     for(int i  = mpBorders.size() - 2; i >= nLimit; --i)
    1980             :                     {
    1981           0 :                         mpBorders[i].nPos += lDiff;
    1982             :                     }
    1983           0 :                     SetMargin2( GetMargin2() + lDiff, 0 );
    1984             :                 }
    1985             :             }
    1986             :             else
    1987           0 :                 mpBorders[nIndex].nPos += lDiff;
    1988           0 :             break;
    1989             :         }
    1990             :       case RULER_DRAGSIZE_1:
    1991             :         {
    1992           0 :             lDiff = lPos - mpBorders[nIndex].nPos;
    1993           0 :             mpBorders[nIndex].nWidth += mpBorders[nIndex].nPos - lPos;
    1994           0 :             mpBorders[nIndex].nPos = lPos;
    1995           0 :             break;
    1996             :         }
    1997             :       case RULER_DRAGSIZE_2:
    1998             :         {
    1999           0 :             const long nOld = mpBorders[nIndex].nWidth;
    2000           0 :             mpBorders[nIndex].nWidth = lPos - mpBorders[nIndex].nPos;
    2001           0 :             lDiff = mpBorders[nIndex].nWidth - nOld;
    2002           0 :             break;
    2003             :         }
    2004             :     }
    2005           0 :     if(!bRightIndentsCorrected &&
    2006           0 :        GetActRightColumn() == nIndex &&
    2007           0 :        nDragSize != RULER_DRAGSIZE_2 &&
    2008           0 :        !mpIndents.empty() &&
    2009           0 :        !mxRulerImpl->bIsTableRows)
    2010             :     {
    2011           0 :         UpdateParaContents_Impl(lDiff, MOVE_RIGHT);
    2012             :     }
    2013           0 :     else if(!bLeftIndentsCorrected &&
    2014           0 :             GetActLeftColumn() == nIndex &&
    2015           0 :             nDragSize != RULER_DRAGSIZE_1 &&
    2016           0 :             !mpIndents.empty())
    2017             :     {
    2018           0 :         UpdateParaContents_Impl(lDiff, MOVE_LEFT);
    2019             :     }
    2020           0 :     SetBorders(mxColumnItem->Count() - 1, &mpBorders[0]);
    2021           0 : }
    2022             : 
    2023           0 : void SvxRuler::DragObjectBorder()
    2024             : {
    2025             :     /* Dragging of object edges */
    2026           0 :     if(RULER_DRAGSIZE_MOVE == GetDragSize())
    2027             :     {
    2028           0 :         const long lPosition = MakePositionSticky(GetCorrectedDragPos(), GetLeftFrameMargin());
    2029             : 
    2030           0 :         const sal_uInt16 nIdx = GetDragAryPos();
    2031           0 :         mpObjectBorders[GetObjectBordersOff(nIdx)].nPos = lPosition;
    2032           0 :         SetBorders(2, &mpObjectBorders[0] + GetObjectBordersOff(0));
    2033           0 :         DrawLine_Impl(lTabPos, 7, bHorz);
    2034             : 
    2035             :     }
    2036           0 : }
    2037             : 
    2038           0 : void SvxRuler::ApplyMargins()
    2039             : {
    2040             :     /* Applying margins; changed by dragging. */
    2041           0 :     const SfxPoolItem* pItem = NULL;
    2042           0 :     sal_uInt16 nId = SID_ATTR_LONG_LRSPACE;
    2043             : 
    2044           0 :     if(bHorz)
    2045             :     {
    2046           0 :         const long lOldNull = lLogicNullOffset;
    2047           0 :         if(mxRulerImpl->lMaxLeftLogic != -1 && nMaxLeft == GetMargin1() + Ruler::GetNullOffset())
    2048             :         {
    2049           0 :             lLogicNullOffset = mxRulerImpl->lMaxLeftLogic;
    2050           0 :             mxLRSpaceItem->SetLeft(lLogicNullOffset);
    2051             :         }
    2052             :         else
    2053             :         {
    2054           0 :             lLogicNullOffset = ConvertHPosLogic(GetFrameLeft()) - lAppNullOffset;
    2055           0 :             mxLRSpaceItem->SetLeft(PixelHAdjust(lLogicNullOffset, mxLRSpaceItem->GetLeft()));
    2056             :         }
    2057             : 
    2058           0 :         if(bAppSetNullOffset)
    2059             :         {
    2060           0 :             lAppNullOffset += lLogicNullOffset - lOldNull;
    2061             :         }
    2062             : 
    2063             :         long nRight;
    2064           0 :         if(mxRulerImpl->lMaxRightLogic != -1
    2065           0 :            && nMaxRight == GetMargin2() + Ruler::GetNullOffset())
    2066             :         {
    2067           0 :             nRight = GetPageWidth() - mxRulerImpl->lMaxRightLogic;
    2068             :         }
    2069             :         else
    2070             :         {
    2071             :             nRight = std::max((long)0,
    2072           0 :                             mxPagePosItem->GetWidth() - mxLRSpaceItem->GetLeft() -
    2073           0 :                                 (ConvertHPosLogic(GetMargin2()) - lAppNullOffset));
    2074             : 
    2075           0 :             nRight = PixelHAdjust( nRight, mxLRSpaceItem->GetRight());
    2076             :         }
    2077           0 :         mxLRSpaceItem->SetRight(nRight);
    2078             : 
    2079           0 :         pItem = mxLRSpaceItem.get();
    2080             : 
    2081             : #ifdef DEBUGLIN
    2082             :         Debug_Impl(pEditWin, *mxLRSpaceItem);
    2083             : #endif // DEBUGLIN
    2084             : 
    2085             :     }
    2086             :     else
    2087             :     {
    2088           0 :         const long lOldNull = lLogicNullOffset;
    2089             :         mxULSpaceItem->SetUpper(
    2090             :             PixelVAdjust(
    2091             :                 lLogicNullOffset =
    2092           0 :                 ConvertVPosLogic(GetFrameLeft()) -
    2093           0 :                 lAppNullOffset, mxULSpaceItem->GetUpper()));
    2094           0 :         if(bAppSetNullOffset)
    2095             :         {
    2096           0 :             lAppNullOffset += lLogicNullOffset - lOldNull;
    2097             :         }
    2098             :         mxULSpaceItem->SetLower(
    2099             :             PixelVAdjust(
    2100           0 :                 std::max((long)0, mxPagePosItem->GetHeight() -
    2101           0 :                     mxULSpaceItem->GetUpper() -
    2102           0 :                     (ConvertVPosLogic(GetMargin2()) -
    2103           0 :                      lAppNullOffset)), mxULSpaceItem->GetLower()));
    2104           0 :         pItem = mxULSpaceItem.get();
    2105           0 :         nId = SID_ATTR_LONG_ULSPACE;
    2106             : 
    2107             : #ifdef DEBUGLIN
    2108             :         Debug_Impl(pEditWin,*mxULSpaceItem.get());
    2109             : #endif // DEBUGLIN
    2110             : 
    2111             :     }
    2112           0 :     pBindings->GetDispatcher()->Execute( nId, SfxCallMode::RECORD, pItem, 0L );
    2113           0 :     if(mxTabStopItem.get())
    2114           0 :         UpdateTabs();
    2115           0 : }
    2116             : 
    2117           0 : long SvxRuler::RoundToCurrentMapMode(long lValue) const
    2118             : {
    2119           0 :     RulerUnitData aUnitData = GetCurrentRulerUnit();
    2120           0 :     double aRoundingFactor = aUnitData.nTickUnit / aUnitData.nTick1;
    2121             : 
    2122           0 :     long lNewValue = OutputDevice::LogicToLogic(Size(lValue, 0), pEditWin->GetMapMode(), GetCurrentMapMode()).Width();
    2123           0 :     lNewValue = (rtl::math::round(lNewValue / (double) aUnitData.nTickUnit * aRoundingFactor) / aRoundingFactor) * aUnitData.nTickUnit;
    2124           0 :     return OutputDevice::LogicToLogic(Size(lNewValue, 0), GetCurrentMapMode(), pEditWin->GetMapMode()).Width();
    2125             : }
    2126             : 
    2127           0 : void SvxRuler::ApplyIndents()
    2128             : {
    2129             :     /* Applying paragraph settings; changed by dragging. */
    2130             : 
    2131           0 :     long nLeftFrameMargin  = GetLeftFrameMargin();
    2132             : 
    2133           0 :     bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
    2134             : 
    2135             :     long nNewTxtLeft;
    2136             :     long nNewFirstLineOffset;
    2137             :     long nNewRight;
    2138             : 
    2139           0 :     long nFirstLine    = ConvertPosLogic(mpIndents[INDENT_FIRST_LINE].nPos);
    2140           0 :     long nLeftMargin   = ConvertPosLogic(mpIndents[INDENT_LEFT_MARGIN].nPos);
    2141           0 :     long nRightMargin  = ConvertPosLogic(mpIndents[INDENT_RIGHT_MARGIN].nPos);
    2142             : 
    2143           0 :     if(mxColumnItem.get() && ((bRTL && !IsActLastColumn(true)) || (!bRTL && !IsActFirstColumn(true))))
    2144             :     {
    2145           0 :         if(bRTL)
    2146             :         {
    2147           0 :             long nRightColumn  = GetActRightColumn(true);
    2148           0 :             long nRightBorder  = ConvertPosLogic(mpBorders[nRightColumn].nPos);
    2149           0 :             nNewTxtLeft = nRightBorder - nLeftMargin - lAppNullOffset;
    2150             :         }
    2151             :         else
    2152             :         {
    2153           0 :             long nLeftColumn = GetActLeftColumn(true);
    2154           0 :             long nLeftBorder = ConvertPosLogic(mpBorders[nLeftColumn].nPos + mpBorders[nLeftColumn].nWidth);
    2155           0 :             nNewTxtLeft = nLeftMargin - nLeftBorder - lAppNullOffset;
    2156             :         }
    2157             :     }
    2158             :     else
    2159             :     {
    2160           0 :         if(bRTL)
    2161             :         {
    2162           0 :             long nRightBorder = ConvertPosLogic(GetMargin2());
    2163           0 :             nNewTxtLeft = nRightBorder - nLeftMargin - lAppNullOffset;
    2164             :         }
    2165             :         else
    2166             :         {
    2167           0 :             long nLeftBorder = ConvertPosLogic(GetMargin1());
    2168           0 :             nNewTxtLeft = nLeftBorder + nLeftMargin - nLeftFrameMargin - lAppNullOffset;
    2169             :         }
    2170             :     }
    2171             : 
    2172           0 :     if(bRTL)
    2173           0 :         nNewFirstLineOffset = nLeftMargin - nFirstLine - lAppNullOffset;
    2174             :     else
    2175           0 :         nNewFirstLineOffset = nFirstLine - nLeftMargin - lAppNullOffset;
    2176             : 
    2177           0 :     if(mxColumnItem.get() && ((!bRTL && !IsActLastColumn(true)) || (bRTL && !IsActFirstColumn(true))))
    2178             :     {
    2179           0 :         if(bRTL)
    2180             :         {
    2181           0 :             long nLeftColumn = GetActLeftColumn(true);
    2182           0 :             long nLeftBorder = ConvertPosLogic(mpBorders[nLeftColumn].nPos + mpBorders[nLeftColumn].nWidth);
    2183           0 :             nNewRight = nRightMargin - nLeftBorder - lAppNullOffset;
    2184             :         }
    2185             :         else
    2186             :         {
    2187           0 :             long nRightColumn  = GetActRightColumn(true);
    2188           0 :             long nRightBorder  = ConvertPosLogic(mpBorders[nRightColumn].nPos);
    2189           0 :             nNewRight = nRightBorder - nRightMargin - lAppNullOffset;
    2190             :         }
    2191             :     }
    2192             :     else
    2193             :     {
    2194           0 :         if(bRTL)
    2195             :         {
    2196           0 :             long nLeftBorder = ConvertPosLogic(GetMargin1());
    2197           0 :             nNewRight = nLeftBorder + nRightMargin - nLeftFrameMargin - lAppNullOffset;
    2198             :         }
    2199             :         else
    2200             :         {
    2201           0 :             long nRightBorder = ConvertPosLogic(GetMargin2());
    2202           0 :             nNewRight = nRightBorder - nRightMargin - lAppNullOffset;
    2203             :         }
    2204             :     }
    2205             : 
    2206           0 :     if (mbSnapping)
    2207             :     {
    2208           0 :         nNewTxtLeft         = RoundToCurrentMapMode(nNewTxtLeft);
    2209           0 :         nNewFirstLineOffset = RoundToCurrentMapMode(nNewFirstLineOffset);
    2210           0 :         nNewRight           = RoundToCurrentMapMode(nNewRight);
    2211             :     }
    2212             : 
    2213           0 :     mxParaItem->SetTextFirstLineOfst(sal::static_int_cast<short>(nNewFirstLineOffset));
    2214           0 :     mxParaItem->SetTextLeft(nNewTxtLeft);
    2215           0 :     mxParaItem->SetRight(nNewRight);
    2216             : 
    2217           0 :     sal_uInt16 nParagraphId  = bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL;
    2218           0 :     pBindings->GetDispatcher()->Execute( nParagraphId, SfxCallMode::RECORD, mxParaItem.get(), 0L );
    2219           0 :     UpdateTabs();
    2220           0 : }
    2221             : 
    2222           0 : void SvxRuler::ApplyTabs()
    2223             : {
    2224             :     /* Apply tab settings, changed by dragging. */
    2225           0 :     bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
    2226           0 :     const sal_uInt16 nCoreIdx = GetDragAryPos();
    2227           0 :     if(IsDragDelete())
    2228             :     {
    2229           0 :         mxTabStopItem->Remove(nCoreIdx);
    2230             :     }
    2231           0 :     else if(SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType ||
    2232           0 :             SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType)
    2233             :     {
    2234           0 :         SvxTabStopItem *pItem = new SvxTabStopItem(mxTabStopItem->Which());
    2235             :         //remove default tab stops
    2236           0 :         for ( sal_uInt16 i = 0; i < pItem->Count(); )
    2237             :         {
    2238           0 :             if ( SVX_TAB_ADJUST_DEFAULT == (*pItem)[i].GetAdjustment() )
    2239             :             {
    2240           0 :                 pItem->Remove(i);
    2241           0 :                 continue;
    2242             :             }
    2243           0 :             ++i;
    2244             :         }
    2245             : 
    2246             :         sal_uInt16 j;
    2247           0 :         for(j = 0; j < nCoreIdx; ++j)
    2248             :         {
    2249           0 :             pItem->Insert(mxTabStopItem->At(j));
    2250             :         }
    2251           0 :         for(; j < mxTabStopItem->Count(); ++j)
    2252             :         {
    2253           0 :             SvxTabStop aTabStop = mxTabStopItem->At(j);
    2254           0 :             aTabStop.GetTabPos() = PixelHAdjust(
    2255             :                 ConvertHPosLogic(
    2256           0 :                     mpTabs[j + TAB_GAP].nPos - GetLeftIndent()) - lAppNullOffset,
    2257           0 :                 aTabStop.GetTabPos());
    2258           0 :             pItem->Insert(aTabStop);
    2259             :         }
    2260           0 :         mxTabStopItem.reset(pItem);
    2261             :     }
    2262           0 :     else if( mxTabStopItem->Count() == 0 )
    2263           0 :         return;
    2264             :     else
    2265             :     {
    2266           0 :         SvxTabStop aTabStop = mxTabStopItem->At(nCoreIdx);
    2267           0 :         if( mxRulerImpl->lMaxRightLogic != -1 &&
    2268           0 :             mpTabs[nCoreIdx + TAB_GAP].nPos + Ruler::GetNullOffset() == nMaxRight )
    2269             :         {
    2270           0 :             aTabStop.GetTabPos() = mxRulerImpl->lMaxRightLogic - lLogicNullOffset;
    2271             :         }
    2272             :         else
    2273             :         {
    2274           0 :             if(bRTL)
    2275             :             {
    2276             :                 //#i24363# tab stops relative to indent
    2277           0 :                 const long nTmpLeftIndent = mxRulerImpl->bIsTabsRelativeToIndent ?
    2278             :                                             GetLeftIndent() :
    2279           0 :                                             ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset );
    2280             : 
    2281           0 :                 long nNewPosition = ConvertHPosLogic(nTmpLeftIndent - mpTabs[nCoreIdx + TAB_GAP].nPos);
    2282           0 :                 aTabStop.GetTabPos() = PixelHAdjust(nNewPosition - lAppNullOffset, aTabStop.GetTabPos());
    2283             :             }
    2284             :             else
    2285             :             {
    2286             :                 //#i24363# tab stops relative to indent
    2287           0 :                 const long nTmpLeftIndent = mxRulerImpl->bIsTabsRelativeToIndent ?
    2288           0 :                                             GetLeftIndent() : 0;
    2289             : 
    2290           0 :                 long nNewPosition = ConvertHPosLogic(mpTabs[nCoreIdx + TAB_GAP].nPos - nTmpLeftIndent);
    2291           0 :                 aTabStop.GetTabPos() = PixelHAdjust(nNewPosition - lAppNullOffset, aTabStop.GetTabPos());
    2292             :             }
    2293             :         }
    2294           0 :         mxTabStopItem->Remove(nCoreIdx);
    2295           0 :         mxTabStopItem->Insert(aTabStop);
    2296             :     }
    2297           0 :     sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
    2298           0 :     pBindings->GetDispatcher()->Execute( nTabStopId, SfxCallMode::RECORD, mxTabStopItem.get(), 0L );
    2299           0 :     UpdateTabs();
    2300             : }
    2301             : 
    2302           0 : void SvxRuler::ApplyBorders()
    2303             : {
    2304             :     /* Applying (table) column settings; changed by dragging. */
    2305           0 :     if(mxColumnItem->IsTable())
    2306             :     {
    2307           0 :         long lValue = GetFrameLeft();
    2308           0 :         if(lValue != mxRulerImpl->nColLeftPix)
    2309             :         {
    2310             :             long nLeft = PixelHAdjust(
    2311           0 :                             ConvertHPosLogic(lValue) -
    2312             :                                 lAppNullOffset,
    2313           0 :                             mxColumnItem->GetLeft());
    2314           0 :             mxColumnItem->SetLeft(nLeft);
    2315             :         }
    2316             : 
    2317           0 :         lValue = GetMargin2();
    2318             : 
    2319           0 :         if(lValue != mxRulerImpl->nColRightPix)
    2320             :         {
    2321           0 :             long nWidthOrHeight = bHorz ? mxPagePosItem->GetWidth() : mxPagePosItem->GetHeight();
    2322             :             long nRight = PixelHAdjust(
    2323           0 :                             nWidthOrHeight -
    2324           0 :                                 mxColumnItem->GetLeft() -
    2325           0 :                                 ConvertHPosLogic(lValue) -
    2326             :                                 lAppNullOffset,
    2327           0 :                             mxColumnItem->GetRight() );
    2328           0 :             mxColumnItem->SetRight(nRight);
    2329             :         }
    2330             :     }
    2331             : 
    2332           0 :     for(sal_uInt16 i = 0; i < mxColumnItem->Count() - 1; ++i)
    2333             :     {
    2334           0 :         long& nEnd = mxColumnItem->At(i).nEnd;
    2335             :         nEnd = PixelHAdjust(
    2336           0 :                 ConvertPosLogic(mpBorders[i].nPos),
    2337           0 :                 mxColumnItem->At(i).nEnd);
    2338           0 :         long& nStart = mxColumnItem->At(i + 1).nStart;
    2339             :         nStart = PixelHAdjust(
    2340           0 :                     ConvertSizeLogic(mpBorders[i].nPos +
    2341           0 :                         mpBorders[i].nWidth) -
    2342             :                         lAppNullOffset,
    2343           0 :                     mxColumnItem->At(i + 1).nStart);
    2344             :         // It may be that, due to the PixelHAdjust readjustment to old values,
    2345             :         // the width becomes  < 0. This we readjust.
    2346           0 :         if( nEnd > nStart )
    2347           0 :             nStart = nEnd;
    2348             :     }
    2349             : 
    2350             : #ifdef DEBUGLIN
    2351             :         Debug_Impl(pEditWin,*mxColumnItem.get());
    2352             : #endif // DEBUGLIN
    2353             : 
    2354             :     SfxBoolItem aFlag(SID_RULER_ACT_LINE_ONLY,
    2355           0 :                       bool(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY));
    2356             : 
    2357           0 :     sal_uInt16 nColId = mxRulerImpl->bIsTableRows ? (bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL) :
    2358           0 :                             (bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
    2359             : 
    2360           0 :     pBindings->GetDispatcher()->Execute( nColId, SfxCallMode::RECORD, mxColumnItem.get(), &aFlag, 0L );
    2361           0 : }
    2362             : 
    2363           0 : void SvxRuler::ApplyObject()
    2364             : {
    2365             :     /* Applying object settings, changed by dragging. */
    2366             : 
    2367             :     // to the page margin
    2368           0 :     long nMargin = mxLRSpaceItem.get() ? mxLRSpaceItem->GetLeft() : 0;
    2369             :     long nStartX = PixelAdjust(
    2370           0 :                     ConvertPosLogic(mpObjectBorders[0].nPos) +
    2371             :                         nMargin -
    2372             :                         lAppNullOffset,
    2373           0 :                     mxObjectItem->GetStartX());
    2374           0 :     mxObjectItem->SetStartX(nStartX);
    2375             : 
    2376             :     long nEndX = PixelAdjust(
    2377           0 :                     ConvertPosLogic(mpObjectBorders[1].nPos) +
    2378             :                         nMargin -
    2379             :                         lAppNullOffset,
    2380           0 :                     mxObjectItem->GetEndX());
    2381           0 :     mxObjectItem->SetEndX(nEndX);
    2382             : 
    2383           0 :     nMargin = mxULSpaceItem.get() ? mxULSpaceItem->GetUpper() : 0;
    2384             :     long nStartY = PixelAdjust(
    2385           0 :                     ConvertPosLogic(mpObjectBorders[2].nPos) +
    2386             :                         nMargin -
    2387             :                         lAppNullOffset,
    2388           0 :                     mxObjectItem->GetStartY());
    2389           0 :     mxObjectItem->SetStartY(nStartY);
    2390             : 
    2391             :     long nEndY = PixelAdjust(
    2392           0 :                     ConvertPosLogic(mpObjectBorders[3].nPos) +
    2393             :                         nMargin -
    2394             :                         lAppNullOffset,
    2395           0 :                     mxObjectItem->GetEndY());
    2396           0 :     mxObjectItem->SetEndY(nEndY);
    2397             : 
    2398           0 :     pBindings->GetDispatcher()->Execute(SID_RULER_OBJECT, SfxCallMode::RECORD, mxObjectItem.get(), 0L);
    2399           0 : }
    2400             : 
    2401           0 : void SvxRuler::PrepareProportional_Impl(RulerType eType)
    2402             : {
    2403             :     /*
    2404             :        Preparation proportional dragging, and it is calculated based on the
    2405             :        proportional share of the total width in parts per thousand.
    2406             :     */
    2407           0 :     mxRulerImpl->nTotalDist = GetMargin2();
    2408           0 :     switch((int)eType)
    2409             :     {
    2410             :       case RULER_TYPE_MARGIN2:
    2411             :       case RULER_TYPE_MARGIN1:
    2412             :       case RULER_TYPE_BORDER:
    2413             :         {
    2414             :             DBG_ASSERT(mxColumnItem.get(), "no ColumnItem");
    2415             : 
    2416           0 :             mxRulerImpl->SetPercSize(mxColumnItem->Count());
    2417             : 
    2418             :             long lPos;
    2419           0 :             long lWidth=0;
    2420             :             sal_uInt16 nStart;
    2421           0 :             sal_uInt16 nIdx=GetDragAryPos();
    2422           0 :             long lActWidth=0;
    2423             :             long lActBorderSum;
    2424             :             long lOrigLPos;
    2425             : 
    2426           0 :             if(eType != RULER_TYPE_BORDER)
    2427             :             {
    2428           0 :                 lOrigLPos = GetMargin1();
    2429           0 :                 nStart = 0;
    2430           0 :                 lActBorderSum = 0;
    2431             :             }
    2432             :             else
    2433             :             {
    2434           0 :                 if(mxRulerImpl->bIsTableRows &&!bHorz)
    2435             :                 {
    2436           0 :                     lOrigLPos = GetMargin1();
    2437           0 :                     nStart = 0;
    2438             :                 }
    2439             :                 else
    2440             :                 {
    2441           0 :                     lOrigLPos = mpBorders[nIdx].nPos + mpBorders[nIdx].nWidth;
    2442           0 :                     nStart = 1;
    2443             :                 }
    2444           0 :                 lActBorderSum = mpBorders[nIdx].nWidth;
    2445             :             }
    2446             : 
    2447             :             //in horizontal mode the percentage value has to be
    2448             :             //calculated on a "current change" position base
    2449             :             //because the height of the table changes while dragging
    2450           0 :             if(mxRulerImpl->bIsTableRows && RULER_TYPE_BORDER == eType)
    2451             :             {
    2452             :                 sal_uInt16 nStartBorder;
    2453             :                 sal_uInt16 nEndBorder;
    2454           0 :                 if(bHorz)
    2455             :                 {
    2456           0 :                     nStartBorder = nIdx + 1;
    2457           0 :                     nEndBorder = mxColumnItem->Count() - 1;
    2458             :                 }
    2459             :                 else
    2460             :                 {
    2461           0 :                     nStartBorder = 0;
    2462           0 :                     nEndBorder = nIdx;
    2463             :                 }
    2464             : 
    2465           0 :                 lWidth = mpBorders[nIdx].nPos;
    2466           0 :                 if(bHorz)
    2467           0 :                     lWidth = GetMargin2() - lWidth;
    2468           0 :                 mxRulerImpl->nTotalDist = lWidth;
    2469           0 :                 lPos = lOrigLPos = mpBorders[nIdx].nPos;
    2470             : 
    2471           0 :                 for(sal_uInt16 i = nStartBorder; i < nEndBorder; ++i)
    2472             :                 {
    2473           0 :                     if(bHorz)
    2474             :                     {
    2475           0 :                         lActWidth += mpBorders[i].nPos - lPos;
    2476           0 :                         lPos = mpBorders[i].nPos + mpBorders[i].nWidth;
    2477             :                     }
    2478             :                     else
    2479           0 :                         lActWidth = mpBorders[i].nPos;
    2480           0 :                     mxRulerImpl->pPercBuf[i] = (sal_uInt16)((lActWidth * 1000)
    2481           0 :                                                     / mxRulerImpl->nTotalDist);
    2482           0 :                     mxRulerImpl->pBlockBuf[i] = (sal_uInt16)lActBorderSum;
    2483           0 :                     lActBorderSum += mpBorders[i].nWidth;
    2484             :                 }
    2485             :             }
    2486             :             else
    2487             :             {
    2488           0 :                 lPos = lOrigLPos;
    2489           0 :                 for(sal_uInt16 ii = nStart; ii < mxColumnItem->Count() - 1; ++ii)
    2490             :                 {
    2491           0 :                     lWidth += mpBorders[ii].nPos - lPos;
    2492           0 :                     lPos = mpBorders[ii].nPos + mpBorders[ii].nWidth;
    2493             :                 }
    2494             : 
    2495           0 :                 lWidth += GetMargin2() - lPos;
    2496           0 :                 mxRulerImpl->nTotalDist = lWidth;
    2497           0 :                 lPos = lOrigLPos;
    2498             : 
    2499           0 :                 for(sal_uInt16 i = nStart; i < mxColumnItem->Count() - 1; ++i)
    2500             :                 {
    2501           0 :                     lActWidth += mpBorders[i].nPos - lPos;
    2502           0 :                     lPos = mpBorders[i].nPos + mpBorders[i].nWidth;
    2503           0 :                     mxRulerImpl->pPercBuf[i] = (sal_uInt16)((lActWidth * 1000)
    2504           0 :                                                     / mxRulerImpl->nTotalDist);
    2505           0 :                     mxRulerImpl->pBlockBuf[i] = (sal_uInt16)lActBorderSum;
    2506           0 :                     lActBorderSum += mpBorders[i].nWidth;
    2507             :                 }
    2508             :             }
    2509             :         }
    2510           0 :         break;
    2511             :         case RULER_TYPE_TAB:
    2512             :         {
    2513           0 :             const sal_uInt16 nIdx = GetDragAryPos()+TAB_GAP;
    2514           0 :             mxRulerImpl->nTotalDist -= mpTabs[nIdx].nPos;
    2515           0 :             mxRulerImpl->SetPercSize(nTabCount);
    2516           0 :             for(sal_uInt16 n=0;n<=nIdx;mxRulerImpl->pPercBuf[n++]=0) ;
    2517           0 :             for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i)
    2518             :             {
    2519           0 :                 const long nDelta = mpTabs[i].nPos - mpTabs[nIdx].nPos;
    2520           0 :                 mxRulerImpl->pPercBuf[i] = (sal_uInt16)((nDelta * 1000) / mxRulerImpl->nTotalDist);
    2521             :             }
    2522           0 :             break;
    2523             :         }
    2524             :     }
    2525           0 : }
    2526             : 
    2527           0 : void SvxRuler::EvalModifier()
    2528             : {
    2529             :     /*
    2530             :     Eval Drag Modifier
    2531             :     Shift: move linear
    2532             :     Control: move proportional
    2533             :     Shift + Control: Table: only current line
    2534             :     Alt: disable snapping
    2535             :     Alt + Shift: coarse snapping
    2536             :     */
    2537             : 
    2538           0 :     sal_uInt16 nModifier = GetDragModifier();
    2539           0 :     if(mxRulerImpl->bIsTableRows)
    2540             :     {
    2541             :         //rows can only be moved in one way, additionally current column is possible
    2542           0 :         if(nModifier == KEY_SHIFT)
    2543           0 :             nModifier = 0;
    2544             :     }
    2545             : 
    2546           0 :     switch(nModifier)
    2547             :     {
    2548             :         case KEY_SHIFT:
    2549           0 :             nDragType = SvxRulerDragFlags::OBJECT_SIZE_LINEAR;
    2550           0 :         break;
    2551             :         case KEY_MOD2 | KEY_SHIFT:
    2552           0 :             mbCoarseSnapping = true;
    2553           0 :         break;
    2554             :         case KEY_MOD2:
    2555           0 :             mbSnapping = false;
    2556           0 :         break;
    2557             :         case KEY_MOD1:
    2558             :         {
    2559           0 :             const RulerType eType = GetDragType();
    2560           0 :             nDragType = SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL;
    2561           0 :             if( RULER_TYPE_TAB == eType ||
    2562           0 :                 ( ( RULER_TYPE_BORDER == eType  ||
    2563           0 :                     RULER_TYPE_MARGIN1 == eType ||
    2564           0 :                     RULER_TYPE_MARGIN2 == eType ) &&
    2565           0 :                 mxColumnItem.get() ) )
    2566             :             {
    2567           0 :                 PrepareProportional_Impl(eType);
    2568             :             }
    2569             :         }
    2570           0 :         break;
    2571             :         case KEY_MOD1 | KEY_SHIFT:
    2572           0 :             if( GetDragType() != RULER_TYPE_MARGIN1 &&
    2573           0 :                 GetDragType() != RULER_TYPE_MARGIN2 )
    2574             :             {
    2575           0 :                 nDragType = SvxRulerDragFlags::OBJECT_ACTLINE_ONLY;
    2576             :             }
    2577           0 :         break;
    2578             :     }
    2579           0 : }
    2580             : 
    2581           0 : void SvxRuler::Click()
    2582             : {
    2583             :     /* Override handler SV; sets Tab per dispatcher call */
    2584           0 :     Ruler::Click();
    2585           0 :     if( bActive )
    2586             :     {
    2587           0 :         pBindings->Update( SID_RULER_LR_MIN_MAX );
    2588           0 :         pBindings->Update( SID_ATTR_LONG_ULSPACE );
    2589           0 :         pBindings->Update( SID_ATTR_LONG_LRSPACE );
    2590           0 :         pBindings->Update( SID_RULER_PAGE_POS );
    2591           0 :         pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL);
    2592           0 :         pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL);
    2593           0 :         pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
    2594           0 :         pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL);
    2595           0 :         pBindings->Update( SID_RULER_OBJECT );
    2596           0 :         pBindings->Update( SID_RULER_PROTECT );
    2597           0 :         pBindings->Update( SID_ATTR_PARA_LRSPACE_VERTICAL );
    2598             :     }
    2599           0 :     bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
    2600           0 :     if(mxTabStopItem.get() &&
    2601           0 :        (nFlags & SvxRulerSupportFlags::TABS) == SvxRulerSupportFlags::TABS)
    2602             :     {
    2603           0 :         bool bContentProtected = mxRulerImpl->aProtectItem.IsContentProtected();
    2604           0 :         if( bContentProtected ) return;
    2605           0 :         const long lPos = GetClickPos();
    2606           0 :         if((bRTL && lPos < std::min(GetFirstLineIndent(), GetLeftIndent()) && lPos > GetRightIndent()) ||
    2607           0 :             (!bRTL && lPos > std::min(GetFirstLineIndent(), GetLeftIndent()) && lPos < GetRightIndent()))
    2608             :         {
    2609             :             //convert position in left-to-right text
    2610             :             long nTabPos;
    2611             :     //#i24363# tab stops relative to indent
    2612           0 :             if(bRTL)
    2613           0 :                 nTabPos = ( mxRulerImpl->bIsTabsRelativeToIndent ?
    2614             :                             GetLeftIndent() :
    2615           0 :                             ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset ) ) -
    2616           0 :                           lPos;
    2617             :             else
    2618           0 :                 nTabPos = lPos -
    2619           0 :                           ( mxRulerImpl->bIsTabsRelativeToIndent ?
    2620             :                             GetLeftIndent() :
    2621           0 :                             0 );
    2622             : 
    2623           0 :             SvxTabStop aTabStop(ConvertHPosLogic(nTabPos),
    2624           0 :                                 ToAttrTab_Impl(nDefTabType));
    2625           0 :             mxTabStopItem->Insert(aTabStop);
    2626           0 :             UpdateTabs();
    2627             :         }
    2628             :     }
    2629             : }
    2630             : 
    2631           0 : bool SvxRuler::CalcLimits ( long& nMax1,    // minimum value to be set
    2632             :                             long& nMax2,    // minimum value to be set
    2633             :                             bool )
    2634             : {
    2635             :     /*
    2636             :        Default implementation of the virtual function; the application can be
    2637             :        overridden to implement customized limits. The values are based on the page.
    2638             :     */
    2639           0 :     nMax1 = LONG_MIN;
    2640           0 :     nMax2 = LONG_MAX;
    2641           0 :     return false;
    2642             : }
    2643             : 
    2644           0 : void SvxRuler::CalcMinMax()
    2645             : {
    2646             :     /*
    2647             :        Calculates the limits for dragging; which are in pixels relative to the
    2648             :        page edge
    2649             :     */
    2650           0 :     bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
    2651           0 :     const long lNullPix = ConvertPosPixel(lLogicNullOffset);
    2652           0 :     mxRulerImpl->lMaxLeftLogic=mxRulerImpl->lMaxRightLogic=-1;
    2653           0 :     switch(GetDragType())
    2654             :     {
    2655             :         case RULER_TYPE_MARGIN1:
    2656             :         {        // left edge of the surrounding Frame
    2657             :             // DragPos - NOf between left - right
    2658           0 :             mxRulerImpl->lMaxLeftLogic = GetLeftMin();
    2659           0 :             nMaxLeft=ConvertSizePixel(mxRulerImpl->lMaxLeftLogic);
    2660             : 
    2661           0 :             if (!mxColumnItem.get() || mxColumnItem->Count() == 1 )
    2662             :             {
    2663           0 :                 if(bRTL)
    2664             :                 {
    2665           0 :                     nMaxRight = lNullPix - GetRightIndent() +
    2666           0 :                         std::max(GetFirstLineIndent(), GetLeftIndent()) -
    2667           0 :                         lMinFrame;
    2668             :                 }
    2669             :                 else
    2670             :                 {
    2671           0 :                     nMaxRight = lNullPix + GetRightIndent() -
    2672           0 :                         std::max(GetFirstLineIndent(), GetLeftIndent()) -
    2673           0 :                         lMinFrame;
    2674             :                 }
    2675             :             }
    2676           0 :             else if(mxRulerImpl->bIsTableRows)
    2677             :             {
    2678             :                 //top border is not moveable when table rows are displayed
    2679             :                 // protection of content means the margin is not moveable
    2680             :                 // - it's just a page break inside of a cell
    2681           0 :                 if(bHorz && !mxRulerImpl->aProtectItem.IsContentProtected())
    2682             :                 {
    2683           0 :                     nMaxLeft = mpBorders[0].nMinPos + lNullPix;
    2684           0 :                     if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
    2685           0 :                         nMaxRight = GetRightIndent() + lNullPix -
    2686           0 :                                 (mxColumnItem->Count() - 1 ) * lMinFrame;
    2687             :                     else
    2688           0 :                         nMaxRight = mpBorders[0].nPos - lMinFrame + lNullPix;
    2689             :                 }
    2690             :                 else
    2691           0 :                     nMaxLeft = nMaxRight = lNullPix;
    2692             :             }
    2693             :             else
    2694             :             {
    2695           0 :                 if (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
    2696             :                 {
    2697           0 :                     nMaxRight=lNullPix+CalcPropMaxRight();
    2698             :                 }
    2699           0 :                 else if (nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR)
    2700             :                 {
    2701             :                     nMaxRight = ConvertPosPixel(
    2702           0 :                         GetPageWidth() - (
    2703           0 :                             (mxColumnItem->IsTable() && mxLRSpaceItem.get())
    2704           0 :                             ? mxLRSpaceItem->GetRight() : 0))
    2705           0 :                             - GetMargin2() + GetMargin1();
    2706             :                 }
    2707             :                 else
    2708             :                 {
    2709           0 :                     nMaxRight = lNullPix - lMinFrame;
    2710           0 :                     if (mxColumnItem->IsFirstAct())
    2711             :                     {
    2712           0 :                         if(bRTL)
    2713             :                         {
    2714             :                             nMaxRight += std::min(
    2715           0 :                                 mpBorders[0].nPos,
    2716           0 :                                 std::max(GetFirstLineIndent(), GetLeftIndent()) - GetRightIndent());
    2717             :                         }
    2718             :                         else
    2719             :                         {
    2720             :                             nMaxRight += std::min(
    2721           0 :                                 mpBorders[0].nPos, GetRightIndent() -
    2722           0 :                                 std::max(GetFirstLineIndent(), GetLeftIndent()));
    2723             :                         }
    2724             :                     }
    2725           0 :                     else if ( mxColumnItem->Count() > 1 )
    2726             :                     {
    2727           0 :                         nMaxRight += mpBorders[0].nPos;
    2728             :                     }
    2729             :                     else
    2730             :                     {
    2731           0 :                         nMaxRight += GetRightIndent() - std::max(GetFirstLineIndent(), GetLeftIndent());
    2732             :                     }
    2733             :                     // Do not drag the left table edge over the edge of the page
    2734           0 :                     if(mxLRSpaceItem.get() && mxColumnItem->IsTable())
    2735             :                     {
    2736           0 :                         long nTmp=ConvertSizePixel(mxLRSpaceItem->GetLeft());
    2737           0 :                         if(nTmp>nMaxLeft)
    2738           0 :                             nMaxLeft=nTmp;
    2739             :                     }
    2740             :                 }
    2741             :             }
    2742           0 :             break;
    2743             :         }
    2744             :         case RULER_TYPE_MARGIN2:
    2745             :         {        // right edge of the surrounding Frame
    2746           0 :             mxRulerImpl->lMaxRightLogic =
    2747           0 :                 mxMinMaxItem.get() ?
    2748           0 :                     GetPageWidth() - GetRightMax() :
    2749           0 :                     GetPageWidth();
    2750           0 :             nMaxRight = ConvertSizePixel(mxRulerImpl->lMaxRightLogic);
    2751             : 
    2752             : 
    2753           0 :             if(!mxColumnItem.get())
    2754             :             {
    2755           0 :                 if(bRTL)
    2756             :                 {
    2757           0 :                     nMaxLeft =  GetMargin2() + GetRightIndent() -
    2758           0 :                         std::max(GetFirstLineIndent(),GetLeftIndent())  - GetMargin1()+
    2759           0 :                             lMinFrame + lNullPix;
    2760             :                 }
    2761             :                 else
    2762             :                 {
    2763           0 :                     nMaxLeft =  GetMargin2() - GetRightIndent() +
    2764           0 :                         std::max(GetFirstLineIndent(),GetLeftIndent())  - GetMargin1()+
    2765           0 :                             lMinFrame + lNullPix;
    2766             :                 }
    2767             :             }
    2768           0 :             else if(mxRulerImpl->bIsTableRows)
    2769             :             {
    2770             :                 // get the bottom move range from the last border position - only available for rows!
    2771             :                 // protection of content means the margin is not moveable - it's just a page break inside of a cell
    2772           0 :                 if(bHorz || mxRulerImpl->aProtectItem.IsContentProtected())
    2773             :                 {
    2774           0 :                     nMaxLeft = nMaxRight = mpBorders[mxColumnItem->Count() - 1].nMaxPos + lNullPix;
    2775             :                 }
    2776             :                 else
    2777             :                 {
    2778           0 :                     if(nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)
    2779             :                     {
    2780           0 :                         nMaxLeft = (mxColumnItem->Count()) * lMinFrame + lNullPix;
    2781             :                     }
    2782             :                     else
    2783             :                     {
    2784           0 :                         if(mxColumnItem->Count() > 1)
    2785           0 :                             nMaxLeft = mpBorders[mxColumnItem->Count() - 2].nPos + lMinFrame + lNullPix;
    2786             :                         else
    2787           0 :                             nMaxLeft = lMinFrame + lNullPix;
    2788             :                     }
    2789           0 :                     if(mxColumnItem->Count() > 1)
    2790           0 :                         nMaxRight = mpBorders[mxColumnItem->Count() - 2].nMaxPos + lNullPix;
    2791             :                     else
    2792           0 :                         nMaxRight -= GetRightIndent() - lNullPix;
    2793             :                 }
    2794             :             }
    2795             :             else
    2796             :             {
    2797           0 :                 nMaxLeft = lMinFrame + lNullPix;
    2798           0 :                 if(IsActLastColumn() || mxColumnItem->Count() < 2 ) //If last active column
    2799             :                 {
    2800           0 :                     if(bRTL)
    2801             :                     {
    2802           0 :                         nMaxLeft = lMinFrame + lNullPix + GetMargin2() +
    2803           0 :                             GetRightIndent() - std::max(GetFirstLineIndent(),
    2804           0 :                                                    GetLeftIndent());
    2805             :                     }
    2806             :                     else
    2807             :                     {
    2808           0 :                         nMaxLeft = lMinFrame + lNullPix + GetMargin2() -
    2809           0 :                             GetRightIndent() + std::max(GetFirstLineIndent(),
    2810           0 :                                                    GetLeftIndent());
    2811             :                     }
    2812             :                 }
    2813           0 :                 if( mxColumnItem->Count() >= 2 )
    2814             :                 {
    2815             :                     long nNewMaxLeft =
    2816           0 :                         lMinFrame + lNullPix +
    2817           0 :                         mpBorders[mxColumnItem->Count() - 2].nPos +
    2818           0 :                         mpBorders[mxColumnItem->Count() - 2].nWidth;
    2819           0 :                     nMaxLeft = std::max(nMaxLeft, nNewMaxLeft);
    2820             :                 }
    2821             : 
    2822             :             }
    2823           0 :             break;
    2824             :         }
    2825             :         case RULER_TYPE_BORDER:
    2826             :         {                // Table, column (Modifier)
    2827           0 :         const sal_uInt16 nIdx = GetDragAryPos();
    2828           0 :         switch(GetDragSize())
    2829             :         {
    2830             :           case RULER_DRAGSIZE_1 :
    2831             :             {
    2832           0 :                 nMaxRight = mpBorders[nIdx].nPos +
    2833           0 :                     mpBorders[nIdx].nWidth + lNullPix;
    2834             : 
    2835           0 :                 if(0 == nIdx)
    2836           0 :                     nMaxLeft = lNullPix;
    2837             :                 else
    2838           0 :                     nMaxLeft = mpBorders[nIdx - 1].nPos + mpBorders[nIdx - 1].nWidth + lNullPix;
    2839           0 :                 if(nIdx == mxColumnItem->GetActColumn())
    2840             :                 {
    2841           0 :                     if(bRTL)
    2842             :                     {
    2843           0 :                         nMaxLeft += mpBorders[nIdx].nPos +
    2844           0 :                             GetRightIndent() - std::max(GetFirstLineIndent(),
    2845           0 :                                                    GetLeftIndent());
    2846             :                     }
    2847             :                     else
    2848             :                     {
    2849           0 :                         nMaxLeft += mpBorders[nIdx].nPos -
    2850           0 :                             GetRightIndent() + std::max(GetFirstLineIndent(),
    2851           0 :                                                    GetLeftIndent());
    2852             :                     }
    2853           0 :                     if(0 != nIdx)
    2854           0 :                         nMaxLeft -= mpBorders[nIdx-1].nPos +
    2855           0 :                             mpBorders[nIdx-1].nWidth;
    2856             :                 }
    2857           0 :                 nMaxLeft += lMinFrame;
    2858           0 :                 nMaxLeft += nDragOffset;
    2859           0 :                 break;
    2860             :             }
    2861             :           case RULER_DRAGSIZE_MOVE:
    2862             :             {
    2863           0 :                 if(mxColumnItem.get())
    2864             :                 {
    2865             :                     //nIdx contains the position of the currently moved item
    2866             :                     //next visible separator on the left
    2867           0 :                     sal_uInt16 nLeftCol=GetActLeftColumn(false, nIdx);
    2868             :                     //next visible separator on the right
    2869           0 :                     sal_uInt16 nRightCol=GetActRightColumn(false, nIdx);
    2870             :                     //next separator on the left - regardless if visible or not
    2871           0 :                     sal_uInt16 nActLeftCol=GetActLeftColumn();
    2872             :                     //next separator on the right - regardless if visible or not
    2873           0 :                     sal_uInt16 nActRightCol=GetActRightColumn();
    2874           0 :                     if(mxColumnItem->IsTable())
    2875             :                     {
    2876           0 :                         if(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY)
    2877             :                         {
    2878             :                             //the current row/column should be modified only
    2879             :                             //then the next/previous visible border position
    2880             :                             //marks the min/max positions
    2881             :                             nMaxLeft = nLeftCol == USHRT_MAX ?
    2882             :                                 0 :
    2883           0 :                                 mpBorders[nLeftCol].nPos;
    2884             :                             //rows can always be increased without a limit
    2885           0 :                             if(mxRulerImpl->bIsTableRows)
    2886           0 :                                 nMaxRight = mpBorders[nIdx].nMaxPos;
    2887             :                             else
    2888             :                                 nMaxRight = nRightCol == USHRT_MAX ?
    2889           0 :                                     GetMargin2():
    2890           0 :                                     mpBorders[nRightCol].nPos;
    2891           0 :                             nMaxLeft += lNullPix;
    2892           0 :                             nMaxRight += lNullPix;
    2893             :                         }
    2894             :                         else
    2895             :                         {
    2896           0 :                             if(SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType && !bHorz && mxRulerImpl->bIsTableRows)
    2897           0 :                                 nMaxLeft = (nIdx + 1) * lMinFrame + lNullPix;
    2898             :                             else
    2899           0 :                                 nMaxLeft = mpBorders[nIdx].nMinPos + lNullPix;
    2900           0 :                             if((SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType) ||
    2901           0 :                                (SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType) )
    2902             :                             {
    2903           0 :                                 if(mxRulerImpl->bIsTableRows)
    2904             :                                 {
    2905           0 :                                     if(bHorz)
    2906           0 :                                         nMaxRight = GetRightIndent() + lNullPix -
    2907           0 :                                                 (mxColumnItem->Count() - nIdx - 1) * lMinFrame;
    2908             :                                     else
    2909           0 :                                         nMaxRight = mpBorders[nIdx].nMaxPos + lNullPix;
    2910             :                                 }
    2911             :                                 else
    2912           0 :                                     nMaxRight=lNullPix+CalcPropMaxRight(nIdx);
    2913             :                             }
    2914             :                             else
    2915           0 :                                 nMaxRight = mpBorders[nIdx].nMaxPos + lNullPix;
    2916             :                         }
    2917           0 :                         nMaxLeft += lMinFrame;
    2918           0 :                         nMaxRight -= lMinFrame;
    2919             : 
    2920             :                     }
    2921             :                     else
    2922             :                     {
    2923           0 :                         if(nLeftCol==USHRT_MAX)
    2924           0 :                             nMaxLeft=lNullPix;
    2925             :                         else
    2926           0 :                             nMaxLeft = mpBorders[nLeftCol].nPos +
    2927           0 :                                 mpBorders[nLeftCol].nWidth + lNullPix;
    2928             : 
    2929           0 :                         if(nActRightCol == nIdx)
    2930             :                         {
    2931           0 :                             if(bRTL)
    2932             :                             {
    2933           0 :                                 nMaxLeft += mpBorders[nIdx].nPos +
    2934           0 :                                     GetRightIndent() - std::max(GetFirstLineIndent(),
    2935           0 :                                                            GetLeftIndent());
    2936           0 :                                 if(nActLeftCol!=USHRT_MAX)
    2937           0 :                                     nMaxLeft -= mpBorders[nActLeftCol].nPos +
    2938           0 :                                         mpBorders[nActLeftCol].nWidth;
    2939             :                             }
    2940             :                             else
    2941             :                             {
    2942           0 :                                 nMaxLeft += mpBorders[nIdx].nPos -
    2943           0 :                                     GetRightIndent() + std::max(GetFirstLineIndent(),
    2944           0 :                                                            GetLeftIndent());
    2945           0 :                                 if(nActLeftCol!=USHRT_MAX)
    2946           0 :                                     nMaxLeft -= mpBorders[nActLeftCol].nPos +
    2947           0 :                                         mpBorders[nActLeftCol].nWidth;
    2948             :                             }
    2949             :                         }
    2950           0 :                         nMaxLeft += lMinFrame;
    2951           0 :                         nMaxLeft += nDragOffset;
    2952             : 
    2953             :                         // nMaxRight
    2954             :                         // linear / proprotional move
    2955           0 :                         if((SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL & nDragType) ||
    2956           0 :                            (SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType) )
    2957             :                         {
    2958           0 :                             nMaxRight=lNullPix+CalcPropMaxRight(nIdx);
    2959             :                         }
    2960           0 :                         else if(SvxRulerDragFlags::OBJECT_SIZE_LINEAR & nDragType)
    2961             :                         {
    2962           0 :                             nMaxRight = lNullPix + GetMargin2() - GetMargin1() +
    2963           0 :                                 (mpBorders.size() - nIdx - 1) * lMinFrame;
    2964             :                         }
    2965             :                         else
    2966             :                         {
    2967           0 :                             if(nRightCol==USHRT_MAX)
    2968             :                             { // last column
    2969           0 :                                 nMaxRight = GetMargin2() + lNullPix;
    2970           0 :                                 if(IsActLastColumn())
    2971             :                                 {
    2972           0 :                                     if(bRTL)
    2973             :                                     {
    2974             :                                         nMaxRight -=
    2975           0 :                                             GetMargin2() + GetRightIndent() -
    2976           0 :                                                 std::max(GetFirstLineIndent(),
    2977           0 :                                                     GetLeftIndent());
    2978             :                                     }
    2979             :                                     else
    2980             :                                     {
    2981             :                                         nMaxRight -=
    2982           0 :                                             GetMargin2() - GetRightIndent() +
    2983           0 :                                                 std::max(GetFirstLineIndent(),
    2984           0 :                                                     GetLeftIndent());
    2985             :                                     }
    2986           0 :                                     nMaxRight += mpBorders[nIdx].nPos +
    2987           0 :                                         mpBorders[nIdx].nWidth;
    2988             :                                 }
    2989             :                             }
    2990             :                             else
    2991             :                             {
    2992           0 :                                 nMaxRight = lNullPix + mpBorders[nRightCol].nPos;
    2993             :                                 sal_uInt16 nNotHiddenRightCol =
    2994           0 :                                     GetActRightColumn(true, nIdx);
    2995             : 
    2996           0 :                                 if( nActLeftCol == nIdx )
    2997             :                                 {
    2998             :                                     long nBorder = nNotHiddenRightCol ==
    2999             :                                         USHRT_MAX ?
    3000           0 :                                         GetMargin2() :
    3001           0 :                                         mpBorders[nNotHiddenRightCol].nPos;
    3002           0 :                                     if(bRTL)
    3003             :                                     {
    3004           0 :                                         nMaxRight -= nBorder + GetRightIndent() -
    3005           0 :                                             std::max(GetFirstLineIndent(),
    3006           0 :                                                 GetLeftIndent());
    3007             :                                     }
    3008             :                                     else
    3009             :                                     {
    3010           0 :                                         nMaxRight -= nBorder - GetRightIndent() +
    3011           0 :                                             std::max(GetFirstLineIndent(),
    3012           0 :                                                 GetLeftIndent());
    3013             :                                     }
    3014           0 :                                     nMaxRight += mpBorders[nIdx].nPos +
    3015           0 :                                         mpBorders[nIdx].nWidth;
    3016             :                                 }
    3017             :                             }
    3018           0 :                             nMaxRight -= lMinFrame;
    3019           0 :                             nMaxRight -= mpBorders[nIdx].nWidth;
    3020             :                         }
    3021             :                     }
    3022             :                 }
    3023             :                 // ObjectItem
    3024             :                 else
    3025             :                 {
    3026           0 :                     if(mxObjectItem->HasLimits())
    3027             :                     {
    3028           0 :                         if(CalcLimits(nMaxLeft, nMaxRight, (nIdx & 1) == 0))
    3029             :                         {
    3030           0 :                             nMaxLeft = ConvertPosPixel(nMaxLeft);
    3031           0 :                             nMaxRight = ConvertPosPixel(nMaxRight);
    3032             :                         }
    3033             :                     }
    3034             :                     else
    3035             :                     {
    3036           0 :                         nMaxLeft = LONG_MIN;
    3037           0 :                         nMaxRight = LONG_MAX;
    3038             :                     }
    3039             :                 }
    3040           0 :                 break;
    3041             :             }
    3042             :           case RULER_DRAGSIZE_2:
    3043             :             {
    3044           0 :                 nMaxLeft = lNullPix + mpBorders[nIdx].nPos;
    3045           0 :                 if(nIdx == mxColumnItem->Count()-2) { // last column
    3046           0 :                     nMaxRight = GetMargin2() + lNullPix;
    3047           0 :                     if(mxColumnItem->IsLastAct()) {
    3048             :                         nMaxRight -=
    3049           0 :                             GetMargin2() - GetRightIndent() +
    3050           0 :                                 std::max(GetFirstLineIndent(),
    3051           0 :                                     GetLeftIndent());
    3052           0 :                         nMaxRight += mpBorders[nIdx].nPos +
    3053           0 :                             mpBorders[nIdx].nWidth;
    3054             :                     }
    3055             :                 }
    3056             :                 else {
    3057           0 :                     nMaxRight = lNullPix + mpBorders[nIdx+1].nPos;
    3058           0 :                     if(mxColumnItem->GetActColumn()-1 == nIdx) {
    3059           0 :                         nMaxRight -= mpBorders[nIdx+1].nPos  - GetRightIndent() +
    3060           0 :                             std::max(GetFirstLineIndent(),
    3061           0 :                                 GetLeftIndent());
    3062           0 :                         nMaxRight += mpBorders[nIdx].nPos +
    3063           0 :                             mpBorders[nIdx].nWidth;
    3064             :                     }
    3065             :             }
    3066           0 :                 nMaxRight -= lMinFrame;
    3067           0 :                 nMaxRight -= mpBorders[nIdx].nWidth;
    3068           0 :                 break;
    3069             :             }
    3070             :         }
    3071           0 :         nMaxRight += nDragOffset;
    3072           0 :         break;
    3073             :     }
    3074             :       case RULER_TYPE_INDENT:
    3075             :         {
    3076           0 :         const sal_uInt16 nIdx = GetDragAryPos();
    3077           0 :         switch(nIdx) {
    3078             :         case INDENT_FIRST_LINE - INDENT_GAP:
    3079             :         case INDENT_LEFT_MARGIN - INDENT_GAP:
    3080             :             {
    3081           0 :                 if(bRTL)
    3082             :                 {
    3083           0 :                     nMaxLeft = lNullPix + GetRightIndent();
    3084             : 
    3085           0 :                     if(mxColumnItem.get() && !mxColumnItem->IsFirstAct())
    3086           0 :                         nMaxLeft += mpBorders[mxColumnItem->GetActColumn()-1].nPos +
    3087           0 :                             mpBorders[mxColumnItem->GetActColumn()-1].nWidth;
    3088           0 :                     nMaxRight = lNullPix + GetMargin2();
    3089             : 
    3090             :                     // Dragging along
    3091           0 :                     if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
    3092           0 :                        !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY))
    3093             :                     {
    3094           0 :                         if(GetLeftIndent() > GetFirstLineIndent())
    3095           0 :                             nMaxLeft += GetLeftIndent() - GetFirstLineIndent();
    3096             :                         else
    3097           0 :                             nMaxRight -= GetFirstLineIndent() - GetLeftIndent();
    3098             :                     }
    3099             :                 }
    3100             :                 else
    3101             :                 {
    3102           0 :                     nMaxLeft = lNullPix;
    3103             : 
    3104           0 :                     if(mxColumnItem.get() && !mxColumnItem->IsFirstAct())
    3105           0 :                         nMaxLeft += mpBorders[mxColumnItem->GetActColumn()-1].nPos +
    3106           0 :                             mpBorders[mxColumnItem->GetActColumn()-1].nWidth;
    3107           0 :                     nMaxRight = lNullPix + GetRightIndent() - lMinFrame;
    3108             : 
    3109             :                     // Dragging along
    3110           0 :                     if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
    3111           0 :                        !(nDragType & SvxRulerDragFlags::OBJECT_LEFT_INDENT_ONLY))
    3112             :                     {
    3113           0 :                         if(GetLeftIndent() > GetFirstLineIndent())
    3114           0 :                             nMaxLeft += GetLeftIndent() - GetFirstLineIndent();
    3115             :                         else
    3116           0 :                             nMaxRight -= GetFirstLineIndent() - GetLeftIndent();
    3117             :                     }
    3118             :                 }
    3119             :             }
    3120           0 :           break;
    3121             :           case INDENT_RIGHT_MARGIN - INDENT_GAP:
    3122             :             {
    3123           0 :                 if(bRTL)
    3124             :                 {
    3125           0 :                     nMaxLeft = lNullPix;
    3126           0 :                     nMaxRight = lNullPix + std::min(GetFirstLineIndent(), GetLeftIndent()) - lMinFrame;
    3127           0 :                     if(mxColumnItem.get())
    3128             :                     {
    3129           0 :                         sal_uInt16 nRightCol=GetActRightColumn( true );
    3130           0 :                         if(!IsActLastColumn( true ))
    3131           0 :                             nMaxRight += mpBorders[nRightCol].nPos;
    3132             :                         else
    3133           0 :                             nMaxRight += GetMargin2();
    3134             :                     }
    3135             :                     else
    3136             :                     {
    3137           0 :                         nMaxLeft += GetMargin1();
    3138             :                     }
    3139           0 :                     nMaxLeft += lMinFrame;
    3140             :                 }
    3141             :                 else
    3142             :                 {
    3143           0 :                     nMaxLeft = lNullPix +
    3144           0 :                         std::max(GetFirstLineIndent(), GetLeftIndent());
    3145           0 :                     nMaxRight = lNullPix;
    3146           0 :                     if(mxColumnItem.get())
    3147             :                     {
    3148           0 :                         sal_uInt16 nRightCol=GetActRightColumn( true );
    3149           0 :                         if(!IsActLastColumn( true ))
    3150           0 :                             nMaxRight += mpBorders[nRightCol].nPos;
    3151             :                         else
    3152           0 :                             nMaxRight += GetMargin2();
    3153             :                     }
    3154             :                     else
    3155           0 :                         nMaxRight += GetMargin2();
    3156           0 :                     nMaxLeft += lMinFrame;
    3157             :                 }
    3158             :             }
    3159           0 :             break;
    3160             :         }
    3161           0 :         break;
    3162             :     }
    3163             :     case RULER_TYPE_TAB:                // Tabs (Modifier)
    3164             :         /* left = NOf + Max(LAR, EZ)
    3165             :            right = NOf + RAR */
    3166             : 
    3167           0 :         if (bRTL)
    3168           0 :             nMaxLeft = lNullPix + GetRightIndent();
    3169             :         else
    3170           0 :             nMaxLeft = lNullPix + std::min(GetFirstLineIndent(), GetLeftIndent());
    3171             : 
    3172           0 :         mxRulerImpl->lMaxRightLogic = GetLogicRightIndent() + lLogicNullOffset;
    3173           0 :         nMaxRight = ConvertSizePixel(mxRulerImpl->lMaxRightLogic);
    3174           0 :         break;
    3175             :     default: ; //prevent warning
    3176             :     }
    3177           0 : }
    3178             : 
    3179           0 : bool SvxRuler::StartDrag()
    3180             : {
    3181             :     /*
    3182             :        Beginning of a drag operation (SV-handler) evaluates modifier and
    3183             :        calculated values
    3184             : 
    3185             :        [Cross-reference]
    3186             : 
    3187             :        <SvxRuler::EvalModifier()>
    3188             :        <SvxRuler::CalcMinMax()>
    3189             :        <SvxRuler::EndDrag()>
    3190             :     */
    3191           0 :     bool bContentProtected = mxRulerImpl->aProtectItem.IsContentProtected();
    3192             : 
    3193           0 :     if(!bValid)
    3194           0 :         return false;
    3195             : 
    3196           0 :     mxRulerImpl->lLastLMargin = GetMargin1();
    3197           0 :     mxRulerImpl->lLastRMargin = GetMargin2();
    3198             : 
    3199           0 :     bool bOk = true;
    3200             : 
    3201           0 :     if(GetStartDragHdl().IsSet())
    3202           0 :         bOk = Ruler::StartDrag();
    3203             : 
    3204           0 :     if(bOk)
    3205             :     {
    3206           0 :         lInitialDragPos = GetDragPos();
    3207           0 :         switch(GetDragType())
    3208             :         {
    3209             :             case RULER_TYPE_MARGIN1:        // left edge of the surrounding Frame
    3210             :             case RULER_TYPE_MARGIN2:        // right edge of the surrounding Frame
    3211           0 :                 if((bHorz && mxLRSpaceItem.get()) || (!bHorz && mxULSpaceItem.get()))
    3212             :                 {
    3213           0 :                     if(!mxColumnItem.get())
    3214           0 :                         EvalModifier();
    3215             :                     else
    3216           0 :                         nDragType = SvxRulerDragFlags::OBJECT;
    3217             :                 }
    3218             :                 else
    3219             :                 {
    3220           0 :                     bOk = false;
    3221             :                 }
    3222           0 :                 break;
    3223             :             case RULER_TYPE_BORDER: // Table, column (Modifier)
    3224           0 :                 if(mxColumnItem.get())
    3225             :                 {
    3226           0 :                     nDragOffset = 0;
    3227           0 :                     if (!mxColumnItem->IsTable())
    3228           0 :                         nDragOffset = GetDragPos() - mpBorders[GetDragAryPos()].nPos;
    3229           0 :                     EvalModifier();
    3230             :                 }
    3231             :                 else
    3232           0 :                     nDragOffset = 0;
    3233           0 :                 break;
    3234             :             case RULER_TYPE_INDENT: // Paragraph indents (Modifier)
    3235             :             {
    3236           0 :                 if( bContentProtected )
    3237           0 :                     return false;
    3238           0 :                 sal_uInt16 nIndent = INDENT_LEFT_MARGIN;
    3239           0 :                 if((nIndent) == GetDragAryPos() + INDENT_GAP) {  // Left paragraph indent
    3240           0 :                     mpIndents[0] = mpIndents[INDENT_FIRST_LINE];
    3241           0 :                     mpIndents[0].nStyle |= RULER_STYLE_DONTKNOW;
    3242           0 :                     EvalModifier();
    3243             :                 }
    3244             :                 else
    3245             :                 {
    3246           0 :                     nDragType = SvxRulerDragFlags::OBJECT;
    3247             :                 }
    3248           0 :                 mpIndents[1] = mpIndents[GetDragAryPos() + INDENT_GAP];
    3249           0 :                 mpIndents[1].nStyle |= RULER_STYLE_DONTKNOW;
    3250           0 :                 break;
    3251             :             }
    3252             :             case RULER_TYPE_TAB: // Tabs (Modifier)
    3253           0 :                 if( bContentProtected )
    3254           0 :                     return false;
    3255           0 :                 EvalModifier();
    3256           0 :                 mpTabs[0] = mpTabs[GetDragAryPos() + 1];
    3257           0 :                 mpTabs[0].nStyle |= RULER_STYLE_DONTKNOW;
    3258           0 :                 break;
    3259             :             default:
    3260           0 :                 nDragType = SvxRulerDragFlags::NONE;
    3261             :         }
    3262             :     }
    3263             :     else
    3264             :     {
    3265           0 :         nDragType = SvxRulerDragFlags::NONE;
    3266             :     }
    3267             : 
    3268           0 :     if(bOk)
    3269           0 :         CalcMinMax();
    3270             : 
    3271           0 :     return bOk;
    3272             : }
    3273             : 
    3274           0 : void  SvxRuler::Drag()
    3275             : {
    3276             :     /* SV-Draghandler */
    3277           0 :     if(IsDragCanceled())
    3278             :     {
    3279           0 :         Ruler::Drag();
    3280           0 :         return;
    3281             :     }
    3282           0 :     switch(GetDragType()) {
    3283             :         case RULER_TYPE_MARGIN1: // left edge of the surrounding Frame
    3284           0 :             DragMargin1();
    3285           0 :             mxRulerImpl->lLastLMargin = GetMargin1();
    3286           0 :             break;
    3287             :         case RULER_TYPE_MARGIN2: // right edge of the surrounding Frame
    3288           0 :             DragMargin2();
    3289           0 :             mxRulerImpl->lLastRMargin = GetMargin2();
    3290           0 :             break;
    3291             :         case RULER_TYPE_INDENT: // Paragraph indents
    3292           0 :             DragIndents();
    3293           0 :             break;
    3294             :         case RULER_TYPE_BORDER: // Table, columns
    3295           0 :             if(mxColumnItem.get())
    3296           0 :                 DragBorders();
    3297           0 :             else if(mxObjectItem.get())
    3298           0 :                 DragObjectBorder();
    3299           0 :             break;
    3300             :         case RULER_TYPE_TAB: // Tabs
    3301           0 :             DragTabs();
    3302           0 :             break;
    3303             :         default:
    3304           0 :             break; //prevent warning
    3305             :     }
    3306           0 :     Ruler::Drag();
    3307             : }
    3308             : 
    3309           0 : void SvxRuler::EndDrag()
    3310             : {
    3311             :     /*
    3312             :        SV-handler; is called when ending the dragging. Triggers the updating of data
    3313             :        on the application, by calling the respective Apply...() methods to send the
    3314             :        data to the application.
    3315             :     */
    3316           0 :     const bool bUndo = IsDragCanceled();
    3317           0 :     const long lPos = GetDragPos();
    3318           0 :     DrawLine_Impl(lTabPos, 6, bHorz);
    3319           0 :     lTabPos = -1;
    3320             : 
    3321           0 :     if(!bUndo)
    3322             :     {
    3323           0 :         switch(GetDragType())
    3324             :         {
    3325             :             case RULER_TYPE_MARGIN1: // upper left edge of the surrounding Frame
    3326             :             case RULER_TYPE_MARGIN2: // lower right edge of the surrounding Frame
    3327             :                 {
    3328           0 :                     if(!mxColumnItem.get() || !mxColumnItem->IsTable())
    3329           0 :                         ApplyMargins();
    3330             : 
    3331           0 :                     if(mxColumnItem.get() &&
    3332           0 :                        (mxColumnItem->IsTable() ||
    3333           0 :                         (nDragType & SvxRulerDragFlags::OBJECT_SIZE_PROPORTIONAL)))
    3334           0 :                         ApplyBorders();
    3335             : 
    3336             :                 }
    3337           0 :                 break;
    3338             :             case RULER_TYPE_BORDER: // Table, columns
    3339           0 :                 if(lInitialDragPos != lPos ||
    3340           0 :                     (mxRulerImpl->bIsTableRows && bHorz)) //special case - the null offset is changed here
    3341             :                 {
    3342           0 :                     if(mxColumnItem.get())
    3343             :                     {
    3344           0 :                         ApplyBorders();
    3345           0 :                         if(bHorz)
    3346           0 :                             UpdateTabs();
    3347             :                     }
    3348           0 :                     else if(mxObjectItem.get())
    3349           0 :                         ApplyObject();
    3350             :                 }
    3351           0 :                 break;
    3352             :             case RULER_TYPE_INDENT: // Paragraph indents
    3353           0 :                 if(lInitialDragPos != lPos)
    3354           0 :                     ApplyIndents();
    3355           0 :                 SetIndents(INDENT_COUNT, &mpIndents[0] + INDENT_GAP);
    3356           0 :                 break;
    3357             :             case RULER_TYPE_TAB: // Tabs
    3358             :                 {
    3359           0 :                     ApplyTabs();
    3360           0 :                     mpTabs[GetDragAryPos()].nStyle &= ~RULER_STYLE_INVISIBLE;
    3361           0 :                     SetTabs(nTabCount, &mpTabs[0] + TAB_GAP);
    3362             :                 }
    3363           0 :                 break;
    3364             :             default:
    3365           0 :                 break; //prevent warning
    3366             :         }
    3367             :     }
    3368           0 :     nDragType = SvxRulerDragFlags::NONE;
    3369             : 
    3370           0 :     mbCoarseSnapping = false;
    3371           0 :     mbSnapping = true;
    3372             : 
    3373           0 :     Ruler::EndDrag();
    3374           0 :     if(bUndo)
    3375             :     {
    3376           0 :         for(sal_uInt16 i = 0; i < mxRulerImpl->nControlerItems; i++)
    3377             :         {
    3378           0 :             pCtrlItems[i]->ClearCache();
    3379           0 :             pCtrlItems[i]->GetBindings().Invalidate(pCtrlItems[i]->GetId());
    3380             :         }
    3381             :     }
    3382           0 : }
    3383             : 
    3384           0 : void SvxRuler::ExtraDown()
    3385             : {
    3386             :     /* Override SV method, sets the new type for the Default tab. */
    3387             : 
    3388             :     // Switch Tab Type
    3389           0 :     if(mxTabStopItem.get() &&
    3390           0 :         (nFlags & SvxRulerSupportFlags::TABS) == SvxRulerSupportFlags::TABS)
    3391             :     {
    3392           0 :         ++nDefTabType;
    3393           0 :         if(RULER_TAB_DEFAULT == nDefTabType)
    3394           0 :             nDefTabType = RULER_TAB_LEFT;
    3395           0 :         SetExtraType(RULER_EXTRA_TAB, nDefTabType);
    3396             :     }
    3397           0 :     Ruler::ExtraDown();
    3398           0 : }
    3399             : 
    3400         730 : void SvxRuler::Notify(SfxBroadcaster&, const SfxHint& rHint)
    3401             : {
    3402             :     /*
    3403             :        Report through the bindings that the status update is completed. The ruler
    3404             :        updates its appearance and gets registered again in the bindings.
    3405             :     */
    3406             : 
    3407             :     // start update
    3408         730 :     const SfxSimpleHint* pSimpleHint = dynamic_cast<const SfxSimpleHint*>( &rHint );
    3409        1460 :     if(bActive &&
    3410        1392 :        pSimpleHint &&
    3411         662 :        pSimpleHint->GetId() == SFX_HINT_UPDATEDONE )
    3412             :      {
    3413         659 :         Update();
    3414         659 :         EndListening(*pBindings);
    3415         659 :         bValid = true;
    3416         659 :         bListening = false;
    3417             :     }
    3418         730 : }
    3419             : 
    3420             : 
    3421           0 : IMPL_LINK( SvxRuler, MenuSelect, Menu *, pMenu )
    3422             : {
    3423             :     /* Handler of the context menus for switching the unit of measurement */
    3424           0 :     SetUnit(FieldUnit(pMenu->GetCurItemId()));
    3425           0 :     return 0;
    3426             : }
    3427             : 
    3428           0 : IMPL_LINK( SvxRuler, TabMenuSelect, Menu *, pMenu )
    3429             : {
    3430             :     /* Handler of the tab menu for setting the type */
    3431           0 :     if(mxTabStopItem.get() && mxTabStopItem->Count() > mxRulerImpl->nIdx)
    3432             :     {
    3433           0 :         SvxTabStop aTabStop = mxTabStopItem->At(mxRulerImpl->nIdx);
    3434           0 :         aTabStop.GetAdjustment() = ToAttrTab_Impl(pMenu->GetCurItemId() - 1);
    3435           0 :         mxTabStopItem->Remove(mxRulerImpl->nIdx);
    3436           0 :         mxTabStopItem->Insert(aTabStop);
    3437           0 :         sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
    3438           0 :         pBindings->GetDispatcher()->Execute( nTabStopId, SfxCallMode::RECORD, mxTabStopItem.get(), 0L );
    3439           0 :         UpdateTabs();
    3440           0 :         mxRulerImpl->nIdx = 0;
    3441             :     }
    3442           0 :     return 0;
    3443             : }
    3444             : 
    3445           0 : void SvxRuler::Command( const CommandEvent& rCommandEvent )
    3446             : {
    3447             :     /* Mouse context menu for switching the unit of measurement */
    3448           0 :     if ( CommandEventId::ContextMenu == rCommandEvent.GetCommand() )
    3449             :     {
    3450           0 :         CancelDrag();
    3451           0 :         bool bRTL = mxRulerImpl->pTextRTLItem && mxRulerImpl->pTextRTLItem->GetValue();
    3452           0 :         if ( !mpTabs.empty() &&
    3453             :              RULER_TYPE_TAB ==
    3454           0 :              GetType( rCommandEvent.GetMousePosPixel(), &mxRulerImpl->nIdx ) &&
    3455           0 :              mpTabs[mxRulerImpl->nIdx + TAB_GAP].nStyle < RULER_TAB_DEFAULT )
    3456             :         {
    3457           0 :             PopupMenu aMenu;
    3458           0 :             aMenu.SetSelectHdl(LINK(this, SvxRuler, TabMenuSelect));
    3459           0 :             ScopedVclPtrInstance< VirtualDevice > pDev;
    3460           0 :             const Size aSz(ruler_tab_svx.width + 2, ruler_tab_svx.height + 2);
    3461           0 :             pDev->SetOutputSize(aSz);
    3462           0 :             pDev->SetBackground(Wallpaper(Color(COL_WHITE)));
    3463           0 :             Color aFillColor(pDev->GetSettings().GetStyleSettings().GetShadowColor());
    3464           0 :             const Point aPt(aSz.Width() / 2, aSz.Height() / 2);
    3465             : 
    3466           0 :             for ( sal_uInt16 i = RULER_TAB_LEFT; i < RULER_TAB_DEFAULT; ++i )
    3467             :             {
    3468           0 :                 sal_uInt16 nStyle = bRTL ? i|RULER_TAB_RTL : i;
    3469           0 :                 nStyle |= static_cast<sal_uInt16>(bHorz ? WB_HORZ : WB_VERT);
    3470           0 :                 DrawTab(*pDev, aFillColor, aPt, nStyle);
    3471             :                 aMenu.InsertItem(i + 1,
    3472           0 :                                  ResId(RID_SVXSTR_RULER_START + i, DIALOG_MGR()).toString(),
    3473           0 :                                  Image(pDev->GetBitmap(Point(), aSz), Color(COL_WHITE)));
    3474           0 :                 aMenu.CheckItem(i + 1, i == mpTabs[mxRulerImpl->nIdx + TAB_GAP].nStyle);
    3475           0 :                 pDev->SetOutputSize(aSz); // delete device
    3476             :             }
    3477           0 :             aMenu.Execute( this, rCommandEvent.GetMousePosPixel() );
    3478             :         }
    3479             :         else
    3480             :         {
    3481           0 :             PopupMenu aMenu(ResId(RID_SVXMN_RULER, DIALOG_MGR()));
    3482           0 :             aMenu.SetSelectHdl(LINK(this, SvxRuler, MenuSelect));
    3483           0 :             FieldUnit eUnit = GetUnit();
    3484           0 :             const sal_uInt16 nCount = aMenu.GetItemCount();
    3485             : 
    3486           0 :             bool bReduceMetric = bool(nFlags & SvxRulerSupportFlags::REDUCED_METRIC);
    3487           0 :             for ( sal_uInt16 i = nCount; i; --i )
    3488             :             {
    3489           0 :                 const sal_uInt16 nId = aMenu.GetItemId(i - 1);
    3490           0 :                 aMenu.CheckItem(nId, nId == (sal_uInt16)eUnit);
    3491           0 :                 if( bReduceMetric )
    3492             :                 {
    3493           0 :                     if ( nId == FUNIT_M    ||
    3494           0 :                          nId == FUNIT_KM   ||
    3495           0 :                          nId == FUNIT_FOOT ||
    3496             :                          nId == FUNIT_MILE )
    3497             :                     {
    3498           0 :                         aMenu.RemoveItem(i - 1);
    3499             :                     }
    3500           0 :                     else if (( nId == FUNIT_CHAR ) && !bHorz )
    3501             :                     {
    3502           0 :                         aMenu.RemoveItem(i - 1);
    3503             :                     }
    3504           0 :                     else if (( nId == FUNIT_LINE ) && bHorz )
    3505             :                     {
    3506           0 :                         aMenu.RemoveItem(i - 1);
    3507             :                     }
    3508             :                 }
    3509             :             }
    3510           0 :             aMenu.Execute( this, rCommandEvent.GetMousePosPixel() );
    3511             :         }
    3512             :     }
    3513             :     else
    3514             :     {
    3515           0 :         Ruler::Command( rCommandEvent );
    3516             :     }
    3517           0 : }
    3518             : 
    3519          12 : sal_uInt16 SvxRuler::GetActRightColumn(
    3520             :                         bool bForceDontConsiderHidden,
    3521             :                         sal_uInt16 nAct ) const
    3522             : {
    3523          12 :     if( nAct == USHRT_MAX )
    3524          12 :         nAct = mxColumnItem->GetActColumn();
    3525             :     else
    3526           0 :         nAct++; //To be able to pass on the ActDrag
    3527             : 
    3528          12 :     bool bConsiderHidden = !bForceDontConsiderHidden &&
    3529          12 :                                !(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY);
    3530             : 
    3531          24 :     while( nAct < mxColumnItem->Count() - 1 )
    3532             :     {
    3533          12 :         if (mxColumnItem->At(nAct).bVisible || bConsiderHidden)
    3534          12 :             return nAct;
    3535             :         else
    3536           0 :             nAct++;
    3537             :     }
    3538           0 :     return USHRT_MAX;
    3539             : }
    3540             : 
    3541           0 : sal_uInt16 SvxRuler::GetActLeftColumn(
    3542             :                         bool bForceDontConsiderHidden,
    3543             :                         sal_uInt16 nAct ) const
    3544             : {
    3545           0 :     if(nAct == USHRT_MAX)
    3546           0 :         nAct = mxColumnItem->GetActColumn();
    3547             : 
    3548           0 :     sal_uInt16 nLeftOffset = 1;
    3549             : 
    3550           0 :     bool bConsiderHidden = !bForceDontConsiderHidden &&
    3551           0 :                                !(nDragType & SvxRulerDragFlags::OBJECT_ACTLINE_ONLY);
    3552             : 
    3553           0 :     while(nAct >= nLeftOffset)
    3554             :     {
    3555           0 :         if (mxColumnItem->At(nAct - nLeftOffset).bVisible || bConsiderHidden)
    3556           0 :             return nAct - nLeftOffset;
    3557             :         else
    3558           0 :             nLeftOffset++;
    3559             :     }
    3560           0 :     return USHRT_MAX;
    3561             : }
    3562             : 
    3563           6 : bool SvxRuler::IsActLastColumn(
    3564             :                         bool bForceDontConsiderHidden,
    3565             :                         sal_uInt16 nAct) const
    3566             : {
    3567           6 :     return GetActRightColumn(bForceDontConsiderHidden, nAct) == USHRT_MAX;
    3568             : }
    3569             : 
    3570           0 : bool SvxRuler::IsActFirstColumn(
    3571             :                         bool bForceDontConsiderHidden,
    3572             :                         sal_uInt16 nAct) const
    3573             : {
    3574           0 :     return GetActLeftColumn(bForceDontConsiderHidden, nAct) == USHRT_MAX;
    3575             : }
    3576             : 
    3577           0 : long SvxRuler::CalcPropMaxRight(sal_uInt16 nCol) const
    3578             : {
    3579             : 
    3580           0 :     if(!(nDragType & SvxRulerDragFlags::OBJECT_SIZE_LINEAR))
    3581             :     {
    3582             :         // Remove the minimum width for all affected columns
    3583             :         // starting from the right edge
    3584           0 :         long _nMaxRight = GetMargin2() - GetMargin1();
    3585             : 
    3586           0 :         long lFences = 0;
    3587           0 :         long lMinSpace = USHRT_MAX;
    3588             :         long lOldPos;
    3589           0 :         long lColumns = 0;
    3590             : 
    3591             :         sal_uInt16 nStart;
    3592           0 :         if(!mxColumnItem->IsTable())
    3593             :         {
    3594           0 :             if(nCol == USHRT_MAX)
    3595             :             {
    3596           0 :                 lOldPos = GetMargin1();
    3597           0 :                 nStart = 0;
    3598             :             }
    3599             :             else
    3600             :             {
    3601           0 :                 lOldPos = mpBorders[nCol].nPos + mpBorders[nCol].nWidth;
    3602           0 :                 nStart = nCol + 1;
    3603           0 :                 lFences = mpBorders[nCol].nWidth;
    3604             :             }
    3605             : 
    3606           0 :             for(sal_uInt16 i = nStart; i < mpBorders.size() - 1; ++i)
    3607             :             {
    3608           0 :                 long lWidth = mpBorders[i].nPos - lOldPos;
    3609           0 :                 lColumns += lWidth;
    3610           0 :                 if(lWidth < lMinSpace)
    3611           0 :                     lMinSpace = lWidth;
    3612           0 :                 lOldPos = mpBorders[i].nPos + mpBorders[i].nWidth;
    3613           0 :                 lFences += mpBorders[i].nWidth;
    3614             :             }
    3615           0 :             long lWidth = GetMargin2() - lOldPos;
    3616           0 :             lColumns += lWidth;
    3617           0 :             if(lWidth < lMinSpace)
    3618           0 :                 lMinSpace = lWidth;
    3619             :         }
    3620             :         else
    3621             :         {
    3622             :             sal_uInt16 nActCol;
    3623           0 :             if(nCol == USHRT_MAX) //CalcMinMax for LeftMargin
    3624             :             {
    3625           0 :                 lOldPos = GetMargin1();
    3626             :             }
    3627             :             else
    3628             :             {
    3629           0 :                 lOldPos = mpBorders[nCol].nPos;
    3630             :             }
    3631           0 :             lColumns = GetMargin2()-lOldPos;
    3632           0 :             nActCol = nCol;
    3633           0 :             lFences = 0;
    3634           0 :             while(nActCol < mpBorders.size() || nActCol == USHRT_MAX)
    3635             :             {
    3636             :                 sal_uInt16 nRight;
    3637           0 :                 if(nActCol == USHRT_MAX)
    3638             :                 {
    3639           0 :                     nRight = 0;
    3640           0 :                     while(!(*mxColumnItem.get())[nRight].bVisible)
    3641             :                     {
    3642           0 :                         nRight++;
    3643             :                     }
    3644             :                 }
    3645             :                 else
    3646             :                 {
    3647           0 :                     nRight = GetActRightColumn(false, nActCol);
    3648             :                 }
    3649             : 
    3650             :                 long lWidth;
    3651           0 :                 if(nRight != USHRT_MAX)
    3652             :                 {
    3653           0 :                     lWidth = mpBorders[nRight].nPos - lOldPos;
    3654           0 :                     lOldPos = mpBorders[nRight].nPos;
    3655             :                 }
    3656             :                 else
    3657             :                 {
    3658           0 :                     lWidth=GetMargin2() - lOldPos;
    3659             :                 }
    3660           0 :                 nActCol = nRight;
    3661           0 :                 if(lWidth < lMinSpace)
    3662           0 :                     lMinSpace = lWidth;
    3663           0 :                 if(nActCol == USHRT_MAX)
    3664           0 :                     break;
    3665             :             }
    3666             :         }
    3667             : 
    3668           0 :         _nMaxRight -= (long)(lFences + lMinFrame / (float) lMinSpace * lColumns);
    3669           0 :         return _nMaxRight;
    3670             :     }
    3671             :     else
    3672             :     {
    3673           0 :         if(mxColumnItem->IsTable())
    3674             :         {
    3675           0 :             sal_uInt16 nVisCols = 0;
    3676           0 :             for(size_t i = GetActRightColumn(false, nCol); i < mpBorders.size();)
    3677             :             {
    3678           0 :                 if((*mxColumnItem.get())[i].bVisible)
    3679           0 :                     nVisCols++;
    3680           0 :                 i = GetActRightColumn(false, i);
    3681             :             }
    3682           0 :             return GetMargin2() - GetMargin1() - (nVisCols + 1) * lMinFrame;
    3683             :         }
    3684             :         else
    3685             :         {
    3686           0 :             long lWidth = 0;
    3687           0 :             for(sal_uInt16 i = nCol; i < mpBorders.size() - 1; i++)
    3688             :             {
    3689           0 :                 lWidth += lMinFrame + mpBorders[i].nWidth;
    3690             :             }
    3691           0 :             return GetMargin2() - GetMargin1() - lWidth;
    3692             :         }
    3693             :     }
    3694             : }
    3695             : 
    3696             : // Tab stops relative to indent (#i24363#)
    3697        5218 : void SvxRuler::SetTabsRelativeToIndent( bool bRel )
    3698             : {
    3699        5218 :     mxRulerImpl->bIsTabsRelativeToIndent = bRel;
    3700        5608 : }
    3701             : 
    3702             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11