summaryrefslogtreecommitdiff
path: root/svtools/inc/ruler.hxx
blob: bcf441e5c2d23ab42d85bbc9839e5fb8d4c9cb2b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2000, 2010 Oracle and/or its affiliates.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/

#ifndef _RULER_HXX
#define _RULER_HXX

#include "svtools/svtdllapi.h"
#include <tools/link.hxx>
#include <vcl/window.hxx>
#ifndef _VIRDEV_HXX
#include <vcl/virdev.hxx>
#endif
#include <vcl/field.hxx>

class MouseEvent;
class TrackingEvent;
class DataChangedEvent;

/*************************************************************************

Beschreibung
============

class Ruler

Diese Klasse dient zur Anzeige eines Lineals. Dabei kann diese Klasse nicht
nur als Anzeige-Control verwendet werden, sondern auch als aktives Control
zum Setzen/Verschieben von Tabulatoren und Raendern.

--------------------------------------------------------------------------

WinBits

WB_HORZ             Lineal wird horizontal dargestellt
WB_VERT             Lineal wird vertikal dargestellt
WB_3DLOOK           3D-Darstellung
WB_BORDER           Border am unteren/rechten Rand
WB_EXTRAFIELD       Feld in der linken/oberen Ecke zur Anzeige und
                    Auswahl von Tabs, Null-Punkt, ...
WB_RIGHT_ALIGNED    Marks the vertical ruler as right aligned

--------------------------------------------------------------------------

Beim Lineal werden alle Werte als Pixel-Werte eingestellt. Dadurch werden
doppelte Umrechnungen und Rundungsfehler vermieden und die Raender werden
im Lineal auch an der Position angezeigt, den Sie auch im Dokument haben.
Dadurch kann die Applikation zum Beispiel bei Tabellendarstellung auch
eigene Rundungen vornehmen und die Positionen im Lineal passen trotzdem noch
zu denen im Dokument. Damit aber das Lineal weiss, wie das Dokument auf dem
Bildschirm dargestellt wird, muessen noch ein paar zusaetzliche Werte
eingestellt werden.

Mit SetWinPos() wird der Offset des Edit-Fenster zum Lineal eingestellt.
Dabei kann auch die Breite des Fensters eingestellt werden. Wenn bei den
Werten 0 uebergeben wird, wird die Position/Breite vom Fenster automatisch
so breit gesetzt, wie das Lineal breit ist.

Mit SetPagePos() wird der Offset der Seite zum Edit-Fenster eingestellt und
die Breite der Seite eingestellt. Wenn bei den Werten 0 uebergeben wird,
wird die Position/Breite automatisch so gesetzt, als ob die Seite das ganze
Editfenster ausfuellen wuerde.

Mit SetBorderPos() kann der Offset eingestellt werden, ab dem der
Border ausgegeben wird. Die Position bezieht sich auf die linke bzw. obere
Fensterkante. Dies wird gebraucht, wenn ein horizontales und vertikales
Lineal gleichzeitig sichtbar sind. Beispiel:
        aHRuler.SetBorderPos( aVRuler.GetSizePixel().Width()-1 );

Mit SetNullOffset() wird der Null-Punkt bezogen auf die Seite gesetzt.

Alle anderen Werte (Raender, Einzug, Tabs, ...) beziehen sich auf den 0 Punkt,
der mit SetNullOffset() eingestellt wird.

Die Werte werden zum Beispiel folgendermassen berechnet:

- WinPos (wenn beide Fenster den gleichen Parent haben)

    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() );

- Alle anderen Werte

    Die logischen Werte zusammenaddieren, als Position umrechnen und
    die vorher gemerkten Pixel-Positionen (von PagePos und NullOffset)
    entsprechend abziehen.

--------------------------------------------------------------------------

Mit SetUnit() und SetZoom() wird eingestellt, in welcher Einheit das Lineal
die Werte anzeigt. Folgende Einheiten werden akzeptiert:

    FUNIT_MM
    FUNIT_CM (Default)
    FUNIT_M
    FUNIT_KM
    FUNIT_INCH
    FUNIT_FOOT
    FUNIT_MILE
    FUNIT_POINT
    FUNIT_PICA

--------------------------------------------------------------------------

Mit SetMargin1() kann der linke/obere Rand und mit SetMargin2() kann
der rechte/untere Rand gesetzt werden. Falls diese Methoden ohne Parameter
aufgerufen werden, werden keine Raender angezeigt. Wenn SetMargin1() bzw.
SetMargin2() mit Parametern aufgerufen werden, kann bei diesen
folgendes angegeben werden:

    long    nPos            - Offset zum NullPunkt in Pixel
    USHORT  nStyle          - Bit-Style:
                                RULER_MARGIN_SIZEABLE
                                Rand kann in der Groesse veraendert werden.

                                Zu diesen Style's koennen folgende Style-
                                Bits dazugeodert werden:
                                RULER_STYLE_INVISIBLE (fuer nicht sichtbar)


Mit SetBorders() kann ein Array von Raendern gesetzt werden. Dabei muss
ein Array vom Typ RulerBorder uebergeben werden, wobei folgende Werte
initialisiert werden muessen:

    long    nPos            - Offset zum NullPunkt in Pixel
    long    nWidth          - Breite des Spaltenabstands in Pixel (kann zum
                              Beispiel fuer Tabellenspalten auch 0 sein)
    USHORT  nStyle          - Bit-Style:
                                RULER_BORDER_SIZEABLE
                                Spaltenabstand kann in der Groesse veraendert
                                werden. Dieses Flag sollte nur gesetzt werden,
                                wenn ein Abstand in der Groesse geaendert wird
                                und nicht die Groesse einer Zelle.
                                RULER_BORDER_MOVEABLE
                                Spaltenabstand/Begrenzung kann verschoben
                                werden. Wenn Tabellenbegrenzungen verschoben
                                werden, sollte dieses Flag gesetzt werden und
                                nicht Sizeable. Denn Sizeable gibt an, das
                                ein Abstand vergroessert werden kann und nicht
                                eine einzelne Zelle in der Groesse geaendert
                                werden kann.
                                RULER_BORDER_VARIABLE
                                Nicht alle Spaltenabstande sind gleich
                                RULER_BORDER_TABLE
                                Tabellenrahmen. Wenn dieser Style gesetzt
                                wird, muss die Spaltenbreite 0 sein.
                                RULER_BORDER_SNAP
                                Hilfslinie / Fanglinie. Wenn dieser Style
                                gesetzt wird, muss die Spaltenbreite 0 sein.
                                RULER_BORDER_MARGIN
                                Margin. Wenn dieser Style gesetzt wird,
                                muss die Spaltenbreite 0 sein.

                                Zu diesen Style's koennen folgende Style-
                                Bits dazugeodert werden:
                                RULER_STYLE_INVISIBLE (fuer nicht sichtbar)

Mit SetIndents() kann ein Array von Indents gesetzt werden. Diese Methode darf
nur angewendet werden, wenn es sich um ein horizontales Lineal handelt. Als
Parameter muss ein Array vom Typ RulerIndent uebergeben werden, wobei folgende
Werte initialisiert werden muessen:

    long    nPos            - Offset zum NullPunkt in Pixel
    USHORT  nStyle          - Bit-Style:
                                RULER_INDENT_TOP    (Erstzeileneinzug)
                                RULER_INDENT_BOTTOM (Linker/Rechter Einzug)
                                RULER_INDENT_BORDER (Verical line that shows the border distance)
                                Zu diesen Style's koennen folgende Style-
                                Bits dazugeodert werden:
                                RULER_STYLE_DONTKNOW (fuer alte Position oder
                                                     fuer Uneindeutigkeit)
                                RULER_STYLE_INVISIBLE (fuer nicht sichtbar)

Mit SetTabs() kann ein Array von Tabs gesetzt werden. Diese Methode darf nur
angewendet werden, wenn es sich um ein horizontales Lineal handelt. Als
Parameter muss ein Array vom Typ RulerTab uebergeben werden, wobei folgende
Werte initialisiert werden muessen:

    long    nPos            - Offset zum NullPunkt in Pixel
    USHORT  nStyle          - Bit-Style:
                                RULER_TAB_DEFAULT (kann nicht selektiert werden)
                                RULER_TAB_LEFT
                                RULER_TAB_CENTER
                                RULER_TAB_RIGHT
                                RULER_TAB_DECIMAL
                                Zu diesen Style's koennen folgende Style-
                                Bits dazugeodert werden:
                                RULER_STYLE_DONTKNOW (fuer alte Position oder
                                                     fuer Uneindeutigkeit)
                                RULER_STYLE_INVISIBLE (fuer nicht sichtbar)

Mit SetLines() koennen Positionslinien im Lineal angezeigt werden. Dabei
muss ein Array vom Typ RulerLine uebergeben werden, wobei folgende Werte
initialisiert werden muessen:

    long    nPos            - Offset zum NullPunkt in Pixel
    USHORT  nStyle          - Bit-Style (muss zur Zeit immer 0 sein)

Mit SetArrows() koennen Bemassungspfeile im Lineal angezeigt werden. Wenn
Bemassungspfeile gesetzt werden, werden im Lineal auch keine Unterteilungen
mehr angezeigt. Deshalb sollten die Bemassungspfeile immer ueber die ganze
Linealbreite gesetzt werden. Dabei muss ein Array vom Typ RulerArrow
uebergeben werden, wobei folgende Werte initialisiert werden muessen:

    long    nPos            - Offset zum NullPunkt in Pixel
    long    nWidth          - Breite des Pfeils
    long    nLogWidth       - Breite des Pfeils in logischer Einheit
    USHORT  nStyle          - Bit-Style (muss zur Zeit immer 0 sein)

Mit SetSourceUnit() wird die Einheit eingestellt, in welcher die logischen
Werte vorliegen, die bei SetArrows() uebergeben werden. Dabei werden nur die
Einheiten MAP_TWIP und MAP_100TH_MM (default) akzeptiert.

--------------------------------------------------------------------------

Wenn auch vom Benutzer die Raender, Tabs, Border, ... ueber das Lineal
geaendert werden koennen, muss etwas mehr Aufwand getrieben werden. Dazu
muessen die Methoden StartDrag(), Drag() und EndDrag() ueberlagert werden.
Bei der Methode StartDrag() besteht die Moeglichkeit durch das zurueckgeben
von FALSE das Draggen zu verhindern. Im Drag-Handler muss die Drag-Position
abgefragt werden und die Werte muessen an die neue Position verschoben werden.
Dazu ruft man einfach die einzelnen Set-Methoden auf. Solange man sich
im Drag-Handler befindet, werden sich die Werte nur gemerkt und erst
danach das Lineal neu ausgegeben. Alle Handler koennen auch als Links ueber
entsprechende Set..Hdl()-Methoden gesetzt werden.

    - StartDrag()
        Wird gerufen, wenn das Draggen gestartet wird. Wenn FALSE
        zurueckgegeben wird, wird das Draggen nicht ausgefuehrt. Bei TRUE
        wird das Draggen zugelassen. Wenn der Handler nicht ueberlagert
        wird, wird FALSE zurueckgegeben.

    - EndDrag()
        Wird gerufen, wenn das Draggen beendet wird.

    - Drag()
        Wird gerufen, wenn gedragt wird.

    - Click()
        Dieser Handler wird gerufen, wenn kein Element angeklickt wurde.
        Die Position kann mit GetClickPos() abgefragt werden. Dadurch
        kann man zum Beispiel Tabs in das Lineal setzen. Nach Aufruf des
        Click-Handlers wird gegebenenfalls das Drag sofort ausgeloest. Dadurch
        ist es moeglich, einen neuen Tab im Click-Handler zu setzen und
        danach gleich zu verschieben.

    - DoubleClick()
        Dieser Handler wird gerufen, wenn ein DoubleClick ausserhalb des
        Extrafeldes gemacht wurde. Was angeklickt wurde, kann mit
        GetClickType(), GetClickAryPos() und GetClickPos() abgefragt werden.
        Somit kann man zum Beispiel den Tab-Dialog anzeigen, wenn ein
        Tab mit einem DoubleClick betaetigt wurde.

Im Drag-Handler kann man abfragen, was und wohin gedragt wurde. Dazu gibt
es folgende Abfrage-Methoden.

    - GetDragType()
        Liefert zurueck, was gedragt wird:
            RULER_TYPE_MARGIN1
            RULER_TYPE_MARGIN2
            RULER_TYPE_BORDER
            RULER_TYPE_INDENT
            RULER_TYPE_TAB

    - GetDragPos()
        Liefert die Pixel-Position bezogen auf den eingestellten Null-Offset
        zurueck, wohin der Anwender die Maus bewegt hat.

    - 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 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 USHORT, 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 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.

    - GetDocType()
        Dieser Methode wird die Position vom Dokumentfenster uebergeben und
        testet, was sich unter der Position befindet. Dabei kann wie bei
        StartDocDrag() der entsprechende Test auf ein bestimmtes Element
        eingeschraenkt werden. Im Gegensatz zu GetType() liefert diese
        Methode immer DontKnow zurueck, falls kein Element getroffen wurde.
        Falls man den HitTest selber durchfuehren moechte, kann man
        folgende Defines fuer die Toleranz benutzen (Werte gelten fuer
        eine Richtung):
            RULER_MOUSE_TABLEWIDTH      - fuer Tabellenspalten
            RULER_MOUSE_MARGINWIDTH     - fuer Margins

--------------------------------------------------------------------------

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)
            - USHORT 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   ((USHORT)0x8000)
#define RULER_STYLE_DONTKNOW    ((USHORT)0x4000)
#define RULER_STYLE_INVISIBLE   ((USHORT)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_TABLEWIDTH  1
#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   ((USHORT)0x0001)

// ---------------
// - RulerBorder -
// ---------------

#define RULER_BORDER_SIZEABLE   ((USHORT)0x0001)
#define RULER_BORDER_MOVEABLE   ((USHORT)0x0002)
#define RULER_BORDER_VARIABLE   ((USHORT)0x0004)
#define RULER_BORDER_TABLE      ((USHORT)0x0008)
#define RULER_BORDER_SNAP       ((USHORT)0x0010)
#define RULER_BORDER_MARGIN     ((USHORT)0x0020)

struct RulerBorder
{
    long    nPos;
    long    nWidth;
    USHORT  nStyle;
    //minimum/maximum position, supported for table borders/rows
    long    nMinPos;
    long    nMaxPos;
};

// ---------------
// - RulerIndent -
// ---------------

#define RULER_INDENT_TOP        ((USHORT)0x0000)
#define RULER_INDENT_BOTTOM     ((USHORT)0x0001)
#define RULER_INDENT_BORDER     ((USHORT)0x0002)
#define RULER_INDENT_STYLE      ((USHORT)0x000F)

struct RulerIndent
{
    long    nPos;
    USHORT  nStyle;
};

// ------------
// - RulerTab -
// ------------

#define RULER_TAB_LEFT          ((USHORT)0x0000)
#define RULER_TAB_RIGHT         ((USHORT)0x0001)
#define RULER_TAB_DECIMAL       ((USHORT)0x0002)
#define RULER_TAB_CENTER        ((USHORT)0x0003)
#define RULER_TAB_DEFAULT       ((USHORT)0x0004)
#define RULER_TAB_STYLE         ((USHORT)0x000F)
#define RULER_TAB_RTL           ((USHORT)0x0010)

struct RulerTab
{
    long    nPos;
    USHORT  nStyle;
};

#define RULER_TAB_WIDTH         7
#define RULER_TAB_HEIGHT        6

// -------------
// - RulerLine -
// -------------

struct RulerLine
{
    long    nPos;
    USHORT  nStyle;
};

// --------------
// - RulerArrow -
// --------------

struct RulerArrow
{
    long    nPos;
    long    nWidth;
    long    nLogWidth;
    USHORT  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;
    ULONG               mnUpdateEvtId;
    ImplRulerData*      mpSaveData;
    ImplRulerData*      mpData;
    ImplRulerData*      mpDragData;
    Rectangle           maExtraRect;
    WinBits             mnWinStyle;
    USHORT              mnUnitIndex;
    USHORT              mnDragAryPos;
    USHORT              mnDragSize;
    USHORT              mnDragScroll;
    USHORT              mnDragModifier;
    USHORT              mnExtraStyle;
    USHORT              mnExtraClicks;
    USHORT              mnExtraModifier;
// Amelia
    long                mnCharWidth;
    long                mnLineHeight;

    RulerExtra          meExtraType;
    RulerType           meDragType;
    MapUnit             meSourceUnit;
    FieldUnit           meUnit;
    Fraction            maZoom;
    BOOL                mbCalc;
    BOOL                mbFormat;
    BOOL                mbDrag;
    BOOL                mbDragDelete;
    BOOL                mbDragCanceled;
    BOOL                mbAutoWinWidth;
    BOOL                mbActive;
    BYTE                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 );

    SVT_DLLPRIVATE void                ImplDrawTicks( long nMin, long nMax, long nStart, long nCenter );
    SVT_DLLPRIVATE void                ImplDrawArrows( long nCenter );
    SVT_DLLPRIVATE void                ImplDrawBorders( long nMin, long nMax, long nVirTop, long nVirBottom );
    SVT_DLLPRIVATE void                ImplDrawIndent( const Polygon& rPoly, USHORT nStyle );
    SVT_DLLPRIVATE void                ImplDrawIndents( long nMin, long nMax, long nVirTop, long nVirBottom );
    SVT_DLLPRIVATE void                ImplDrawTab( OutputDevice* pDevice, const Point& rPos, USHORT 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( BOOL bFont, BOOL bForeground, BOOL bBackground );
    SVT_DLLPRIVATE void                ImplCalc();
    SVT_DLLPRIVATE void                ImplFormat();
    SVT_DLLPRIVATE void                ImplInitExtraField( BOOL bUpdate );
    SVT_DLLPRIVATE void                ImplInvertLines( BOOL bErase = FALSE );
    SVT_DLLPRIVATE void                ImplDraw();
    SVT_DLLPRIVATE void                ImplDrawExtra( BOOL bPaint = FALSE );
    SVT_DLLPRIVATE void                ImplUpdate( BOOL bMustCalc = FALSE );
    using Window::ImplHitTest;
    SVT_DLLPRIVATE BOOL                ImplHitTest( const Point& rPos,
                                     ImplRulerHitTest* pHitTest,
                                     BOOL bRequiredStyle = FALSE,
                                     USHORT nRequiredStyle = 0 ) const;
    SVT_DLLPRIVATE BOOL                ImplDocHitTest( const Point& rPos, RulerType eDragType, ImplRulerHitTest* pHitTest ) const;
    SVT_DLLPRIVATE BOOL                ImplStartDrag( ImplRulerHitTest* pHitTest, USHORT 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 &);

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();
    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, USHORT nStyle = 0 );
    RulerExtra          GetExtraType() const { return meExtraType; }
    USHORT              GetExtraStyle()  const { return mnExtraStyle; }
    USHORT              GetExtraClicks() const { return mnExtraClicks; }
    USHORT              GetExtraModifier() const { return mnExtraModifier; }

    BOOL                StartDocDrag( const MouseEvent& rMEvt,
                                      RulerType eDragType = RULER_TYPE_DONTKNOW );
    RulerType           GetDocType( const Point& rPos,
                                    RulerType eDragType = RULER_TYPE_DONTKNOW,
                                    USHORT* pAryPos = NULL ) const;
    RulerType           GetDragType() const { return meDragType; }
    long                GetDragPos() const { return mnDragPos; }
    USHORT              GetDragAryPos() const { return mnDragAryPos; }
    USHORT              GetDragSize() const { return mnDragSize; }
    BOOL                IsDragDelete() const { return mbDragDelete; }
    BOOL                IsDragCanceled() const { return mbDragCanceled; }
    USHORT              GetDragScroll() const { return mnDragScroll; }
    USHORT              GetDragModifier() const { return mnDragModifier; }
    BOOL                IsDrag() const { return mbDrag; }
    void                CancelDrag();
    long                GetClickPos() const { return mnDragPos; }
    RulerType           GetClickType() const { return meDragType; }
    USHORT              GetClickAryPos() const { return mnDragAryPos; }
    using Window::GetType;
    RulerType           GetType( const Point& rPos,
                                 USHORT* pAryPos = NULL ) const;

    void                SetNullOffset( long nPos );
    long                GetNullOffset() const;
    void                SetMargin1() { SetMargin1( 0, RULER_STYLE_INVISIBLE ); }
    void                SetMargin1( long nPos, USHORT nMarginStyle = RULER_MARGIN_SIZEABLE );
    long                GetMargin1() const;
    USHORT              GetMargin1Style() const;
    void                SetMargin2() { SetMargin2( 0, RULER_STYLE_INVISIBLE ); }
    void                SetMargin2( long nPos, USHORT nMarginStyle = RULER_MARGIN_SIZEABLE );
    long                GetMargin2() const;
    USHORT              GetMargin2Style() const;

    void                SetLines( USHORT n = 0, const RulerLine* pLineAry = NULL );
    USHORT              GetLineCount() const;
    const RulerLine*    GetLines() const;

    void                SetArrows( USHORT n = 0, const RulerArrow* pArrowAry = NULL );
    USHORT              GetArrowCount() const;
    const RulerArrow*   GetArrows() const;

    void                SetBorders( USHORT n = 0, const RulerBorder* pBrdAry = NULL );
    USHORT              GetBorderCount() const;
    const RulerBorder*  GetBorders() const;

    void                SetIndents( USHORT n = 0, const RulerIndent* pIndentAry = NULL );
    USHORT              GetIndentCount() const;
    const RulerIndent*  GetIndents() const;

    void                SetTabs( USHORT n = 0, const RulerTab* pTabAry = NULL );
    USHORT              GetTabCount() const;
    const RulerTab*     GetTabs() const;

    static void         DrawTab( OutputDevice* pDevice,
                                 const Point& rPos, USHORT 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(BOOL bRTL);

    void                SetCharWidth( long nWidth ) { mnCharWidth = nWidth ; }
    void                SetLineHeight( long nHeight ) { mnLineHeight = nHeight ; }
};

#endif  // _RULER_HXX