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 : #include <string.h>
21 : #include <limits.h>
22 : #include <tools/shl.hxx>
23 : #include <vcl/image.hxx>
24 : #include <svl/eitem.hxx>
25 : #include <svl/rectitem.hxx>
26 : #include <sfx2/dispatch.hxx>
27 :
28 : #include <svl/smplhint.hxx>
29 :
30 : #include <svx/dialogs.hrc>
31 : #include <svx/dialmgr.hxx>
32 : #include <svx/ruler.hxx>
33 : #include "rlrcitem.hxx"
34 : #include "svx/rulritem.hxx"
35 : #include <editeng/tstpitem.hxx>
36 : #include <editeng/lrspitem.hxx>
37 : #include "editeng/protitem.hxx"
38 : #include <vcl/svapp.hxx>
39 : #ifndef RULER_TAB_RTL
40 : #define RULER_TAB_RTL ((sal_uInt16)0x0010)
41 : #endif
42 :
43 : // STATIC DATA -----------------------------------------------------------
44 :
45 : #define CTRL_ITEM_COUNT 14
46 : #define GAP 10
47 : #define OBJECT_BORDER_COUNT 4
48 : #define TAB_GAP 1
49 : #define INDENT_GAP 2
50 : #define INDENT_FIRST_LINE 4
51 : #define INDENT_LEFT_MARGIN 5
52 : #define INDENT_RIGHT_MARGIN 6
53 : #define INDENT_LEFT_BORDER 2
54 : #define INDENT_RIGHT_BORDER 3
55 : #define INDENT_COUNT 5 //without the first two old values
56 :
57 : #define PIXEL_H_ADJUST( l1, l2 ) PixelHAdjust(l1,l2)
58 :
59 : #ifdef DEBUGLIN
60 :
61 : inline long ToMM(Window *pWin, long lVal)
62 : {
63 : return pWin->PixelToLogic(Size(lVal, 0), MapMode(MAP_MM)).Width();
64 : }
65 :
66 : void Debug_Impl(Window *pWin, SvxColumnItem& rColItem)
67 : {
68 : String aTmp("Aktuell: ");
69 : aTmp += rColItem.GetActColumn();
70 : aTmp += " ColLeft: ";
71 : aTmp += String(ToMM(pWin, rColItem.GetLeft()));
72 : aTmp += " ColRight: ";
73 : aTmp += String(ToMM(pWin, rColItem.GetRight()));
74 : for(sal_uInt16 i = 0; i < rColItem.Count(); ++i) {
75 : aTmp += " Start: ";
76 : aTmp += String(ToMM(pWin, rColItem[i].nStart));
77 : aTmp += " End: ";
78 : aTmp += String(ToMM(pWin, rColItem[i].nEnd));
79 : }
80 :
81 : InfoBox(0, aTmp).Execute();
82 : }
83 :
84 : void Debug_Impl(Window *pWin, const SvxLongLRSpaceItem& rLRSpace)
85 : {
86 : String aTmp("Left: ");
87 : aTmp += pWin->PixelToLogic(Size(rLRSpace.GetLeft(), 0), MapMode(MAP_MM)).Width();
88 : aTmp += " Right: ";
89 : aTmp +=pWin->PixelToLogic(Size(rLRSpace.GetRight(), 0), MapMode(MAP_MM)).Width();
90 : InfoBox(0, aTmp).Execute();
91 : }
92 :
93 : void Debug_Impl(Window *pWin, const SvxLongULSpaceItem& rULSpace)
94 : {
95 : String aTmp("Upper: ");
96 : aTmp += pWin->PixelToLogic(Size(rULSpace.GetUpper(), 0), MapMode(MAP_MM)).Width();
97 : aTmp += " Lower: ";
98 : aTmp += pWin->PixelToLogic(Size(rULSpace.GetLower(), 0), MapMode(MAP_MM)).Width();
99 :
100 : InfoBox(0, aTmp).Execute();
101 : }
102 :
103 : void DebugTabStops_Impl(const SvxTabStopItem& rTabs)
104 : {
105 : String aTmp("Tabs: ");
106 :
107 : // Delete Def Tabs
108 : for(sal_uInt16 i = 0; i < rTabs.Count(); ++i)
109 : {
110 : aTmp += String(rTabs[i].GetTabPos() / 56);
111 : aTmp += " : ";
112 : }
113 : InfoBox(0, aTmp).Execute();
114 : }
115 :
116 : void DebugParaMargin_Impl(const SvxLRSpaceItem& rLRSpace)
117 : {
118 : String aTmp("ParaLeft: ");
119 : aTmp += rLRSpace.GetTxtLeft() / 56;
120 : aTmp += " ParaRight: ";
121 : aTmp += rLRSpace.GetRight() / 56;
122 : aTmp += " FLI: ";
123 : aTmp += rLRSpace.GetTxtFirstLineOfst() / 56;
124 : InfoBox(0, aTmp).Execute();
125 : }
126 :
127 : #endif // DEBUGLIN
128 : #ifdef DEBUG_RULER
129 : #include <vcl/lstbox.hxx>
130 : class RulerDebugWindow : public Window
131 : {
132 : ListBox aBox;
133 : public:
134 : RulerDebugWindow(Window* pParent) :
135 : Window(pParent, WB_BORDER|WB_SIZEMOVE|WB_DIALOGCONTROL|WB_CLIPCHILDREN|WB_SYSTEMWINDOW),
136 : aBox(this, WB_BORDER)
137 : {
138 : Size aOutput(200, 400);
139 : SetOutputSizePixel(aOutput);
140 : aBox.SetSizePixel(aOutput);
141 : aBox.Show();
142 : Show();
143 : Size aParentSize(pParent->GetOutputSizePixel());
144 : Size aOwnSize(GetSizePixel());
145 : aParentSize.Width() -= aOwnSize.Width();
146 : aParentSize.Height() -= aOwnSize.Height();
147 : SetPosPixel(Point(aParentSize.Width(), aParentSize.Height()));
148 : }
149 : ~RulerDebugWindow();
150 :
151 : ListBox& GetLBox() {return aBox;}
152 : static void AddDebugText(const sal_Char* pDescription, const String& rText );
153 : };
154 : static RulerDebugWindow* pDebugWindow = 0;
155 :
156 : RulerDebugWindow::~RulerDebugWindow()
157 : {
158 : pDebugWindow = 0;
159 : }
160 : void RulerDebugWindow::AddDebugText(const sal_Char* pDescription, const String& rText )
161 : {
162 : if(!pDebugWindow)
163 : {
164 : Window* pParent = Application::GetFocusWindow();
165 : while(pParent->GetParent())
166 : pParent = pParent->GetParent();
167 : pDebugWindow = new RulerDebugWindow(pParent);
168 : }
169 : String sContent(String::CreateFromAscii(pDescription));
170 : sContent += rText;
171 : sal_uInt16 nPos = pDebugWindow->GetLBox().InsertEntry(sContent);
172 : pDebugWindow->GetLBox().SelectEntryPos(nPos);
173 : pDebugWindow->GrabFocus();
174 : }
175 :
176 : #define ADD_DEBUG_TEXT(cDescription, sValue) \
177 : RulerDebugWindow::AddDebugText(cDescription, sValue);
178 :
179 : #define REMOVE_DEBUG_WINDOW \
180 : delete pDebugWindow; \
181 : pDebugWindow = 0;
182 :
183 : #else
184 : #define ADD_DEBUG_TEXT(cDescription, sValue)
185 : #define REMOVE_DEBUG_WINDOW
186 : #endif
187 :
188 : struct SvxRuler_Impl {
189 : sal_uInt16 *pPercBuf;
190 : sal_uInt16 *pBlockBuf;
191 : sal_uInt16 nPercSize;
192 : long nTotalDist;
193 : long lOldWinPos;
194 : long lMaxLeftLogic;
195 : long lMaxRightLogic;
196 : long lLastLMargin;
197 : long lLastRMargin;
198 : SvxProtectItem aProtectItem;
199 : SfxBoolItem* pTextRTLItem;
200 : sal_uInt16 nControlerItems;
201 : sal_uInt16 nIdx;
202 : sal_uInt16 nColLeftPix, nColRightPix; // Pixel values for left / right edge
203 : // For columns; buffered to prevent
204 : // recalculation errors
205 : // May be has to be widen for future values
206 : sal_Bool bIsTableRows : 1; // pColumnItem contains table rows instead of columns
207 : //#i24363# tab stops relative to indent
208 : sal_Bool bIsTabsRelativeToIndent : 1; // Tab stops relative to paragraph indent?
209 472 : SvxRuler_Impl() :
210 : pPercBuf(0), pBlockBuf(0),
211 : nPercSize(0), nTotalDist(0),
212 : lOldWinPos(0),
213 : lMaxLeftLogic(0), lMaxRightLogic(0),
214 : lLastLMargin(0), lLastRMargin(0),
215 : aProtectItem(SID_RULER_PROTECT),
216 : pTextRTLItem(0), nControlerItems(0),
217 : nIdx(0),
218 : nColLeftPix(0), nColRightPix(0),
219 :
220 : bIsTableRows(sal_False),
221 472 : bIsTabsRelativeToIndent(sal_True)
222 : {
223 472 : }
224 126 : ~SvxRuler_Impl()
225 126 : {
226 126 : nPercSize = 0; nTotalDist = 0;
227 126 : delete[] pPercBuf; delete[] pBlockBuf; pPercBuf = 0;
228 126 : delete pTextRTLItem;
229 126 : }
230 : void SetPercSize(sal_uInt16 nSize);
231 :
232 : };
233 :
234 :
235 :
236 0 : void SvxRuler_Impl::SetPercSize(sal_uInt16 nSize)
237 : {
238 0 : if(nSize > nPercSize)
239 : {
240 0 : delete[] pPercBuf;
241 0 : delete[] pBlockBuf;
242 0 : pPercBuf = new sal_uInt16[nPercSize = nSize];
243 0 : pBlockBuf = new sal_uInt16[nPercSize = nSize];
244 : }
245 0 : size_t nSize2 = sizeof(sal_uInt16) * nPercSize;
246 0 : memset(pPercBuf, 0, nSize2);
247 0 : memset(pBlockBuf, 0, nSize2);
248 0 : }
249 :
250 :
251 : // Constructor of the ruler
252 :
253 : // SID_ATTR_ULSPACE, SID_ATTR_LRSPACE
254 : // expects as parameter SvxULSpaceItem for page edge
255 : // (either left/right or top/bottom)
256 : // Ruler: SetMargin1, SetMargin2
257 :
258 : // SID_RULER_PAGE_POS
259 : // expectes as parameter the initial value of the page and page width
260 : // Ruler: SetPagePos
261 :
262 : // SID_ATTR_TABSTOP
263 : // expects: SvxTabStopItem
264 : // Ruler: SetTabs
265 :
266 : // SID_ATTR_PARA_LRSPACE
267 : // left, right paragraph edge in H-ruler
268 : // Ruler: SetIndents
269 :
270 : // SID_RULER_BORDERS
271 : // Table borders, columns
272 : // expects: something like SwTabCols
273 : // Ruler: SetBorders
274 :
275 :
276 472 : SvxRuler::SvxRuler
277 : (
278 : Window* pParent, // StarView Parent
279 : Window* pWin, // Output window: is used for conversion
280 : // logical units <-> pixels
281 : sal_uInt16 flags, // Display flags, see ruler.hxx
282 : SfxBindings &rBindings, // associated Bindings
283 : WinBits nWinStyle // StarView WinBits
284 : )
285 : : Ruler(pParent, nWinStyle),
286 472 : pCtrlItem(new SvxRulerItem *[CTRL_ITEM_COUNT]),
287 : pLRSpaceItem(0),
288 : pMinMaxItem(0),
289 : pULSpaceItem(0),
290 : pTabStopItem(0),
291 : pParaItem(0),
292 : pParaBorderItem(0),
293 : pPagePosItem(0),
294 : pColumnItem(0),
295 : pObjectItem(0),
296 : pEditWin(pWin),
297 472 : pRuler_Imp(new SvxRuler_Impl),
298 : bAppSetNullOffset(sal_False), // Is the 0-offset of the ruler set by the application?
299 : lLogicNullOffset(0),
300 : lAppNullOffset(LONG_MAX),
301 : lMinFrame(5),
302 : lInitialDragPos(0),
303 : nFlags(flags),
304 : nDragType(NONE),
305 : nDefTabType(RULER_TAB_LEFT),
306 : nTabCount(0),
307 : nTabBufSize(0),
308 : lDefTabDist(50),
309 : lTabPos(-1),
310 : pTabs(0),
311 : pIndents(0),
312 472 : pBorders(new RulerBorder[1]), // due to one column tables
313 : nBorderCount(0),
314 : pObjectBorders(0),
315 : pBindings(&rBindings),
316 : nDragOffset(0),
317 : nMaxLeft(0),
318 : nMaxRight(0),
319 : bValid(sal_False),
320 : bListening(sal_False),
321 1888 : bActive(sal_True)
322 :
323 : /* [Description]
324 :
325 : Constructor; Initialize data buffer; controller items are created
326 : */
327 : {
328 472 : memset(pCtrlItem, 0, sizeof(SvxRulerItem *) * CTRL_ITEM_COUNT);
329 :
330 472 : rBindings.EnterRegistrations();
331 :
332 : // Create Supported Items
333 472 : sal_uInt16 i = 0;
334 : // Page edges
335 :
336 472 : pCtrlItem[i++] = new SvxRulerItem(SID_RULER_LR_MIN_MAX, *this, rBindings);
337 472 : if((nWinStyle & WB_VSCROLL) == WB_VSCROLL)
338 : {
339 236 : bHorz = sal_False;
340 236 : pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_LONG_ULSPACE, *this, rBindings);
341 : }
342 : else
343 : {
344 236 : bHorz = sal_True;
345 236 : pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_LONG_LRSPACE, *this, rBindings);
346 : }
347 :
348 : // Page Position
349 472 : pCtrlItem[i++] = new SvxRulerItem(SID_RULER_PAGE_POS, *this, rBindings);
350 :
351 472 : if((nFlags & SVXRULER_SUPPORT_TABS) == SVXRULER_SUPPORT_TABS)
352 : {
353 472 : sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
354 472 : pCtrlItem[i++] = new SvxRulerItem(nTabStopId, *this, rBindings);
355 472 : SetExtraType(RULER_EXTRA_TAB, nDefTabType);
356 : }
357 :
358 :
359 472 : if(0 != (nFlags & (SVXRULER_SUPPORT_PARAGRAPH_MARGINS |SVXRULER_SUPPORT_PARAGRAPH_MARGINS_VERTICAL)))
360 : {
361 472 : if(bHorz)
362 236 : pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_PARA_LRSPACE, *this, rBindings);
363 : else
364 236 : pCtrlItem[i++] = new SvxRulerItem(SID_ATTR_PARA_LRSPACE_VERTICAL, *this, rBindings);
365 472 : pIndents = new RulerIndent[5+INDENT_GAP];
366 472 : memset(pIndents, 0, sizeof(RulerIndent)*(3+INDENT_GAP));
367 472 : pIndents[0].nStyle = RULER_STYLE_DONTKNOW;
368 472 : pIndents[1].nStyle = RULER_STYLE_DONTKNOW;
369 472 : pIndents[INDENT_FIRST_LINE].nStyle = RULER_INDENT_TOP;
370 472 : pIndents[INDENT_LEFT_MARGIN].nStyle = RULER_INDENT_BOTTOM;
371 472 : pIndents[INDENT_RIGHT_MARGIN].nStyle = RULER_INDENT_BOTTOM;
372 472 : pIndents[INDENT_LEFT_BORDER].nStyle = RULER_INDENT_BORDER;
373 472 : pIndents[INDENT_RIGHT_BORDER].nStyle = RULER_INDENT_BORDER;
374 3776 : for(sal_uInt16 nIn = 0; nIn < 7; nIn++)
375 3304 : pIndents[nIn].nPos = 0;
376 : }
377 :
378 472 : if((nFlags & SVXRULER_SUPPORT_BORDERS) == SVXRULER_SUPPORT_BORDERS)
379 : {
380 472 : pCtrlItem[i++] = new SvxRulerItem(bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL, *this, rBindings);
381 472 : pCtrlItem[i++] = new SvxRulerItem(bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL, *this, rBindings);
382 : }
383 :
384 472 : pCtrlItem[i++] = new SvxRulerItem(SID_RULER_TEXT_RIGHT_TO_LEFT, *this, rBindings);
385 :
386 472 : if((nFlags & SVXRULER_SUPPORT_OBJECT) == SVXRULER_SUPPORT_OBJECT)
387 : {
388 0 : pCtrlItem[i++] = new SvxRulerItem(SID_RULER_OBJECT, *this, rBindings );
389 0 : pObjectBorders = new RulerBorder[OBJECT_BORDER_COUNT];
390 0 : size_t nSize = sizeof( RulerBorder ) * OBJECT_BORDER_COUNT;
391 0 : memset(pObjectBorders, 0, nSize);
392 0 : for(sal_uInt16 nBorder = 0; nBorder < OBJECT_BORDER_COUNT; ++nBorder)
393 : {
394 0 : pObjectBorders[nBorder].nPos = 0;
395 0 : pObjectBorders[nBorder].nWidth = 0;
396 0 : pObjectBorders[nBorder].nStyle = RULER_BORDER_MOVEABLE;
397 : }
398 : }
399 :
400 472 : pCtrlItem[i++] = new SvxRulerItem( SID_RULER_PROTECT, *this, rBindings );
401 472 : pCtrlItem[i++] = new SvxRulerItem(SID_RULER_BORDER_DISTANCE, *this, rBindings);
402 472 : pRuler_Imp->nControlerItems=i;
403 :
404 472 : if((nFlags & SVXRULER_SUPPORT_SET_NULLOFFSET) ==
405 : SVXRULER_SUPPORT_SET_NULLOFFSET)
406 0 : SetExtraType(RULER_EXTRA_NULLOFFSET, 0);
407 :
408 472 : rBindings.LeaveRegistrations();
409 472 : }
410 :
411 :
412 378 : SvxRuler::~SvxRuler()
413 :
414 : /* [Description]
415 :
416 : Destructor ruler; release internal buffer
417 : */
418 : {
419 : REMOVE_DEBUG_WINDOW
420 126 : if(bListening)
421 0 : EndListening(*pBindings);
422 :
423 126 : pBindings->EnterRegistrations();
424 :
425 1386 : for(sal_uInt16 i = 0; i < CTRL_ITEM_COUNT && pCtrlItem[i]; ++i)
426 1260 : delete pCtrlItem[i];
427 126 : delete[] pCtrlItem;
428 :
429 126 : delete pLRSpaceItem;
430 126 : delete pMinMaxItem;
431 126 : delete pULSpaceItem;
432 126 : delete pTabStopItem;
433 126 : delete pParaItem;
434 126 : delete pParaBorderItem;
435 126 : delete pPagePosItem;
436 126 : delete pColumnItem;
437 126 : delete pObjectItem;
438 126 : delete[] pIndents;
439 126 : delete[] pBorders;
440 126 : delete[] pObjectBorders;
441 126 : delete[] pTabs;
442 126 : delete pRuler_Imp;
443 :
444 126 : pBindings->LeaveRegistrations();
445 252 : }
446 :
447 : /* [Description]
448 :
449 : Internal conversion routines
450 : */
451 :
452 100 : long SvxRuler::ConvertHPosPixel(long nVal) const
453 : {
454 100 : return pEditWin->LogicToPixel(Size(nVal, 0)).Width();
455 : }
456 :
457 20 : long SvxRuler::ConvertVPosPixel(long nVal) const
458 : {
459 20 : return pEditWin->LogicToPixel(Size(0, nVal)).Height();
460 : }
461 :
462 20 : long SvxRuler::ConvertHSizePixel(long nVal) const
463 : {
464 20 : return pEditWin->LogicToPixel(Size(nVal, 0)).Width();
465 : }
466 :
467 0 : long SvxRuler::ConvertVSizePixel(long nVal) const
468 : {
469 0 : return pEditWin->LogicToPixel(Size(0, nVal)).Height();
470 : }
471 :
472 0 : long SvxRuler::ConvertPosPixel(long nVal) const
473 : {
474 0 : return bHorz ? ConvertHPosPixel(nVal): ConvertVPosPixel(nVal);
475 : }
476 :
477 20 : long SvxRuler::ConvertSizePixel(long nVal) const
478 : {
479 20 : return bHorz? ConvertHSizePixel(nVal): ConvertVSizePixel(nVal);
480 : }
481 :
482 :
483 0 : inline long SvxRuler::ConvertHPosLogic(long nVal) const
484 : {
485 0 : return pEditWin->PixelToLogic(Size(nVal, 0)).Width();
486 : }
487 :
488 0 : inline long SvxRuler::ConvertVPosLogic(long nVal) const
489 : {
490 0 : return pEditWin->PixelToLogic(Size(0, nVal)).Height();
491 : }
492 :
493 0 : inline long SvxRuler::ConvertHSizeLogic(long nVal) const
494 : {
495 0 : return pEditWin->PixelToLogic(Size(nVal, 0)).Width();
496 : }
497 :
498 0 : inline long SvxRuler::ConvertVSizeLogic(long nVal) const
499 : {
500 0 : return pEditWin->PixelToLogic(Size(0, nVal)).Height();
501 : }
502 :
503 0 : inline long SvxRuler::ConvertPosLogic(long nVal) const
504 : {
505 0 : return bHorz? ConvertHPosLogic(nVal): ConvertVPosLogic(nVal);
506 : }
507 :
508 0 : inline long SvxRuler::ConvertSizeLogic(long nVal) const
509 : {
510 0 : return bHorz? ConvertHSizeLogic(nVal): ConvertVSizeLogic(nVal);
511 : }
512 :
513 0 : long SvxRuler::PixelHAdjust(long nVal, long nValOld) const
514 : {
515 0 : if(ConvertHSizePixel(nVal)!=ConvertHSizePixel(nValOld))
516 0 : return nVal;
517 : else
518 0 : return nValOld;
519 : }
520 :
521 0 : long SvxRuler::PixelVAdjust(long nVal, long nValOld) const
522 : {
523 0 : if(ConvertVSizePixel(nVal)!=ConvertVSizePixel(nValOld))
524 0 : return nVal;
525 : else
526 0 : return nValOld;
527 : }
528 :
529 0 : long SvxRuler::PixelAdjust(long nVal, long nValOld) const
530 : {
531 0 : if(ConvertSizePixel(nVal)!=ConvertSizePixel(nValOld))
532 0 : return nVal;
533 : else
534 0 : return nValOld;
535 : }
536 :
537 :
538 0 : inline sal_uInt16 SvxRuler::GetObjectBordersOff(sal_uInt16 nIdx) const
539 : {
540 0 : return bHorz? nIdx: nIdx + 2;
541 : }
542 :
543 :
544 2380 : void SvxRuler::UpdateFrame()
545 :
546 : /* [Description]
547 :
548 : Update Upper Left edge.
549 : Items are translated into the representation of the ruler.
550 : */
551 :
552 : {
553 : const sal_uInt16 nMarginStyle =
554 2380 : ( pRuler_Imp->aProtectItem.IsSizeProtected() ||
555 2380 : pRuler_Imp->aProtectItem.IsPosProtected() ) ?
556 4760 : 0 : RULER_MARGIN_SIZEABLE;
557 :
558 2380 : if(pLRSpaceItem && pPagePosItem)
559 : {
560 : // if no initialization by default app behavior
561 10 : const long nOld = lLogicNullOffset;
562 : lLogicNullOffset = pColumnItem?
563 10 : pColumnItem->GetLeft(): pLRSpaceItem->GetLeft();
564 10 : if(bAppSetNullOffset)
565 0 : lAppNullOffset += lLogicNullOffset - nOld;
566 10 : if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX)
567 : {
568 10 : Ruler::SetNullOffset(ConvertHPosPixel(lLogicNullOffset));
569 10 : SetMargin1( 0, nMarginStyle );
570 10 : lAppNullOffset = 0;
571 : }
572 : else
573 0 : SetMargin1( ConvertHPosPixel( lAppNullOffset ), nMarginStyle );
574 10 : long lRight = 0;
575 : // evaluate the table right edge of the table
576 10 : if(pColumnItem && pColumnItem->IsTable())
577 0 : lRight = pColumnItem->GetRight();
578 : else
579 10 : lRight = pLRSpaceItem->GetRight();
580 :
581 : sal_uIntPtr aWidth=
582 10 : ConvertHPosPixel(pPagePosItem->GetWidth() - lRight -
583 10 : lLogicNullOffset + lAppNullOffset);
584 10 : SetMargin2( aWidth, nMarginStyle );
585 : }
586 : else
587 2370 : if(pULSpaceItem && pPagePosItem)
588 : {
589 : // relative the upper edge of the surrounding frame
590 10 : const long nOld = lLogicNullOffset;
591 : lLogicNullOffset = pColumnItem?
592 10 : pColumnItem->GetLeft(): pULSpaceItem->GetUpper();
593 10 : if(bAppSetNullOffset)
594 0 : lAppNullOffset += lLogicNullOffset - nOld;
595 10 : if(!bAppSetNullOffset || lAppNullOffset == LONG_MAX) {
596 10 : Ruler::SetNullOffset(ConvertVPosPixel(lLogicNullOffset));
597 10 : lAppNullOffset = 0;
598 10 : SetMargin1( 0, nMarginStyle );
599 : }
600 : else
601 0 : SetMargin1( ConvertVPosPixel( lAppNullOffset ),nMarginStyle );
602 :
603 : long lLower = pColumnItem ?
604 10 : pColumnItem->GetRight() : pULSpaceItem->GetLower();
605 :
606 10 : SetMargin2(ConvertVPosPixel(pPagePosItem->GetHeight() - lLower -
607 : lLogicNullOffset + lAppNullOffset),
608 20 : nMarginStyle );
609 : }
610 : else
611 : {
612 : // turns off the view
613 2360 : SetMargin1();
614 2360 : SetMargin2();
615 : }
616 2380 : if(pColumnItem)
617 : {
618 0 : pRuler_Imp->nColLeftPix = (sal_uInt16) ConvertSizePixel(pColumnItem->GetLeft());
619 0 : pRuler_Imp->nColRightPix = (sal_uInt16) ConvertSizePixel(pColumnItem->GetRight());
620 : }
621 :
622 2380 : }
623 :
624 0 : void SvxRuler::MouseMove( const MouseEvent& rMEvt )
625 : {
626 0 : if( bActive )
627 : {
628 0 : pBindings->Update( SID_RULER_LR_MIN_MAX );
629 0 : pBindings->Update( SID_ATTR_LONG_ULSPACE );
630 0 : pBindings->Update( SID_ATTR_LONG_LRSPACE );
631 0 : pBindings->Update( SID_RULER_PAGE_POS );
632 0 : pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL);
633 0 : pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL);
634 0 : pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
635 0 : pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL);
636 0 : pBindings->Update( SID_RULER_OBJECT );
637 0 : pBindings->Update( SID_RULER_PROTECT );
638 : }
639 0 : Ruler::MouseMove( rMEvt );
640 0 : }
641 150 : void SvxRuler::StartListening_Impl()
642 : {
643 150 : if(!bListening)
644 : {
645 20 : bValid = sal_False;
646 20 : StartListening(*pBindings);
647 20 : bListening = sal_True;
648 : }
649 150 : }
650 :
651 10 : void SvxRuler::UpdateFrame
652 : (
653 : const SvxLongLRSpaceItem *pItem // new value LRSpace
654 : )
655 :
656 : /* [Description]
657 :
658 : Store new value LRSpace; delete old ones if possible
659 : */
660 :
661 : {
662 10 : if(bActive)
663 : {
664 10 : delete pLRSpaceItem; pLRSpaceItem = 0;
665 10 : if(pItem)
666 10 : pLRSpaceItem = new SvxLongLRSpaceItem(*pItem);
667 10 : StartListening_Impl();
668 : }
669 10 : }
670 :
671 :
672 20 : void SvxRuler::UpdateFrameMinMax
673 : (
674 : const SfxRectangleItem *pItem // value for MinMax
675 : )
676 :
677 : /* [Description]
678 :
679 : Set new value for MinMax; delete old ones if possible
680 : */
681 :
682 : {
683 20 : if(bActive)
684 : {
685 20 : delete pMinMaxItem; pMinMaxItem = 0;
686 20 : if(pItem)
687 20 : pMinMaxItem = new SfxRectangleItem(*pItem);
688 : }
689 20 : }
690 :
691 :
692 10 : void SvxRuler::UpdateFrame
693 : (
694 : const SvxLongULSpaceItem *pItem // new value
695 : )
696 :
697 : /* [Description]
698 :
699 : Update Right/bottom margin
700 : */
701 :
702 :
703 : {
704 10 : if(bActive && !bHorz)
705 : {
706 10 : delete pULSpaceItem; pULSpaceItem = 0;
707 10 : if(pItem)
708 10 : pULSpaceItem = new SvxLongULSpaceItem(*pItem);
709 10 : StartListening_Impl();
710 : }
711 10 : }
712 :
713 20 : void SvxRuler::Update( const SvxProtectItem* pItem )
714 : {
715 20 : if( pItem ) pRuler_Imp->aProtectItem = *pItem;
716 20 : }
717 :
718 20 : void SvxRuler::UpdateTextRTL(const SfxBoolItem* pItem)
719 : {
720 20 : if(bActive && bHorz)
721 : {
722 10 : delete pRuler_Imp->pTextRTLItem; pRuler_Imp->pTextRTLItem = 0;
723 10 : if(pItem)
724 10 : pRuler_Imp->pTextRTLItem = new SfxBoolItem(*pItem);
725 10 : SetTextRTL(pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue());
726 10 : StartListening_Impl();
727 : }
728 20 : }
729 :
730 40 : void SvxRuler::Update
731 : (
732 : const SvxColumnItem *pItem, // new value
733 : sal_uInt16 nSID //Slot Id to identify NULL items
734 : )
735 :
736 : /* [Description]
737 :
738 : Set new value for column view
739 : */
740 :
741 : {
742 40 : if(bActive)
743 : {
744 40 : if(pItem)
745 : {
746 0 : delete pColumnItem; pColumnItem = 0;
747 0 : pRuler_Imp->bIsTableRows = (pItem->Which() == SID_RULER_ROWS || pItem->Which() == SID_RULER_ROWS_VERTICAL);
748 0 : pColumnItem = new SvxColumnItem(*pItem);
749 0 : if(!bHorz && !pRuler_Imp->bIsTableRows)
750 0 : pColumnItem->SetWhich(SID_RULER_BORDERS_VERTICAL);
751 : }
752 40 : else if(pColumnItem && pColumnItem->Which() == nSID)
753 : //there are two groups of column items table/frame columns and table rows
754 : //both can occur in vertical or horizontal mode
755 : //the horizontal ruler handles the SID_RULER_BORDERS and SID_RULER_ROWS_VERTICAL
756 : //and the vertical handles SID_RULER_BORDERS_VERTICAL and SID_RULER_ROWS
757 : //if pColumnItem is already set with one of the ids then a NULL pItem argument
758 : //must not delete it
759 : {
760 0 : delete pColumnItem; pColumnItem = 0;
761 0 : pRuler_Imp->bIsTableRows = sal_False;
762 : }
763 40 : StartListening_Impl();
764 : }
765 40 : }
766 :
767 :
768 2380 : void SvxRuler::UpdateColumns()
769 :
770 : /* [Description]
771 :
772 : Update column view
773 : */
774 : {
775 2380 : if(pColumnItem && pColumnItem->Count() > 1)
776 : {
777 0 : if( nBorderCount < pColumnItem->Count())
778 : {
779 0 : delete[] pBorders;
780 0 : nBorderCount = pColumnItem->Count();
781 0 : pBorders = new RulerBorder[nBorderCount];
782 : }
783 0 : sal_uInt16 _nFlags = RULER_BORDER_VARIABLE;
784 : sal_Bool bProtectColumns =
785 0 : pRuler_Imp->aProtectItem.IsSizeProtected() ||
786 0 : pRuler_Imp->aProtectItem.IsPosProtected();
787 0 : if( !bProtectColumns )
788 0 : _nFlags |= RULER_BORDER_MOVEABLE;
789 0 : if( pColumnItem->IsTable() )
790 0 : _nFlags |= RULER_BORDER_TABLE;
791 : else
792 0 : if ( !bProtectColumns )
793 0 : _nFlags |= RULER_BORDER_SIZEABLE;
794 :
795 0 : sal_uInt16 nBorders = pColumnItem->Count();
796 0 : if(!pRuler_Imp->bIsTableRows)
797 0 : --nBorders;
798 0 : for(sal_uInt16 i = 0; i < nBorders; ++i)
799 : {
800 0 : pBorders[i].nStyle = _nFlags;
801 0 : if(!(*pColumnItem)[i].bVisible)
802 0 : pBorders[i].nStyle |= RULER_STYLE_INVISIBLE;
803 0 : pBorders[i].nPos =
804 0 : ConvertPosPixel((*pColumnItem)[i].nEnd + lAppNullOffset);
805 0 : if(pColumnItem->Count() == i + 1)
806 : {
807 : //with table rows the end of the table is contained in the
808 : //column item but it has no width!
809 0 : pBorders[i].nWidth = 0;
810 : }
811 : else
812 : {
813 0 : pBorders[i].nWidth =
814 0 : ConvertSizePixel((*pColumnItem)[i+1].nStart -
815 0 : (*pColumnItem)[i].nEnd);
816 : }
817 0 : pBorders[i].nMinPos =
818 0 : ConvertPosPixel((*pColumnItem)[i].nEndMin + lAppNullOffset);
819 0 : pBorders[i].nMaxPos =
820 0 : ConvertPosPixel((*pColumnItem)[i].nEndMax + lAppNullOffset);
821 : }
822 0 : SetBorders(pColumnItem->Count()-1, pBorders);
823 : }
824 : else
825 : {
826 2380 : SetBorders();
827 : }
828 2380 : }
829 :
830 :
831 0 : void SvxRuler::UpdateObject()
832 :
833 : /* [Description]
834 :
835 : Update view of object representation
836 : */
837 :
838 : {
839 0 : if(pObjectItem)
840 : {
841 : DBG_ASSERT(pObjectBorders, "no Buffer");
842 : // !! to the page margin
843 0 : long nMargin = pLRSpaceItem? pLRSpaceItem->GetLeft(): 0;
844 0 : pObjectBorders[0].nPos =
845 0 : ConvertPosPixel(pObjectItem->GetStartX() -
846 0 : nMargin + lAppNullOffset);
847 0 : pObjectBorders[1].nPos =
848 0 : ConvertPosPixel(pObjectItem->GetEndX() - nMargin + lAppNullOffset);
849 0 : nMargin = pULSpaceItem? pULSpaceItem->GetUpper(): 0;
850 0 : pObjectBorders[2].nPos =
851 0 : ConvertPosPixel(pObjectItem->GetStartY() -
852 0 : nMargin + lAppNullOffset);
853 0 : pObjectBorders[3].nPos =
854 0 : ConvertPosPixel(pObjectItem->GetEndY() - nMargin + lAppNullOffset);
855 :
856 0 : const sal_uInt16 nOff = GetObjectBordersOff(0);
857 0 : SetBorders(2, pObjectBorders + nOff);
858 : }
859 : else
860 : {
861 0 : SetBorders();
862 : }
863 0 : }
864 :
865 :
866 2380 : void SvxRuler::UpdatePara()
867 :
868 : /* [Description]
869 :
870 : Update the view for paragraph indents:
871 : Left margin, first line indent, right margin paragraph update
872 : pIndents[0] = Buffer for old intent
873 : pIndents[1] = Buffer for old intent
874 : pIndents[INDENT_FIRST_LINE] = First line indent
875 : pIndents[3] = left margin
876 : pIndents[4] = right margin
877 : pIndents[5] = left border distance
878 : pIndents[6] = right border distance
879 :
880 : */
881 :
882 : {
883 : // Dependence on PagePosItem
884 2380 : if(pParaItem && pPagePosItem && !pObjectItem)
885 : {
886 10 : sal_Bool bRTLText = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
887 : // First-line indent is negative to the left paragraph margin
888 10 : long nLeftFrameMargin = GetLeftFrameMargin();
889 10 : long nRightFrameMargin = GetRightFrameMargin();
890 10 : if(bRTLText)
891 0 : pIndents[INDENT_FIRST_LINE].nPos =
892 : ConvertHPosPixel(
893 : nRightFrameMargin -
894 0 : pParaItem->GetTxtLeft() -
895 0 : pParaItem->GetTxtFirstLineOfst() + lAppNullOffset );
896 : else
897 10 : pIndents[INDENT_FIRST_LINE].nPos =
898 : ConvertHPosPixel(
899 : nLeftFrameMargin +
900 10 : pParaItem->GetTxtLeft() +
901 10 : pParaItem->GetTxtFirstLineOfst() +
902 20 : lAppNullOffset);
903 10 : if( pParaItem->IsAutoFirst() )
904 0 : pIndents[INDENT_FIRST_LINE].nStyle |= RULER_STYLE_INVISIBLE;
905 : else
906 10 : pIndents[INDENT_FIRST_LINE].nStyle &= ~RULER_STYLE_INVISIBLE;
907 :
908 10 : if(bRTLText)
909 : {
910 : // left margin
911 0 : pIndents[INDENT_LEFT_MARGIN].nPos =
912 : ConvertHPosPixel(
913 : nRightFrameMargin -
914 0 : pParaItem->GetTxtLeft() + lAppNullOffset);
915 : // right margin
916 0 : pIndents[INDENT_RIGHT_MARGIN].nPos =
917 : ConvertHPosPixel(
918 : nLeftFrameMargin +
919 0 : pParaItem->GetRight() + lAppNullOffset);
920 : }
921 : else
922 : {
923 : // left margin
924 10 : pIndents[INDENT_LEFT_MARGIN].nPos =
925 : ConvertHPosPixel(
926 : nLeftFrameMargin +
927 10 : pParaItem->GetTxtLeft() + lAppNullOffset);
928 : // right margin, always negative to the right edge of the surrounding frames
929 10 : pIndents[INDENT_RIGHT_MARGIN].nPos =
930 : ConvertHPosPixel(
931 : nRightFrameMargin -
932 10 : pParaItem->GetRight() + lAppNullOffset);
933 : }
934 10 : if(pParaBorderItem)
935 : {
936 9 : pIndents[INDENT_LEFT_BORDER].nPos =
937 9 : ConvertHPosPixel( nLeftFrameMargin + lAppNullOffset);
938 9 : pIndents[INDENT_RIGHT_BORDER].nPos =
939 9 : ConvertHPosPixel(nRightFrameMargin - lAppNullOffset);
940 9 : pIndents[INDENT_LEFT_BORDER].nStyle = pIndents[INDENT_RIGHT_BORDER].nStyle &= ~RULER_STYLE_INVISIBLE;
941 : }
942 : else
943 1 : pIndents[INDENT_LEFT_BORDER].nStyle = pIndents[INDENT_RIGHT_BORDER].nStyle |= RULER_STYLE_INVISIBLE;
944 :
945 10 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
946 : }
947 : else
948 : {
949 2370 : if(pIndents)
950 : {
951 2370 : pIndents[INDENT_FIRST_LINE].nPos =
952 2370 : pIndents[INDENT_LEFT_MARGIN].nPos =
953 2370 : pIndents[INDENT_RIGHT_MARGIN].nPos = 0;
954 : }
955 2370 : SetIndents(); // turn off
956 : }
957 2380 : }
958 :
959 :
960 20 : void SvxRuler::UpdatePara
961 : (
962 : const SvxLRSpaceItem *pItem // new value of paragraph indents
963 : )
964 :
965 : /* [Description]
966 :
967 : Store new value of paragraph indents
968 : */
969 :
970 : {
971 20 : if(bActive)
972 : {
973 20 : delete pParaItem; pParaItem = 0;
974 20 : if(pItem)
975 10 : pParaItem = new SvxLRSpaceItem(*pItem);
976 20 : StartListening_Impl();
977 : }
978 20 : }
979 20 : void SvxRuler::UpdateParaBorder(const SvxLRSpaceItem * pItem )
980 :
981 : /* [Description]
982 :
983 : Border distance
984 : */
985 :
986 : {
987 20 : if(bActive)
988 : {
989 20 : delete pParaBorderItem; pParaBorderItem = 0;
990 20 : if(pItem)
991 18 : pParaBorderItem = new SvxLRSpaceItem(*pItem);
992 20 : StartListening_Impl();
993 : }
994 20 : }
995 :
996 :
997 2380 : void SvxRuler::UpdatePage()
998 :
999 : /* [Description]
1000 :
1001 : Update view of position and width of page
1002 : */
1003 :
1004 : {
1005 2380 : if(pPagePosItem)
1006 : {
1007 : // all objects are automatically adjusted
1008 20 : if(bHorz)
1009 : SetPagePos(
1010 20 : pEditWin->LogicToPixel(pPagePosItem->GetPos()).X(),
1011 20 : pEditWin->LogicToPixel(Size(pPagePosItem->GetWidth(),0)).
1012 30 : Width());
1013 : else
1014 : SetPagePos(
1015 20 : pEditWin->LogicToPixel(pPagePosItem->GetPos()).Y(),
1016 20 : pEditWin->LogicToPixel(Size(0, pPagePosItem->GetHeight())).
1017 30 : Height());
1018 20 : if(bAppSetNullOffset)
1019 0 : SetNullOffset(ConvertSizePixel(-lAppNullOffset + lLogicNullOffset));
1020 : }
1021 : else
1022 2360 : SetPagePos();
1023 :
1024 2380 : long lPos = 0;
1025 2380 : Point aOwnPos = GetPosPixel();
1026 2380 : Point aEdtWinPos = pEditWin->GetPosPixel();
1027 2380 : if( Application::GetSettings().GetLayoutRTL() && bHorz )
1028 : {
1029 : //#i73321# in RTL the window and the ruler is not mirrored but the
1030 : // influence of the vertical ruler is inverted
1031 0 : Size aOwnSize = GetSizePixel();
1032 0 : Size aEdtWinSize = pEditWin->GetSizePixel();
1033 0 : lPos = aOwnSize.Width() - aEdtWinSize.Width();
1034 0 : lPos -= (aEdtWinPos - aOwnPos).X();
1035 : }
1036 : else
1037 : {
1038 2380 : Point aPos(aEdtWinPos - aOwnPos);
1039 2380 : lPos= bHorz ? aPos.X() : aPos.Y();
1040 : }
1041 :
1042 : // Unfortunately, we get the offset of the edit window to the ruler never
1043 : // through a status message. So we set it ourselves if necessary.
1044 2380 : if(lPos!=pRuler_Imp->lOldWinPos)
1045 : {
1046 186 : pRuler_Imp->lOldWinPos=lPos;
1047 186 : SetWinPos(lPos);
1048 : }
1049 2380 : }
1050 :
1051 :
1052 20 : void SvxRuler::Update
1053 : (
1054 : const SvxPagePosSizeItem *pItem // new value of page attributes
1055 : )
1056 :
1057 : /* [Description]
1058 :
1059 : Store new value of page attributes
1060 : */
1061 :
1062 : {
1063 20 : if(bActive)
1064 : {
1065 20 : delete pPagePosItem; pPagePosItem = 0;
1066 20 : if(pItem)
1067 20 : pPagePosItem = new SvxPagePosSizeItem(*pItem);
1068 20 : StartListening_Impl();
1069 : }
1070 20 : }
1071 :
1072 :
1073 : //
1074 :
1075 208 : void SvxRuler::SetDefTabDist
1076 : (
1077 : long l // New distance for DefaultTabs in App-Metrics
1078 : )
1079 :
1080 : /* [Description]
1081 :
1082 : New distance is set for DefaultTabs
1083 : */
1084 :
1085 : {
1086 :
1087 208 : lDefTabDist = l;
1088 208 : UpdateTabs();
1089 208 : }
1090 :
1091 :
1092 1 : sal_uInt16 ToSvTab_Impl(SvxTabAdjust eAdj)
1093 :
1094 : /* [Description]
1095 :
1096 : Internal convertion routine between SV-Tab.-Enum and Svx
1097 : */
1098 :
1099 : {
1100 1 : switch(eAdj) {
1101 1 : case SVX_TAB_ADJUST_LEFT: return RULER_TAB_LEFT;
1102 0 : case SVX_TAB_ADJUST_RIGHT: return RULER_TAB_RIGHT;
1103 0 : case SVX_TAB_ADJUST_DECIMAL: return RULER_TAB_DECIMAL;
1104 0 : case SVX_TAB_ADJUST_CENTER: return RULER_TAB_CENTER;
1105 0 : case SVX_TAB_ADJUST_DEFAULT: return RULER_TAB_DEFAULT;
1106 : default: ;//prevent warning
1107 : }
1108 0 : return 0;
1109 : }
1110 :
1111 :
1112 0 : SvxTabAdjust ToAttrTab_Impl(sal_uInt16 eAdj)
1113 : {
1114 0 : switch(eAdj) {
1115 0 : case RULER_TAB_LEFT: return SVX_TAB_ADJUST_LEFT ;
1116 0 : case RULER_TAB_RIGHT: return SVX_TAB_ADJUST_RIGHT ;
1117 0 : case RULER_TAB_DECIMAL: return SVX_TAB_ADJUST_DECIMAL ;
1118 0 : case RULER_TAB_CENTER: return SVX_TAB_ADJUST_CENTER ;
1119 0 : case RULER_TAB_DEFAULT: return SVX_TAB_ADJUST_DEFAULT ;
1120 : }
1121 0 : return SVX_TAB_ADJUST_LEFT;
1122 : }
1123 :
1124 :
1125 2588 : void SvxRuler::UpdateTabs()
1126 :
1127 : /* [Description]
1128 :
1129 : Update of Tabs
1130 : */
1131 :
1132 : {
1133 2588 : if(IsDrag())
1134 2588 : return;
1135 2588 : if(pPagePosItem && pParaItem && pTabStopItem && !pObjectItem)
1136 : {
1137 : // buffer for DefaultTabStop
1138 : // Distance last Tab <-> Right paragraph margin / DefaultTabDist
1139 10 : sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
1140 10 : long nLeftFrameMargin = GetLeftFrameMargin();
1141 10 : long nRightFrameMargin = GetRightFrameMargin();
1142 :
1143 : //#i24363# tab stops relative to indent
1144 10 : const long nParaItemTxtLeft = pParaItem->GetTxtLeft();
1145 :
1146 10 : const long lParaIndent = nLeftFrameMargin + nParaItemTxtLeft;
1147 :
1148 : const long lLastTab =
1149 10 : pTabStopItem->Count()?
1150 10 : ConvertHPosPixel((*pTabStopItem)[pTabStopItem->Count()-1].GetTabPos()): 0;
1151 : const long lPosPixel =
1152 10 : ConvertHPosPixel(lParaIndent) + lLastTab;
1153 : const long lRightIndent =
1154 10 : ConvertHPosPixel(nRightFrameMargin - pParaItem->GetRight());
1155 10 : long nDefTabDist = ConvertHPosPixel(lDefTabDist);
1156 10 : if( !nDefTabDist )
1157 0 : nDefTabDist = 1;
1158 : const sal_uInt16 nDefTabBuf = lPosPixel > lRightIndent ||
1159 : lLastTab > lRightIndent
1160 : ? 0
1161 10 : : (sal_uInt16)( (lRightIndent - lPosPixel) / nDefTabDist );
1162 :
1163 10 : if(pTabStopItem->Count() + TAB_GAP + nDefTabBuf > nTabBufSize)
1164 : {
1165 10 : delete[] pTabs;
1166 : // 10 (GAP) in stock
1167 10 : nTabBufSize = pTabStopItem->Count() + TAB_GAP + nDefTabBuf + GAP;
1168 10 : pTabs = new RulerTab[nTabBufSize];
1169 : }
1170 :
1171 10 : nTabCount = 0;
1172 : sal_uInt16 j;
1173 : //#i24363# tab stops relative to indent
1174 10 : const long lRightPixMargin = ConvertSizePixel(nRightFrameMargin - nParaItemTxtLeft );
1175 10 : const long lParaIndentPix = ConvertSizePixel(lParaIndent);
1176 11 : for(j = 0; j < pTabStopItem->Count(); ++j)
1177 : {
1178 1 : const SvxTabStop *pTab = &(*pTabStopItem)[j];
1179 1 : pTabs[nTabCount+TAB_GAP].nPos =
1180 : ConvertHPosPixel(
1181 1 : (pRuler_Imp->bIsTabsRelativeToIndent ? lParaIndent : 0 ) + pTab->GetTabPos() + lAppNullOffset);
1182 1 : if(bRTL)
1183 : {
1184 0 : pTabs[nTabCount+TAB_GAP].nPos = lParaIndentPix + lRightPixMargin - pTabs[nTabCount+TAB_GAP].nPos;
1185 : }
1186 1 : pTabs[nTabCount+TAB_GAP].nStyle = ToSvTab_Impl(pTab->GetAdjustment());
1187 1 : ++nTabCount;
1188 : }
1189 10 : if(!pTabStopItem->Count())
1190 9 : pTabs[0].nPos = bRTL ? lRightPixMargin : lParaIndentPix;
1191 :
1192 : // fill the rest with default Tabs
1193 10 : if(bRTL)
1194 : {
1195 0 : for(j = 0; j < nDefTabBuf; ++j)
1196 : {
1197 0 : pTabs[nTabCount + TAB_GAP].nPos =
1198 0 : pTabs[nTabCount].nPos - nDefTabDist;
1199 :
1200 0 : if(j == 0 )
1201 : pTabs[nTabCount + TAB_GAP].nPos -=
1202 0 : ((pTabs[nTabCount + TAB_GAP].nPos - lRightPixMargin)
1203 0 : % nDefTabDist );
1204 0 : if(pTabs[nTabCount+TAB_GAP].nPos <= lParaIndentPix)
1205 0 : break;
1206 0 : pTabs[nTabCount + TAB_GAP].nStyle = RULER_TAB_DEFAULT;
1207 0 : ++nTabCount;
1208 : }
1209 : }
1210 : else
1211 : {
1212 130 : for(j = 0; j < nDefTabBuf; ++j)
1213 : {
1214 124 : if( j == 0 )
1215 : {
1216 : //set the first default tab stop
1217 10 : if(pRuler_Imp->bIsTabsRelativeToIndent)
1218 : {
1219 1 : pTabs[nTabCount + TAB_GAP].nPos =
1220 1 : (pTabs[nTabCount].nPos + nDefTabDist);
1221 : pTabs[nTabCount + TAB_GAP].nPos -=
1222 1 : ((pTabs[nTabCount + TAB_GAP].nPos - lParaIndentPix)
1223 2 : % nDefTabDist );
1224 : }
1225 : else
1226 : {
1227 9 : if( pTabs[nTabCount].nPos < 0 )
1228 : {
1229 0 : pTabs[nTabCount + TAB_GAP].nPos = ( pTabs[nTabCount].nPos / nDefTabDist ) * nDefTabDist;
1230 : }
1231 : else
1232 : {
1233 9 : pTabs[nTabCount + TAB_GAP].nPos = ( pTabs[nTabCount].nPos / nDefTabDist + 1 ) * nDefTabDist;
1234 : }
1235 : }
1236 :
1237 : }
1238 : else
1239 : {
1240 : //simply add the default distance to the last position
1241 114 : pTabs[nTabCount + TAB_GAP].nPos =
1242 114 : pTabs[nTabCount].nPos + nDefTabDist;
1243 : }
1244 :
1245 124 : if(pTabs[nTabCount+TAB_GAP].nPos >= lRightIndent)
1246 4 : break;
1247 120 : pTabs[nTabCount + TAB_GAP].nStyle = RULER_TAB_DEFAULT;
1248 120 : ++nTabCount;
1249 : }
1250 : }
1251 10 : SetTabs(nTabCount, pTabs+TAB_GAP);
1252 10 : DBG_ASSERT(nTabCount + TAB_GAP <= nTabBufSize, "BufferSize too small");
1253 : }
1254 : else
1255 : {
1256 2578 : SetTabs();
1257 : }
1258 : }
1259 :
1260 :
1261 20 : void SvxRuler::Update
1262 : (
1263 : const SvxTabStopItem *pItem // new value for tabs
1264 : )
1265 :
1266 : /* [Description]
1267 :
1268 : Store new value for tabs; delete old ones if possible
1269 : */
1270 :
1271 : {
1272 20 : if(bActive)
1273 : {
1274 20 : delete pTabStopItem; pTabStopItem = 0;
1275 20 : if(pItem)
1276 : {
1277 10 : pTabStopItem = new SvxTabStopItem(*pItem);
1278 10 : if(!bHorz)
1279 0 : pTabStopItem->SetWhich(SID_ATTR_TABSTOP_VERTICAL);
1280 : }
1281 20 : StartListening_Impl();
1282 : }
1283 20 : }
1284 :
1285 :
1286 0 : void SvxRuler::Update
1287 : (
1288 : const SvxObjectItem *pItem // new value for objects
1289 : )
1290 :
1291 : /* [Description]
1292 :
1293 : Store new value for objects
1294 : */
1295 :
1296 : {
1297 0 : if(bActive)
1298 : {
1299 0 : delete pObjectItem; pObjectItem = 0;
1300 0 : if(pItem)
1301 0 : pObjectItem = new SvxObjectItem(*pItem);
1302 0 : StartListening_Impl();
1303 : }
1304 0 : }
1305 :
1306 :
1307 0 : void SvxRuler::SetNullOffsetLogic
1308 : (
1309 : long lVal // Setting of the logic NullOffsets
1310 : )
1311 : {
1312 0 : lAppNullOffset = lLogicNullOffset - lVal;
1313 0 : bAppSetNullOffset = sal_True;
1314 0 : Ruler::SetNullOffset(ConvertSizePixel(lVal));
1315 0 : Update();
1316 0 : }
1317 :
1318 :
1319 2380 : void SvxRuler::Update()
1320 :
1321 : /* [Description]
1322 :
1323 : Perform update of view
1324 : */
1325 :
1326 : {
1327 2380 : if(IsDrag())
1328 2380 : return;
1329 2380 : UpdatePage();
1330 2380 : UpdateFrame();
1331 2380 : if((nFlags & SVXRULER_SUPPORT_OBJECT) == SVXRULER_SUPPORT_OBJECT)
1332 0 : UpdateObject();
1333 : else
1334 2380 : UpdateColumns();
1335 :
1336 2380 : if(0 != (nFlags & (SVXRULER_SUPPORT_PARAGRAPH_MARGINS |SVXRULER_SUPPORT_PARAGRAPH_MARGINS_VERTICAL)))
1337 2380 : UpdatePara();
1338 2380 : if(0 != (nFlags & SVXRULER_SUPPORT_TABS))
1339 2380 : UpdateTabs();
1340 : }
1341 :
1342 :
1343 0 : inline long SvxRuler::GetPageWidth() const
1344 : {
1345 0 : return bHorz ? pPagePosItem->GetWidth() : pPagePosItem->GetHeight();
1346 :
1347 : }
1348 :
1349 :
1350 0 : inline long SvxRuler::GetFrameLeft() const
1351 :
1352 : /* [Description]
1353 :
1354 : Get Left margin in Pixels
1355 : */
1356 :
1357 :
1358 : {
1359 : return bAppSetNullOffset?
1360 0 : GetMargin1() + ConvertSizePixel(lLogicNullOffset):
1361 0 : Ruler::GetNullOffset();
1362 : }
1363 :
1364 : inline void SvxRuler::SetFrameLeft(long l)
1365 :
1366 : /* [Description]
1367 :
1368 : Set Left margin in Pixels
1369 : */
1370 :
1371 : {
1372 : sal_Bool bProtectColumns =
1373 : pRuler_Imp->aProtectItem.IsSizeProtected() ||
1374 : pRuler_Imp->aProtectItem.IsPosProtected();
1375 : if(bAppSetNullOffset)
1376 : SetMargin1(l - ConvertSizePixel(lLogicNullOffset),
1377 : bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE);
1378 : else
1379 : Ruler::SetNullOffset(l);
1380 : }
1381 :
1382 :
1383 0 : long SvxRuler::GetFirstLineIndent() const
1384 :
1385 : /* [Description]
1386 :
1387 : Get First-line indent in pixels
1388 : */
1389 :
1390 : {
1391 0 : return pParaItem? pIndents[INDENT_FIRST_LINE].nPos: GetMargin1();
1392 : }
1393 :
1394 :
1395 0 : long SvxRuler::GetLeftIndent() const
1396 :
1397 : /* [Description]
1398 :
1399 : Get Left paragraph margin in Pixels
1400 : */
1401 :
1402 : {
1403 0 : return pParaItem? pIndents[INDENT_LEFT_MARGIN].nPos: GetMargin1();
1404 : }
1405 :
1406 :
1407 :
1408 0 : long SvxRuler::GetRightIndent() const
1409 :
1410 : /* [Description]
1411 :
1412 : Get Right paragraph margin in Pixels
1413 : */
1414 :
1415 : {
1416 0 : return pParaItem? pIndents[INDENT_RIGHT_MARGIN].nPos: GetMargin2();
1417 : }
1418 :
1419 :
1420 0 : long SvxRuler::GetLogicRightIndent() const
1421 :
1422 : /* [Description]
1423 :
1424 : Get Right paragraph margin in Logic
1425 : */
1426 :
1427 : {
1428 0 : return pParaItem ? GetRightFrameMargin()-pParaItem->GetRight() : GetRightFrameMargin();
1429 : }
1430 :
1431 : // Left margin in App values, is either the margin (= 0) or the left edge of
1432 : // the column that is set in the column attribute as current column.
1433 20 : long SvxRuler::GetLeftFrameMargin() const
1434 : {
1435 : // #126721# for some unknown reason the current column is set to 0xffff
1436 : DBG_ASSERT(!pColumnItem || pColumnItem->GetActColumn() < pColumnItem->Count(),
1437 : "issue #126721# - invalid current column!");
1438 : long nLeft =
1439 0 : pColumnItem && pColumnItem->Count() && pColumnItem->GetActColumn() < pColumnItem->Count() ?
1440 20 : (*pColumnItem)[pColumnItem->GetActColumn()].nStart : 0;
1441 20 : if(pParaBorderItem && (!pColumnItem || pColumnItem->IsTable()))
1442 18 : nLeft += pParaBorderItem->GetLeft();
1443 20 : return nLeft;
1444 : }
1445 :
1446 0 : inline long SvxRuler::GetLeftMin() const
1447 : {
1448 : DBG_ASSERT(pMinMaxItem, "no MinMax value set");
1449 : return pMinMaxItem?
1450 0 : bHorz? pMinMaxItem->GetValue().Left(): pMinMaxItem->GetValue().Top()
1451 0 : : 0;
1452 : }
1453 :
1454 0 : inline long SvxRuler::GetRightMax() const
1455 : {
1456 : DBG_ASSERT(pMinMaxItem, "no MinMax value set");
1457 : return pMinMaxItem?
1458 0 : bHorz? pMinMaxItem->GetValue().Right(): pMinMaxItem->GetValue().Bottom()
1459 0 : : 0;
1460 : }
1461 :
1462 :
1463 20 : long SvxRuler::GetRightFrameMargin() const
1464 :
1465 : /* [Description]
1466 :
1467 : Get right frame margin (in logical units)
1468 : */
1469 :
1470 : {
1471 20 : if(pColumnItem)
1472 : {
1473 0 : if(!IsActLastColumn( sal_True ))
1474 : {
1475 0 : long nRet = (*pColumnItem)[GetActRightColumn( sal_True )].nEnd;
1476 0 : if(pColumnItem->IsTable() && pParaBorderItem)
1477 0 : nRet -= pParaBorderItem->GetRight();
1478 0 : return nRet;
1479 : }
1480 : }
1481 :
1482 20 : long l = lLogicNullOffset;
1483 :
1484 : // If possible deduct right table entry
1485 20 : if(pColumnItem && pColumnItem->IsTable())
1486 0 : l += pColumnItem->GetRight();
1487 20 : else if(bHorz && pLRSpaceItem)
1488 20 : l += pLRSpaceItem->GetRight();
1489 0 : else if(!bHorz && pULSpaceItem)
1490 0 : l += pULSpaceItem->GetLower();
1491 :
1492 38 : if(pParaBorderItem &&
1493 18 : (!pColumnItem || pColumnItem->IsTable()||IsActLastColumn( sal_True )))
1494 18 : l += pParaBorderItem->GetRight();
1495 :
1496 20 : if(bHorz)
1497 20 : l = pPagePosItem->GetWidth() - l;
1498 : else
1499 0 : l = pPagePosItem->GetHeight() - l;
1500 20 : return l;
1501 : }
1502 :
1503 : #define NEG_FLAG ( (nFlags & SVXRULER_SUPPORT_NEGATIVE_MARGINS) == \
1504 : SVXRULER_SUPPORT_NEGATIVE_MARGINS )
1505 : #define TAB_FLAG ( pColumnItem && pColumnItem->IsTable() )
1506 :
1507 0 : long SvxRuler::GetCorrectedDragPos( sal_Bool bLeft, sal_Bool bRight )
1508 :
1509 : /* [Description]
1510 :
1511 : Corrects the position within the calculated limits. The limit values are in
1512 : pixels relative to the page edge.
1513 : */
1514 :
1515 : {
1516 0 : const long lNullPix = Ruler::GetNullOffset();
1517 0 : long lDragPos = GetDragPos() + lNullPix;
1518 : ADD_DEBUG_TEXT("lDragPos: ", String::CreateFromInt32(lDragPos))
1519 0 : sal_Bool bHoriRows = bHorz && pRuler_Imp->bIsTableRows;
1520 0 : if((bLeft || (bHoriRows)) && lDragPos < nMaxLeft)
1521 0 : lDragPos = nMaxLeft;
1522 0 : else if((bRight||bHoriRows) && lDragPos > nMaxRight)
1523 0 : lDragPos = nMaxRight;
1524 0 : return lDragPos - lNullPix;
1525 : }
1526 :
1527 :
1528 :
1529 0 : void ModifyTabs_Impl
1530 : (
1531 : sal_uInt16 nCount, // Number of Tabs
1532 : RulerTab *pTabs, // Tab buffer
1533 : long lDiff // difference to be added
1534 : )
1535 :
1536 : /* [Description]
1537 :
1538 : Helper function, move all the tabs by a fixed value
1539 : */
1540 : {
1541 0 : if( pTabs )
1542 0 : for(sal_uInt16 i = 0; i < nCount; ++i) pTabs[i].nPos += lDiff;
1543 0 : }
1544 :
1545 :
1546 :
1547 0 : void SvxRuler::DragMargin1()
1548 :
1549 : /* [Description]
1550 :
1551 : Dragging the left edge of frame
1552 : */
1553 : {
1554 0 : const long lDragPos = GetCorrectedDragPos( !TAB_FLAG || !NEG_FLAG, sal_True );
1555 0 : DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 3 : 7, bHorz);
1556 0 : if(pColumnItem&&
1557 : (nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL))
1558 0 : DragBorders();
1559 0 : AdjustMargin1(lDragPos);
1560 0 : }
1561 0 : void SvxRuler::AdjustMargin1(long lDiff)
1562 : {
1563 0 : const long nOld = bAppSetNullOffset? GetMargin1(): GetNullOffset();
1564 0 : const long lDragPos = lDiff;
1565 : sal_Bool bProtectColumns =
1566 0 : pRuler_Imp->aProtectItem.IsSizeProtected() ||
1567 0 : pRuler_Imp->aProtectItem.IsPosProtected();
1568 :
1569 : const sal_uInt16 nMarginStyle =
1570 0 : bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE;
1571 :
1572 0 : if(!bAppSetNullOffset)
1573 : {
1574 0 : long _lDiff = lDragPos;
1575 0 : SetNullOffset(nOld + _lDiff);
1576 0 : if(!pColumnItem||!(nDragType & DRAG_OBJECT_SIZE_LINEAR))
1577 : {
1578 0 : SetMargin2( GetMargin2() - _lDiff, nMarginStyle );
1579 :
1580 0 : if(!pColumnItem && !pObjectItem && pParaItem)
1581 : {
1582 : // Right indent of the old position
1583 0 : pIndents[INDENT_RIGHT_MARGIN].nPos -= _lDiff;
1584 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1585 : }
1586 0 : if(pObjectItem)
1587 : {
1588 0 : pObjectBorders[GetObjectBordersOff(0)].nPos -= _lDiff;
1589 0 : pObjectBorders[GetObjectBordersOff(1)].nPos -= _lDiff;
1590 0 : SetBorders(2, pObjectBorders + GetObjectBordersOff(0));
1591 : }
1592 0 : if(pColumnItem)
1593 : {
1594 0 : for(sal_uInt16 i = 0; i < pColumnItem->Count()-1; ++i)
1595 0 : pBorders[i].nPos -= _lDiff;
1596 0 : SetBorders(pColumnItem->Count()-1, pBorders);
1597 0 : if(pColumnItem->IsFirstAct())
1598 : {
1599 : // Right indent of the old position
1600 0 : if(pParaItem)
1601 : {
1602 0 : pIndents[INDENT_RIGHT_MARGIN].nPos -= _lDiff;
1603 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1604 : }
1605 : }
1606 : else
1607 : {
1608 0 : if(pParaItem)
1609 : {
1610 0 : pIndents[INDENT_FIRST_LINE].nPos -= _lDiff;
1611 0 : pIndents[INDENT_LEFT_MARGIN].nPos -= _lDiff;
1612 0 : pIndents[INDENT_RIGHT_MARGIN].nPos -= _lDiff;
1613 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1614 : }
1615 : }
1616 0 : if(pTabStopItem&& (nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
1617 0 : &&!IsActFirstColumn())
1618 : {
1619 0 : ModifyTabs_Impl(nTabCount+TAB_GAP, pTabs, -_lDiff);
1620 0 : SetTabs(nTabCount, pTabs+TAB_GAP);
1621 : }
1622 : }
1623 : }
1624 : }
1625 : else
1626 : {
1627 0 : long _lDiff = lDragPos - nOld;
1628 0 : SetMargin1(nOld + _lDiff, nMarginStyle );
1629 :
1630 0 : if(!pColumnItem||!(nDragType & (DRAG_OBJECT_SIZE_LINEAR |
1631 0 : DRAG_OBJECT_SIZE_PROPORTIONAL)))
1632 : {
1633 0 : if(!pColumnItem && !pObjectItem && pParaItem)
1634 : {
1635 : // Left indent of the old position
1636 0 : pIndents[INDENT_FIRST_LINE].nPos += _lDiff;
1637 0 : pIndents[INDENT_LEFT_MARGIN].nPos += _lDiff;
1638 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1639 : }
1640 :
1641 0 : if(pColumnItem)
1642 : {
1643 0 : for(sal_uInt16 i = 0; i < pColumnItem->Count()-1; ++i)
1644 0 : pBorders[i].nPos += _lDiff;
1645 0 : SetBorders(pColumnItem->Count()-1, pBorders);
1646 0 : if(pColumnItem->IsFirstAct())
1647 : {
1648 : // Left indent of the old position
1649 0 : if(pParaItem)
1650 : {
1651 0 : pIndents[INDENT_FIRST_LINE].nPos += _lDiff;
1652 0 : pIndents[INDENT_LEFT_MARGIN].nPos += _lDiff;
1653 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1654 : }
1655 : }
1656 : else
1657 : {
1658 0 : if(pParaItem)
1659 : {
1660 0 : pIndents[INDENT_FIRST_LINE].nPos += _lDiff;
1661 0 : pIndents[INDENT_LEFT_MARGIN].nPos += _lDiff;
1662 0 : pIndents[INDENT_RIGHT_MARGIN].nPos += _lDiff;
1663 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1664 : }
1665 : }
1666 : }
1667 0 : if(pTabStopItem)
1668 : {
1669 0 : ModifyTabs_Impl(nTabCount+TAB_GAP, pTabs, _lDiff);
1670 0 : SetTabs(nTabCount, pTabs+TAB_GAP);
1671 : }
1672 : }
1673 : }
1674 0 : }
1675 :
1676 :
1677 0 : void SvxRuler::DragMargin2()
1678 :
1679 : /* [Description]
1680 :
1681 : Dragging the right edge of frame
1682 : */
1683 : {
1684 0 : const long lDragPos = GetCorrectedDragPos( sal_True, !TAB_FLAG || !NEG_FLAG);
1685 0 : DrawLine_Impl(lTabPos, ( TAB_FLAG && NEG_FLAG ) ? 5 : 7, bHorz);
1686 0 : long lDiff = lDragPos - GetMargin2();
1687 :
1688 0 : if(pRuler_Imp->bIsTableRows && !bHorz && pColumnItem&&
1689 : (nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL))
1690 0 : DragBorders();
1691 :
1692 : sal_Bool bProtectColumns =
1693 0 : pRuler_Imp->aProtectItem.IsSizeProtected() ||
1694 0 : pRuler_Imp->aProtectItem.IsPosProtected();
1695 : const sal_uInt16 nMarginStyle =
1696 0 : bProtectColumns ? 0 : RULER_MARGIN_SIZEABLE;
1697 0 : SetMargin2( lDragPos, nMarginStyle );
1698 :
1699 : // Right indent of the old position
1700 0 : if((!pColumnItem || IsActLastColumn()) && pParaItem)
1701 : {
1702 0 : pIndents[INDENT_FIRST_LINE].nPos += lDiff;
1703 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1704 : }
1705 0 : }
1706 :
1707 :
1708 0 : void SvxRuler::DragIndents()
1709 :
1710 : /* [Description]
1711 :
1712 : Dragging the paragraph indents
1713 : */
1714 : {
1715 0 : const long lDragPos = NEG_FLAG ? GetDragPos() : GetCorrectedDragPos();
1716 0 : const sal_uInt16 nIdx = GetDragAryPos()+INDENT_GAP;
1717 0 : const long lDiff = pIndents[nIdx].nPos - lDragPos;
1718 :
1719 0 : if((nIdx == INDENT_FIRST_LINE ||
1720 : nIdx == INDENT_LEFT_MARGIN ) &&
1721 : (nDragType & DRAG_OBJECT_LEFT_INDENT_ONLY) !=
1722 : DRAG_OBJECT_LEFT_INDENT_ONLY)
1723 0 : pIndents[INDENT_FIRST_LINE].nPos -= lDiff;
1724 :
1725 0 : pIndents[nIdx].nPos = lDragPos;
1726 :
1727 0 : SetIndents(INDENT_COUNT, pIndents + INDENT_GAP);
1728 0 : DrawLine_Impl(lTabPos, 1, bHorz);
1729 0 : }
1730 :
1731 :
1732 0 : void SvxRuler::DrawLine_Impl(long &_lTabPos, int nNew, sal_Bool Hori)
1733 :
1734 : /* [Description]
1735 :
1736 : Output routine for the ledger line when moving tabs, tables and other
1737 : columns
1738 : */
1739 : {
1740 0 : if(Hori)
1741 : {
1742 0 : const long nHeight = pEditWin->GetOutputSize().Height();
1743 0 : Point aZero=pEditWin->GetMapMode().GetOrigin();
1744 0 : if(_lTabPos!=-1)
1745 : pEditWin->InvertTracking(
1746 0 : Rectangle( Point(_lTabPos, -aZero.Y()),
1747 0 : Point(_lTabPos, -aZero.Y()+nHeight)),
1748 0 : SHOWTRACK_SPLIT | SHOWTRACK_CLIP );
1749 0 : if( nNew & 1 )
1750 : {
1751 :
1752 : _lTabPos = ConvertHSizeLogic(
1753 0 : GetCorrectedDragPos( ( nNew&4 ) != 0, ( nNew&2 ) != 0 ) +
1754 0 : GetNullOffset() );
1755 0 : if(pPagePosItem)
1756 0 : _lTabPos += pPagePosItem->GetPos().X();
1757 : pEditWin->InvertTracking(
1758 0 : Rectangle(Point(_lTabPos, -aZero.Y()),
1759 0 : Point(_lTabPos, -aZero.Y()+nHeight)),
1760 0 : SHOWTRACK_CLIP | SHOWTRACK_SPLIT );
1761 : }
1762 : }
1763 : else
1764 : {
1765 0 : const long nWidth = pEditWin->GetOutputSize().Width();
1766 0 : Point aZero=pEditWin->GetMapMode().GetOrigin();
1767 0 : if(_lTabPos != -1)
1768 : {
1769 : pEditWin->InvertTracking(
1770 0 : Rectangle( Point(-aZero.X(), _lTabPos),
1771 0 : Point(-aZero.X()+nWidth, _lTabPos)),
1772 0 : SHOWTRACK_SPLIT | SHOWTRACK_CLIP );
1773 : }
1774 :
1775 0 : if(nNew & 1)
1776 : {
1777 0 : _lTabPos = ConvertVSizeLogic(GetCorrectedDragPos()+GetNullOffset());
1778 0 : if(pPagePosItem)
1779 0 : _lTabPos += pPagePosItem->GetPos().Y();
1780 : pEditWin->InvertTracking(
1781 0 : Rectangle( Point(-aZero.X(), _lTabPos),
1782 0 : Point(-aZero.X()+nWidth, _lTabPos)),
1783 0 : SHOWTRACK_CLIP | SHOWTRACK_SPLIT );
1784 : }
1785 : }
1786 0 : }
1787 :
1788 :
1789 :
1790 :
1791 0 : void SvxRuler::DragTabs()
1792 :
1793 : /* [Description]
1794 :
1795 : Dragging of Tabs
1796 : */
1797 : {
1798 :
1799 0 : long lDragPos = GetCorrectedDragPos(sal_True, sal_False);
1800 :
1801 0 : sal_uInt16 nIdx = GetDragAryPos()+TAB_GAP;
1802 0 : DrawLine_Impl(lTabPos, 7, bHorz);
1803 :
1804 0 : long nDiff = lDragPos - pTabs[nIdx].nPos;
1805 :
1806 0 : if(nDragType & DRAG_OBJECT_SIZE_LINEAR)
1807 : {
1808 :
1809 0 : for(sal_uInt16 i = nIdx; i < nTabCount; ++i)
1810 : {
1811 0 : pTabs[i].nPos += nDiff;
1812 : // limit on maximum
1813 0 : if(pTabs[i].nPos > GetMargin2())
1814 0 : pTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
1815 : else
1816 0 : pTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE;
1817 : }
1818 : }
1819 0 : else if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
1820 : {
1821 0 : pRuler_Imp->nTotalDist -= nDiff;
1822 0 : pTabs[nIdx].nPos = lDragPos;
1823 0 : for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i)
1824 : {
1825 0 : if(pTabs[i].nStyle & RULER_TAB_DEFAULT)
1826 : // can be canceled at the DefaultTabs
1827 0 : break;
1828 0 : long nDelta = pRuler_Imp->nTotalDist * pRuler_Imp->pPercBuf[i];
1829 0 : nDelta /= 1000;
1830 0 : pTabs[i].nPos = pTabs[nIdx].nPos + nDelta;
1831 0 : if(pTabs[i].nPos+GetNullOffset() > nMaxRight)
1832 0 : pTabs[i].nStyle |= RULER_STYLE_INVISIBLE;
1833 : else
1834 0 : pTabs[i].nStyle &= ~RULER_STYLE_INVISIBLE;
1835 : }
1836 : }
1837 : else
1838 0 : pTabs[nIdx].nPos = lDragPos;
1839 :
1840 0 : if(IsDragDelete())
1841 0 : pTabs[nIdx].nStyle |= RULER_STYLE_INVISIBLE;
1842 : else
1843 0 : pTabs[nIdx].nStyle &= ~RULER_STYLE_INVISIBLE;
1844 0 : SetTabs(nTabCount, pTabs+TAB_GAP);
1845 0 : }
1846 :
1847 :
1848 :
1849 1888 : void SvxRuler::SetActive(sal_Bool bOn)
1850 : {
1851 1888 : if(bOn)
1852 : {
1853 944 : Activate();
1854 : }
1855 : else
1856 944 : Deactivate();
1857 1888 : if(bActive!=bOn)
1858 : {
1859 1416 : pBindings->EnterRegistrations();
1860 1416 : if(bOn)
1861 5192 : for(sal_uInt16 i=0;i<pRuler_Imp->nControlerItems;i++)
1862 4720 : pCtrlItem[i]->ReBind();
1863 : else
1864 10384 : for(sal_uInt16 j=0;j<pRuler_Imp->nControlerItems;j++)
1865 9440 : pCtrlItem[j]->UnBind();
1866 1416 : pBindings->LeaveRegistrations();
1867 : }
1868 1888 : bActive = bOn;
1869 1888 : }
1870 :
1871 :
1872 :
1873 :
1874 0 : void SvxRuler::UpdateParaContents_Impl
1875 : (
1876 : long l, // Difference
1877 : UpdateType eType // Art (all, left or right)
1878 : )
1879 :
1880 : /* [Description]
1881 :
1882 : Helper function; carry Tabs and Paragraph Margins
1883 : */
1884 : {
1885 0 : switch(eType) {
1886 : case MOVE_RIGHT:
1887 0 : pIndents[INDENT_RIGHT_MARGIN].nPos += l;
1888 0 : break;
1889 : case MOVE_ALL:
1890 0 : pIndents[INDENT_RIGHT_MARGIN].nPos += l;
1891 : // no break
1892 : case MOVE_LEFT:
1893 : {
1894 0 : pIndents[INDENT_FIRST_LINE].nPos += l;
1895 0 : pIndents[INDENT_LEFT_MARGIN].nPos += l;
1896 0 : if ( pTabs )
1897 : {
1898 0 : for(sal_uInt16 i = 0; i < nTabCount+TAB_GAP;++i)
1899 0 : pTabs[i].nPos += l;
1900 0 : SetTabs(nTabCount, pTabs+TAB_GAP);
1901 : }
1902 0 : break;
1903 : }
1904 : }
1905 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
1906 0 : }
1907 :
1908 :
1909 0 : void SvxRuler::DragBorders()
1910 :
1911 : /* [Description]
1912 :
1913 : Dragging of Borders (Tables and other columns)
1914 : */
1915 : {
1916 0 : sal_Bool bLeftIndentsCorrected = sal_False, bRightIndentsCorrected = sal_False;
1917 : int nIdx;
1918 :
1919 0 : if(GetDragType()==RULER_TYPE_BORDER)
1920 : {
1921 0 : DrawLine_Impl(lTabPos, 7, bHorz);
1922 0 : nIdx = GetDragAryPos();
1923 : }
1924 : else
1925 0 : nIdx=0;
1926 :
1927 0 : sal_uInt16 nDragSize = GetDragSize();
1928 0 : long lDiff = 0;
1929 :
1930 : // the drag position has to be corrected to be able to prevent borders from passing each other
1931 0 : long lPos = GetCorrectedDragPos();
1932 :
1933 :
1934 0 : switch(nDragSize)
1935 : {
1936 : case RULER_DRAGSIZE_MOVE:
1937 : {
1938 : ADD_DEBUG_TEXT("lLastLMargin: ", String::CreateFromInt32(pRuler_Imp->lLastLMargin))
1939 0 : lDiff = GetDragType()==RULER_TYPE_BORDER ?
1940 0 : lPos-nDragOffset - pBorders[nIdx].nPos
1941 0 : : GetDragType() == RULER_TYPE_MARGIN1 ? lPos - pRuler_Imp->lLastLMargin : lPos - pRuler_Imp->lLastRMargin;
1942 :
1943 0 : if(nDragType & DRAG_OBJECT_SIZE_LINEAR)
1944 : {
1945 0 : long nRight = GetMargin2()-lMinFrame; // Right limiters
1946 0 : for(int i = nBorderCount-2; i >= nIdx; --i)
1947 : {
1948 0 : long l = pBorders[i].nPos;
1949 0 : pBorders[i].nPos += lDiff;
1950 0 : pBorders[i].nPos = Min(pBorders[i].nPos, nRight - pBorders[i].nWidth);
1951 0 : nRight = pBorders[i].nPos - lMinFrame;
1952 : // RR update the column
1953 0 : if(i == GetActRightColumn())
1954 : {
1955 0 : UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_RIGHT);
1956 0 : bRightIndentsCorrected = sal_True;
1957 : }
1958 : // LAR, EZE update the column
1959 0 : else if(i == GetActLeftColumn())
1960 : {
1961 0 : UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_LEFT);
1962 0 : bLeftIndentsCorrected = sal_True;
1963 : }
1964 : }
1965 : }
1966 0 : else if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
1967 : {
1968 : int nLimit;
1969 : long lLeft;
1970 0 : int nStartLimit = nBorderCount-2;
1971 0 : switch(GetDragType())
1972 : {
1973 : default: ;//prevent warning
1974 : OSL_FAIL("svx::SvxRuler::DragBorders(), unknown drag type!" );
1975 : case RULER_TYPE_BORDER:
1976 0 : if(pRuler_Imp->bIsTableRows)
1977 : {
1978 0 : pBorders[nIdx].nPos += lDiff;
1979 0 : if(bHorz)
1980 : {
1981 0 : lLeft = pBorders[nIdx].nPos;
1982 0 : pRuler_Imp->nTotalDist -= lDiff;
1983 0 : nLimit=nIdx+1;
1984 : }
1985 : else
1986 : {
1987 0 : lLeft = 0;
1988 0 : nStartLimit = nIdx - 1;
1989 0 : pRuler_Imp->nTotalDist += lDiff;
1990 0 : nLimit = 0;
1991 : }
1992 : }
1993 : else
1994 : {
1995 0 : nLimit=nIdx+1;
1996 0 : pBorders[nIdx].nPos += lDiff;
1997 0 : lLeft = pBorders[nIdx].nPos;
1998 0 : pRuler_Imp->nTotalDist-=lDiff;
1999 : }
2000 0 : break;
2001 : case RULER_TYPE_MARGIN1:
2002 0 : nLimit=0;
2003 0 : lLeft=pRuler_Imp->lLastLMargin+lDiff;
2004 0 : pRuler_Imp->nTotalDist-=lDiff;
2005 0 : break;
2006 : case RULER_TYPE_MARGIN2:
2007 0 : nLimit = 0;
2008 0 : lLeft= 0;
2009 0 : nStartLimit = nBorderCount - 2;
2010 0 : pRuler_Imp->nTotalDist += lDiff;
2011 0 : break;
2012 : }
2013 :
2014 0 : for(int i = nStartLimit; i >= nLimit; --i)
2015 : {
2016 :
2017 0 : long l = pBorders[i].nPos;
2018 0 : pBorders[i].nPos=lLeft+
2019 0 : (pRuler_Imp->nTotalDist*pRuler_Imp->pPercBuf[i])/1000+
2020 0 : pRuler_Imp->pBlockBuf[i];
2021 :
2022 : // RR update the column
2023 0 : if(!pRuler_Imp->bIsTableRows)
2024 : {
2025 0 : if(i == GetActRightColumn())
2026 : {
2027 0 : UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_RIGHT);
2028 0 : bRightIndentsCorrected = sal_True;
2029 : }
2030 : // LAR, EZE update the column
2031 0 : else if(i == GetActLeftColumn())
2032 : {
2033 0 : UpdateParaContents_Impl(pBorders[i].nPos - l, MOVE_LEFT);
2034 0 : bLeftIndentsCorrected = sal_True;
2035 : }
2036 : }
2037 : }
2038 0 : if(pRuler_Imp->bIsTableRows)
2039 : {
2040 : //in vertical tables the left borders have to be moved
2041 0 : if(bHorz)
2042 : {
2043 0 : for(int i = 0; i < nIdx; ++i)
2044 0 : pBorders[i].nPos += lDiff;
2045 0 : AdjustMargin1(lDiff);
2046 : }
2047 : else
2048 : {
2049 : //otherwise the right borders are moved
2050 0 : for(int i = pColumnItem->Count() - 1; i > nIdx; --i)
2051 0 : pBorders[i].nPos += lDiff;
2052 0 : SetMargin2( GetMargin2() + lDiff, 0 );
2053 : }
2054 : }
2055 : }
2056 0 : else if(pRuler_Imp->bIsTableRows)
2057 : {
2058 : //moving rows: if a row is resized all following rows
2059 : //have to be moved by the same amount.
2060 : //This includes the left border when the table is not limited
2061 : //to a lower frame border.
2062 : int nLimit;
2063 0 : if(GetDragType()==RULER_TYPE_BORDER)
2064 : {
2065 0 : nLimit=nIdx+1;
2066 0 : pBorders[nIdx].nPos+=lDiff;
2067 : }
2068 : else
2069 : {
2070 0 : nLimit=0;
2071 : }
2072 : //in vertical tables the left borders have to be moved
2073 0 : if(bHorz)
2074 : {
2075 0 : for(int i = 0; i < nIdx; ++i)
2076 : {
2077 0 : pBorders[i].nPos += lDiff;
2078 : }
2079 0 : AdjustMargin1(lDiff);
2080 : }
2081 : else
2082 : {
2083 : //otherwise the right borders are moved
2084 0 : for(int i = nBorderCount-2; i >= nLimit; --i)
2085 : {
2086 0 : pBorders[i].nPos += lDiff;
2087 : }
2088 0 : SetMargin2( GetMargin2() + lDiff, 0 );
2089 : }
2090 : }
2091 : else
2092 0 : pBorders[nIdx].nPos+=lDiff;
2093 0 : break;
2094 : }
2095 : case RULER_DRAGSIZE_1:
2096 : {
2097 0 : lDiff = lPos - pBorders[nIdx].nPos;
2098 0 : pBorders[nIdx].nWidth += pBorders[nIdx].nPos - lPos;
2099 0 : pBorders[nIdx].nPos = lPos;
2100 0 : break;
2101 : }
2102 : case RULER_DRAGSIZE_2:
2103 : {
2104 0 : const long nOld = pBorders[nIdx].nWidth;
2105 0 : pBorders[nIdx].nWidth = lPos - pBorders[nIdx].nPos;
2106 0 : lDiff = pBorders[nIdx].nWidth - nOld;
2107 0 : break;
2108 : }
2109 : }
2110 0 : if(!bRightIndentsCorrected &&
2111 0 : GetActRightColumn() == nIdx &&
2112 : nDragSize != RULER_DRAGSIZE_2 && pIndents &&
2113 0 : !pRuler_Imp->bIsTableRows)
2114 : {
2115 0 : UpdateParaContents_Impl(lDiff, MOVE_RIGHT);
2116 : }
2117 0 : else if(!bLeftIndentsCorrected &&
2118 0 : GetActLeftColumn()==nIdx &&
2119 : nDragSize != RULER_DRAGSIZE_1 && pIndents)
2120 : {
2121 0 : UpdateParaContents_Impl(lDiff, MOVE_LEFT);
2122 : }
2123 0 : SetBorders(pColumnItem->Count()-1, pBorders);
2124 0 : }
2125 :
2126 :
2127 0 : void SvxRuler::DragObjectBorder()
2128 :
2129 : /* [Description]
2130 :
2131 : Dragging of object edges
2132 : */
2133 : {
2134 0 : if(RULER_DRAGSIZE_MOVE == GetDragSize())
2135 : {
2136 0 : const long lPos = GetCorrectedDragPos();
2137 0 : const sal_uInt16 nIdx = GetDragAryPos();
2138 0 : pObjectBorders[GetObjectBordersOff(nIdx)].nPos = lPos;
2139 0 : SetBorders(2, pObjectBorders + GetObjectBordersOff(0));
2140 0 : DrawLine_Impl(lTabPos, 7, bHorz);
2141 :
2142 : }
2143 0 : }
2144 :
2145 :
2146 0 : void SvxRuler::ApplyMargins()
2147 :
2148 : /* [Description]
2149 :
2150 : Applying margins; changed by dragging.
2151 : */
2152 : {
2153 0 : const SfxPoolItem *pItem = 0;
2154 0 : sal_uInt16 nId = SID_ATTR_LONG_LRSPACE;
2155 0 : if(bHorz)
2156 : {
2157 0 : const long lOldNull = lLogicNullOffset;
2158 0 : if(pRuler_Imp->lMaxLeftLogic!=-1&&nMaxLeft==GetMargin1()+Ruler::GetNullOffset())
2159 0 : pLRSpaceItem->SetLeft(lLogicNullOffset=pRuler_Imp->lMaxLeftLogic);
2160 : else
2161 : pLRSpaceItem->SetLeft(PixelHAdjust(
2162 0 : lLogicNullOffset = ConvertHPosLogic(GetFrameLeft()) -
2163 0 : lAppNullOffset, pLRSpaceItem->GetLeft()));
2164 :
2165 0 : if(bAppSetNullOffset)
2166 0 : lAppNullOffset += lLogicNullOffset - lOldNull;
2167 :
2168 0 : if(pRuler_Imp->lMaxRightLogic!=-1
2169 0 : &&nMaxRight==GetMargin2()+Ruler::GetNullOffset())
2170 0 : pLRSpaceItem->SetRight(GetPageWidth()-pRuler_Imp->lMaxRightLogic);
2171 : else
2172 : pLRSpaceItem->SetRight(
2173 : PixelHAdjust(
2174 0 : Max((long)0,pPagePosItem->GetWidth() -
2175 0 : pLRSpaceItem->GetLeft() -
2176 0 : (ConvertHPosLogic(GetMargin2()) -
2177 0 : lAppNullOffset)),pLRSpaceItem->GetRight()));
2178 0 : pItem = pLRSpaceItem;
2179 : #ifdef DEBUGLIN
2180 : Debug_Impl(pEditWin,*pLRSpaceItem);
2181 : #endif // DEBUGLIN
2182 : }
2183 : else {
2184 0 : const long lOldNull = lLogicNullOffset;
2185 : pULSpaceItem->SetUpper(
2186 : PixelVAdjust(
2187 : lLogicNullOffset =
2188 0 : ConvertVPosLogic(GetFrameLeft()) -
2189 0 : lAppNullOffset,pULSpaceItem->GetUpper()));
2190 0 : if(bAppSetNullOffset)
2191 0 : lAppNullOffset += lLogicNullOffset - lOldNull;
2192 : pULSpaceItem->SetLower(
2193 : PixelVAdjust(
2194 0 : Max((long)0, pPagePosItem->GetHeight() -
2195 0 : pULSpaceItem->GetUpper() -
2196 0 : (ConvertVPosLogic(GetMargin2()) -
2197 0 : lAppNullOffset)),pULSpaceItem->GetLower()));
2198 0 : pItem = pULSpaceItem;
2199 0 : nId = SID_ATTR_LONG_ULSPACE;
2200 : #ifdef DEBUGLIN
2201 : Debug_Impl(pEditWin,*pULSpaceItem);
2202 : #endif // DEBUGLIN
2203 : }
2204 0 : pBindings->GetDispatcher()->Execute( nId, SFX_CALLMODE_RECORD, pItem, 0L );
2205 0 : if(pTabStopItem)
2206 0 : UpdateTabs();
2207 0 : }
2208 :
2209 :
2210 0 : void SvxRuler::ApplyIndents()
2211 :
2212 : /* [Description]
2213 :
2214 : Applying paragraph settings; changed by dragging.
2215 : */
2216 : {
2217 : long nNewTxtLeft;
2218 0 : if(pColumnItem&&!IsActFirstColumn( sal_True ))
2219 : {
2220 0 : long nLeftCol=GetActLeftColumn( sal_True );
2221 : nNewTxtLeft =
2222 : PixelHAdjust(
2223 : ConvertHPosLogic(
2224 0 : pIndents[INDENT_LEFT_MARGIN].nPos-
2225 0 : (pBorders[nLeftCol].nPos +
2226 0 : pBorders[nLeftCol].nWidth))-
2227 0 : lAppNullOffset,pParaItem->GetTxtLeft());
2228 : }
2229 : else
2230 : nNewTxtLeft =
2231 : PixelHAdjust(
2232 0 : ConvertHPosLogic(pIndents[INDENT_LEFT_MARGIN].nPos),
2233 0 : pParaItem->GetTxtLeft());
2234 :
2235 0 : sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
2236 :
2237 : long nNewFirstLineOffset;
2238 0 : if(bRTL)
2239 : {
2240 0 : long nRightFrameMargin = GetRightFrameMargin();
2241 : nNewFirstLineOffset = PixelHAdjust(nRightFrameMargin -
2242 0 : ConvertHPosLogic(pIndents[INDENT_FIRST_LINE].nPos ) -
2243 : lAppNullOffset,
2244 0 : pParaItem->GetTxtFirstLineOfst());
2245 : }
2246 : else
2247 : nNewFirstLineOffset=
2248 : PixelHAdjust(
2249 0 : ConvertHPosLogic(pIndents[INDENT_FIRST_LINE].nPos -
2250 0 : pIndents[INDENT_LEFT_MARGIN].nPos) -
2251 : lAppNullOffset,
2252 0 : pParaItem->GetTxtFirstLineOfst());
2253 :
2254 : // If the new TxtLeft is smaller than the old FirstLineIndent, then the
2255 : // difference is lost and the paragraph is in total indented too far,
2256 : // so first set the FirstLineOffset, then the TxtLeft
2257 :
2258 0 : if(bRTL)
2259 : {
2260 0 : long nLeftFrameMargin = GetLeftFrameMargin();
2261 0 : long nRightFrameMargin = GetRightFrameMargin();
2262 0 : nNewTxtLeft = nRightFrameMargin - nNewTxtLeft - nLeftFrameMargin;
2263 0 : nNewFirstLineOffset -= nNewTxtLeft;
2264 0 : if(pParaBorderItem)
2265 : {
2266 0 : nNewTxtLeft += pParaBorderItem->GetLeft() + pParaBorderItem->GetRight();
2267 0 : nNewFirstLineOffset -= pParaBorderItem->GetRight();
2268 : }
2269 : }
2270 : pParaItem->SetTxtFirstLineOfst(
2271 0 : sal::static_int_cast< short >(nNewFirstLineOffset));
2272 0 : pParaItem->SetTxtLeft(nNewTxtLeft);
2273 :
2274 0 : if(pColumnItem && ((!bRTL && !IsActLastColumn( sal_True ))|| (bRTL && !IsActFirstColumn())))
2275 : {
2276 0 : if(bRTL)
2277 : {
2278 0 : long nActBorder = pBorders[GetActLeftColumn( sal_True )].nPos;
2279 0 : long nRightMargin = pIndents[INDENT_RIGHT_MARGIN].nPos;
2280 0 : long nConvert = ConvertHPosLogic( nRightMargin - nActBorder );
2281 0 : pParaItem->SetRight( PixelHAdjust( nConvert - lAppNullOffset, pParaItem->GetRight() ) );
2282 : }
2283 : else
2284 : {
2285 : pParaItem->SetRight(
2286 : PixelHAdjust(
2287 : ConvertHPosLogic(
2288 0 : pBorders[GetActRightColumn( sal_True )].nPos -
2289 0 : pIndents[INDENT_RIGHT_MARGIN].nPos) -
2290 : lAppNullOffset,
2291 0 : pParaItem->GetRight()));
2292 : }
2293 :
2294 : }
2295 : else
2296 : {
2297 0 : if(bRTL)
2298 : {
2299 : pParaItem->SetRight( PixelHAdjust(
2300 0 : ConvertHPosLogic(GetMargin1() +
2301 0 : pIndents[INDENT_RIGHT_MARGIN].nPos) - GetLeftFrameMargin() +
2302 0 : (pParaBorderItem ? pParaBorderItem->GetLeft() : 0) -
2303 0 : lAppNullOffset, pParaItem->GetRight()));
2304 : }
2305 : else
2306 : {
2307 : pParaItem->SetRight( PixelHAdjust(
2308 0 : ConvertHPosLogic(GetMargin2() -
2309 0 : pIndents[INDENT_RIGHT_MARGIN].nPos) -
2310 0 : lAppNullOffset, pParaItem->GetRight()));
2311 : }
2312 : }
2313 0 : sal_uInt16 nParaId = bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL;
2314 0 : pBindings->GetDispatcher()->Execute( nParaId, SFX_CALLMODE_RECORD, pParaItem, 0L );
2315 0 : UpdateTabs();
2316 0 : }
2317 :
2318 :
2319 0 : void SvxRuler::ApplyTabs()
2320 :
2321 : /* [Description]
2322 :
2323 : Apply tab settings, changed by dragging.
2324 : */
2325 : {
2326 0 : sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
2327 0 : const sal_uInt16 nCoreIdx = GetDragAryPos();
2328 0 : if(IsDragDelete())
2329 : {
2330 0 : pTabStopItem->Remove(nCoreIdx);
2331 : }
2332 0 : else if(DRAG_OBJECT_SIZE_LINEAR & nDragType ||
2333 : DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType)
2334 : {
2335 0 : SvxTabStopItem *pItem = new SvxTabStopItem(pTabStopItem->Which());
2336 : //remove default tab stops
2337 0 : for ( sal_uInt16 i = 0; i < pItem->Count(); )
2338 : {
2339 0 : if ( SVX_TAB_ADJUST_DEFAULT == (*pItem)[i].GetAdjustment() )
2340 : {
2341 0 : pItem->Remove(i);
2342 0 : continue;
2343 : }
2344 0 : ++i;
2345 : }
2346 :
2347 : sal_uInt16 j;
2348 0 : for(j = 0; j < nCoreIdx; ++j)
2349 : {
2350 0 : pItem->Insert((*pTabStopItem)[j]);
2351 : }
2352 0 : for(; j < pTabStopItem->Count(); ++j)
2353 : {
2354 0 : SvxTabStop aTabStop = (*pTabStopItem)[j];
2355 0 : aTabStop.GetTabPos() = PixelHAdjust(
2356 0 : ConvertHPosLogic(pTabs[j+TAB_GAP].nPos -
2357 0 : GetLeftIndent()) -
2358 : lAppNullOffset,
2359 0 : aTabStop.GetTabPos());
2360 0 : pItem->Insert(aTabStop);
2361 : }
2362 0 : delete pTabStopItem;
2363 0 : pTabStopItem = pItem;
2364 : }
2365 0 : else if( pTabStopItem->Count() == 0 )
2366 0 : return;
2367 : else
2368 : {
2369 0 : SvxTabStop aTabStop = (*pTabStopItem)[nCoreIdx];
2370 0 : if(pRuler_Imp->lMaxRightLogic!=-1&&
2371 0 : pTabs[nCoreIdx+TAB_GAP].nPos+Ruler::GetNullOffset()==nMaxRight)
2372 0 : aTabStop.GetTabPos() = pRuler_Imp->lMaxRightLogic-lLogicNullOffset;
2373 : else
2374 : {
2375 0 : if(bRTL)
2376 : {
2377 : //#i24363# tab stops relative to indent
2378 : const long nTmpLeftIndent = pRuler_Imp->bIsTabsRelativeToIndent ?
2379 : GetLeftIndent() :
2380 0 : ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset );
2381 :
2382 0 : aTabStop.GetTabPos() = PixelHAdjust(
2383 0 : ConvertHPosLogic( nTmpLeftIndent - pTabs[nCoreIdx+TAB_GAP].nPos) - lAppNullOffset,
2384 0 : aTabStop.GetTabPos());
2385 : }
2386 : else
2387 : {
2388 : //#i24363# tab stops relative to indent
2389 : const long nTmpLeftIndent = pRuler_Imp->bIsTabsRelativeToIndent ?
2390 : GetLeftIndent() :
2391 0 : 0;
2392 :
2393 0 : aTabStop.GetTabPos() = PixelHAdjust(
2394 0 : ConvertHPosLogic( pTabs[nCoreIdx+TAB_GAP].nPos - nTmpLeftIndent ) - lAppNullOffset,
2395 0 : aTabStop.GetTabPos() );
2396 : }
2397 : }
2398 0 : pTabStopItem->Remove(nCoreIdx);
2399 0 : pTabStopItem->Insert(aTabStop);
2400 : }
2401 0 : sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
2402 0 : pBindings->GetDispatcher()->Execute( nTabStopId, SFX_CALLMODE_RECORD, pTabStopItem, 0L );
2403 0 : UpdateTabs();
2404 : }
2405 :
2406 :
2407 0 : void SvxRuler::ApplyBorders()
2408 :
2409 : /* [Description]
2410 :
2411 : Applying (table) column settings; changed by dragging.
2412 : */
2413 : {
2414 0 : if(pColumnItem->IsTable())
2415 : {
2416 0 : long l = GetFrameLeft();
2417 0 : if(l != pRuler_Imp->nColLeftPix)
2418 : pColumnItem->SetLeft( PixelHAdjust(
2419 0 : ConvertHPosLogic(l) - lAppNullOffset, pColumnItem->GetLeft()));
2420 0 : l = GetMargin2();
2421 0 : if(l != pRuler_Imp->nColRightPix)
2422 : {
2423 0 : long nWidthOrHeight = bHorz ? pPagePosItem->GetWidth() : pPagePosItem->GetHeight();
2424 : pColumnItem->SetRight( PixelHAdjust( nWidthOrHeight -
2425 0 : pColumnItem->GetLeft() - ConvertHPosLogic(l) -
2426 0 : lAppNullOffset, pColumnItem->GetRight() ) );
2427 : }
2428 : }
2429 0 : for(sal_uInt16 i = 0; i < pColumnItem->Count()-1; ++i)
2430 : {
2431 0 : long& nEnd = (*pColumnItem)[i].nEnd;
2432 0 : nEnd = PIXEL_H_ADJUST(
2433 : ConvertPosLogic(pBorders[i].nPos),
2434 0 : (*pColumnItem)[i].nEnd);
2435 0 : long& nStart = (*pColumnItem)[i+1].nStart;
2436 0 : nStart = PIXEL_H_ADJUST(
2437 : ConvertSizeLogic(pBorders[i].nPos +
2438 : pBorders[i].nWidth) -
2439 : lAppNullOffset,
2440 0 : (*pColumnItem)[i+1].nStart);
2441 : // It may be that, due to the PIXEL_H_ADJUST readjustment to old values,
2442 : // the width becomes < 0. This we readjust.
2443 0 : if( nEnd > nStart )
2444 0 : nStart = nEnd;
2445 : }
2446 : #ifdef DEBUGLIN
2447 : Debug_Impl(pEditWin,*pColumnItem);
2448 : #endif // DEBUGLIN
2449 : SfxBoolItem aFlag(SID_RULER_ACT_LINE_ONLY,
2450 0 : nDragType & DRAG_OBJECT_ACTLINE_ONLY? sal_True : sal_False);
2451 : sal_uInt16 nColId = pRuler_Imp->bIsTableRows ? (bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL) :
2452 0 : (bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
2453 0 : pBindings->GetDispatcher()->Execute( nColId, SFX_CALLMODE_RECORD, pColumnItem, &aFlag, 0L );
2454 0 : }
2455 :
2456 0 : void SvxRuler::ApplyObject()
2457 :
2458 : /* [Description]
2459 :
2460 : Applying object settings, changed by dragging.
2461 : */
2462 : {
2463 : // to the page margin
2464 0 : long nMargin = pLRSpaceItem? pLRSpaceItem->GetLeft(): 0;
2465 : pObjectItem->SetStartX(
2466 : PixelAdjust(
2467 0 : ConvertPosLogic(pObjectBorders[0].nPos)
2468 0 : + nMargin - lAppNullOffset,pObjectItem->GetStartX()));
2469 : pObjectItem->SetEndX(
2470 : PixelAdjust(
2471 0 : ConvertPosLogic(pObjectBorders[1].nPos)
2472 0 : + nMargin - lAppNullOffset,pObjectItem->GetEndX()));
2473 0 : nMargin = pULSpaceItem? pULSpaceItem->GetUpper(): 0;
2474 : pObjectItem->SetStartY(
2475 : PixelAdjust(
2476 0 : ConvertPosLogic(pObjectBorders[2].nPos)
2477 0 : + nMargin - lAppNullOffset,pObjectItem->GetStartY()));
2478 : pObjectItem->SetEndY(
2479 : PixelAdjust(
2480 0 : ConvertPosLogic(pObjectBorders[3].nPos)
2481 0 : + nMargin - lAppNullOffset,pObjectItem->GetEndY()));
2482 0 : pBindings->GetDispatcher()->Execute( SID_RULER_OBJECT, SFX_CALLMODE_RECORD, pObjectItem, 0L );
2483 0 : }
2484 :
2485 0 : void SvxRuler::PrepareProportional_Impl(RulerType eType)
2486 :
2487 : /* [Description]
2488 :
2489 : Preparation proportional dragging, and it is calculated based on the
2490 : proportional share of the total width in parts per thousand.
2491 : */
2492 : {
2493 0 : pRuler_Imp->nTotalDist = GetMargin2();
2494 0 : switch((int)eType)
2495 : {
2496 : case RULER_TYPE_MARGIN2:
2497 : case RULER_TYPE_MARGIN1:
2498 : case RULER_TYPE_BORDER:
2499 : {
2500 : DBG_ASSERT(pColumnItem, "no ColumnItem");
2501 :
2502 0 : pRuler_Imp->SetPercSize(pColumnItem->Count());
2503 :
2504 : long lPos;
2505 0 : long lWidth=0;
2506 : sal_uInt16 nStart;
2507 0 : sal_uInt16 nIdx=GetDragAryPos();
2508 0 : long lActWidth=0;
2509 : long lActBorderSum;
2510 : long lOrigLPos;
2511 :
2512 0 : if(eType != RULER_TYPE_BORDER)
2513 : {
2514 0 : lOrigLPos = GetMargin1();
2515 0 : nStart = 0;
2516 0 : lActBorderSum = 0;
2517 : }
2518 : else
2519 : {
2520 0 : if(pRuler_Imp->bIsTableRows &&!bHorz)
2521 : {
2522 0 : lOrigLPos = GetMargin1();
2523 0 : nStart = 0;
2524 : }
2525 : else
2526 : {
2527 0 : lOrigLPos = pBorders[nIdx].nPos + pBorders[nIdx].nWidth;
2528 0 : nStart = 1;
2529 : }
2530 0 : lActBorderSum = pBorders[nIdx].nWidth;
2531 : }
2532 :
2533 : //in horizontal mode the percentage value has to be
2534 : //calculated on a "current change" position base
2535 : //because the height of the table changes while dragging
2536 0 : if(pRuler_Imp->bIsTableRows && RULER_TYPE_BORDER == eType)
2537 : {
2538 : sal_uInt16 nStartBorder;
2539 : sal_uInt16 nEndBorder;
2540 0 : if(bHorz)
2541 : {
2542 0 : nStartBorder = nIdx + 1;
2543 0 : nEndBorder = pColumnItem->Count() - 1;
2544 : }
2545 : else
2546 : {
2547 0 : nStartBorder = 0;
2548 0 : nEndBorder = nIdx;
2549 : }
2550 :
2551 0 : lWidth = pBorders[nIdx].nPos;
2552 0 : if(bHorz)
2553 0 : lWidth = GetMargin2() - lWidth;
2554 0 : pRuler_Imp->nTotalDist = lWidth;
2555 0 : lPos = lOrigLPos = pBorders[nIdx].nPos;
2556 :
2557 0 : for(sal_uInt16 i = nStartBorder; i < nEndBorder; ++i)
2558 : {
2559 0 : if(bHorz)
2560 : {
2561 0 : lActWidth += pBorders[i].nPos - lPos;
2562 0 : lPos = pBorders[i].nPos + pBorders[i].nWidth;
2563 : }
2564 : else
2565 0 : lActWidth = pBorders[i].nPos;
2566 0 : pRuler_Imp->pPercBuf[i] = (sal_uInt16)((lActWidth * 1000)
2567 0 : / pRuler_Imp->nTotalDist);
2568 0 : pRuler_Imp->pBlockBuf[i] = (sal_uInt16)lActBorderSum;
2569 0 : lActBorderSum += pBorders[i].nWidth;
2570 0 : }
2571 : }
2572 : else
2573 : {
2574 0 : lPos = lOrigLPos;
2575 0 : for(sal_uInt16 ii = nStart; ii < pColumnItem->Count() - 1; ++ii)
2576 : {
2577 0 : lWidth += pBorders[ii].nPos - lPos;
2578 0 : lPos = pBorders[ii].nPos + pBorders[ii].nWidth;
2579 : }
2580 :
2581 0 : lWidth += GetMargin2() - lPos;
2582 0 : pRuler_Imp->nTotalDist = lWidth;
2583 0 : lPos = lOrigLPos;
2584 :
2585 0 : for(sal_uInt16 i = nStart; i < pColumnItem->Count() - 1; ++i)
2586 : {
2587 0 : lActWidth += pBorders[i].nPos - lPos;
2588 0 : lPos = pBorders[i].nPos + pBorders[i].nWidth;
2589 0 : pRuler_Imp->pPercBuf[i] = (sal_uInt16)((lActWidth * 1000)
2590 0 : / pRuler_Imp->nTotalDist);
2591 0 : pRuler_Imp->pBlockBuf[i] = (sal_uInt16)lActBorderSum;
2592 0 : lActBorderSum += pBorders[i].nWidth;
2593 : }
2594 : }
2595 : }
2596 0 : break;
2597 : case RULER_TYPE_TAB:
2598 : {
2599 0 : const sal_uInt16 nIdx = GetDragAryPos()+TAB_GAP;
2600 0 : pRuler_Imp->nTotalDist -= pTabs[nIdx].nPos;
2601 0 : pRuler_Imp->SetPercSize(nTabCount);
2602 0 : for(sal_uInt16 n=0;n<=nIdx;pRuler_Imp->pPercBuf[n++]=0) ;
2603 0 : for(sal_uInt16 i = nIdx+1; i < nTabCount; ++i)
2604 : {
2605 0 : const long nDelta = pTabs[i].nPos - pTabs[nIdx].nPos;
2606 0 : pRuler_Imp->pPercBuf[i] = (sal_uInt16)((nDelta * 1000) / pRuler_Imp->nTotalDist);
2607 : }
2608 0 : break;
2609 : }
2610 : }
2611 0 : }
2612 :
2613 :
2614 0 : void SvxRuler::EvalModifier()
2615 :
2616 : /* [Description]
2617 :
2618 : Eval Drag Modifier
2619 :
2620 : Shift: move linear
2621 : Control: move proportional
2622 : Shift+Control: Table: only current line
2623 : Alt: dimension arrows (not implemented) //!!
2624 :
2625 : */
2626 :
2627 : {
2628 0 : sal_uInt16 nModifier = GetDragModifier();
2629 0 : if(pRuler_Imp->bIsTableRows)
2630 : {
2631 : //rows can only be moved in one way, additionally current column is possible
2632 0 : if(nModifier == KEY_SHIFT)
2633 0 : nModifier = 0;
2634 : }
2635 0 : switch(nModifier)
2636 : {
2637 : case KEY_SHIFT:
2638 0 : nDragType = DRAG_OBJECT_SIZE_LINEAR;
2639 0 : break;
2640 : case KEY_MOD1: {
2641 0 : const RulerType eType = GetDragType();
2642 0 : nDragType = DRAG_OBJECT_SIZE_PROPORTIONAL;
2643 0 : if( RULER_TYPE_TAB == eType ||
2644 : ( ( RULER_TYPE_BORDER == eType || RULER_TYPE_MARGIN1 == eType ||
2645 : RULER_TYPE_MARGIN2 == eType ) &&
2646 : pColumnItem ) )
2647 0 : PrepareProportional_Impl(eType);
2648 0 : break;
2649 : }
2650 : case KEY_MOD1 | KEY_SHIFT:
2651 0 : if(GetDragType()!=RULER_TYPE_MARGIN1&&
2652 0 : GetDragType()!=RULER_TYPE_MARGIN2)
2653 0 : nDragType = DRAG_OBJECT_ACTLINE_ONLY;
2654 0 : break;
2655 : // ALT: Dimension arrows
2656 : }
2657 0 : }
2658 :
2659 :
2660 0 : void SvxRuler::Click()
2661 :
2662 : /* [Description]
2663 :
2664 : Overloaded handler SV; sets Tab per dispatcher call
2665 : */
2666 :
2667 : {
2668 0 : Ruler::Click();
2669 0 : if( bActive )
2670 : {
2671 0 : pBindings->Update( SID_RULER_LR_MIN_MAX );
2672 0 : pBindings->Update( SID_ATTR_LONG_ULSPACE );
2673 0 : pBindings->Update( SID_ATTR_LONG_LRSPACE );
2674 0 : pBindings->Update( SID_RULER_PAGE_POS );
2675 0 : pBindings->Update( bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL);
2676 0 : pBindings->Update( bHorz ? SID_ATTR_PARA_LRSPACE : SID_ATTR_PARA_LRSPACE_VERTICAL);
2677 0 : pBindings->Update( bHorz ? SID_RULER_BORDERS : SID_RULER_BORDERS_VERTICAL);
2678 0 : pBindings->Update( bHorz ? SID_RULER_ROWS : SID_RULER_ROWS_VERTICAL);
2679 0 : pBindings->Update( SID_RULER_OBJECT );
2680 0 : pBindings->Update( SID_RULER_PROTECT );
2681 0 : pBindings->Update( SID_ATTR_PARA_LRSPACE_VERTICAL );
2682 : }
2683 0 : sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
2684 0 : if(pTabStopItem &&
2685 : (nFlags & SVXRULER_SUPPORT_TABS) == SVXRULER_SUPPORT_TABS)
2686 : {
2687 0 : sal_Bool bContentProtected = pRuler_Imp->aProtectItem.IsCntntProtected();
2688 0 : if( bContentProtected ) return;
2689 0 : const long lPos = GetClickPos();
2690 0 : if((bRTL && lPos < Min(GetFirstLineIndent(), GetLeftIndent()) && lPos > GetRightIndent()) ||
2691 0 : (!bRTL && lPos > Min(GetFirstLineIndent(), GetLeftIndent()) && lPos < GetRightIndent()))
2692 : {
2693 : //convert position in left-to-right text
2694 : long nTabPos;
2695 : //#i24363# tab stops relative to indent
2696 0 : if(bRTL)
2697 : nTabPos = ( pRuler_Imp->bIsTabsRelativeToIndent ?
2698 : GetLeftIndent() :
2699 0 : ConvertHPosPixel( GetRightFrameMargin() + lAppNullOffset ) ) -
2700 0 : lPos;
2701 : else
2702 : nTabPos = lPos -
2703 : ( pRuler_Imp->bIsTabsRelativeToIndent ?
2704 : GetLeftIndent() :
2705 0 : 0 );
2706 :
2707 : SvxTabStop aTabStop(ConvertHPosLogic(nTabPos),
2708 0 : ToAttrTab_Impl(nDefTabType));
2709 0 : pTabStopItem->Insert(aTabStop);
2710 0 : UpdateTabs();
2711 : }
2712 : }
2713 : }
2714 :
2715 :
2716 0 : sal_Bool SvxRuler::CalcLimits
2717 : (
2718 : long &nMax1, // minimum value to be set
2719 : long &nMax2, // minimum value to be set
2720 : sal_Bool
2721 : ) const
2722 :
2723 : /* [Description]
2724 :
2725 : Default implementation of the virtual function; the application can be
2726 : overloaded to implement customized limits. The values are based on the page.
2727 : */
2728 : {
2729 0 : nMax1 = LONG_MIN;
2730 0 : nMax2 = LONG_MAX;
2731 0 : return sal_False;
2732 : }
2733 :
2734 :
2735 0 : void SvxRuler::CalcMinMax()
2736 :
2737 : /* [Description]
2738 :
2739 : Calculates the limits for dragging; which are in pixels relative to the
2740 : page edge
2741 : */
2742 :
2743 : {
2744 0 : sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
2745 0 : const long lNullPix = ConvertPosPixel(lLogicNullOffset);
2746 0 : pRuler_Imp->lMaxLeftLogic=pRuler_Imp->lMaxRightLogic=-1;
2747 0 : switch(GetDragType())
2748 : {
2749 : case RULER_TYPE_MARGIN1:
2750 : { // left edge of the surrounding Frame
2751 : // DragPos - NOf between left - right
2752 0 : pRuler_Imp->lMaxLeftLogic = GetLeftMin();
2753 0 : nMaxLeft=ConvertSizePixel(pRuler_Imp->lMaxLeftLogic);
2754 :
2755 0 : if(!pColumnItem || pColumnItem->Count() == 1 )
2756 : {
2757 0 : if(bRTL)
2758 : {
2759 0 : nMaxRight = lNullPix - GetRightIndent() +
2760 0 : Max(GetFirstLineIndent(), GetLeftIndent()) -
2761 0 : lMinFrame;
2762 : }
2763 : else
2764 : {
2765 0 : nMaxRight = lNullPix + GetRightIndent() -
2766 0 : Max(GetFirstLineIndent(), GetLeftIndent()) -
2767 0 : lMinFrame;
2768 : }
2769 : }
2770 0 : else if(pRuler_Imp->bIsTableRows)
2771 : {
2772 : //top border is not moveable when table rows are displayed
2773 : // protection of content means the margin is not moveable
2774 : // - it's just a page break inside of a cell
2775 0 : if(bHorz && !pRuler_Imp->aProtectItem.IsCntntProtected())
2776 : {
2777 0 : nMaxLeft = pBorders[0].nMinPos + lNullPix;
2778 0 : if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
2779 0 : nMaxRight = GetRightIndent() + lNullPix -
2780 0 : (pColumnItem->Count() - 1 ) * lMinFrame;
2781 : else
2782 0 : nMaxRight = pBorders[0].nPos - lMinFrame + lNullPix;
2783 : }
2784 : else
2785 0 : nMaxLeft = nMaxRight = lNullPix;
2786 : }
2787 : else
2788 : {
2789 0 : if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
2790 : {
2791 0 : nMaxRight=lNullPix+CalcPropMaxRight();
2792 : }
2793 0 : else if(nDragType & DRAG_OBJECT_SIZE_LINEAR)
2794 : {
2795 : nMaxRight = ConvertPosPixel(
2796 0 : GetPageWidth() - (
2797 0 : (pColumnItem->IsTable() && pLRSpaceItem)
2798 0 : ? pLRSpaceItem->GetRight() : 0))
2799 0 : - GetMargin2() + GetMargin1();
2800 : }
2801 : else
2802 : {
2803 0 : nMaxRight = lNullPix - lMinFrame;
2804 0 : if(pColumnItem->IsFirstAct())
2805 : {
2806 0 : if(bRTL)
2807 : {
2808 : nMaxRight += Min(
2809 0 : pBorders[0].nPos,
2810 0 : Max(GetFirstLineIndent(), GetLeftIndent()) - GetRightIndent());
2811 : }
2812 : else
2813 : {
2814 : nMaxRight += Min(
2815 0 : pBorders[0].nPos, GetRightIndent() -
2816 0 : Max(GetFirstLineIndent(), GetLeftIndent()));
2817 : }
2818 : }
2819 0 : else if( pColumnItem->Count() > 1 )
2820 0 : nMaxRight += pBorders[0].nPos;
2821 : else
2822 0 : nMaxRight +=GetRightIndent() -
2823 0 : Max(GetFirstLineIndent(), GetLeftIndent());
2824 : // Do not drag the left table edge over the edge of the page
2825 0 : if(pLRSpaceItem&&pColumnItem->IsTable())
2826 : {
2827 0 : long nTmp=ConvertSizePixel(pLRSpaceItem->GetLeft());
2828 0 : if(nTmp>nMaxLeft)
2829 0 : nMaxLeft=nTmp;
2830 : }
2831 : }
2832 : }
2833 0 : break;
2834 : }
2835 : case RULER_TYPE_MARGIN2:
2836 : { // right edge of the surrounding Frame
2837 : pRuler_Imp->lMaxRightLogic =
2838 : pMinMaxItem ?
2839 0 : GetPageWidth() - GetRightMax() : GetPageWidth();
2840 0 : nMaxRight = ConvertSizePixel(pRuler_Imp->lMaxRightLogic);
2841 :
2842 :
2843 0 : if(!pColumnItem)
2844 : {
2845 0 : if(bRTL)
2846 : {
2847 0 : nMaxLeft = GetMargin2() + GetRightIndent() -
2848 0 : Max(GetFirstLineIndent(),GetLeftIndent()) - GetMargin1()+
2849 0 : lMinFrame + lNullPix;
2850 : }
2851 : else
2852 : {
2853 0 : nMaxLeft = GetMargin2() - GetRightIndent() +
2854 0 : Max(GetFirstLineIndent(),GetLeftIndent()) - GetMargin1()+
2855 0 : lMinFrame + lNullPix;
2856 : }
2857 : }
2858 0 : else if(pRuler_Imp->bIsTableRows)
2859 : {
2860 : // get the bottom move range from the last border position - only available for rows!
2861 : // protection of content means the margin is not moveable - it's just a page break inside of a cell
2862 0 : if(bHorz || pRuler_Imp->aProtectItem.IsCntntProtected())
2863 : {
2864 0 : nMaxLeft = nMaxRight = pBorders[pColumnItem->Count() - 1].nMaxPos + lNullPix;
2865 : }
2866 : else
2867 : {
2868 0 : if(nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)
2869 : {
2870 0 : nMaxLeft = (pColumnItem->Count()) * lMinFrame + lNullPix;
2871 : }
2872 : else
2873 : {
2874 0 : if(pColumnItem->Count() > 1)
2875 0 : nMaxLeft = pBorders[pColumnItem->Count() - 2].nPos + lMinFrame + lNullPix;
2876 : else
2877 0 : nMaxLeft = lMinFrame + lNullPix;
2878 : }
2879 0 : if(pColumnItem->Count() > 1)
2880 0 : nMaxRight = pBorders[pColumnItem->Count() - 2].nMaxPos + lNullPix;
2881 : else
2882 0 : nMaxRight -= GetRightIndent() - lNullPix;
2883 : }
2884 : }
2885 : else
2886 : {
2887 0 : nMaxLeft = lMinFrame + lNullPix;
2888 0 : if(IsActLastColumn() || pColumnItem->Count() < 2 ) //If last active column
2889 : {
2890 0 : if(bRTL)
2891 : {
2892 0 : nMaxLeft = lMinFrame + lNullPix + GetMargin2() +
2893 0 : GetRightIndent() - Max(GetFirstLineIndent(),
2894 0 : GetLeftIndent());
2895 : }
2896 : else
2897 : {
2898 0 : nMaxLeft = lMinFrame + lNullPix + GetMargin2() -
2899 0 : GetRightIndent() + Max(GetFirstLineIndent(),
2900 0 : GetLeftIndent());
2901 : }
2902 : }
2903 0 : if( pColumnItem->Count() >= 2 )
2904 : {
2905 : long nNewMaxLeft =
2906 : lMinFrame + lNullPix +
2907 0 : pBorders[pColumnItem->Count()-2].nPos +
2908 0 : pBorders[pColumnItem->Count()-2].nWidth;
2909 0 : nMaxLeft=Max(nMaxLeft,nNewMaxLeft);
2910 : }
2911 :
2912 : }
2913 0 : break;
2914 : }
2915 : case RULER_TYPE_BORDER:
2916 : { // Table, column (Modifier)
2917 0 : const sal_uInt16 nIdx = GetDragAryPos();
2918 0 : switch(GetDragSize())
2919 : {
2920 : case RULER_DRAGSIZE_1 :
2921 : {
2922 0 : nMaxRight = pBorders[nIdx].nPos +
2923 0 : pBorders[nIdx].nWidth + lNullPix;
2924 :
2925 0 : if(0 == nIdx)
2926 0 : nMaxLeft = lNullPix;
2927 : else
2928 0 : nMaxLeft = pBorders[nIdx-1].nPos +
2929 0 : pBorders[nIdx-1].nWidth + lNullPix;
2930 0 : if(nIdx == pColumnItem->GetActColumn())
2931 : {
2932 0 : if(bRTL)
2933 : {
2934 0 : nMaxLeft += pBorders[nIdx].nPos +
2935 0 : GetRightIndent() - Max(GetFirstLineIndent(),
2936 0 : GetLeftIndent());
2937 : }
2938 : else
2939 : {
2940 0 : nMaxLeft += pBorders[nIdx].nPos -
2941 0 : GetRightIndent() + Max(GetFirstLineIndent(),
2942 0 : GetLeftIndent());
2943 : }
2944 0 : if(0 != nIdx)
2945 0 : nMaxLeft -= pBorders[nIdx-1].nPos +
2946 0 : pBorders[nIdx-1].nWidth;
2947 : }
2948 0 : nMaxLeft += lMinFrame;
2949 0 : nMaxLeft += nDragOffset;
2950 0 : break;
2951 : }
2952 : case RULER_DRAGSIZE_MOVE:
2953 : {
2954 0 : if(pColumnItem)
2955 : {
2956 : //nIdx contains the position of the currently moved item
2957 : //next visible separator on the left
2958 0 : sal_uInt16 nLeftCol=GetActLeftColumn(sal_False, nIdx);
2959 : //next visible separator on the right
2960 0 : sal_uInt16 nRightCol=GetActRightColumn(sal_False, nIdx);
2961 : //next separator on the left - regardless if visible or not
2962 0 : sal_uInt16 nActLeftCol=GetActLeftColumn();
2963 : //next separator on the right - regardless if visible or not
2964 0 : sal_uInt16 nActRightCol=GetActRightColumn();
2965 0 : if(pColumnItem->IsTable())
2966 : {
2967 0 : if(nDragType & DRAG_OBJECT_ACTLINE_ONLY)
2968 : {
2969 : //the current row/column should be modified only
2970 : //then the next/previous visible border position
2971 : //marks the min/max positions
2972 : nMaxLeft = nLeftCol == USHRT_MAX ?
2973 : 0 :
2974 0 : pBorders[nLeftCol].nPos;
2975 : //rows can always be increased without a limit
2976 0 : if(pRuler_Imp->bIsTableRows)
2977 0 : nMaxRight = pBorders[nIdx].nMaxPos;
2978 : else
2979 : nMaxRight = nRightCol == USHRT_MAX ?
2980 0 : GetMargin2():
2981 0 : pBorders[nRightCol].nPos;
2982 0 : nMaxLeft += lNullPix;
2983 0 : nMaxRight += lNullPix;
2984 : }
2985 : else
2986 : {
2987 0 : if(DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType && !bHorz && pRuler_Imp->bIsTableRows)
2988 0 : nMaxLeft = (nIdx + 1) * lMinFrame + lNullPix;
2989 : else
2990 0 : nMaxLeft = pBorders[nIdx].nMinPos + lNullPix;
2991 0 : if(DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType||
2992 : (DRAG_OBJECT_SIZE_LINEAR & nDragType) )
2993 : {
2994 0 : if(pRuler_Imp->bIsTableRows)
2995 : {
2996 0 : if(bHorz)
2997 0 : nMaxRight = GetRightIndent() + lNullPix -
2998 0 : (pColumnItem->Count() - nIdx - 1) * lMinFrame;
2999 : else
3000 0 : nMaxRight = pBorders[nIdx].nMaxPos + lNullPix;
3001 : }
3002 : else
3003 0 : nMaxRight=lNullPix+CalcPropMaxRight(nIdx);
3004 : }
3005 : else
3006 0 : nMaxRight = pBorders[nIdx].nMaxPos + lNullPix;
3007 : }
3008 0 : nMaxLeft += lMinFrame;
3009 0 : nMaxRight -= lMinFrame;
3010 :
3011 : }
3012 : else
3013 : {
3014 0 : if(nLeftCol==USHRT_MAX)
3015 0 : nMaxLeft=lNullPix;
3016 : else
3017 0 : nMaxLeft = pBorders[nLeftCol].nPos +
3018 0 : pBorders[nLeftCol].nWidth + lNullPix;
3019 :
3020 0 : if(nActRightCol == nIdx)
3021 : {
3022 0 : if(bRTL)
3023 : {
3024 0 : nMaxLeft += pBorders[nIdx].nPos +
3025 0 : GetRightIndent() - Max(GetFirstLineIndent(),
3026 0 : GetLeftIndent());
3027 0 : if(nActLeftCol!=USHRT_MAX)
3028 0 : nMaxLeft -= pBorders[nActLeftCol].nPos +
3029 0 : pBorders[nActLeftCol].nWidth;
3030 : }
3031 : else
3032 : {
3033 0 : nMaxLeft += pBorders[nIdx].nPos -
3034 0 : GetRightIndent() + Max(GetFirstLineIndent(),
3035 0 : GetLeftIndent());
3036 0 : if(nActLeftCol!=USHRT_MAX)
3037 0 : nMaxLeft -= pBorders[nActLeftCol].nPos +
3038 0 : pBorders[nActLeftCol].nWidth;
3039 : }
3040 : }
3041 0 : nMaxLeft += lMinFrame;
3042 0 : nMaxLeft += nDragOffset;
3043 :
3044 : // nMaxRight
3045 : // linear / proprotional move
3046 0 : if(DRAG_OBJECT_SIZE_PROPORTIONAL & nDragType||
3047 : (DRAG_OBJECT_SIZE_LINEAR & nDragType) )
3048 : {
3049 0 : nMaxRight=lNullPix+CalcPropMaxRight(nIdx);
3050 : }
3051 0 : else if(DRAG_OBJECT_SIZE_LINEAR & nDragType)
3052 : {
3053 0 : nMaxRight=lNullPix+GetMargin2()-GetMargin1()+
3054 0 : (nBorderCount-nIdx-1)*lMinFrame;
3055 : }
3056 : else
3057 : {
3058 0 : if(nRightCol==USHRT_MAX)
3059 : { // last column
3060 0 : nMaxRight = GetMargin2() + lNullPix;
3061 0 : if(IsActLastColumn())
3062 : {
3063 0 : if(bRTL)
3064 : {
3065 : nMaxRight -=
3066 0 : GetMargin2() + GetRightIndent() -
3067 : Max(GetFirstLineIndent(),
3068 0 : GetLeftIndent());
3069 : }
3070 : else
3071 : {
3072 : nMaxRight -=
3073 0 : GetMargin2() - GetRightIndent() +
3074 : Max(GetFirstLineIndent(),
3075 0 : GetLeftIndent());
3076 : }
3077 0 : nMaxRight += pBorders[nIdx].nPos +
3078 0 : pBorders[nIdx].nWidth;
3079 : }
3080 : }
3081 : else
3082 : {
3083 0 : nMaxRight = lNullPix + pBorders[nRightCol].nPos;
3084 : sal_uInt16 nNotHiddenRightCol =
3085 0 : GetActRightColumn(sal_True, nIdx);
3086 :
3087 0 : if( nActLeftCol == nIdx )
3088 : {
3089 : long nBorder = nNotHiddenRightCol ==
3090 : USHRT_MAX ?
3091 0 : GetMargin2() :
3092 0 : pBorders[nNotHiddenRightCol].nPos;
3093 0 : if(bRTL)
3094 : {
3095 0 : nMaxRight -= nBorder + GetRightIndent() -
3096 : Max(GetFirstLineIndent(),
3097 0 : GetLeftIndent());
3098 : }
3099 : else
3100 : {
3101 0 : nMaxRight -= nBorder - GetRightIndent() +
3102 : Max(GetFirstLineIndent(),
3103 0 : GetLeftIndent());
3104 : }
3105 0 : nMaxRight += pBorders[nIdx].nPos +
3106 0 : pBorders[nIdx].nWidth;
3107 : }
3108 : }
3109 0 : nMaxRight -= lMinFrame;
3110 0 : nMaxRight -= pBorders[nIdx].nWidth;
3111 : }
3112 : }
3113 : }
3114 : // ObjectItem
3115 : else
3116 : {
3117 0 : if(pObjectItem->HasLimits())
3118 : {
3119 0 : if(CalcLimits(nMaxLeft, nMaxRight, nIdx & 1? sal_False : sal_True))
3120 : {
3121 0 : nMaxLeft = ConvertPosPixel(nMaxLeft);
3122 0 : nMaxRight = ConvertPosPixel(nMaxRight);
3123 : }
3124 : }
3125 : else
3126 : {
3127 0 : nMaxLeft = LONG_MIN;
3128 0 : nMaxRight = LONG_MAX;
3129 : }
3130 : }
3131 0 : break;
3132 : }
3133 : case RULER_DRAGSIZE_2:
3134 : {
3135 0 : nMaxLeft = lNullPix + pBorders[nIdx].nPos;
3136 0 : if(nIdx == pColumnItem->Count()-2) { // last column
3137 0 : nMaxRight = GetMargin2() + lNullPix;
3138 0 : if(pColumnItem->IsLastAct()) {
3139 : nMaxRight -=
3140 0 : GetMargin2() - GetRightIndent() +
3141 : Max(GetFirstLineIndent(),
3142 0 : GetLeftIndent());
3143 0 : nMaxRight += pBorders[nIdx].nPos +
3144 0 : pBorders[nIdx].nWidth;
3145 : }
3146 : }
3147 : else {
3148 0 : nMaxRight = lNullPix + pBorders[nIdx+1].nPos;
3149 0 : if(pColumnItem->GetActColumn()-1 == nIdx) {
3150 0 : nMaxRight -= pBorders[nIdx+1].nPos - GetRightIndent() +
3151 : Max(GetFirstLineIndent(),
3152 0 : GetLeftIndent());
3153 0 : nMaxRight += pBorders[nIdx].nPos +
3154 0 : pBorders[nIdx].nWidth;
3155 : }
3156 : }
3157 0 : nMaxRight -= lMinFrame;
3158 0 : nMaxRight -= pBorders[nIdx].nWidth;
3159 0 : break;
3160 : }
3161 : }
3162 0 : nMaxRight += nDragOffset;
3163 0 : break;
3164 : }
3165 : case RULER_TYPE_INDENT:
3166 : {
3167 0 : const sal_uInt16 nIdx = GetDragAryPos();
3168 0 : switch(nIdx) {
3169 : case INDENT_FIRST_LINE - INDENT_GAP:
3170 : case INDENT_LEFT_MARGIN - INDENT_GAP:
3171 : {
3172 0 : if(bRTL)
3173 : {
3174 0 : nMaxLeft = lNullPix + GetRightIndent();
3175 :
3176 0 : if(pColumnItem && !pColumnItem->IsFirstAct())
3177 0 : nMaxLeft += pBorders[pColumnItem->GetActColumn()-1].nPos +
3178 0 : pBorders[pColumnItem->GetActColumn()-1].nWidth;
3179 0 : nMaxRight = lNullPix + GetMargin2();
3180 :
3181 : // Dragging along
3182 0 : if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
3183 : (nDragType & DRAG_OBJECT_LEFT_INDENT_ONLY) !=
3184 : DRAG_OBJECT_LEFT_INDENT_ONLY)
3185 : {
3186 0 : if(GetLeftIndent() > GetFirstLineIndent())
3187 0 : nMaxLeft += GetLeftIndent() - GetFirstLineIndent();
3188 : else
3189 0 : nMaxRight -= GetFirstLineIndent() - GetLeftIndent();
3190 : }
3191 : }
3192 : else
3193 : {
3194 0 : nMaxLeft = lNullPix;
3195 :
3196 0 : if(pColumnItem && !pColumnItem->IsFirstAct())
3197 0 : nMaxLeft += pBorders[pColumnItem->GetActColumn()-1].nPos +
3198 0 : pBorders[pColumnItem->GetActColumn()-1].nWidth;
3199 0 : nMaxRight = lNullPix + GetRightIndent() - lMinFrame;
3200 :
3201 : // Dragging along
3202 0 : if((INDENT_FIRST_LINE - INDENT_GAP) != nIdx &&
3203 : (nDragType & DRAG_OBJECT_LEFT_INDENT_ONLY) !=
3204 : DRAG_OBJECT_LEFT_INDENT_ONLY)
3205 : {
3206 0 : if(GetLeftIndent() > GetFirstLineIndent())
3207 0 : nMaxLeft += GetLeftIndent() - GetFirstLineIndent();
3208 : else
3209 0 : nMaxRight -= GetFirstLineIndent() - GetLeftIndent();
3210 : }
3211 : }
3212 : }
3213 0 : break;
3214 : case INDENT_RIGHT_MARGIN - INDENT_GAP:
3215 : {
3216 0 : if(bRTL)
3217 : {
3218 0 : nMaxLeft = lNullPix;
3219 0 : nMaxRight = lNullPix + Min(GetFirstLineIndent(), GetLeftIndent()) - lMinFrame;
3220 0 : if(pColumnItem)
3221 : {
3222 0 : sal_uInt16 nRightCol=GetActRightColumn( sal_True );
3223 0 : if(!IsActLastColumn( sal_True ))
3224 0 : nMaxRight += pBorders[nRightCol].nPos;
3225 : else
3226 0 : nMaxRight += GetMargin2();
3227 : }
3228 : else
3229 0 : nMaxLeft += GetMargin1();
3230 0 : nMaxLeft += lMinFrame;
3231 : }
3232 : else
3233 : {
3234 : nMaxLeft = lNullPix +
3235 0 : Max(GetFirstLineIndent(), GetLeftIndent());
3236 0 : nMaxRight = lNullPix;
3237 0 : if(pColumnItem)
3238 : {
3239 0 : sal_uInt16 nRightCol=GetActRightColumn( sal_True );
3240 0 : if(!IsActLastColumn( sal_True ))
3241 0 : nMaxRight += pBorders[nRightCol].nPos;
3242 : else
3243 0 : nMaxRight += GetMargin2();
3244 : }
3245 : else
3246 0 : nMaxRight += GetMargin2();
3247 0 : nMaxLeft += lMinFrame;
3248 : }
3249 : }
3250 0 : break;
3251 : }
3252 0 : break;
3253 : }
3254 : case RULER_TYPE_TAB: // Tabs (Modifier)
3255 : /*
3256 : left = NOf + Max(LAR, EZ)
3257 : right = NOf + RAR
3258 : */
3259 0 : nMaxLeft = bRTL ? lNullPix + GetRightIndent()
3260 0 : : lNullPix + Min(GetFirstLineIndent(), GetLeftIndent());
3261 0 : pRuler_Imp->lMaxRightLogic=GetLogicRightIndent()+lLogicNullOffset;
3262 0 : nMaxRight = ConvertSizePixel(pRuler_Imp->lMaxRightLogic);
3263 0 : break;
3264 : default: ; //prevent warning
3265 : }
3266 : #ifdef DEBUGLIN
3267 : {
3268 : String aStr("MinLeft: ");
3269 : Size aSize(nMaxLeft + lNullPix, 0);
3270 : Size aSize2(nMaxRight + lNullPix, 0);
3271 : aSize = pEditWin->PixelToLogic(aSize, MapMode(MAP_MM));
3272 : aSize2 = pEditWin->PixelToLogic(aSize2, MapMode(MAP_MM));
3273 : aStr += String(aSize.Width());
3274 : aStr += " MaxRight: ";
3275 : aStr += String(aSize2.Width());
3276 : InfoBox(0, aStr).Execute();
3277 : }
3278 : #endif
3279 0 : }
3280 :
3281 :
3282 0 : long SvxRuler::StartDrag()
3283 :
3284 : /* [Description]
3285 :
3286 : Beginning of a drag operation (SV-handler) evaluates modifier and
3287 : calculated values
3288 :
3289 : [Cross-reference]
3290 :
3291 : <SvxRuler::EvalModifier()>
3292 : <SvxRuler::CalcMinMax()>
3293 : <SvxRuler::EndDrag()>
3294 : */
3295 :
3296 : {
3297 0 : sal_Bool bContentProtected = pRuler_Imp->aProtectItem.IsCntntProtected();
3298 0 : if(!bValid)
3299 0 : return sal_False;
3300 :
3301 0 : pRuler_Imp->lLastLMargin=GetMargin1();
3302 0 : pRuler_Imp->lLastRMargin=GetMargin2();
3303 0 : long bOk = 1;
3304 0 : if(GetStartDragHdl().IsSet())
3305 0 : bOk = Ruler::StartDrag();
3306 0 : if(bOk) {
3307 0 : lInitialDragPos = GetDragPos();
3308 0 : switch(GetDragType()) {
3309 : case RULER_TYPE_MARGIN1: // left edge of the surrounding Frame
3310 : case RULER_TYPE_MARGIN2: // right edge of the surrounding Frame
3311 0 : if((bHorz && pLRSpaceItem) || (!bHorz && pULSpaceItem))
3312 : {
3313 0 : if(pColumnItem)
3314 0 : EvalModifier();
3315 : else
3316 0 : nDragType = DRAG_OBJECT;
3317 : }
3318 : else
3319 0 : bOk = sal_False;
3320 0 : break;
3321 : case RULER_TYPE_BORDER: // Table, column (Modifier)
3322 0 : if(pColumnItem)
3323 : {
3324 0 : nDragOffset = pColumnItem->IsTable()? 0 :
3325 0 : GetDragPos() - pBorders[GetDragAryPos()].nPos;
3326 0 : EvalModifier();
3327 :
3328 : }
3329 : else
3330 0 : nDragOffset = 0;
3331 0 : break;
3332 : case RULER_TYPE_INDENT: { // Paragraph indents (Modifier)
3333 0 : if( bContentProtected )
3334 0 : return sal_False;
3335 0 : sal_uInt16 nIndent = INDENT_LEFT_MARGIN;
3336 0 : if((nIndent) == GetDragAryPos() + INDENT_GAP) { // Left paragraph indent
3337 0 : pIndents[0] = pIndents[INDENT_FIRST_LINE];
3338 0 : pIndents[0].nStyle |= RULER_STYLE_DONTKNOW;
3339 0 : EvalModifier();
3340 : }
3341 : else
3342 0 : nDragType = DRAG_OBJECT;
3343 0 : pIndents[1] = pIndents[GetDragAryPos()+INDENT_GAP];
3344 0 : pIndents[1].nStyle |= RULER_STYLE_DONTKNOW;
3345 0 : break;
3346 : }
3347 : case RULER_TYPE_TAB: // Tabs (Modifier)
3348 0 : if( bContentProtected ) return sal_False;
3349 0 : EvalModifier();
3350 0 : pTabs[0] = pTabs[GetDragAryPos()+1];
3351 0 : pTabs[0].nStyle |= RULER_STYLE_DONTKNOW;
3352 0 : break;
3353 : default:
3354 0 : nDragType = NONE;
3355 : }
3356 : }
3357 : else
3358 0 : nDragType = NONE;
3359 0 : if(bOk)
3360 0 : CalcMinMax();
3361 0 : return bOk;
3362 : }
3363 :
3364 :
3365 0 : void SvxRuler::Drag()
3366 :
3367 : /* [Description]
3368 :
3369 : SV-Draghandler
3370 : */
3371 : {
3372 0 : if(IsDragCanceled())
3373 : {
3374 0 : Ruler::Drag();
3375 0 : return;
3376 : }
3377 0 : switch(GetDragType()) {
3378 : case RULER_TYPE_MARGIN1: // left edge of the surrounding Frame
3379 0 : DragMargin1();
3380 0 : pRuler_Imp->lLastLMargin=GetMargin1();
3381 0 : break;
3382 : case RULER_TYPE_MARGIN2: // right edge of the surrounding Frame
3383 0 : DragMargin2();
3384 0 : pRuler_Imp->lLastRMargin = GetMargin2();
3385 0 : break;
3386 : case RULER_TYPE_INDENT: // Paragraph indents
3387 0 : DragIndents();
3388 0 : break;
3389 : case RULER_TYPE_BORDER: // Table, columns
3390 0 : if(pColumnItem)
3391 0 : DragBorders();
3392 0 : else if(pObjectItem)
3393 0 : DragObjectBorder();
3394 0 : break;
3395 : case RULER_TYPE_TAB: // Tabs
3396 0 : DragTabs();
3397 0 : break;
3398 : default: ;//prevent warning
3399 : }
3400 0 : Ruler::Drag();
3401 : }
3402 :
3403 :
3404 0 : void SvxRuler::EndDrag()
3405 :
3406 : /* [Description]
3407 :
3408 : SV-handler; is called when ending the dragging. Triggers the updating of data
3409 : on the application, by calling the respective Apply...() methods to send the
3410 : data to the application.
3411 : */
3412 : {
3413 0 : const sal_Bool bUndo = IsDragCanceled();
3414 0 : const long lPos = GetDragPos();
3415 0 : DrawLine_Impl(lTabPos, 6, bHorz);
3416 0 : lTabPos=-1;
3417 0 : if(!bUndo)
3418 0 : switch(GetDragType())
3419 : {
3420 : case RULER_TYPE_MARGIN1: // upper left edge of the surrounding Frame
3421 : case RULER_TYPE_MARGIN2: // lower right edge of the surrounding Frame
3422 : {
3423 0 : if(!pColumnItem || !pColumnItem->IsTable())
3424 0 : ApplyMargins();
3425 :
3426 0 : if(pColumnItem &&
3427 0 : (pColumnItem->IsTable() ||
3428 : (nDragType & DRAG_OBJECT_SIZE_PROPORTIONAL)))
3429 0 : ApplyBorders();
3430 :
3431 : }
3432 0 : break;
3433 : case RULER_TYPE_BORDER: // Table, columns
3434 0 : if(lInitialDragPos != lPos ||
3435 : (pRuler_Imp->bIsTableRows && bHorz)) //special case - the null offset is changed here
3436 : {
3437 0 : if(pColumnItem)
3438 : {
3439 0 : ApplyBorders();
3440 0 : if(bHorz)
3441 0 : UpdateTabs();
3442 : }
3443 0 : else if(pObjectItem)
3444 0 : ApplyObject();
3445 : }
3446 0 : break;
3447 : case RULER_TYPE_INDENT: // Paragraph indents
3448 0 : if(lInitialDragPos != lPos)
3449 0 : ApplyIndents();
3450 0 : SetIndents(INDENT_COUNT, pIndents+INDENT_GAP);
3451 0 : break;
3452 : case RULER_TYPE_TAB: // Tabs
3453 : {
3454 0 : ApplyTabs();
3455 0 : pTabs[GetDragAryPos()].nStyle &= ~RULER_STYLE_INVISIBLE;
3456 0 : SetTabs(nTabCount, pTabs+TAB_GAP);
3457 : }
3458 0 : break;
3459 : default: ; //prevent warning
3460 : }
3461 0 : nDragType = NONE;
3462 0 : Ruler::EndDrag();
3463 0 : if(bUndo)
3464 0 : for(sal_uInt16 i=0;i<pRuler_Imp->nControlerItems;i++)
3465 : {
3466 0 : pCtrlItem[i]->ClearCache();
3467 0 : pCtrlItem[i]->GetBindings().Invalidate(pCtrlItem[i]->GetId());
3468 : }
3469 0 : }
3470 :
3471 :
3472 0 : void SvxRuler::ExtraDown()
3473 :
3474 : /* [Description]
3475 :
3476 : Overloaded SV method, sets the new type for the Default tab.
3477 : */
3478 :
3479 : {
3480 : // Switch Tab Type
3481 0 : if(pTabStopItem &&
3482 : (nFlags & SVXRULER_SUPPORT_TABS) == SVXRULER_SUPPORT_TABS) {
3483 0 : ++nDefTabType;
3484 0 : if(RULER_TAB_DEFAULT == nDefTabType)
3485 0 : nDefTabType = RULER_TAB_LEFT;
3486 0 : SetExtraType(RULER_EXTRA_TAB, nDefTabType);
3487 : }
3488 0 : Ruler::ExtraDown();
3489 0 : }
3490 :
3491 :
3492 20 : void SvxRuler::Notify(SfxBroadcaster&, const SfxHint& rHint)
3493 :
3494 : /* [Description]
3495 :
3496 : Report through the bindings that the status update is completed. The ruler
3497 : updates its appearance and gets registered again in the bindings.
3498 : */
3499 :
3500 : {
3501 : // start update
3502 60 : if(bActive &&
3503 20 : rHint.Type() == TYPE(SfxSimpleHint) &&
3504 20 : ((SfxSimpleHint&) rHint ).GetId() == SFX_HINT_UPDATEDONE ) {
3505 20 : Update();
3506 20 : EndListening(*pBindings);
3507 20 : bValid = sal_True;
3508 20 : bListening = sal_False;
3509 : }
3510 20 : }
3511 :
3512 :
3513 0 : IMPL_LINK_INLINE_START( SvxRuler, MenuSelect, Menu *, pMenu )
3514 :
3515 : /* [Description]
3516 :
3517 : Handler of the context menus for switching the unit of measurement
3518 : */
3519 :
3520 : {
3521 0 : SetUnit(FieldUnit(pMenu->GetCurItemId()));
3522 0 : return 0;
3523 : }
3524 0 : IMPL_LINK_INLINE_END( SvxRuler, MenuSelect, Menu *, pMenu )
3525 :
3526 :
3527 0 : IMPL_LINK( SvxRuler, TabMenuSelect, Menu *, pMenu )
3528 :
3529 : /* [Description]
3530 :
3531 : Handler of the tab menu for setting the type
3532 : */
3533 :
3534 : {
3535 0 : if(pTabStopItem && pTabStopItem->Count() > pRuler_Imp->nIdx)
3536 : {
3537 0 : SvxTabStop aTabStop = (*pTabStopItem)[pRuler_Imp->nIdx];
3538 0 : aTabStop.GetAdjustment() = ToAttrTab_Impl(pMenu->GetCurItemId()-1);
3539 0 : pTabStopItem->Remove(pRuler_Imp->nIdx);
3540 0 : pTabStopItem->Insert(aTabStop);
3541 0 : sal_uInt16 nTabStopId = bHorz ? SID_ATTR_TABSTOP : SID_ATTR_TABSTOP_VERTICAL;
3542 0 : pBindings->GetDispatcher()->Execute( nTabStopId, SFX_CALLMODE_RECORD, pTabStopItem, 0L );
3543 0 : UpdateTabs();
3544 0 : pRuler_Imp->nIdx = 0;
3545 : }
3546 0 : return 0;
3547 : }
3548 :
3549 :
3550 0 : void SvxRuler::Command( const CommandEvent& rCEvt )
3551 :
3552 : /* [Description]
3553 :
3554 : Mouse context menu for switching the unit of measurement
3555 : */
3556 :
3557 : {
3558 0 : if ( COMMAND_CONTEXTMENU == rCEvt.GetCommand() )
3559 : {
3560 0 : CancelDrag();
3561 0 : sal_Bool bRTL = pRuler_Imp->pTextRTLItem && pRuler_Imp->pTextRTLItem->GetValue();
3562 0 : if ( pTabs &&
3563 : RULER_TYPE_TAB ==
3564 0 : GetType( rCEvt.GetMousePosPixel(), &pRuler_Imp->nIdx ) &&
3565 0 : pTabs[pRuler_Imp->nIdx+TAB_GAP].nStyle < RULER_TAB_DEFAULT )
3566 : {
3567 0 : PopupMenu aMenu;
3568 0 : aMenu.SetSelectHdl(LINK(this, SvxRuler, TabMenuSelect));
3569 0 : VirtualDevice aDev;
3570 0 : const Size aSz(RULER_TAB_WIDTH+2, RULER_TAB_HEIGHT+2);
3571 0 : aDev.SetOutputSize(aSz);
3572 0 : aDev.SetBackground(Wallpaper(Color(COL_WHITE)));
3573 0 : const Point aPt(aSz.Width() / 2, aSz.Height() / 2);
3574 :
3575 0 : for ( sal_uInt16 i = RULER_TAB_LEFT; i < RULER_TAB_DEFAULT; ++i )
3576 : {
3577 0 : sal_uInt16 nStyle = bRTL ? i|RULER_TAB_RTL : i;
3578 0 : nStyle |= (sal_uInt16)(bHorz ? WB_HORZ : WB_VERT);
3579 0 : DrawTab(&aDev, aPt, nStyle);
3580 : aMenu.InsertItem(i+1,
3581 0 : String(ResId(RID_SVXSTR_RULER_START+i, DIALOG_MGR())),
3582 0 : Image(aDev.GetBitmap(Point(), aSz), Color(COL_WHITE)));
3583 0 : aMenu.CheckItem(i+1, i == pTabs[pRuler_Imp->nIdx+TAB_GAP].nStyle);
3584 0 : aDev.SetOutputSize(aSz); // delete device
3585 : }
3586 0 : aMenu.Execute( this, rCEvt.GetMousePosPixel() );
3587 : }
3588 : else
3589 : {
3590 0 : PopupMenu aMenu(ResId(RID_SVXMN_RULER, DIALOG_MGR()));
3591 0 : aMenu.SetSelectHdl(LINK(this, SvxRuler, MenuSelect));
3592 0 : FieldUnit eUnit = GetUnit();
3593 0 : const sal_uInt16 nCount = aMenu.GetItemCount();
3594 :
3595 0 : sal_Bool bReduceMetric = 0 != (nFlags &SVXRULER_SUPPORT_REDUCED_METRIC);
3596 0 : for ( sal_uInt16 i = nCount; i; --i )
3597 : {
3598 0 : const sal_uInt16 nId = aMenu.GetItemId(i - 1);
3599 0 : aMenu.CheckItem(nId, nId == (sal_uInt16)eUnit);
3600 0 : if(bReduceMetric &&
3601 : (nId == FUNIT_M ||
3602 : nId == FUNIT_KM ||
3603 : nId == FUNIT_FOOT ||
3604 : nId == FUNIT_MILE ||
3605 : nId == FUNIT_CHAR ||
3606 : nId == FUNIT_LINE ))
3607 : {
3608 0 : if (( nId == FUNIT_CHAR ) && bHorz )
3609 : ;
3610 0 : else if (( nId == FUNIT_LINE ) && !bHorz )
3611 : ;
3612 : else
3613 0 : aMenu.RemoveItem(i - 1);
3614 : }
3615 : }
3616 0 : aMenu.Execute( this, rCEvt.GetMousePosPixel() );
3617 : }
3618 : }
3619 : else
3620 0 : Ruler::Command( rCEvt );
3621 0 : }
3622 :
3623 :
3624 0 : sal_uInt16 SvxRuler::GetActRightColumn(
3625 : sal_Bool bForceDontConsiderHidden, sal_uInt16 nAct ) const
3626 : {
3627 0 : if( nAct == USHRT_MAX )
3628 0 : nAct = pColumnItem->GetActColumn();
3629 0 : else nAct++; //To be able to pass on the ActDrag
3630 :
3631 : sal_Bool bConsiderHidden = !bForceDontConsiderHidden &&
3632 0 : !( nDragType & DRAG_OBJECT_ACTLINE_ONLY );
3633 :
3634 0 : while( nAct < pColumnItem->Count() - 1 )
3635 : {
3636 0 : if( (*pColumnItem)[nAct].bVisible || bConsiderHidden )
3637 0 : return nAct;
3638 : else
3639 0 : nAct++;
3640 : }
3641 0 : return USHRT_MAX;
3642 : }
3643 :
3644 :
3645 :
3646 0 : sal_uInt16 SvxRuler::GetActLeftColumn(
3647 : sal_Bool bForceDontConsiderHidden, sal_uInt16 nAct ) const
3648 : {
3649 0 : if(nAct==USHRT_MAX)
3650 0 : nAct=pColumnItem->GetActColumn();
3651 :
3652 0 : sal_uInt16 nLOffs=1;
3653 :
3654 : sal_Bool bConsiderHidden = !bForceDontConsiderHidden &&
3655 0 : !( nDragType & DRAG_OBJECT_ACTLINE_ONLY );
3656 :
3657 0 : while(nAct>=nLOffs)
3658 : {
3659 0 : if( (*pColumnItem)[ nAct - nLOffs ].bVisible || bConsiderHidden )
3660 0 : return nAct-nLOffs;
3661 : else
3662 0 : nLOffs++;
3663 : }
3664 0 : return USHRT_MAX;
3665 : }
3666 :
3667 :
3668 0 : sal_Bool SvxRuler::IsActLastColumn(
3669 : sal_Bool bForceDontConsiderHidden, sal_uInt16 nAct) const
3670 : {
3671 0 : return GetActRightColumn(bForceDontConsiderHidden, nAct)==USHRT_MAX;
3672 : }
3673 :
3674 0 : sal_Bool SvxRuler::IsActFirstColumn(
3675 : sal_Bool bForceDontConsiderHidden, sal_uInt16 nAct) const
3676 : {
3677 0 : return GetActLeftColumn(bForceDontConsiderHidden, nAct)==USHRT_MAX;
3678 : }
3679 :
3680 0 : long SvxRuler::CalcPropMaxRight(sal_uInt16 nCol) const
3681 : {
3682 :
3683 0 : if(!(nDragType & DRAG_OBJECT_SIZE_LINEAR))
3684 : {
3685 : // Remove the minimum width for all affected columns
3686 : // starting from the right edge
3687 0 : long _nMaxRight = GetMargin2()-GetMargin1();
3688 :
3689 0 : long lFences=0;
3690 0 : long lMinSpace=USHRT_MAX;
3691 : long lOldPos;
3692 0 : long lColumns=0;
3693 : sal_uInt16 nStart;
3694 0 : if(!pColumnItem->IsTable())
3695 : {
3696 0 : if(nCol==USHRT_MAX)
3697 : {
3698 0 : lOldPos=GetMargin1();
3699 0 : nStart=0;
3700 : }
3701 : else
3702 : {
3703 0 : lOldPos=pBorders[nCol].nPos+pBorders[nCol].nWidth;
3704 0 : nStart=nCol+1;
3705 0 : lFences=pBorders[nCol].nWidth;
3706 : }
3707 :
3708 0 : for(sal_uInt16 i = nStart; i < nBorderCount-1; ++i)
3709 : {
3710 0 : long lWidth=pBorders[i].nPos-lOldPos;
3711 0 : lColumns+=lWidth;
3712 0 : if(lWidth<lMinSpace)
3713 0 : lMinSpace=lWidth;
3714 0 : lOldPos=pBorders[i].nPos+pBorders[i].nWidth;
3715 0 : lFences+=pBorders[i].nWidth;
3716 : }
3717 0 : long lWidth=GetMargin2()-lOldPos;
3718 0 : lColumns+=lWidth;
3719 0 : if(lWidth<lMinSpace)
3720 0 : lMinSpace=lWidth;
3721 : }
3722 : else
3723 : {
3724 : sal_uInt16 nActCol;
3725 0 : if(nCol==USHRT_MAX) //CalcMinMax for LeftMargin
3726 : {
3727 0 : lOldPos=GetMargin1();
3728 : }
3729 : else
3730 : {
3731 0 : lOldPos=pBorders[nCol].nPos;
3732 : }
3733 0 : lColumns=GetMargin2()-lOldPos;
3734 0 : nActCol=nCol;
3735 0 : lFences=0;
3736 0 : while(nActCol<nBorderCount||nActCol==USHRT_MAX)
3737 : {
3738 : sal_uInt16 nRight;
3739 0 : if(nActCol==USHRT_MAX)
3740 : {
3741 0 : nRight=0;
3742 0 : while(!(*pColumnItem)[nRight].bVisible)
3743 0 : nRight++;
3744 : }
3745 : else
3746 0 : nRight=GetActRightColumn(sal_False, nActCol);
3747 : long lWidth;
3748 0 : if(nRight!=USHRT_MAX)
3749 : {
3750 0 : lWidth=pBorders[nRight].nPos-lOldPos;
3751 0 : lOldPos=pBorders[nRight].nPos;
3752 : }
3753 : else
3754 0 : lWidth=GetMargin2()-lOldPos;
3755 0 : nActCol=nRight;
3756 0 : if(lWidth<lMinSpace)
3757 0 : lMinSpace=lWidth;
3758 0 : if(nActCol==USHRT_MAX)
3759 0 : break;
3760 : }
3761 : }
3762 :
3763 0 : _nMaxRight-=(long)(lFences+lMinFrame/(float)lMinSpace*lColumns);
3764 0 : return _nMaxRight;
3765 : }
3766 : else
3767 : {
3768 0 : if(pColumnItem->IsTable())
3769 : {
3770 0 : sal_uInt16 nVisCols=0;
3771 0 : for(sal_uInt16 i=GetActRightColumn(sal_False, nCol);i<nBorderCount;)
3772 : {
3773 0 : if((*pColumnItem)[i].bVisible)
3774 0 : nVisCols++;
3775 0 : i=GetActRightColumn(sal_False, i);
3776 : }
3777 0 : return GetMargin2()-GetMargin1()-(nVisCols+1)*lMinFrame;
3778 : }
3779 : else
3780 : {
3781 0 : long lWidth=0;
3782 0 : for(sal_uInt16 i=nCol;i<nBorderCount-1;i++)
3783 : {
3784 0 : lWidth+=lMinFrame+pBorders[i].nWidth;
3785 : }
3786 0 : return GetMargin2()-GetMargin1()-lWidth;
3787 : }
3788 : }
3789 : }
3790 :
3791 : // Tab stops relative to indent (#i24363#)
3792 208 : void SvxRuler::SetTabsRelativeToIndent( sal_Bool bRel )
3793 : {
3794 208 : pRuler_Imp->bIsTabsRelativeToIndent = bRel;
3795 208 : }
3796 :
3797 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
