summaryrefslogtreecommitdiffstats
path: root/include/svtools/ruler.hxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 09:06:44 +0000
commited5640d8b587fbcfed7dd7967f3de04b37a76f26 (patch)
tree7a5f7c6c9d02226d7471cb3cc8fbbf631b415303 /include/svtools/ruler.hxx
parentInitial commit. (diff)
downloadlibreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.tar.xz
libreoffice-ed5640d8b587fbcfed7dd7967f3de04b37a76f26.zip
Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'include/svtools/ruler.hxx')
-rw-r--r--include/svtools/ruler.hxx799
1 files changed, 799 insertions, 0 deletions
diff --git a/include/svtools/ruler.hxx b/include/svtools/ruler.hxx
new file mode 100644
index 000000000..8acc70aa1
--- /dev/null
+++ b/include/svtools/ruler.hxx
@@ -0,0 +1,799 @@
+/* -*- 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 <memory>
+#include <map>
+#include <vector>
+#include <svtools/svtdllapi.h>
+#include <rtl/ref.hxx>
+#include <tools/fldunit.hxx>
+#include <tools/link.hxx>
+#include <tools/fract.hxx>
+#include <vcl/window.hxx>
+#include <vcl/glyphitem.hxx>
+
+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<RulerMarginStyle> : is_typed_flags<RulerMarginStyle, 0x0003> {};
+}
+
+
+enum class RulerBorderStyle {
+ Sizeable = 0x0001,
+ Moveable = 0x0002,
+ Variable = 0x0004,
+ Invisible = 0x0008
+};
+namespace o3tl {
+ template<> struct typed_flags<RulerBorderStyle> : is_typed_flags<RulerBorderStyle, 0x000f> {};
+}
+
+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<VirtualDevice> 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<ImplRulerData> mpSaveData;
+ ImplRulerData* mpData;
+ std::unique_ptr<ImplRulerData> 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<Ruler*,void> maDoubleClickHdl;
+
+ std::unique_ptr<RulerSelection> mxCurrentHitTest;
+ std::unique_ptr<RulerSelection> mxPreviousHitTest;
+
+ rtl::Reference<SvtRulerAccessible> mxAccContext;
+
+ std::map<OUString, SalLayoutGlyphs> 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 ) const;
+ SVT_DLLPRIVATE bool ImplDocHitTest( const Point& rPos, RulerType eDragType, RulerSelection* pHitTest ) 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 );
+ 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<RulerTab>& 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<Ruler*,void>& 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: */