/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ /* * This file is part of the LibreOffice project. * * This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. * * This file incorporates work covered by the following license notice: * * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed * with this work for additional information regarding copyright * ownership. The ASF licenses this file to you under the Apache * License, Version 2.0 (the "License"); you may not use this file * except in compliance with the License. You may obtain a copy of * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ #pragma once #include #include #include #include #include #include #include #include #include #include class MouseEvent; class TrackingEvent; class DataChangedEvent; class SvtRulerAccessible; /************************************************************************* Description ============ class Ruler This class is used for displaying a ruler, but it can also be used for setting or moving tabs and margins. -------------------------------------------------------------------------- WinBits WB_HORZ ruler is displayed horizontally WB_VERT ruler is displayed vertically WB_3DLOOK 3D look WB_BORDER border at the bottom/right margin WB_EXTRAFIELD Field in the upper left corner for displaying and selecting tabs, origin of coordinates, ... WB_RIGHT_ALIGNED Marks the vertical ruler as right aligned -------------------------------------------------------------------------- All ruler parameters are set in pixel units. This way double conversions and rounding errors are avoided and the ruler displays the margins at their actual position in the document. Because of this, the application can, for example in tables, do its own roundings and the positions on the ruler will still match those in the document. However, for the ruler to know how the document is displayed on the screen, some additional values have to be configured SetWinPos() sets the offset of the ruler's edit window. In doing so, the width of the window can also be configured. If there is a 0 among the values passed to the function, the position/width is automatically set to the width of the ruler. SetPagePos() sets the offset of the page relative to the edit window and the width of the page. If there is a 0 among the values passed to the function, the position/width is automatically set as if the page filled the whole edit window. SetBorderPos() sets the offset of the border. The position is relative to the upper/left margin of the window. This is needed when there are a horizontal and a vertical ruler visible at the same time. Example: aHRuler.SetBorderPos( aVRuler.GetSizePixel().Width()-1 ); SetNullOffset() sets the origin relative to the page. All the other values (margins, indentation, tabs, ...) refer to the origin, which is set with SetNullOffset(). The values are computed as described below: - WinPos (if both windows have the same parent) Point aHRulerPos = aHRuler.GetPosPixel(); Point aEditWinPos = aEditWin.GetPosPixel(); aHRuler.SetWinPos( aEditWinPos().X() - aHRulerPos.X() ); - PagePos Point aPagePos = aEditWin.LogicToPixel( aEditWin.GetPagePos() ); aHRuler.SetPagePos( aPagePos().X() ); - All other values Add the logical values, recompute as position and subtract the previously saved pixel positions (of PagePos and Null Offset). -------------------------------------------------------------------------- SetUnit() and SetZoom() configure which unit is used to display the values on the ruler. The following units are accepted: FieldUnit::MM FieldUnit::CM (Default) FieldUnit::M FieldUnit::KM FieldUnit::INCH FieldUnit::FOOT FieldUnit::MILE FieldUnit::POINT FieldUnit::PICA -------------------------------------------------------------------------- SetMargin1() sets the upper/left margin and SetMargin2() sets the bottom/right margin. If these methods are called without arguments, no margins are displayed. Otherwise, the following arguments can be passed: long nPos - offset in pixels relative to the origin sal_uInt16 nStyle - bit style: RULER_MARGIN_SIZEABLE margin size can be changed The following bits can be set in addition to these styles: RULER_STYLE_INVISIBLE SetBorders() sets an array of margins. To do this, an array of type RulerBorder has to be passed. In the array, the following values have to be initialized: long nPos - offset in pixels relative to the origin long nWidth - column spacing in pixels (can also be 0, for example, for table columns) sal_uInt16 nStyle - bit style: RulerBorderStyle::Sizeable Column spacing can be changed. This flag should only be set if the size of the spacing is changed, not that of a cell. RulerBorderStyle::Moveable Column spacing/border can be moved. Whenever table borders are to be moved, this flag should be set instead of SIZEABLE (SIZEABLE indicates that the size of a spacing, not that of a single cell can be changed). RulerBorderStyle::Variable Not all of the column spacings are equal RulerBorderStyle::Table Table border. Whenever this style is set, the column width must be 0. RulerBorderStyle::Snap Auxiliary line. Whenever this style is set, the column width must be 0. RulerBorderStyle::Margin Margin. Whenever this style is set, the column width must be 0. The following bits can be set in addition to these styles: RULER_STYLE_INVISIBLE SetIndents() sets an array of indents. This method may only be used for horizontal rulers. A Ruler Indent must be passed as an argument, with the following values initialized: long nPos - offset relative to the origin in pixels sal_uInt16 nStyle - bit style: RulerIndentStyle::Top (indent of the first line) RulerIndentStyle::Bottom (left/right indent) RulerIndentStyle::Border (Vertical line that shows the border distance) The following bits can be set in addition to these styles: RULER_STYLE_DONTKNOW (for old position or for ambiguity) RULER_STYLE_INVISIBLE SetTabs() sets an array of tabs. This method may only be used for horizontal rulers. An array of type RulerTab must be passed as an argument, with the following values initialized: long nPos - offset relative to the origin in pixels sal_uInt16 nStyle - bit style: RULER_TAB_DEFAULT (can't be selected) RULER_TAB_LEFT RULER_TAB_CENTER RULER_TAB_RIGHT RULER_TAB_DECIMAL The following bits can be set in addition to these styles: RULER_STYLE_DONTKNOW (for old position of for ambiguity) RULER_STYLE_INVISIBLE SetLines() displays position lines in the ruler. An array of type RulerLine must be passed, with the following values initialized: long nPos - offset relative to the origin in pixels sal_uInt16 nStyle - bit style (has to be 0 currently) -------------------------------------------------------------------------- If the user should also be able to change the margins tabs, borders, ... in the ruler, a bit more effort is necessary. In this case, the StartDrag(), Drag() and EndDrag() methods have to be overridden. For the StartDrag() method it is possible to prevent dragging by returning FALSE. In the drag handler, the drag position must be queried and the values must be moved to the new position. This is done by calling the particular Set methods. While in the drag handler, the values are just cached and only afterward the ruler is redrawn. All the handlers can also be set as links with the particular Set..Hdl() methods. - StartDrag() Is called when dragging is started. If FALSE is returned, the dragging. won't be executed. If TRUE is returned, the dragging will be permitted. If the handler isn't overridden, FALSE will be returned. - EndDrag() Is called at the end of dragging. - Drag() Is called when dragging takes place. - Click() This handler is called when no element has been clicked on. The position can be queried with GetClickPos(). This way it is possible to, for example, ser tabs in the ruler. After calling the click handler, the drag, if any, is immediately triggered. This makes it possible to set a new tab in the click handler and then immediately move it. - DoubleClick() This handler is called when a double-click has been performed outside the special panel. The methods GetClickType(), GetClickAryPos() and GetClickPos() can be used to query what has been clicked on. This way you can, for example, show the tab dialog when a double-click is performed on a tab. In the drag handler it is possible to query what has been dragged and where it has been dragged. There are the following query methods: - GetDragType() Returns what has been dragged. RulerType::Margin1 RulerType::Margin2 RulerType::Border RulerType::Indent RulerType::Tab - GetDragPos() Returns the pixel position to which the user has moved the mouse relative to the set zero-offset. - GetDragAryPos() Returns the index in the array if a border, an indent or a tab is being dragged. Attention: During a drag process, the array position of the item that has been set before the drag is returned. Therefore, it is for example also possible, to no longer show a tab if the mouse is dragged out of the ruler in bottom/right direction. - GetDragSize() If Borders are dragged, this can be used to query whether the size resp. which side or the position should be changed. RulerDragSize::Move or 0 - Move RulerDragSize::N1 - left/upper border RulerDragSize::N2 - right/bottom border - IsDragDelete() This method can be used to query whether the mouse has been moved out of the window at the bottom/right while dragging. By this, it can for example be determined whether the user wants to delete a tab. - IsDragCanceled() Using this Handler, it can be queried in the EndDrag handler whether the action was canceled by the user releasing the mouse at the top/left of the window or by pressing ESC. In this case, the values are not applied. If during the dragging, the mouse is dragged out of the window at the top/left, the old values are displayed automatically without the Drag handler being called. But if the user has moved the value to the old position, the method returns 'false' nevertheless. If this should be avoided, the application must remember the old value in the StartDrag handler and compare the value in the EndDrag handler. - GetDragModifier() Returns the modifier keys that were pressed when the Drag process was started. See MouseEvent. - GetClickPos() Returns the pixel position at which the user has pressed the mouse with respect to the configured null-offset. - GetClickType() Returns what is applied by double click: RulerType::DontKnow (no element in the ruler area) RulerType::Outside (outside of the ruler area) RulerType::Margin1 (only Margin1 border) RulerType::Margin2 (only Margin2 border) RulerType::Border (Border: GetClickAryPos()) RulerType::Indent (indent: GetClickAryPos()) RulerType::Tab (Tab: GetClickAryPos()) - GetClickAryPos() Returns the index in the array if a Border, an Indent or a Tab is applied via DoubleClick. - GetType() This method can be used to carry out a HitTest, in order to possibly also apply sth to an Item using the right mouse button by catching the MouseButtonDown handler. As parameters, the window position and possibly a pointer to a sal_uInt16 are passed, in order to determine the array position of a Tab, an Indent, or a Border. The following values are returned as type: RulerType::DontKnow (no element in the ruler area) RulerType::Outside (outside of the ruler area) RulerType::Margin1 (only Margin1 border) RulerType::Margin2 (only Margin2 border) RulerType::Border (Border: GetClickAryPos()) RulerType::Indent (indent: GetClickAryPos()) RulerType::Tab (Tab: GetClickAryPos()) If the drag process should be canceled, this can be done using CancelDrag(). There are the following methods for controlling the Drag: - IsDrag() Returns 'true' if the ruler is in a drag process. - CancelDrag() Cancels the drag process, if one is being carried out. During this, the old values are restored and the Drag and the EndDrag handlers are called. In order to trigger a Drag from the document, there are the following methods: - StartDocDrag() This method is passed the MouseEvent of the document window and what should be dragged. If RulerType::DontKnow is passed as DragType, the ruler decides what should be dragged. In case of the other types, the Drag is only started if a respective element was found at the given position. This is for example necessary if indents and columns are located at the same X position. The return value indicates whether the Drag has been triggered. If a Drag is triggered, the ruler takes over the normal drag control and behaves as if the ruler had been clicked directly. Thus, the ruler captures the mouse and also takes over control of the Cancel (via keyboard, or if the mouse is moved outside of the ruler above it or left of it). All handlers are called, too (including the StartDrag handler). If a MouseEvent with ClickCount 2 is passed, the DoubleClick handler is also called, respectively. -------------------------------------------------------------------------- For the extra field, the content can be determined and there are handlers that can be used to handle specific actions. - ExtraDown() This handler is called when the mouse is pressed in the extra field. - SetExtraType() With this method, it can be defined what should be displayed in the extra field. - ExtraType what should be displayed in the extra field RulerExtra::DontKnow (nothing) RulerExtra::NullOffset (coordinate axes) RulerExtra::Tab (Tab) - sal_uInt16 nStyle bit field as style: RULER_STYLE_HIGHLIGHT (selected) RULER_TAB_... (a Tab style) - GetExtraClick() Returns the number of mouse clicks. By this, it is for example also possible to trigger an action by a DoubleClick in the extra field. - GetExtraModifier() Returns the modifier keys that were pressed when the extra field was clicked. See MouseEvent. -------------------------------------------------------------------------- Further helper functions: - static Ruler::DrawTab() With this method, a Tab can be output on an OutputDevice. By this, it is also possible to show the Tabs in dialogs like they are drawn in the ruler. This method outputs the Tab centred at the given position. The size of the tabs can be defined by the defines RULER_TAB_WIDTH and RULER_TAB_HEIGHT. -------------------------------------------------------------------------- Tips for the use of the ruler: - For the ruler, neither in the Drag mode nor elsewhere, the setting of the values must be bracketed in SetUpdateMode(). The ruler itself takes care that, if multiple values are set, they are automatically grouped together and output flicker-free. - Initially, the sizes, positions and values should be set first for the ruler, before it is displayed. This is important because otherwise many values are calculated unnecessarily. - When the document window, in which the ruler resides, becomes active resp. unactive, the methods Activate() and Deactivate() should be called by the ruler. That is so because the display is switched according to the settings and the system. - For example, while dragging Tabs and Indents, the old positions should also be shown if possible. For that, while setting the Tabs and Indents, the old positions should be inserted first into the array in addition and be linked with the style RULER_STYLE_DONTKNOW. After that, the remaining values should be set in the array. - In case of multiple selected paragraphs and table cells, the Tabs and Indents should be displayed in grey in front of the first cell resp. the first paragraph. This can also be achieved by the style RULER_STYLE_DONTKNOW. - The measuring arrow should always be shown when the Alt key (WW-Like) is pressed during the drag. Maybe, this setting should be configurable always and possibly the measuring arrows always be shown while dragging. For all settings, the values should always be rounded to the multiple of one value because the screen resolution is very imprecise. - DoubleClicks should be handled in the following way (GetClickType()): - RulerType::DontKnow RulerType::Margin1 RulerType::Margin2 If the conditions GetClickPos() <= GetMargin1() or GetClickPos() >= GetMargin2() are met or the type is equal to RulerType::Margin1 or RulerType::Margin2, a side dialog should be displayed in which the focus is at the respective border. - RulerType::Border A column or table dialog should be shown in which the focus is at the respective column that can be queried using GetClickAryPos(). - RulerType::Indent The dialog, in which the indents can be configured, should be shown. In this, the focus should be on the indent which can be queried using GetClickAryPos(). - RulerType::Tab A TabDialog should be displayed in which the Tab, that can be queried using GetClickAryPos(), should be selected. *************************************************************************/ constexpr WinBits WB_EXTRAFIELD = 0x00004000; constexpr WinBits WB_RIGHT_ALIGNED = 0x00008000; constexpr auto WB_STDRULER = WB_HORZ; enum class RulerType { DontKnow, Outside, Margin1, Margin2, Border, Indent, Tab }; enum class RulerExtra { DontKnow, NullOffset, Tab }; constexpr sal_uInt16 RULER_STYLE_HIGHLIGHT = 0x8000; constexpr sal_uInt16 RULER_STYLE_DONTKNOW = 0x4000; constexpr sal_uInt16 RULER_STYLE_INVISIBLE = 0x2000; enum class RulerDragSize { Move, N1, N2 }; constexpr auto RULER_MOUSE_BORDERMOVE = 5; constexpr auto RULER_MOUSE_BORDERWIDTH = 5; constexpr auto RULER_MOUSE_MARGINWIDTH = 3; enum class RulerMarginStyle { NONE = 0x0000, Sizeable = 0x0001, Invisible = 0x0002 }; namespace o3tl { template<> struct typed_flags : is_typed_flags {}; } enum class RulerBorderStyle { Sizeable = 0x0001, Moveable = 0x0002, Variable = 0x0004, Invisible = 0x0008 }; namespace o3tl { template<> struct typed_flags : is_typed_flags {}; } struct RulerBorder { tools::Long nPos; tools::Long nWidth; RulerBorderStyle nStyle; tools::Long nMinPos; //minimum/maximum position, supported for table borders/rows tools::Long nMaxPos; }; enum class RulerIndentStyle { Top, Bottom }; struct RulerIndent { tools::Long nPos; RulerIndentStyle nStyle; bool bInvisible; }; constexpr sal_uInt16 RULER_TAB_LEFT = 0x0000; constexpr sal_uInt16 RULER_TAB_RIGHT = 0x0001; constexpr sal_uInt16 RULER_TAB_CENTER = 0x0002; constexpr sal_uInt16 RULER_TAB_DECIMAL = 0x0003; constexpr sal_uInt16 RULER_TAB_DEFAULT = 0x0004; constexpr sal_uInt16 RULER_TAB_STYLE = 0x000F; constexpr sal_uInt16 RULER_TAB_RTL = 0x0010; struct RulerTab { tools::Long nPos; sal_uInt16 nStyle; }; struct RulerLine { tools::Long nPos; }; struct RulerSelection { tools::Long nPos; RulerType eType; sal_uInt16 nAryPos; RulerDragSize mnDragSize; bool bSize; bool bSizeBar; bool bExpandTest; RulerSelection() : nPos(0) , eType(RulerType::DontKnow) , nAryPos(0) , mnDragSize(RulerDragSize::Move) , bSize(false) , bSizeBar(false) , bExpandTest( false ) {} }; struct RulerUnitData { MapUnit eMapUnit; // MAP_UNIT for calculation tools::Long nTickUnit; // Unit divider double nTick1; // Minimal step double nTick2; // Tick quarter unit double nTick3; // Tick half unit double nTick4; // Tick whole unit char aUnitStr[8]; // Unit string }; // Data for drawing ruler tabstops struct RulerTabData { sal_uInt16 DPIScaleFactor; sal_uInt16 width; sal_uInt16 height; sal_uInt16 height2; sal_uInt16 width2; sal_uInt16 cwidth; sal_uInt16 cwidth2; sal_uInt16 cwidth3; sal_uInt16 cwidth4; sal_uInt16 dheight; sal_uInt16 dheight2; sal_uInt16 dwidth; sal_uInt16 dwidth2; sal_uInt16 dwidth3; sal_uInt16 dwidth4; sal_uInt16 textoff; }; class ImplRulerData; class SVT_DLLPUBLIC Ruler : public vcl::Window { private: ScopedVclPtr maVirDev; MapMode maMapMode; tools::Long mnBorderOff; tools::Long mnWinOff; tools::Long mnWinWidth; tools::Long mnWidth; tools::Long mnHeight; tools::Long mnVirOff; tools::Long mnVirWidth; tools::Long mnVirHeight; tools::Long mnBorderWidth; tools::Long mnStartDragPos; tools::Long mnDragPos; std::unique_ptr mpSaveData; ImplRulerData* mpData; std::unique_ptr mpDragData; tools::Rectangle maExtraRect; WinBits mnWinStyle; sal_uInt16 mnUnitIndex; sal_uInt16 mnDragAryPos; RulerDragSize mnDragSize; sal_uInt16 mnDragModifier; sal_uInt16 mnExtraStyle; tools::Long mnCharWidth; tools::Long mnLineHeight; RulerExtra meExtraType; RulerType meDragType; FieldUnit meUnit; Fraction maZoom; bool mbCalc; bool mbFormat; bool mbDrag; bool mbDragDelete; bool mbDragCanceled; bool mbAutoWinWidth; bool mbActive; sal_uInt8 mnUpdateFlags; RulerSelection maHoverSelection; Link maDoubleClickHdl; std::unique_ptr mxCurrentHitTest; std::unique_ptr mxPreviousHitTest; rtl::Reference mxAccContext; std::map maTextGlyphs; SVT_DLLPRIVATE void ImplVDrawLine(vcl::RenderContext& rRenderContext, tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2 ); SVT_DLLPRIVATE void ImplVDrawRect(vcl::RenderContext& rRenderContext, tools::Long nX1, tools::Long nY1, tools::Long nX2, tools::Long nY2 ); SVT_DLLPRIVATE void ImplVDrawText(vcl::RenderContext& rRenderContext, tools::Long nX, tools::Long nY, const OUString& rText, tools::Long nMin = LONG_MIN, tools::Long nMax = LONG_MAX ); SVT_DLLPRIVATE void ImplDrawTicks(vcl::RenderContext& rRenderContext, tools::Long nMin, tools::Long nMax, tools::Long nStart, tools::Long nVirTop, tools::Long nVirBottom); SVT_DLLPRIVATE void ImplDrawBorders(vcl::RenderContext& rRenderContext, tools::Long nMin, tools::Long nMax, tools::Long nVirTop, tools::Long nVirBottom); SVT_DLLPRIVATE static void ImplDrawIndent(vcl::RenderContext& rRenderContext, const tools::Polygon& rPoly, bool bIsHit); SVT_DLLPRIVATE void ImplDrawIndents(vcl::RenderContext& rRenderContext, tools::Long nMin, tools::Long nMax, tools::Long nVirTop, tools::Long nVirBottom); SVT_DLLPRIVATE void ImplDrawTab(vcl::RenderContext& rRenderContext, const Point& rPos, sal_uInt16 nStyle); SVT_DLLPRIVATE void ImplDrawTabs(vcl::RenderContext& rRenderContext, tools::Long nMin, tools::Long nMax, tools::Long nVirTop, tools::Long nVirBottom); using Window::ImplInit; SVT_DLLPRIVATE void ImplInit( WinBits nWinBits ); SVT_DLLPRIVATE void ImplInitSettings( bool bFont, bool bForeground, bool bBackground ); SVT_DLLPRIVATE void ImplCalc(); SVT_DLLPRIVATE void ImplFormat(vcl::RenderContext const & rRenderContext); SVT_DLLPRIVATE void ImplInitExtraField( bool bUpdate ); SVT_DLLPRIVATE void ImplInvertLines(vcl::RenderContext& rRenderContext); SVT_DLLPRIVATE void ImplDraw(vcl::RenderContext& rRenderContext); SVT_DLLPRIVATE void ImplDrawExtra(vcl::RenderContext& rRenderContext); SVT_DLLPRIVATE void ImplUpdate( bool bMustCalc = false ); virtual void ApplySettings(vcl::RenderContext& rRenderContext) override; SVT_DLLPRIVATE bool ImplDoHitTest( const Point& rPosition, RulerSelection* pHitTest, bool bRequiredStyle = false, RulerIndentStyle nRequiredStyle = RulerIndentStyle::Top, tools::Long nTolerance = 1 ) const; SVT_DLLPRIVATE bool ImplDocHitTest( const Point& rPos, RulerType eDragType, RulerSelection* pHitTest, tools::Long nTolerance = 1 ) const; SVT_DLLPRIVATE bool ImplStartDrag( RulerSelection const * pHitTest, sal_uInt16 nModifier ); SVT_DLLPRIVATE void ImplDrag( const Point& rPos ); SVT_DLLPRIVATE void ImplEndDrag(); Ruler (const Ruler &) = delete; Ruler& operator= (const Ruler &) = delete; protected: tools::Long GetRulerVirHeight() const { return mnVirHeight;} const MapMode& GetCurrentMapMode() const { return maMapMode; } const RulerUnitData& GetCurrentRulerUnit() const; public: Ruler( vcl::Window* pParent, WinBits nWinStyle = WB_STDRULER ); virtual ~Ruler() override; virtual void dispose() override; virtual void MouseButtonDown( const MouseEvent& rMEvt ) override; virtual void MouseMove( const MouseEvent& rMEvt ) override; virtual void Tracking( const TrackingEvent& rTEvt ) override; virtual void Paint(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect) override; virtual void Resize() override; virtual void StateChanged( StateChangedType nStateChange ) override; virtual void DataChanged( const DataChangedEvent& rDCEvt ) override; virtual bool StartDrag(); virtual void Drag(); virtual void EndDrag(); virtual void Click(); void DoubleClick(); virtual void ExtraDown(); void Activate() override; void Deactivate() override; void SetWinPos( tools::Long nOff, tools::Long nWidth = 0 ); tools::Long GetWinOffset() const { return mnWinOff; } void SetPagePos( tools::Long nOff = 0, tools::Long nWidth = 0 ); tools::Long GetPageOffset() const; void SetBorderPos( tools::Long nOff = 0 ); tools::Long GetBorderOffset() const { return mnBorderOff; } const tools::Rectangle& GetExtraRect() const { return maExtraRect; } void SetUnit( FieldUnit eNewUnit ); FieldUnit GetUnit() const { return meUnit; } void SetZoom( const Fraction& rNewZoom ); void SetExtraType( RulerExtra eNewExtraType, sal_uInt16 nStyle = 0 ); bool StartDocDrag( const MouseEvent& rMEvt, RulerType eDragType, tools::Long nTolerance = 1 ); RulerType GetDragType() const { return meDragType; } tools::Long GetDragPos() const { return mnDragPos; } sal_uInt16 GetDragAryPos() const { return mnDragAryPos; } RulerDragSize GetDragSize() const { return mnDragSize; } bool IsDragDelete() const { return mbDragDelete; } bool IsDragCanceled() const { return mbDragCanceled; } sal_uInt16 GetDragModifier() const { return mnDragModifier; } bool IsDrag() const { return mbDrag; } void CancelDrag(); tools::Long GetClickPos() const { return mnDragPos; } RulerType GetClickType() const { return meDragType; } const RulerSelection& GetHoverSelection() const { return maHoverSelection; } RulerType GetRulerType( const Point& rPos, sal_uInt16* pAryPos = nullptr ); void SetNullOffset( tools::Long nPos ); tools::Long GetNullOffset() const; void SetMargin1() { SetMargin1( 0, RulerMarginStyle::Invisible ); } void SetMargin1( tools::Long nPos, RulerMarginStyle nMarginStyle = RulerMarginStyle::Sizeable ); tools::Long GetMargin1() const; void SetMargin2() { SetMargin2( 0, RulerMarginStyle::Invisible ); } void SetMargin2( tools::Long nPos, RulerMarginStyle nMarginStyle = RulerMarginStyle::Sizeable ); tools::Long GetMargin2() const; void SetLeftFrameMargin( tools::Long nPos ); void SetRightFrameMargin( tools::Long nPos ); void SetLines( sal_uInt32 n = 0, const RulerLine* pLineAry = nullptr ); void SetBorders( sal_uInt32 n = 0, const RulerBorder* pBrdAry = nullptr ); void SetIndents( sal_uInt32 n = 0, const RulerIndent* pIndentAry = nullptr ); void SetTabs( sal_uInt32 n = 0, const RulerTab* pTabAry = nullptr ); const std::vector& GetTabs() const; static void DrawTab(vcl::RenderContext& rRenderContext, const Color &rFillColor, const Point& rPos, sal_uInt16 nStyle); void SetStyle( WinBits nStyle ); WinBits GetStyle() const { return mnWinStyle; } void SetDoubleClickHdl( const Link& rLink ) { maDoubleClickHdl = rLink; } void SetTextRTL(bool bRTL); bool GetTextRTL() const; void SetCharWidth( tools::Long nWidth ) { mnCharWidth = nWidth ; } void SetLineHeight( tools::Long nHeight ) { mnLineHeight = nHeight ; } void DrawTicks(); virtual css::uno::Reference< css::accessibility::XAccessible > CreateAccessible() override; }; /* vim:set shiftwidth=4 softtabstop=4 expandtab: */