execute move of global headers

see https://gerrit.libreoffice.org/#/c/3367/
and Change-Id: I00c96fa77d04b33a6f8c8cd3490dfcd9bdc9e84a for details

Change-Id: I199a75bc4042af20817265d5ef85b1134a96ff5a

1 files changed, 802 insertions, 0 deletions

diff --git a/include/svtools/ruler.hxx b/include/svtools/ruler.hxx
new file mode 100644
index 000000000000..a06109bca6a0
--- /dev/null
+++ b/include/svtools/ruler.hxx
@@ -0,0 +1,802 @@
+/* -*- 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 .
+ */
+
+#ifndef _RULER_HXX
+#define _RULER_HXX
+
+#include "svtools/svtdllapi.h"
+#include <tools/link.hxx>
+#include <vcl/window.hxx>
+#include <vcl/virdev.hxx>
+#include <vcl/field.hxx>
+
+class MouseEvent;
+class TrackingEvent;
+class DataChangedEvent;
+
+/*************************************************************************
+
+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:
+
+    FUNIT_MM
+    FUNIT_CM (Default)
+    FUNIT_M
+    FUNIT_KM
+    FUNIT_INCH
+    FUNIT_FOOT
+    FUNIT_MILE
+    FUNIT_POINT
+    FUNIT_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:
+                                RULER_BORDER_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.
+                                RULER_BORDER_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).
+                                RULER_BORDER_VARIABLE
+                                Not all of the column spacings are equal
+                                RULER_BORDER_TABLE
+                                Table border. Whenever this style ist set, the column
+                                width must be 0.
+                                RULER_BORDER_SNAP
+                                Auxiliary line. Whenever this style is set, the
+                                column width must be 0.
+                                RULER_BORDER_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:
+                                RULER_INDENT_TOP    (indent of the first line)
+                                RULER_INDENT_BOTTOM (left/right indent)
+                                RULER_INDENT_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.
+            RULER_TYPE_MARGIN1
+            RULER_TYPE_MARGIN2
+            RULER_TYPE_BORDER
+            RULER_TYPE_INDENT
+            RULER_TYPE_TAB
+
+    - GetDragPos()
+        Returns the pixel position to which the user has moved the mouse
+        relative to the set zero-offset.
+
+    - GetDragAryPos()
+        Liefert den Index im Array zurueck, wenn ein Border, Indent oder ein
+        Tab gedragt wird. Achtung: Es wird die Array-Position waehrend des
+        gesammten Drag-Vorgangs von dem Item im Array was vor dem Drag gesetzt
+        war zurueckgeben. Dadurch ist es zum Beispiel auch moeglich, einen
+        Tab nicht mehr anzuzeigen, wenn die Maus nach unten/rechts aus dem
+        Lineal gezogen wird.
+
+    - GetDragSize()
+        Wenn Borders gedragt werden, kann hierueber abgefragt werden, ob
+        die Groesse bzw. welche Seite oder die Position geaendert werden soll.
+            RULER_DRAGSIZE_MOVE oder 0      - Move
+            RULER_DRAGSIZE_1                - Linke/obere Kante
+            RULER_DRAGSIZE_2                - Rechte/untere Kante
+
+    - IsDragDelete()
+        Mit dieser Methode kann abgefragt werden, ob beim Draggen die
+        Maus unten/rechts aus dem Fenster gezogen wurde. Damit kann
+        zum Beispiel festgestellt werden, ob der Benutzer einen Tab
+        loeschen will.
+
+    - IsDragCanceled()
+        Mit dieser Methode kann im EndDrag-Handler abgefragt werden,
+        ob die Aktion abgebrochen wurde, indem der Anwender die
+        Maus oben/links vom Fenster losgelassen hat oder ESC gedrueckt
+        hat. In diesem Fall werden die Werte nicht uebernommen. Wird
+        waehrend des Draggings die Maus oben/links aus dem Fenster
+        gezogen, werden automatisch die alten Werte dargestellt, ohne das
+        der Drag-Handler gerufen wird.
+        Falls der Benutzer jedoch den Wert auf die alte Position
+        zurueckgeschoben hat, liefert die Methode trotzdem sal_False. Falls
+        dies vermieden werden soll, muss sich die Applikation im StartDrag-
+        Handler den alten Wert merken und im EndDrag-Handler den Wert
+        vergleichen.
+
+    - GetDragScroll()
+        Mit dieser Methode kann abgefragt werden, ob gescrollt werden
+        soll. Es wird einer der folgenden Werte zurueckgegeben:
+            RULER_SCROLL_NO                 - Drag-Position befindet sich
+                                              an keinem Rand und somit
+                                              muss nicht gescrollt werden.
+            RULER_SCROLL_1                  - Drag-Position befindet sich
+                                              am linken/oberen Rand und
+                                              somit sollte das Programm evt.
+                                              ein Srcoll ausloesen.
+            RULER_SCROLL_2                  - Drag-Position befindet sich
+                                              am rechten/unteren Rand und
+                                              somit sollte das Programm evt.
+                                              ein Srcoll ausloesen.
+
+    - GetDragModifier()
+        Liefert die Modifier-Tasten zurueck, die beim Starten des Drag-
+        Vorgangs gedrueckt waren. Siehe MouseEvent.
+
+    - GetClickPos()
+        Liefert die Pixel-Position bezogen auf den eingestellten Null-Offset
+        zurueck, wo der Anwender die Maus gedrueckt hat.
+
+    - GetClickType()
+        Liefert zurueck, was per DoubleClick betaetigt wird:
+            RULER_TYPE_DONTKNOW             (kein Element im Linealbereich)
+            RULER_TYPE_OUTSIDE              (ausserhalb des Linealbereichs)
+            RULER_TYPE_MARGIN1              (nur Margin1-Kante)
+            RULER_TYPE_MARGIN2              (nur Margin2-Kante)
+            RULER_TYPE_BORDER               (Border: GetClickAryPos())
+            RULER_TYPE_INDENT               (Einzug: GetClickAryPos())
+            RULER_TYPE_TAB                  (Tab: GetClickAryPos())
+
+    - GetClickAryPos()
+        Liefert den Index im Array zurueck, wenn ein Border, Indent oder ein
+        Tab per DoubleClick betaetigt wird.
+
+    - GetType()
+        Mit dieser Methode kann man einen HitTest durchfuehren, um
+        gegebenenfalls ueber das Abfangen des MouseButtonDown-Handlers
+        auch ueber die rechte Maustaste etwas auf ein Item anzuwenden. Als
+        Paramter ueber gibt man die Fensterposition und gegebenenfalls
+        einen Pointer auf einen sal_uInt16, um die Array-Position eines
+        Tabs, Indent oder Borders mitzubekommen. Als Type werden folgende
+        Werte zurueckgegeben:
+            RULER_TYPE_DONTKNOW             (kein Element im Linealbereich)
+            RULER_TYPE_OUTSIDE              (ausserhalb des Linealbereichs)
+            RULER_TYPE_MARGIN1              (nur Margin1-Kante)
+            RULER_TYPE_MARGIN2              (nur Margin2-Kante)
+            RULER_TYPE_BORDER               (Border: GetClickAryPos())
+            RULER_TYPE_INDENT               (Einzug: GetClickAryPos())
+            RULER_TYPE_TAB                  (Tab: GetClickAryPos())
+
+Wenn der Drag-Vorgang abgebrochen werden soll, kann der Drag-Vorgang
+mit CancelDrag() abgebrochen werden. Folgende Methoden gibt es fuer die
+Drag-Steuerung:
+
+    - IsDrag()
+        Liefert sal_True zurueck, wenn sich das Lineal im Drag-Vorgang befindet.
+
+    - CancelDrag()
+        Bricht den Drag-Vorgang ab, falls einer durchgefuehrt wird. Dabei
+        werden die alten Werte wieder hergestellt und der Drag und der
+        EndDrag-Handler gerufen.
+
+Um vom Dokument ein Drag auszuloesen, gibt es folgende Methoden:
+
+    - StartDocDrag()
+        Dieser Methode werden der MouseEvent vom Dokumentfenster und
+        was gedragt werden soll uebergeben. Wenn als DragType
+        RULER_TYPE_DONTKNOW uebergeben wird, bestimmt das Lineal, was
+        verschoben werden soll. Bei den anderen, wird der Drag nur dann
+        gestartet, wenn auch an der uebergebenen Position ein entsprechendes
+        Element gefunden wurde. Dies ist zun Beispiel dann notwendig, wenn
+        zum Beispiel Einzuege und Spalten an der gleichen X-Position liegen.
+        Der Rueckgabewert gibt an, ob der Drag ausgeloest wurde. Wenn ein
+        Drag ausgeloest wird, uebernimmt das Lineal die normale Drag-Steuerung
+        und verhaelt sich dann so, wie als wenn direkt in das Lineal geklickt
+        wurde. So captured das Lineal die Mouse und uebernimmt auch die
+        Steuerung des Cancel (ueber Tastatur, oder wenn die Mouse ueber
+        oder links vom Lineal ruasgeschoben wird). Auch alle Handler werden
+        gerufen (inkl. des StartDrag-Handlers). Wenn ein MouseEvent mit
+        Click-Count 2 uebergeben wird auch der DoubleClick-Handler
+        entsprechend gerufen.
+
+--------------------------------------------------------------------------
+
+Fuer das Extra-Feld kann der Inhalt bestimmt werden und es gibt Handler,
+womit man bestimmte Aktionen abfangen kann.
+
+    - ExtraDown()
+        Dieser Handler wird gerufen, wenn im Extra-Feld die Maus
+        gedrueckt wird.
+
+    - SetExtraType()
+        Mit dieser Methode kann festgelegt werden, was im ExtraFeld
+        dargestellt werden soll.
+            - ExtraType         Was im Extrafeld dargestellt werden soll
+                                RULER_EXTRA_DONTKNOW        (Nichts)
+                                RULER_EXTRA_NULLOFFSET      (Koordinaaten-Kreuz)
+                                RULER_EXTRA_TAB             (Tab)
+            - sal_uInt16 nStyle     Bitfeld als Style:
+                                    RULER_STYLE_HIGHLIGHT   (selektiert)
+                                    RULER_TAB_...           (ein Tab-Style)
+
+    - GetExtraClick()
+        Liefert die Anzahl der Mausclicks zurueck. Dadurch ist es zum
+        Beispiel auch moeglich, auch durch einen DoubleClick im Extrafeld
+        eine Aktion auszuloesen.
+
+    - GetExtraModifier()
+        Liefert die Modifier-Tasten zurueck, die beim Klicken in das Extra-
+        Feld gedrueckt waren. Siehe MouseEvent.
+
+--------------------------------------------------------------------------
+
+Weitere Hilfsfunktionen:
+
+- static Ruler::DrawTab()
+    Mit dieser Methode kann ein Tab auf einem OutputDevice ausgegeben
+    werden. Dadurch ist es moeglich, auch in Dialogen die Tabs so
+    anzuzeigen, wie Sie im Lineal gemalt werden.
+
+    Diese Methode gibt den Tab zentriert an der uebergebenen Position
+    aus. Die Groesse der Tabs kann ueber die Defines RULER_TAB_WIDTH und
+    RULER_TAB_HEIGHT bestimmt werden.
+
+--------------------------------------------------------------------------
+
+Tips zur Benutzung des Lineals:
+
+- Bei dem Lineal muss weder im Drag-Modus noch sonst das Setzen der Werte
+  in SetUpdateMode() geklammert werden. Denn das Lineal sorgt von sich
+  aus dafuer, das wenn mehrere Werte gesetzt werden, diese automatisch
+  zusammengefast werden und flackerfrei ausgegeben werden.
+
+- Initial sollten beim Lineal zuerst die Groessen, Positionen und Werte
+  gesetzt werden, bevor es angezeigt wird. Dies ist deshalb wichtig, da
+  ansonsten viele Werte unnoetig berechnet werden.
+
+- Wenn das Dokumentfenster, in dem sich das Lineal befindet aktiv bzw.
+  deaktiv wird, sollten die Methoden Activate() und Deactivate() vom
+  Lineal gerufen werden. Denn je nach Einstellungen und System wird die
+  Anzeige entsprechend umgeschaltet.
+
+- Zum Beispiel sollte beim Drag von Tabs und Einzuegen nach Moeglichkeit die
+  alten Positionen noch mit angezeigt werden. Dazu sollte zusaetzlich beim
+  Setzen der Tabs und Einzuege als erstes im Array die alten Positionen
+  eingetragen werden und mit dem Style RULER_STYLE_DONTKNOW verknuepft
+  werden. Danach sollte im Array die restlichen Werte eingetragen werden.
+
+- Bei mehreren markierten Absaetzen und Tabellen-Zellen, sollten die Tabs
+  und Einzuege in grau von der ersten Zelle, bzw. vom ersten Absatz
+  angezeigt werden. Dies kann man auch ueber den Style RULER_STYLE_DONTKNOW
+  erreichen.
+
+- Die Bemassungspfeile sollten immer dann angezeigt, wenn beim Drag die
+  Alt-Taste (WW-Like) gedrueckt wird. Vielleicht sollte diese Einstellung
+  auch immer vornehmbar sein und vielleicht beim Drag immer die
+  Bemassungspfeile dargestellt werden. Bei allen Einstellung sollten die
+  Werte immer auf ein vielfaches eines Wertes gerundet werden, da die
+  Bildschirmausloesung sehr ungenau ist.
+
+- DoppelKlicks sollten folgendermassen behandelt werden (GetClickType()):
+    - RULER_TYPE_DONTKNOW
+      RULER_TYPE_MARGIN1
+      RULER_TYPE_MARGIN2
+        Wenn die Bedingunden GetClickPos() <= GetMargin1() oder
+        GetClickPos() >= GetMargin2() oder der Type gleich
+        RULER_TYPE_MARGIN1 oder RULER_TYPE_MARGIN2 ist, sollte
+        ein SeitenDialog angezeigt werden, wo der Focus auf dem
+        entsprechenden Rand steht
+    - RULER_TYPE_BORDER
+        Es sollte ein Spalten- oder Tabellen-Dialog angezeigt werden,
+        wo der Focus auf der entsprechenden Spalte steht, die mit
+        GetClickAryPos() abgefragt werden kann.
+    - RULER_TYPE_INDENT
+        Es sollte der Dialog angezeigt werden, wo die Einzuege eingestellt
+        werden koennen. Dabei sollte der Focus auf dem Einzug stehen, der
+        mit GetClickAryPos() ermittelt werden kann.
+    - RULER_TYPE_TAB
+        Es sollte ein TabDialog angezeigt werden, wo der Tab selektiert
+        sein sollte, der ueber GetClickAryPos() abgefragt werden kann.
+
+*************************************************************************/
+
+// -----------
+// - WinBits -
+// -----------
+
+#define WB_EXTRAFIELD       ((WinBits)0x00004000)
+#define WB_RIGHT_ALIGNED    ((WinBits)0x00008000)
+#define WB_STDRULER         WB_HORZ
+
+// ---------------
+// - Ruler-Types -
+// ---------------
+
+struct ImplRulerHitTest;
+
+// --------------
+// - Ruler-Type -
+// --------------
+
+enum RulerType { RULER_TYPE_DONTKNOW, RULER_TYPE_OUTSIDE,
+                 RULER_TYPE_MARGIN1, RULER_TYPE_MARGIN2,
+                 RULER_TYPE_BORDER, RULER_TYPE_INDENT, RULER_TYPE_TAB };
+
+enum RulerExtra { RULER_EXTRA_DONTKNOW,
+                  RULER_EXTRA_NULLOFFSET, RULER_EXTRA_TAB };
+
+#define RULER_STYLE_HIGHLIGHT   ((sal_uInt16)0x8000)
+#define RULER_STYLE_DONTKNOW    ((sal_uInt16)0x4000)
+#define RULER_STYLE_INVISIBLE   ((sal_uInt16)0x2000)
+
+#define RULER_DRAGSIZE_MOVE     0
+#define RULER_DRAGSIZE_1        1
+#define RULER_DRAGSIZE_2        2
+
+#define RULER_MOUSE_BORDERMOVE  5
+#define RULER_MOUSE_BORDERWIDTH 5
+#define RULER_MOUSE_MARGINWIDTH 3
+
+#define RULER_SCROLL_NO         0
+#define RULER_SCROLL_1          1
+#define RULER_SCROLL_2          2
+
+// ---------------
+// - RulerMargin -
+// ---------------
+
+#define RULER_MARGIN_SIZEABLE   ((sal_uInt16)0x0001)
+
+// ---------------
+// - RulerBorder -
+// ---------------
+
+#define RULER_BORDER_SIZEABLE   ((sal_uInt16)0x0001)
+#define RULER_BORDER_MOVEABLE   ((sal_uInt16)0x0002)
+#define RULER_BORDER_VARIABLE   ((sal_uInt16)0x0004)
+#define RULER_BORDER_TABLE      ((sal_uInt16)0x0008)
+#define RULER_BORDER_SNAP       ((sal_uInt16)0x0010)
+#define RULER_BORDER_MARGIN     ((sal_uInt16)0x0020)
+
+struct RulerBorder
+{
+    long    nPos;
+    long    nWidth;
+    sal_uInt16  nStyle;
+    //minimum/maximum position, supported for table borders/rows
+    long    nMinPos;
+    long    nMaxPos;
+};
+
+// ---------------
+// - RulerIndent -
+// ---------------
+
+#define RULER_INDENT_TOP        ((sal_uInt16)0x0000)
+#define RULER_INDENT_BOTTOM     ((sal_uInt16)0x0001)
+#define RULER_INDENT_BORDER     ((sal_uInt16)0x0002)
+#define RULER_INDENT_STYLE      ((sal_uInt16)0x000F)
+
+struct RulerIndent
+{
+    long    nPos;
+    sal_uInt16  nStyle;
+};
+
+// ------------
+// - RulerTab -
+// ------------
+
+#define RULER_TAB_LEFT          ((sal_uInt16)0x0000)
+#define RULER_TAB_RIGHT         ((sal_uInt16)0x0001)
+#define RULER_TAB_DECIMAL       ((sal_uInt16)0x0002)
+#define RULER_TAB_CENTER        ((sal_uInt16)0x0003)
+#define RULER_TAB_DEFAULT       ((sal_uInt16)0x0004)
+#define RULER_TAB_STYLE         ((sal_uInt16)0x000F)
+#define RULER_TAB_RTL           ((sal_uInt16)0x0010)
+
+struct RulerTab
+{
+    long    nPos;
+    sal_uInt16  nStyle;
+};
+
+#define RULER_TAB_WIDTH         7
+#define RULER_TAB_HEIGHT        6
+
+// -------------
+// - RulerLine -
+// -------------
+
+struct RulerLine
+{
+    long    nPos;
+    sal_uInt16  nStyle;
+};
+
+class ImplRulerData;
+// ---------
+// - Ruler -
+// ---------
+
+class SVT_DLLPUBLIC Ruler : public Window
+{
+private:
+    VirtualDevice       maVirDev;
+    MapMode             maMapMode;
+    long                mnBorderOff;
+    long                mnWinOff;
+    long                mnWinWidth;
+    long                mnWidth;
+    long                mnHeight;
+    long                mnVirOff;
+    long                mnVirWidth;
+    long                mnVirHeight;
+    long                mnBorderWidth;
+    long                mnStartDragPos;
+    long                mnDragPos;
+    sal_uLong               mnUpdateEvtId;
+    ImplRulerData*      mpSaveData;
+    ImplRulerData*      mpData;
+    ImplRulerData*      mpDragData;
+    Rectangle           maExtraRect;
+    WinBits             mnWinStyle;
+    sal_uInt16              mnUnitIndex;
+    sal_uInt16              mnDragAryPos;
+    sal_uInt16              mnDragSize;
+    sal_uInt16              mnDragScroll;
+    sal_uInt16              mnDragModifier;
+    sal_uInt16              mnExtraStyle;
+    sal_uInt16              mnExtraClicks;
+    sal_uInt16              mnExtraModifier;
+    long                mnCharWidth;
+    long                mnLineHeight;
+
+    RulerExtra          meExtraType;
+    RulerType           meDragType;
+    MapUnit             meSourceUnit;
+    FieldUnit           meUnit;
+    Fraction            maZoom;
+    sal_Bool                mbCalc;
+    sal_Bool                mbFormat;
+    sal_Bool                mbDrag;
+    sal_Bool                mbDragDelete;
+    sal_Bool                mbDragCanceled;
+    sal_Bool                mbAutoWinWidth;
+    sal_Bool                mbActive;
+    sal_uInt8                mnUpdateFlags;
+    Link                maStartDragHdl;
+    Link                maDragHdl;
+    Link                maEndDragHdl;
+    Link                maClickHdl;
+    Link                maDoubleClickHdl;
+    Link                maExtraDownHdl;
+
+#ifdef _SV_RULER_CXX
+    SVT_DLLPRIVATE void                ImplVDrawLine( long nX1, long nY1, long nX2, long nY2 );
+    SVT_DLLPRIVATE void                ImplVDrawRect( long nX1, long nY1, long nX2, long nY2 );
+    SVT_DLLPRIVATE void                ImplVDrawText( long nX, long nY, const String& rText, long nMin = LONG_MIN, long nMax = LONG_MAX );
+
+    SVT_DLLPRIVATE void                ImplDrawTicks( long nMin, long nMax, long nStart, long nCenter );
+    SVT_DLLPRIVATE void                ImplDrawBorders( long nMin, long nMax, long nVirTop, long nVirBottom );
+    SVT_DLLPRIVATE void                ImplDrawIndent( const Polygon& rPoly, sal_uInt16 nStyle );
+    SVT_DLLPRIVATE void                ImplDrawIndents( long nMin, long nMax, long nVirTop, long nVirBottom );
+    SVT_DLLPRIVATE void                ImplDrawTab( OutputDevice* pDevice, const Point& rPos, sal_uInt16 nStyle );
+    SVT_DLLPRIVATE void                ImplDrawTabs( long nMin, long nMax, long nVirTop, long nVirBottom );
+    using Window::ImplInit;
+    SVT_DLLPRIVATE void                ImplInit( WinBits nWinBits );
+    SVT_DLLPRIVATE void                ImplInitSettings( sal_Bool bFont, sal_Bool bForeground, sal_Bool bBackground );
+    SVT_DLLPRIVATE void                ImplCalc();
+    SVT_DLLPRIVATE void                ImplFormat();
+    SVT_DLLPRIVATE void                ImplInitExtraField( sal_Bool bUpdate );
+    SVT_DLLPRIVATE void                ImplInvertLines( sal_Bool bErase = sal_False );
+    SVT_DLLPRIVATE void                ImplDraw();
+    SVT_DLLPRIVATE void                ImplDrawExtra( sal_Bool bPaint = sal_False );
+    SVT_DLLPRIVATE void                ImplUpdate( sal_Bool bMustCalc = sal_False );
+    using Window::ImplHitTest;
+    SVT_DLLPRIVATE sal_Bool                ImplHitTest( const Point& rPos,
+                                     ImplRulerHitTest* pHitTest,
+                                     sal_Bool bRequiredStyle = sal_False,
+                                     sal_uInt16 nRequiredStyle = 0 ) const;
+    SVT_DLLPRIVATE sal_Bool                ImplDocHitTest( const Point& rPos, RulerType eDragType, ImplRulerHitTest* pHitTest ) const;
+    SVT_DLLPRIVATE sal_Bool                ImplStartDrag( ImplRulerHitTest* pHitTest, sal_uInt16 nModifier );
+    SVT_DLLPRIVATE void                ImplDrag( const Point& rPos );
+    SVT_DLLPRIVATE void                ImplEndDrag();
+                        DECL_DLLPRIVATE_LINK( ImplUpdateHdl, void* );
+#endif
+
+    // Forbidden and not implemented.
+    Ruler (const Ruler &);
+    Ruler & operator= (const Ruler &);
+
+protected:
+    long GetRulerVirHeight() const;
+
+public:
+                        Ruler( Window* pParent, WinBits nWinStyle = WB_STDRULER );
+    virtual             ~Ruler();
+
+    virtual void        MouseButtonDown( const MouseEvent& rMEvt );
+    virtual void        MouseMove( const MouseEvent& rMEvt );
+    virtual void        Tracking( const TrackingEvent& rTEvt );
+    virtual void        Paint( const Rectangle& rRect );
+    virtual void        Resize();
+    virtual void        StateChanged( StateChangedType nStateChange );
+    virtual void        DataChanged( const DataChangedEvent& rDCEvt );
+
+    virtual long        StartDrag();
+    virtual void        Drag();
+    virtual void        EndDrag();
+    virtual void        Click();
+    virtual void        DoubleClick();
+    virtual void        ExtraDown();
+
+    void                Activate();
+    void                Deactivate();
+    sal_Bool                IsActive() const { return mbActive; }
+
+    void                SetWinPos( long nOff = 0, long nWidth = 0 );
+    long                GetWinOffset() const { return mnWinOff; }
+    long                GetWinWidth() const { return mnWinWidth; }
+    void                SetPagePos( long nOff = 0, long nWidth = 0 );
+    long                GetPageOffset() const;
+    long                GetPageWidth() const;
+    void                SetBorderPos( long nOff = 0 );
+    long                GetBorderOffset() const { return mnBorderOff; }
+    Rectangle           GetExtraRect() const { return maExtraRect; }
+
+    void                SetUnit( FieldUnit eNewUnit );
+    FieldUnit           GetUnit() const { return meUnit; }
+    void                SetZoom( const Fraction& rNewZoom );
+    Fraction            GetZoom() const { return maZoom; }
+
+    void                SetSourceUnit( MapUnit eNewUnit ) { meSourceUnit = eNewUnit; }
+    MapUnit             GetSourceUnit() const { return meSourceUnit; }
+
+    void                SetExtraType( RulerExtra eNewExtraType, sal_uInt16 nStyle = 0 );
+    RulerExtra          GetExtraType() const { return meExtraType; }
+    sal_uInt16              GetExtraStyle()  const { return mnExtraStyle; }
+    sal_uInt16              GetExtraClicks() const { return mnExtraClicks; }
+    sal_uInt16              GetExtraModifier() const { return mnExtraModifier; }
+
+    sal_Bool                StartDocDrag( const MouseEvent& rMEvt,
+                                      RulerType eDragType = RULER_TYPE_DONTKNOW );
+    RulerType           GetDragType() const { return meDragType; }
+    long                GetDragPos() const { return mnDragPos; }
+    sal_uInt16              GetDragAryPos() const { return mnDragAryPos; }
+    sal_uInt16              GetDragSize() const { return mnDragSize; }
+    sal_Bool                IsDragDelete() const { return mbDragDelete; }
+    sal_Bool                IsDragCanceled() const { return mbDragCanceled; }
+    sal_uInt16              GetDragScroll() const { return mnDragScroll; }
+    sal_uInt16              GetDragModifier() const { return mnDragModifier; }
+    sal_Bool                IsDrag() const { return mbDrag; }
+    void                CancelDrag();
+    long                GetClickPos() const { return mnDragPos; }
+    RulerType           GetClickType() const { return meDragType; }
+    sal_uInt16              GetClickAryPos() const { return mnDragAryPos; }
+    using Window::GetType;
+    RulerType           GetType( const Point& rPos,
+                                 sal_uInt16* pAryPos = NULL ) const;
+
+    void                SetNullOffset( long nPos );
+    long                GetNullOffset() const;
+    void                SetMargin1() { SetMargin1( 0, RULER_STYLE_INVISIBLE ); }
+    void                SetMargin1( long nPos, sal_uInt16 nMarginStyle = RULER_MARGIN_SIZEABLE );
+    long                GetMargin1() const;
+    void                SetMargin2() { SetMargin2( 0, RULER_STYLE_INVISIBLE ); }
+    void                SetMargin2( long nPos, sal_uInt16 nMarginStyle = RULER_MARGIN_SIZEABLE );
+    long                GetMargin2() const;
+
+    void                SetLines( sal_uInt16 n = 0, const RulerLine* pLineAry = NULL );
+
+    void                SetBorders( sal_uInt16 n = 0, const RulerBorder* pBrdAry = NULL );
+
+    void                SetIndents( sal_uInt16 n = 0, const RulerIndent* pIndentAry = NULL );
+
+    void                SetTabs( sal_uInt16 n = 0, const RulerTab* pTabAry = NULL );
+    sal_uInt16              GetTabCount() const;
+    const RulerTab*     GetTabs() const;
+
+    static void         DrawTab( OutputDevice* pDevice,
+                                 const Point& rPos, sal_uInt16 nStyle );
+
+    void                SetStyle( WinBits nStyle );
+    WinBits             GetStyle() const { return mnWinStyle; }
+
+    void                SetStartDragHdl( const Link& rLink ) { maStartDragHdl = rLink; }
+    const Link&         GetStartDragHdl() const { return maStartDragHdl; }
+    void                SetDragHdl( const Link& rLink ) { maDragHdl = rLink; }
+    const Link&         GetDragHdl() const { return maDragHdl; }
+    void                SetEndDragHdl( const Link& rLink ) { maEndDragHdl = rLink; }
+    const Link&         GetEndDragHdl() const { return maEndDragHdl; }
+    void                SetClickHdl( const Link& rLink ) { maClickHdl = rLink; }
+    const Link&         GetClickHdl() const { return maClickHdl; }
+    void                SetDoubleClickHdl( const Link& rLink ) { maDoubleClickHdl = rLink; }
+    const Link&         GetDoubleClickHdl() const { return maDoubleClickHdl; }
+    void                SetExtraDownHdl( const Link& rLink ) { maExtraDownHdl = rLink; }
+    const Link&         GetExtraDownHdl() const { return maExtraDownHdl; }
+
+    //set text direction right-to-left
+    void                SetTextRTL(sal_Bool bRTL);
+
+    void                SetCharWidth( long nWidth ) { mnCharWidth = nWidth ; }
+    void                SetLineHeight( long nHeight ) { mnLineHeight = nHeight ; }
+
+    void                DrawTicks();
+};
+
+#endif  // _RULER_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */