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