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