Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 : #ifndef _RULER_HXX
21 : #define _RULER_HXX
22 :
23 : #include <svtools/svtdllapi.h>
24 : #include <tools/link.hxx>
25 : #include <vcl/window.hxx>
26 : #include <vcl/virdev.hxx>
27 : #include <vcl/field.hxx>
28 :
29 : #include <boost/scoped_ptr.hpp>
30 :
31 : #include <svtools/accessibleruler.hxx>
32 :
33 : class MouseEvent;
34 : class TrackingEvent;
35 : class DataChangedEvent;
36 :
37 : /*************************************************************************
38 :
39 : Description
40 : ============
41 :
42 : class Ruler
43 :
44 : This class is used for displaying a ruler, but it can also be used
45 : for setting or moving tabs and margins.
46 :
47 : --------------------------------------------------------------------------
48 :
49 : WinBits
50 :
51 : WB_HORZ ruler is displayed horizontally
52 : WB_VERT ruler is displayed vertically
53 : WB_3DLOOK 3D look
54 : WB_BORDER border at the bottom/right margin
55 : WB_EXTRAFIELD Field in the upper left corner for
56 : displaying and selecting tabs, origin of coordinates, ...
57 : WB_RIGHT_ALIGNED Marks the vertical ruler as right aligned
58 :
59 : --------------------------------------------------------------------------
60 :
61 : All ruler parameters are set in pixel units. This way double conversions
62 : and rounding errors are avoided and the ruler displays the margins
63 : at their actual position in the document. Because of this, the application can,
64 : for example in tables, do its own roundings and the positions on the ruler will
65 : still match those in the document. However, for the ruler to know how the
66 : document is displayed on the screen, some additional values have to be configured
67 :
68 : SetWinPos() sets the offset of the ruler's edit window. In doing so,
69 : the width of the window can also be configured. If there is a 0 among the
70 : values passed to the function, the position/width is automatically set to
71 : the width of the ruler.
72 :
73 : SetPagePos() sets the offset of the page relative to the edit window and the
74 : width of the page. If there is a 0 among the values passed to the function,
75 : the position/width is automatically set as if the page filled the whole edit window.
76 :
77 : SetBorderPos() sets the offset of the border. The position is relative to
78 : the upper/left margin of the window. This is needed when there are a horizontal
79 : and a vertical ruler visible at the same time. Example:
80 : aHRuler.SetBorderPos( aVRuler.GetSizePixel().Width()-1 );
81 :
82 : SetNullOffset() sets the origin relative to the page.
83 :
84 : All the other values (margins, indentation, tabs, ...) refer to the origin,
85 : which is set with SetNullOffset().
86 :
87 : The values are computed as described below:
88 :
89 : - WinPos (if both windows have the same parent)
90 :
91 : Point aHRulerPos = aHRuler.GetPosPixel();
92 : Point aEditWinPos = aEditWin.GetPosPixel();
93 : aHRuler.SetWinPos( aEditWinPos().X() - aHRulerPos.X() );
94 :
95 : - PagePos
96 :
97 : Point aPagePos = aEditWin.LogicToPixel( aEditWin.GetPagePos() );
98 : aHRuler.SetPagePos( aPagePos().X() );
99 :
100 : - All other values
101 :
102 : Add the logical values, recompute as position and subtract the
103 : previously saved pixel positions (of PagePos and Null Offset).
104 :
105 : --------------------------------------------------------------------------
106 :
107 : SetUnit() and SetZoom() configure which unit is used to display
108 : the values on the ruler. The following units are accepted:
109 :
110 : FUNIT_MM
111 : FUNIT_CM (Default)
112 : FUNIT_M
113 : FUNIT_KM
114 : FUNIT_INCH
115 : FUNIT_FOOT
116 : FUNIT_MILE
117 : FUNIT_POINT
118 : FUNIT_PICA
119 :
120 : --------------------------------------------------------------------------
121 :
122 : SetMargin1() sets the upper/left margin and SetMargin2() sets the
123 : bottom/right margin. If these methods are called without arguments,
124 : no margins are displayed. Otherwise, the following arguments can be passed:
125 :
126 : long nPos - offset in pixels relative to the origin
127 : sal_uInt16 nStyle - bit style:
128 : RULER_MARGIN_SIZEABLE
129 : margin size can be changed
130 :
131 : The following bits can be set in addition
132 : to these styles:
133 : RULER_STYLE_INVISIBLE
134 :
135 :
136 : SetBorders() sets an array of margins. To do this, an array of type RulerBorder
137 : has to be passed. In the array, the following values have to be initialized:
138 :
139 : long nPos - offset in pixels relative to the origin
140 : long nWidth - column spacing in pixels (can also be 0, for example,
141 : for table columns)
142 : sal_uInt16 nStyle - bit style:
143 : RULER_BORDER_SIZEABLE
144 : Column spacing can be changed. This flag should
145 : only be set if the size of the spacing is changed,
146 : not that of a cell.
147 : RULER_BORDER_MOVEABLE
148 : Column spacing/border can be moved. Whenever
149 : table borders are to be moved, this flag should
150 : be set instead of SIZEABLE (SIZEABLE indicates
151 : that the size of a spacing, not that of a single
152 : cell can be changed).
153 : RULER_BORDER_VARIABLE
154 : Not all of the column spacings are equal
155 : RULER_BORDER_TABLE
156 : Table border. Whenever this style is set, the column
157 : width must be 0.
158 : RULER_BORDER_SNAP
159 : Auxiliary line. Whenever this style is set, the
160 : column width must be 0.
161 : RULER_BORDER_MARGIN
162 : Margin. Whenever this style is set, the column
163 : width must be 0.
164 :
165 : The following bits can be set in addition
166 : to these styles:
167 : RULER_STYLE_INVISIBLE
168 :
169 : SetIndents() sets an array of indents. This method may only be used for horizontal
170 : rulers. A Ruler Indent must be passed as an argument, with the following values
171 : initialized:
172 :
173 : long nPos - offset relative to the origin in pixels
174 : sal_uInt16 nStyle - bit style:
175 : RULER_INDENT_TOP (indent of the first line)
176 : RULER_INDENT_BOTTOM (left/right indent)
177 : RULER_INDENT_BORDER (Vertical line that shows the border distance)
178 : The following bits can be set in addition
179 : to these styles:
180 : RULER_STYLE_DONTKNOW (for old position or for
181 : ambiguity)
182 : RULER_STYLE_INVISIBLE
183 :
184 : SetTabs() sets an array of tabs. This method may only be used for horizontal rulers.
185 : An array of type RulerTab must be passed as an argument, with the following values
186 : initialized:
187 :
188 : long nPos - offset relative to the origin in pixels
189 : sal_uInt16 nStyle - bit style:
190 : RULER_TAB_DEFAULT (can't be selected)
191 : RULER_TAB_LEFT
192 : RULER_TAB_CENTER
193 : RULER_TAB_RIGHT
194 : RULER_TAB_DECIMAL
195 : The following bits can be set in addition
196 : to these styles:
197 : RULER_STYLE_DONTKNOW (for old position of for
198 : ambiguity)
199 : RULER_STYLE_INVISIBLE
200 :
201 : SetLines() displays position lines in the ruler. An array of type RulerLine must be passed, with
202 : the following values initialized:
203 :
204 : long nPos - offset relative to the origin in pixels
205 : sal_uInt16 nStyle - bit style (has to be 0 currently)
206 :
207 : --------------------------------------------------------------------------
208 :
209 : If the user should also be able to change the margins tabs, borders, ...
210 : in the ruler, a bit more effort is necessary. In this case, the StartDrag(),
211 : Drag() and EndDrag() methods have to be overridden. For the StartDrag() method
212 : it is possible to prevent dragging by returning FALSE. In the drag handler,
213 : the drag position must be queried and the values must be moved to the new
214 : position. This is done by calling the particular Set methods. While in the
215 : drag handler, the values are just cached and only afterward the ruler is redrawn.
216 : All the handlers can also be set as links with the particular Set..Hdl() methods.
217 :
218 : - StartDrag()
219 : Is called when dragging is started. If FALSE is returned, the dragging.
220 : won't be executed. If TRUE is returned, the dragging will be permitted.
221 : If the handler isn't overridden, FALSE will be returned.
222 :
223 : - EndDrag()
224 : Is called at the end of dragging.
225 :
226 : - Drag()
227 : Is called when dragging takes place.
228 :
229 : - Click()
230 : This handler is called when no element has been clicked on.
231 : The position can be queried with GetClickPos(). This way it is possible
232 : to, for example, ser tabs in the ruler. After calling the click handler,
233 : the drag, if any, is immediately triggered. This makes it possible to
234 : set a new tab in the click handler and then immediately move it.
235 :
236 : - DoubleClick()
237 : This handler is called when a double-click has been performed outside
238 : the special panel. The methods GetClickType(), GetClickAryPos() and
239 : GetClickPos() can be used to query what has been clicked on.
240 : This way you can, for example, show the tab dialog when a double-click
241 : is performed on a tab.
242 :
243 : In the drag handler it is possible to query what has been dragged and where
244 : it has been dragged. There are the following query methods:
245 :
246 : - GetDragType()
247 : Returns what has been dragged.
248 : RULER_TYPE_MARGIN1
249 : RULER_TYPE_MARGIN2
250 : RULER_TYPE_BORDER
251 : RULER_TYPE_INDENT
252 : RULER_TYPE_TAB
253 :
254 : - GetDragPos()
255 : Returns the pixel position to which the user has moved the mouse
256 : relative to the set zero-offset.
257 :
258 : - GetDragAryPos()
259 : Liefert den Index im Array zurueck, wenn ein Border, Indent oder ein
260 : Tab gedragt wird. Achtung: Es wird die Array-Position waehrend des
261 : gesammten Drag-Vorgangs von dem Item im Array was vor dem Drag gesetzt
262 : war zurueckgeben. Dadurch ist es zum Beispiel auch moeglich, einen
263 : Tab nicht mehr anzuzeigen, wenn die Maus nach unten/rechts aus dem
264 : Lineal gezogen wird.
265 :
266 : - GetDragSize()
267 : Wenn Borders gedragt werden, kann hierueber abgefragt werden, ob
268 : die Groesse bzw. welche Seite oder die Position geaendert werden soll.
269 : RULER_DRAGSIZE_MOVE oder 0 - Move
270 : RULER_DRAGSIZE_1 - Linke/obere Kante
271 : RULER_DRAGSIZE_2 - Rechte/untere Kante
272 :
273 : - IsDragDelete()
274 : Mit dieser Methode kann abgefragt werden, ob beim Draggen die
275 : Maus unten/rechts aus dem Fenster gezogen wurde. Damit kann
276 : zum Beispiel festgestellt werden, ob der Benutzer einen Tab
277 : loeschen will.
278 :
279 : - IsDragCanceled()
280 : Mit dieser Methode kann im EndDrag-Handler abgefragt werden,
281 : ob die Aktion abgebrochen wurde, indem der Anwender die
282 : Maus oben/links vom Fenster losgelassen hat oder ESC gedrueckt
283 : hat. In diesem Fall werden die Werte nicht uebernommen. Wird
284 : waehrend des Draggings die Maus oben/links aus dem Fenster
285 : gezogen, werden automatisch die alten Werte dargestellt, ohne das
286 : der Drag-Handler gerufen wird.
287 : Falls der Benutzer jedoch den Wert auf die alte Position
288 : zurueckgeschoben hat, liefert die Methode trotzdem sal_False. Falls
289 : dies vermieden werden soll, muss sich die Applikation im StartDrag-
290 : Handler den alten Wert merken und im EndDrag-Handler den Wert
291 : vergleichen.
292 :
293 : - GetDragScroll()
294 : Mit dieser Methode kann abgefragt werden, ob gescrollt werden
295 : soll. Es wird einer der folgenden Werte zurueckgegeben:
296 : RULER_SCROLL_NO - Drag-Position befindet sich
297 : an keinem Rand und somit
298 : muss nicht gescrollt werden.
299 : RULER_SCROLL_1 - Drag-Position befindet sich
300 : am linken/oberen Rand und
301 : somit sollte das Programm evt.
302 : ein Srcoll ausloesen.
303 : RULER_SCROLL_2 - Drag-Position befindet sich
304 : am rechten/unteren Rand und
305 : somit sollte das Programm evt.
306 : ein Srcoll ausloesen.
307 :
308 : - GetDragModifier()
309 : Liefert die Modifier-Tasten zurueck, die beim Starten des Drag-
310 : Vorgangs gedrueckt waren. Siehe MouseEvent.
311 :
312 : - GetClickPos()
313 : Liefert die Pixel-Position bezogen auf den eingestellten Null-Offset
314 : zurueck, wo der Anwender die Maus gedrueckt hat.
315 :
316 : - GetClickType()
317 : Liefert zurueck, was per DoubleClick betaetigt wird:
318 : RULER_TYPE_DONTKNOW (kein Element im Linealbereich)
319 : RULER_TYPE_OUTSIDE (ausserhalb des Linealbereichs)
320 : RULER_TYPE_MARGIN1 (nur Margin1-Kante)
321 : RULER_TYPE_MARGIN2 (nur Margin2-Kante)
322 : RULER_TYPE_BORDER (Border: GetClickAryPos())
323 : RULER_TYPE_INDENT (Einzug: GetClickAryPos())
324 : RULER_TYPE_TAB (Tab: GetClickAryPos())
325 :
326 : - GetClickAryPos()
327 : Liefert den Index im Array zurueck, wenn ein Border, Indent oder ein
328 : Tab per DoubleClick betaetigt wird.
329 :
330 : - GetType()
331 : Mit dieser Methode kann man einen HitTest durchfuehren, um
332 : gegebenenfalls ueber das Abfangen des MouseButtonDown-Handlers
333 : auch ueber die rechte Maustaste etwas auf ein Item anzuwenden. Als
334 : Paramter ueber gibt man die Fensterposition und gegebenenfalls
335 : einen Pointer auf einen sal_uInt16, um die Array-Position eines
336 : Tabs, Indent oder Borders mitzubekommen. Als Type werden folgende
337 : Werte zurueckgegeben:
338 : RULER_TYPE_DONTKNOW (kein Element im Linealbereich)
339 : RULER_TYPE_OUTSIDE (ausserhalb des Linealbereichs)
340 : RULER_TYPE_MARGIN1 (nur Margin1-Kante)
341 : RULER_TYPE_MARGIN2 (nur Margin2-Kante)
342 : RULER_TYPE_BORDER (Border: GetClickAryPos())
343 : RULER_TYPE_INDENT (Einzug: GetClickAryPos())
344 : RULER_TYPE_TAB (Tab: GetClickAryPos())
345 :
346 : Wenn der Drag-Vorgang abgebrochen werden soll, kann der Drag-Vorgang
347 : mit CancelDrag() abgebrochen werden. Folgende Methoden gibt es fuer die
348 : Drag-Steuerung:
349 :
350 : - IsDrag()
351 : Liefert sal_True zurueck, wenn sich das Lineal im Drag-Vorgang befindet.
352 :
353 : - CancelDrag()
354 : Bricht den Drag-Vorgang ab, falls einer durchgefuehrt wird. Dabei
355 : werden die alten Werte wieder hergestellt und der Drag und der
356 : EndDrag-Handler gerufen.
357 :
358 : Um vom Dokument ein Drag auszuloesen, gibt es folgende Methoden:
359 :
360 : - StartDocDrag()
361 : Dieser Methode werden der MouseEvent vom Dokumentfenster und
362 : was gedragt werden soll uebergeben. Wenn als DragType
363 : RULER_TYPE_DONTKNOW uebergeben wird, bestimmt das Lineal, was
364 : verschoben werden soll. Bei den anderen, wird der Drag nur dann
365 : gestartet, wenn auch an der uebergebenen Position ein entsprechendes
366 : Element gefunden wurde. Dies ist zun Beispiel dann notwendig, wenn
367 : zum Beispiel Einzuege und Spalten an der gleichen X-Position liegen.
368 : Der Rueckgabewert gibt an, ob der Drag ausgeloest wurde. Wenn ein
369 : Drag ausgeloest wird, uebernimmt das Lineal die normale Drag-Steuerung
370 : und verhaelt sich dann so, wie als wenn direkt in das Lineal geklickt
371 : wurde. So captured das Lineal die Mouse und uebernimmt auch die
372 : Steuerung des Cancel (ueber Tastatur, oder wenn die Mouse ueber
373 : oder links vom Lineal ruasgeschoben wird). Auch alle Handler werden
374 : gerufen (inkl. des StartDrag-Handlers). Wenn ein MouseEvent mit
375 : Click-Count 2 uebergeben wird auch der DoubleClick-Handler
376 : entsprechend gerufen.
377 :
378 : --------------------------------------------------------------------------
379 :
380 : Fuer das Extra-Feld kann der Inhalt bestimmt werden und es gibt Handler,
381 : womit man bestimmte Aktionen abfangen kann.
382 :
383 : - ExtraDown()
384 : Dieser Handler wird gerufen, wenn im Extra-Feld die Maus
385 : gedrueckt wird.
386 :
387 : - SetExtraType()
388 : Mit dieser Methode kann festgelegt werden, was im ExtraFeld
389 : dargestellt werden soll.
390 : - ExtraType Was im Extrafeld dargestellt werden soll
391 : RULER_EXTRA_DONTKNOW (Nichts)
392 : RULER_EXTRA_NULLOFFSET (Koordinaaten-Kreuz)
393 : RULER_EXTRA_TAB (Tab)
394 : - sal_uInt16 nStyle Bitfeld als Style:
395 : RULER_STYLE_HIGHLIGHT (selektiert)
396 : RULER_TAB_... (ein Tab-Style)
397 :
398 : - GetExtraClick()
399 : Liefert die Anzahl der Mausclicks zurueck. Dadurch ist es zum
400 : Beispiel auch moeglich, auch durch einen DoubleClick im Extrafeld
401 : eine Aktion auszuloesen.
402 :
403 : - GetExtraModifier()
404 : Liefert die Modifier-Tasten zurueck, die beim Klicken in das Extra-
405 : Feld gedrueckt waren. Siehe MouseEvent.
406 :
407 : --------------------------------------------------------------------------
408 :
409 : Weitere Hilfsfunktionen:
410 :
411 : - static Ruler::DrawTab()
412 : Mit dieser Methode kann ein Tab auf einem OutputDevice ausgegeben
413 : werden. Dadurch ist es moeglich, auch in Dialogen die Tabs so
414 : anzuzeigen, wie Sie im Lineal gemalt werden.
415 :
416 : Diese Methode gibt den Tab zentriert an der uebergebenen Position
417 : aus. Die Groesse der Tabs kann ueber die Defines RULER_TAB_WIDTH und
418 : RULER_TAB_HEIGHT bestimmt werden.
419 :
420 : --------------------------------------------------------------------------
421 :
422 : Tips zur Benutzung des Lineals:
423 :
424 : - Bei dem Lineal muss weder im Drag-Modus noch sonst das Setzen der Werte
425 : in SetUpdateMode() geklammert werden. Denn das Lineal sorgt von sich
426 : aus dafuer, das wenn mehrere Werte gesetzt werden, diese automatisch
427 : zusammengefast werden und flackerfrei ausgegeben werden.
428 :
429 : - Initial sollten beim Lineal zuerst die Groessen, Positionen und Werte
430 : gesetzt werden, bevor es angezeigt wird. Dies ist deshalb wichtig, da
431 : ansonsten viele Werte unnoetig berechnet werden.
432 :
433 : - Wenn das Dokumentfenster, in dem sich das Lineal befindet aktiv bzw.
434 : deaktiv wird, sollten die Methoden Activate() und Deactivate() vom
435 : Lineal gerufen werden. Denn je nach Einstellungen und System wird die
436 : Anzeige entsprechend umgeschaltet.
437 :
438 : - Zum Beispiel sollte beim Drag von Tabs und Einzuegen nach Moeglichkeit die
439 : alten Positionen noch mit angezeigt werden. Dazu sollte zusaetzlich beim
440 : Setzen der Tabs und Einzuege als erstes im Array die alten Positionen
441 : eingetragen werden und mit dem Style RULER_STYLE_DONTKNOW verknuepft
442 : werden. Danach sollte im Array die restlichen Werte eingetragen werden.
443 :
444 : - Bei mehreren markierten Absaetzen und Tabellen-Zellen, sollten die Tabs
445 : und Einzuege in grau von der ersten Zelle, bzw. vom ersten Absatz
446 : angezeigt werden. Dies kann man auch ueber den Style RULER_STYLE_DONTKNOW
447 : erreichen.
448 :
449 : - Die Bemassungspfeile sollten immer dann angezeigt, wenn beim Drag die
450 : Alt-Taste (WW-Like) gedrueckt wird. Vielleicht sollte diese Einstellung
451 : auch immer vornehmbar sein und vielleicht beim Drag immer die
452 : Bemassungspfeile dargestellt werden. Bei allen Einstellung sollten die
453 : Werte immer auf ein vielfaches eines Wertes gerundet werden, da die
454 : Bildschirmausloesung sehr ungenau ist.
455 :
456 : - DoppelKlicks sollten folgendermassen behandelt werden (GetClickType()):
457 : - RULER_TYPE_DONTKNOW
458 : RULER_TYPE_MARGIN1
459 : RULER_TYPE_MARGIN2
460 : Wenn die Bedingunden GetClickPos() <= GetMargin1() oder
461 : GetClickPos() >= GetMargin2() oder der Type gleich
462 : RULER_TYPE_MARGIN1 oder RULER_TYPE_MARGIN2 ist, sollte
463 : ein SeitenDialog angezeigt werden, wo der Focus auf dem
464 : entsprechenden Rand steht
465 : - RULER_TYPE_BORDER
466 : Es sollte ein Spalten- oder Tabellen-Dialog angezeigt werden,
467 : wo der Focus auf der entsprechenden Spalte steht, die mit
468 : GetClickAryPos() abgefragt werden kann.
469 : - RULER_TYPE_INDENT
470 : Es sollte der Dialog angezeigt werden, wo die Einzuege eingestellt
471 : werden koennen. Dabei sollte der Focus auf dem Einzug stehen, der
472 : mit GetClickAryPos() ermittelt werden kann.
473 : - RULER_TYPE_TAB
474 : Es sollte ein TabDialog angezeigt werden, wo der Tab selektiert
475 : sein sollte, der ueber GetClickAryPos() abgefragt werden kann.
476 :
477 : *************************************************************************/
478 :
479 : // - WinBits -
480 :
481 : #define WB_EXTRAFIELD ((WinBits)0x00004000)
482 : #define WB_RIGHT_ALIGNED ((WinBits)0x00008000)
483 : #define WB_STDRULER WB_HORZ
484 :
485 : // - Ruler-Type -
486 :
487 : enum RulerType { RULER_TYPE_DONTKNOW, RULER_TYPE_OUTSIDE,
488 : RULER_TYPE_MARGIN1, RULER_TYPE_MARGIN2,
489 : RULER_TYPE_BORDER, RULER_TYPE_INDENT, RULER_TYPE_TAB };
490 :
491 : enum RulerExtra { RULER_EXTRA_DONTKNOW,
492 : RULER_EXTRA_NULLOFFSET, RULER_EXTRA_TAB };
493 :
494 : #define RULER_STYLE_HIGHLIGHT ((sal_uInt16)0x8000)
495 : #define RULER_STYLE_DONTKNOW ((sal_uInt16)0x4000)
496 : #define RULER_STYLE_INVISIBLE ((sal_uInt16)0x2000)
497 :
498 : #define RULER_DRAGSIZE_MOVE 0
499 : #define RULER_DRAGSIZE_1 1
500 : #define RULER_DRAGSIZE_2 2
501 :
502 : #define RULER_MOUSE_BORDERMOVE 5
503 : #define RULER_MOUSE_BORDERWIDTH 5
504 : #define RULER_MOUSE_MARGINWIDTH 3
505 :
506 : #define RULER_SCROLL_NO 0
507 : #define RULER_SCROLL_1 1
508 : #define RULER_SCROLL_2 2
509 :
510 : // - RulerMargin -
511 :
512 : #define RULER_MARGIN_SIZEABLE ((sal_uInt16)0x0001)
513 :
514 : // - RulerBorder -
515 :
516 : #define RULER_BORDER_SIZEABLE ((sal_uInt16)0x0001)
517 : #define RULER_BORDER_MOVEABLE ((sal_uInt16)0x0002)
518 : #define RULER_BORDER_VARIABLE ((sal_uInt16)0x0004)
519 : #define RULER_BORDER_TABLE ((sal_uInt16)0x0008)
520 : #define RULER_BORDER_SNAP ((sal_uInt16)0x0010)
521 : #define RULER_BORDER_MARGIN ((sal_uInt16)0x0020)
522 :
523 : struct RulerBorder
524 : {
525 : long nPos;
526 : long nWidth;
527 : sal_uInt16 nStyle;
528 : long nMinPos; //minimum/maximum position, supported for table borders/rows
529 : long nMaxPos;
530 : };
531 :
532 : // - RulerIndent -
533 :
534 : #define RULER_INDENT_TOP ((sal_uInt16)0x0000)
535 : #define RULER_INDENT_BOTTOM ((sal_uInt16)0x0001)
536 : #define RULER_INDENT_BORDER ((sal_uInt16)0x0002)
537 : #define RULER_INDENT_STYLE ((sal_uInt16)0x000F)
538 :
539 : struct RulerIndent
540 : {
541 : long nPos;
542 : sal_uInt16 nStyle;
543 : };
544 :
545 : // - RulerTab -
546 :
547 : #define RULER_TAB_LEFT ((sal_uInt16)0x0000)
548 : #define RULER_TAB_RIGHT ((sal_uInt16)0x0001)
549 : #define RULER_TAB_CENTER ((sal_uInt16)0x0002)
550 : #define RULER_TAB_DECIMAL ((sal_uInt16)0x0003)
551 : #define RULER_TAB_DEFAULT ((sal_uInt16)0x0004)
552 : #define RULER_TAB_STYLE ((sal_uInt16)0x000F)
553 : #define RULER_TAB_RTL ((sal_uInt16)0x0010)
554 :
555 : struct RulerTab
556 : {
557 : long nPos;
558 : sal_uInt16 nStyle;
559 : };
560 :
561 : #define RULER_TAB_WIDTH 7
562 : #define RULER_TAB_HEIGHT 6
563 :
564 : // - RulerLine -
565 :
566 : struct RulerLine
567 : {
568 : long nPos;
569 : sal_uInt16 nStyle;
570 : };
571 :
572 : struct RulerSelection
573 : {
574 : long nPos;
575 : RulerType eType;
576 : sal_uInt16 nAryPos;
577 : sal_uInt16 mnDragSize;
578 : bool bSize;
579 : bool bSizeBar;
580 : bool bExpandTest;
581 :
582 0 : RulerSelection()
583 : : nPos(0)
584 : , eType(RULER_TYPE_DONTKNOW)
585 : , nAryPos(0)
586 : , mnDragSize(0)
587 : , bSize(false)
588 : , bSizeBar(false)
589 0 : , bExpandTest( false )
590 0 : {}
591 : };
592 :
593 : struct RulerUnitData
594 : {
595 : MapUnit eMapUnit; // MAP_UNIT for calculaion
596 : long nTickUnit; // Unit divider
597 : double nTick1; // Minimal step
598 : double nTick2; // Tick quarter unit
599 : double nTick3; // Tick half unit
600 : double nTick4; // Tick whole unit
601 : long n100THMM; // 100mm Unit divider
602 : sal_uInt16 nUnitDigits; // Number of digits
603 : sal_Char aUnitStr[8]; // Unit string
604 : };
605 :
606 : // - Ruler -
607 :
608 : class ImplRulerData;
609 :
610 : class SVT_DLLPUBLIC Ruler : public Window
611 : {
612 : private:
613 : VirtualDevice maVirDev;
614 : MapMode maMapMode;
615 : long mnBorderOff;
616 : long mnWinOff;
617 : long mnWinWidth;
618 : long mnWidth;
619 : long mnHeight;
620 : long mnVirOff;
621 : long mnVirWidth;
622 : long mnVirHeight;
623 : long mnBorderWidth;
624 : long mnStartDragPos;
625 : long mnDragPos;
626 : sal_uLong mnUpdateEvtId;
627 : ImplRulerData* mpSaveData;
628 : ImplRulerData* mpData;
629 : ImplRulerData* mpDragData;
630 : Rectangle maExtraRect;
631 : WinBits mnWinStyle;
632 : sal_uInt16 mnUnitIndex;
633 : sal_uInt16 mnDragAryPos;
634 : sal_uInt16 mnDragSize;
635 : sal_uInt16 mnDragScroll;
636 : sal_uInt16 mnDragModifier;
637 : sal_uInt16 mnExtraStyle;
638 : sal_uInt16 mnExtraClicks;
639 : sal_uInt16 mnExtraModifier;
640 : long mnCharWidth;
641 : long mnLineHeight;
642 :
643 : RulerExtra meExtraType;
644 : RulerType meDragType;
645 : MapUnit meSourceUnit;
646 : FieldUnit meUnit;
647 : Fraction maZoom;
648 : bool mbCalc;
649 : bool mbFormat;
650 : bool mbDrag;
651 : bool mbDragDelete;
652 : bool mbDragCanceled;
653 : bool mbAutoWinWidth;
654 : bool mbActive;
655 : sal_uInt8 mnUpdateFlags;
656 :
657 : RulerSelection maHoverSelection;
658 :
659 : Link maStartDragHdl;
660 : Link maDragHdl;
661 : Link maEndDragHdl;
662 : Link maClickHdl;
663 : Link maDoubleClickHdl;
664 : Link maExtraDownHdl;
665 :
666 : boost::scoped_ptr<RulerSelection> mpCurrentHitTest;
667 : boost::scoped_ptr<RulerSelection> mpPreviousHitTest;
668 :
669 : SvtRulerAccessible* pAccContext;
670 :
671 : SVT_DLLPRIVATE void ImplVDrawLine( long nX1, long nY1, long nX2, long nY2 );
672 : SVT_DLLPRIVATE void ImplVDrawRect( long nX1, long nY1, long nX2, long nY2 );
673 : SVT_DLLPRIVATE void ImplVDrawText( long nX, long nY, const OUString& rText, long nMin = LONG_MIN, long nMax = LONG_MAX );
674 :
675 : SVT_DLLPRIVATE void ImplDrawTicks( long nMin, long nMax, long nStart, long nVirTop, long nVirBottom );
676 : SVT_DLLPRIVATE void ImplDrawBorders( long nMin, long nMax, long nVirTop, long nVirBottom );
677 : SVT_DLLPRIVATE void ImplDrawIndent( const Polygon& rPoly, sal_uInt16 nStyle, bool bIsHit = false );
678 : SVT_DLLPRIVATE void ImplDrawIndents( long nMin, long nMax, long nVirTop, long nVirBottom );
679 : SVT_DLLPRIVATE void ImplDrawTab( OutputDevice* pDevice, const Point& rPos, sal_uInt16 nStyle );
680 : SVT_DLLPRIVATE void ImplDrawTabs( long nMin, long nMax, long nVirTop, long nVirBottom );
681 :
682 : using Window::ImplInit;
683 : SVT_DLLPRIVATE void ImplInit( WinBits nWinBits );
684 : SVT_DLLPRIVATE void ImplInitSettings( bool bFont, bool bForeground, bool bBackground );
685 : SVT_DLLPRIVATE void ImplCalc();
686 : SVT_DLLPRIVATE void ImplFormat();
687 : SVT_DLLPRIVATE void ImplInitExtraField( bool bUpdate );
688 : SVT_DLLPRIVATE void ImplInvertLines( bool bErase = false );
689 : SVT_DLLPRIVATE void ImplDraw();
690 : SVT_DLLPRIVATE void ImplDrawExtra( bool bPaint = false );
691 : SVT_DLLPRIVATE void ImplUpdate( bool bMustCalc = false );
692 :
693 : using Window::ImplHitTest;
694 : SVT_DLLPRIVATE bool ImplHitTest( const Point& rPosition,
695 : RulerSelection* pHitTest,
696 : bool bRequiredStyle = false,
697 : sal_uInt16 nRequiredStyle = 0 ) const;
698 : SVT_DLLPRIVATE bool ImplDocHitTest( const Point& rPos, RulerType eDragType, RulerSelection* pHitTest ) const;
699 : SVT_DLLPRIVATE bool ImplStartDrag( RulerSelection* pHitTest, sal_uInt16 nModifier );
700 : SVT_DLLPRIVATE void ImplDrag( const Point& rPos );
701 : SVT_DLLPRIVATE void ImplEndDrag();
702 :
703 : DECL_DLLPRIVATE_LINK( ImplUpdateHdl, void* );
704 :
705 : // Forbidden and not implemented.
706 : Ruler (const Ruler &);
707 : Ruler& operator= (const Ruler &);
708 :
709 : protected:
710 : long GetRulerVirHeight() const;
711 0 : MapMode GetCurrentMapMode() const { return maMapMode; }
712 : RulerUnitData GetCurrentRulerUnit() const;
713 :
714 : public:
715 : Ruler( Window* pParent, WinBits nWinStyle = WB_STDRULER );
716 : virtual ~Ruler();
717 :
718 : virtual void MouseButtonDown( const MouseEvent& rMEvt ) SAL_OVERRIDE;
719 : virtual void MouseMove( const MouseEvent& rMEvt ) SAL_OVERRIDE;
720 : virtual void Tracking( const TrackingEvent& rTEvt ) SAL_OVERRIDE;
721 : virtual void Paint( const Rectangle& rRect ) SAL_OVERRIDE;
722 : virtual void Resize() SAL_OVERRIDE;
723 : virtual void StateChanged( StateChangedType nStateChange ) SAL_OVERRIDE;
724 : virtual void DataChanged( const DataChangedEvent& rDCEvt ) SAL_OVERRIDE;
725 :
726 : virtual long StartDrag();
727 : virtual void Drag();
728 : virtual void EndDrag();
729 : virtual void Click();
730 : virtual void DoubleClick();
731 : virtual void ExtraDown();
732 :
733 : void Activate() SAL_OVERRIDE;
734 : void Deactivate() SAL_OVERRIDE;
735 : bool IsActive() const { return mbActive; }
736 :
737 : void SetWinPos( long nOff = 0, long nWidth = 0 );
738 0 : long GetWinOffset() const { return mnWinOff; }
739 : long GetWinWidth() const { return mnWinWidth; }
740 : void SetPagePos( long nOff = 0, long nWidth = 0 );
741 : long GetPageOffset() const;
742 : void SetBorderPos( long nOff = 0 );
743 0 : long GetBorderOffset() const { return mnBorderOff; }
744 0 : Rectangle GetExtraRect() const { return maExtraRect; }
745 :
746 : void SetUnit( FieldUnit eNewUnit );
747 0 : FieldUnit GetUnit() const { return meUnit; }
748 : void SetZoom( const Fraction& rNewZoom );
749 : Fraction GetZoom() const { return maZoom; }
750 :
751 0 : void SetSourceUnit( MapUnit eNewUnit ) { meSourceUnit = eNewUnit; }
752 : MapUnit GetSourceUnit() const { return meSourceUnit; }
753 :
754 : void SetExtraType( RulerExtra eNewExtraType, sal_uInt16 nStyle = 0 );
755 : RulerExtra GetExtraType() const { return meExtraType; }
756 : sal_uInt16 GetExtraStyle() const { return mnExtraStyle; }
757 : sal_uInt16 GetExtraClicks() const { return mnExtraClicks; }
758 : sal_uInt16 GetExtraModifier() const { return mnExtraModifier; }
759 :
760 : bool StartDocDrag( const MouseEvent& rMEvt,
761 : RulerType eDragType = RULER_TYPE_DONTKNOW );
762 0 : RulerType GetDragType() const { return meDragType; }
763 0 : long GetDragPos() const { return mnDragPos; }
764 0 : sal_uInt16 GetDragAryPos() const { return mnDragAryPos; }
765 0 : sal_uInt16 GetDragSize() const { return mnDragSize; }
766 0 : bool IsDragDelete() const { return mbDragDelete; }
767 0 : bool IsDragCanceled() const { return mbDragCanceled; }
768 : sal_uInt16 GetDragScroll() const { return mnDragScroll; }
769 0 : sal_uInt16 GetDragModifier() const { return mnDragModifier; }
770 0 : bool IsDrag() const { return mbDrag; }
771 : void CancelDrag();
772 0 : long GetClickPos() const { return mnDragPos; }
773 0 : RulerType GetClickType() const { return meDragType; }
774 : sal_uInt16 GetClickAryPos() const { return mnDragAryPos; }
775 :
776 0 : RulerSelection GetHoverSelection() const { return maHoverSelection; }
777 :
778 : using Window::GetType;
779 : RulerType GetType( const Point& rPos, sal_uInt16* pAryPos = NULL );
780 :
781 : void SetNullOffset( long nPos );
782 : long GetNullOffset() const;
783 0 : void SetMargin1() { SetMargin1( 0, RULER_STYLE_INVISIBLE ); }
784 : void SetMargin1( long nPos, sal_uInt16 nMarginStyle = RULER_MARGIN_SIZEABLE );
785 : long GetMargin1() const;
786 0 : void SetMargin2() { SetMargin2( 0, RULER_STYLE_INVISIBLE ); }
787 : void SetMargin2( long nPos, sal_uInt16 nMarginStyle = RULER_MARGIN_SIZEABLE );
788 : long GetMargin2() const;
789 :
790 : void SetLeftFrameMargin( long nPos );
791 : void SetRightFrameMargin( long nPos );
792 : void SetLines( sal_uInt32 n = 0, const RulerLine* pLineAry = NULL );
793 : void SetBorders( sal_uInt32 n = 0, const RulerBorder* pBrdAry = NULL );
794 : void SetIndents( sal_uInt32 n = 0, const RulerIndent* pIndentAry = NULL );
795 :
796 : void SetTabs( sal_uInt32 n = 0, const RulerTab* pTabAry = NULL );
797 : sal_uInt32 GetTabCount() const;
798 : const RulerTab* GetTabs() const;
799 :
800 : static void DrawTab( OutputDevice* pDevice, const Color &rFillColor,
801 : const Point& rPos, sal_uInt16 nStyle );
802 :
803 : void SetStyle( WinBits nStyle );
804 0 : WinBits GetStyle() const { return mnWinStyle; }
805 :
806 : void SetStartDragHdl( const Link& rLink ) { maStartDragHdl = rLink; }
807 0 : const Link& GetStartDragHdl() const { return maStartDragHdl; }
808 : void SetDragHdl( const Link& rLink ) { maDragHdl = rLink; }
809 : const Link& GetDragHdl() const { return maDragHdl; }
810 : void SetEndDragHdl( const Link& rLink ) { maEndDragHdl = rLink; }
811 : const Link& GetEndDragHdl() const { return maEndDragHdl; }
812 : void SetClickHdl( const Link& rLink ) { maClickHdl = rLink; }
813 : const Link& GetClickHdl() const { return maClickHdl; }
814 0 : void SetDoubleClickHdl( const Link& rLink ) { maDoubleClickHdl = rLink; }
815 : const Link& GetDoubleClickHdl() const { return maDoubleClickHdl; }
816 : void SetExtraDownHdl( const Link& rLink ) { maExtraDownHdl = rLink; }
817 : const Link& GetExtraDownHdl() const { return maExtraDownHdl; }
818 :
819 : void SetTextRTL(bool bRTL);
820 : bool GetTextRTL();
821 0 : void SetCharWidth( long nWidth ) { mnCharWidth = nWidth ; }
822 0 : void SetLineHeight( long nHeight ) { mnLineHeight = nHeight ; }
823 :
824 : void DrawTicks();
825 :
826 : virtual ::com::sun::star::uno::Reference< ::com::sun::star::accessibility::XAccessible > CreateAccessible() SAL_OVERRIDE;
827 : };
828 :
829 : #endif // _RULER_HXX
830 :
831 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
