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_vcl.hxx" 26 27 #include <string.h> 28 29 #include <tools/list.hxx> 30 #include <tools/debug.hxx> 31 #include <tools/rcid.h> 32 33 #include <vcl/event.hxx> 34 #include <vcl/wall.hxx> 35 #include <vcl/bitmap.hxx> 36 #include <vcl/decoview.hxx> 37 #include <vcl/symbol.hxx> 38 #include <vcl/image.hxx> 39 #include <vcl/help.hxx> 40 #include <vcl/splitwin.hxx> 41 42 #include <svdata.hxx> 43 #include <svids.hrc> 44 45 46 // ======================================================================= 47 48 // Attention: Must not contain non-PODs because array is enlarged/copied 49 // with the use of memmove/memcpy. 50 struct ImplSplitItem 51 { 52 long mnSize; 53 long mnPixSize; 54 long mnLeft; 55 long mnTop; 56 long mnWidth; 57 long mnHeight; 58 long mnSplitPos; 59 long mnSplitSize; 60 long mnOldSplitPos; 61 long mnOldSplitSize; 62 long mnOldWidth; 63 long mnOldHeight; 64 ImplSplitSet* mpSet; 65 Window* mpWindow; 66 Window* mpOrgParent; 67 sal_uInt16 mnId; 68 SplitWindowItemBits mnBits; 69 sal_Bool mbFixed; 70 sal_Bool mbSubSize; 71 /// Minimal width or height of the item. -1 means no restriction. 72 long mnMinSize; 73 /// Maximal width or height of the item. -1 means no restriction. 74 long mnMaxSize; 75 }; 76 77 struct ImplSplitSet 78 { 79 ImplSplitItem* mpItems; 80 Wallpaper* mpWallpaper; 81 Bitmap* mpBitmap; 82 long mnLastSize; 83 long mnSplitSize; 84 sal_uInt16 mnItems; 85 sal_uInt16 mnId; 86 sal_Bool mbCalcPix; 87 }; 88 89 90 91 /** Check whether the given size is inside the valid range defined by 92 [rItem.mnMinSize,rItem.mnMaxSize]. When it is not inside it then return 93 the upper or lower bound, respectively. Otherwise return the given size 94 unmodified. 95 Note that either mnMinSize and/or mnMaxSize can be -1 in which case the 96 size has not lower or upper bound. 97 */ 98 namespace { 99 long ValidateSize (const long nSize, const ImplSplitItem& rItem) 100 { 101 if (rItem.mnMinSize>=0 && nSize<rItem.mnMinSize) 102 return rItem.mnMinSize; 103 else if (rItem.mnMaxSize>0 && nSize>rItem.mnMaxSize) 104 return rItem.mnMaxSize; 105 else 106 return nSize; 107 } 108 } 109 110 111 #define SPLITWIN_SPLITSIZE 3 112 #define SPLITWIN_SPLITSIZEEX 4 113 #define SPLITWIN_SPLITSIZEEXLN 6 114 #define SPLITWIN_SPLITSIZEAUTOHIDE 36 115 #define SPLITWIN_SPLITSIZEFADE 36 116 117 #define SPLIT_HORZ ((sal_uInt16)0x0001) 118 #define SPLIT_VERT ((sal_uInt16)0x0002) 119 #define SPLIT_WINDOW ((sal_uInt16)0x0004) 120 #define SPLIT_NOSPLIT ((sal_uInt16)0x8000) 121 122 // ----------------------------------------------------------------------- 123 124 DECLARE_LIST( ImplSplitList, SplitWindow* ) 125 126 // ======================================================================= 127 128 static void ImplCalcBorder( WindowAlign eAlign, sal_Bool bNoAlign, 129 long& rLeft, long& rTop, 130 long& rRight, long& rBottom ) 131 { 132 if ( bNoAlign ) 133 { 134 rLeft = 2; 135 rTop = 2; 136 rRight = 2; 137 rBottom = 2; 138 } 139 else 140 { 141 if ( eAlign == WINDOWALIGN_TOP ) 142 { 143 rLeft = 2; 144 rTop = 2; 145 rRight = 2; 146 rBottom = 0; 147 } 148 else if ( eAlign == WINDOWALIGN_LEFT ) 149 { 150 rLeft = 2; 151 rTop = 2; 152 rRight = 0; 153 rBottom = 2; 154 } 155 else if ( eAlign == WINDOWALIGN_BOTTOM ) 156 { 157 rLeft = 2; 158 rTop = 0; 159 rRight = 2; 160 rBottom = 2; 161 } 162 else 163 { 164 rLeft = 0; 165 rTop = 2; 166 rRight = 2; 167 rBottom = 2; 168 } 169 } 170 } 171 172 // ----------------------------------------------------------------------- 173 174 void SplitWindow::ImplDrawBorder( SplitWindow* pWin ) 175 { 176 const StyleSettings& rStyleSettings = pWin->GetSettings().GetStyleSettings(); 177 long nDX = pWin->mnDX; 178 long nDY = pWin->mnDY; 179 180 if ( pWin->mbNoAlign ) 181 { 182 DecorationView aDecoView( pWin ); 183 Point aTmpPoint; 184 Rectangle aRect( aTmpPoint, Size( nDX, nDY ) ); 185 aDecoView.DrawFrame( aRect, FRAME_DRAW_DOUBLEIN ); 186 } 187 else 188 {/* 189 if ( pWin->meAlign == WINDOWALIGN_BOTTOM ) 190 { 191 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 192 pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) ); 193 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 194 pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) ); 195 } 196 else 197 { 198 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 199 pWin->DrawLine( Point( 0, 0 ), Point( nDX-1, 0 ) ); 200 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 201 pWin->DrawLine( Point( 0, 1 ), Point( nDX-1, 1 ) ); 202 if ( (pWin->meAlign == WINDOWALIGN_LEFT) || (pWin->meAlign == WINDOWALIGN_RIGHT) ) 203 { 204 if ( pWin->meAlign == WINDOWALIGN_LEFT ) 205 { 206 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 207 pWin->DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) ); 208 pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) ); 209 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 210 pWin->DrawLine( Point( 1, 1 ), Point( 1, nDY-3 ) ); 211 pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) ); 212 } 213 else 214 { 215 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 216 pWin->DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-3 ) ); 217 pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-2, nDY-2 ) ); 218 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 219 pWin->DrawLine( Point( nDX-1, 0 ), Point( nDX-1, nDY-1 ) ); 220 pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) ); 221 } 222 } 223 }*/ 224 if ( pWin->meAlign == WINDOWALIGN_BOTTOM ) 225 { 226 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 227 pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) ); 228 pWin->DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) ); 229 pWin->DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-3 ) ); 230 231 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 232 pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) ); 233 pWin->DrawLine( Point( 1, 1 ), Point( 1, nDY-3 ) ); 234 pWin->DrawLine( Point( nDX-1, 0 ), Point( nDX-1, nDY-1 ) ); 235 } 236 else if ( pWin->meAlign == WINDOWALIGN_TOP ) 237 { 238 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 239 pWin->DrawLine( Point( 0, 0 ), Point( nDX-1, 0 ) ); 240 pWin->DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) ); 241 pWin->DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-1 ) ); 242 243 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 244 pWin->DrawLine( Point( 1, 1 ), Point( nDX-3, 1 ) ); 245 pWin->DrawLine( Point( 1, 1 ), Point( 1, nDY-1 ) ); 246 pWin->DrawLine( Point( nDX-1, 1 ), Point( nDX-1, nDY-1 ) ); 247 } 248 else if ( pWin->meAlign == WINDOWALIGN_LEFT ) 249 { 250 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 251 pWin->DrawLine( Point( 0, 0 ), Point( nDX-1, 0 ) ); 252 pWin->DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) ); 253 pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) ); 254 255 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 256 pWin->DrawLine( Point( 1, 1 ), Point( nDX-1, 1 ) ); 257 pWin->DrawLine( Point( 1, 1 ), Point( 1, nDY-3 ) ); 258 pWin->DrawLine( Point( 1, nDY-1 ), Point( nDX-1, nDY-1 ) ); 259 } 260 else 261 { 262 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 263 pWin->DrawLine( Point( 0, 0 ), Point( nDX-2, 0 ) ); 264 pWin->DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-3 ) ); 265 pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-2, nDY-2 ) ); 266 267 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 268 pWin->DrawLine( Point( 0, 1 ), Point( nDX-3, 1 ) ); 269 pWin->DrawLine( Point( nDX-1, 0 ), Point( nDX-1, nDY-1 ) ); 270 pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) ); 271 } 272 } 273 } 274 275 // ----------------------------------------------------------------------- 276 277 void SplitWindow::ImplDrawBorderLine( SplitWindow* pWin ) 278 { 279 if ( pWin->mbFadeOut || pWin->mbAutoHide ) 280 { 281 const StyleSettings& rStyleSettings = pWin->GetSettings().GetStyleSettings(); 282 long nDX = pWin->mnDX; 283 long nDY = pWin->mnDY; 284 285 if ( pWin->meAlign == WINDOWALIGN_LEFT ) 286 { 287 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 288 pWin->DrawLine( Point( nDX-SPLITWIN_SPLITSIZEEXLN-1, 0 ), Point( nDX-SPLITWIN_SPLITSIZEEXLN-1, nDY-3 ) ); 289 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 290 pWin->DrawLine( Point( nDX-SPLITWIN_SPLITSIZEEXLN, 1 ), Point( nDX-SPLITWIN_SPLITSIZEEXLN, nDY-4 ) ); 291 } 292 else if ( pWin->meAlign == WINDOWALIGN_RIGHT ) 293 { 294 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 295 pWin->DrawLine( Point( SPLITWIN_SPLITSIZEEXLN-1, 0 ), Point( SPLITWIN_SPLITSIZEEXLN-1, nDY-3 ) ); 296 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 297 pWin->DrawLine( Point( SPLITWIN_SPLITSIZEEXLN, 1 ), Point( SPLITWIN_SPLITSIZEEXLN, nDY-4 ) ); 298 } 299 else if ( pWin->meAlign == WINDOWALIGN_TOP ) 300 { 301 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 302 pWin->DrawLine( Point( 0, nDY-SPLITWIN_SPLITSIZEEXLN-1 ), Point( nDX-3, nDY-SPLITWIN_SPLITSIZEEXLN-1 ) ); 303 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 304 pWin->DrawLine( Point( 1, nDY-SPLITWIN_SPLITSIZEEXLN ), Point( nDX-4, nDY-SPLITWIN_SPLITSIZEEXLN ) ); 305 } 306 else if ( pWin->meAlign == WINDOWALIGN_BOTTOM ) 307 { 308 pWin->SetLineColor( rStyleSettings.GetShadowColor() ); 309 pWin->DrawLine( Point( 0, SPLITWIN_SPLITSIZEEXLN-1 ), Point( nDX-3, SPLITWIN_SPLITSIZEEXLN-1 ) ); 310 pWin->SetLineColor( rStyleSettings.GetLightColor() ); 311 pWin->DrawLine( Point( 1, SPLITWIN_SPLITSIZEEXLN ), Point( nDX-4, SPLITWIN_SPLITSIZEEXLN ) ); 312 } 313 } 314 } 315 316 // ----------------------------------------------------------------------- 317 318 static ImplSplitSet* ImplFindSet( ImplSplitSet* pSet, sal_uInt16 nId ) 319 { 320 if ( pSet->mnId == nId ) 321 return pSet; 322 323 sal_uInt16 i; 324 sal_uInt16 nItems = pSet->mnItems; 325 ImplSplitItem* pItems = pSet->mpItems; 326 327 for ( i = 0; i < nItems; i++ ) 328 { 329 if ( pItems[i].mnId == nId ) 330 return pItems[i].mpSet; 331 } 332 333 for ( i = 0; i < nItems; i++ ) 334 { 335 if ( pItems[i].mpSet ) 336 { 337 ImplSplitSet* pFindSet = ImplFindSet( pItems[i].mpSet, nId ); 338 if ( pFindSet ) 339 return pFindSet; 340 } 341 } 342 343 return NULL; 344 } 345 346 // ----------------------------------------------------------------------- 347 348 static ImplSplitSet* ImplFindItem( ImplSplitSet* pSet, sal_uInt16 nId, sal_uInt16& rPos ) 349 { 350 sal_uInt16 i; 351 sal_uInt16 nItems = pSet->mnItems; 352 ImplSplitItem* pItems = pSet->mpItems; 353 354 for ( i = 0; i < nItems; i++ ) 355 { 356 if ( pItems[i].mnId == nId ) 357 { 358 rPos = i; 359 return pSet; 360 } 361 } 362 363 for ( i = 0; i < nItems; i++ ) 364 { 365 if ( pItems[i].mpSet ) 366 { 367 ImplSplitSet* pFindSet = ImplFindItem( pItems[i].mpSet, nId, rPos ); 368 if ( pFindSet ) 369 return pFindSet; 370 } 371 } 372 373 return NULL; 374 } 375 376 // ----------------------------------------------------------------------- 377 378 static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, Window* pWindow ) 379 { 380 sal_uInt16 i; 381 sal_uInt16 nItems = pSet->mnItems; 382 ImplSplitItem* pItems = pSet->mpItems; 383 384 for ( i = 0; i < nItems; i++ ) 385 { 386 if ( pItems[i].mpWindow == pWindow ) 387 return pItems[i].mnId; 388 else 389 { 390 if ( pItems[i].mpSet ) 391 { 392 sal_uInt16 nId = ImplFindItem( pItems[i].mpSet, pWindow ); 393 if ( nId ) 394 return nId; 395 } 396 } 397 } 398 399 return 0; 400 } 401 402 // ----------------------------------------------------------------------- 403 404 static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, const Point& rPos, 405 sal_Bool bRows, sal_Bool bDown = sal_True ) 406 { 407 sal_uInt16 i; 408 sal_uInt16 nItems = pSet->mnItems; 409 ImplSplitItem* pItems = pSet->mpItems; 410 411 for ( i = 0; i < nItems; i++ ) 412 { 413 if ( pItems[i].mnWidth && pItems[i].mnHeight ) 414 { 415 // Wegen ICC auftrennen 416 Point aPoint( pItems[i].mnLeft, pItems[i].mnTop ); 417 Size aSize( pItems[i].mnWidth, pItems[i].mnHeight ); 418 Rectangle aRect( aPoint, aSize ); 419 if ( bRows ) 420 { 421 if ( bDown ) 422 aRect.Bottom() += pSet->mnSplitSize; 423 else 424 aRect.Top() -= pSet->mnSplitSize; 425 } 426 else 427 { 428 if ( bDown ) 429 aRect.Right() += pSet->mnSplitSize; 430 else 431 aRect.Left() -= pSet->mnSplitSize; 432 } 433 434 if ( aRect.IsInside( rPos ) ) 435 { 436 if ( pItems[i].mpSet && pItems[i].mpSet->mpItems ) 437 { 438 return ImplFindItem( pItems[i].mpSet, rPos, 439 ((pItems[i].mnBits & SWIB_COLSET) == 0) ); 440 } 441 else 442 return pItems[i].mnId; 443 } 444 } 445 } 446 447 return 0; 448 } 449 450 // ----------------------------------------------------------------------- 451 452 static void ImplDeleteSet( ImplSplitSet* pSet ) 453 { 454 sal_uInt16 i; 455 sal_uInt16 nItems = pSet->mnItems; 456 ImplSplitItem* pItems = pSet->mpItems; 457 458 for ( i = 0; i < nItems; i++ ) 459 { 460 if ( pItems[i].mpSet ) 461 ImplDeleteSet( pItems[i].mpSet ); 462 } 463 464 if ( pSet->mpWallpaper ) 465 delete pSet->mpWallpaper; 466 467 if ( pSet->mpBitmap ) 468 delete pSet->mpBitmap; 469 470 delete [] pItems; 471 delete pSet; 472 } 473 474 // ----------------------------------------------------------------------- 475 476 static void ImplSetSplitSize( ImplSplitSet* pSet, long nNewSize ) 477 { 478 pSet->mnSplitSize = nNewSize; 479 for ( sal_uInt16 i = 0; i < pSet->mnItems; i++ ) 480 { 481 if ( pSet->mpItems[i].mpSet ) 482 ImplSetSplitSize( pSet->mpItems[i].mpSet, nNewSize ); 483 } 484 } 485 486 // ----------------------------------------------------------------------- 487 488 static void ImplCalcSet( ImplSplitSet* pSet, 489 long nSetLeft, long nSetTop, 490 long nSetWidth, long nSetHeight, 491 sal_Bool bRows, sal_Bool bDown = sal_True ) 492 { 493 if ( !pSet->mpItems ) 494 return; 495 496 sal_uInt16 i; 497 sal_uInt16 j; 498 sal_uInt16 nMins; 499 sal_uInt16 nCalcItems; 500 sal_uInt16 nItems = pSet->mnItems; 501 sal_uInt16 nVisItems; 502 sal_uInt16 nAbsItems; 503 long nCalcSize; 504 long nSizeDelta; 505 long nCurSize; 506 long nSizeWinSize; 507 long nNewSizeWinSize; 508 long nTemp; 509 long nTempErr; 510 long nErrorSum; 511 long nCurSizeDelta; 512 long nPos; 513 long nMaxPos; 514 long* pSize; 515 ImplSplitItem* pItems = pSet->mpItems; 516 sal_Bool bEmpty; 517 518 // Anzahl sichtbarer Items ermitteln 519 nVisItems = 0; 520 for ( i = 0; i < nItems; i++ ) 521 { 522 if ( !(pItems[i].mnBits & SWIB_INVISIBLE) ) 523 nVisItems++; 524 } 525 526 // Groessen berechnen 527 if ( bRows ) 528 nCalcSize = nSetHeight; 529 else 530 nCalcSize = nSetWidth; 531 nCalcSize -= (nVisItems-1)*pSet->mnSplitSize; 532 nCurSize = 0; 533 if ( pSet->mbCalcPix || (pSet->mnLastSize != nCalcSize) ) 534 { 535 long nPercentFactor = 10; 536 long nRelCount = 0; 537 long nPercent = 0; 538 long nRelPercent = 0; 539 long nAbsSize = 0; 540 for ( i = 0; i < nItems; i++ ) 541 { 542 if ( !(pItems[i].mnBits & SWIB_INVISIBLE) ) 543 { 544 if ( pItems[i].mnBits & SWIB_RELATIVESIZE ) 545 nRelCount += pItems[i].mnSize; 546 else if ( pItems[i].mnBits & SWIB_PERCENTSIZE ) 547 nPercent += pItems[i].mnSize; 548 else 549 nAbsSize += pItems[i].mnSize; 550 } 551 } 552 // Relative-Werte auf prozentual mappen (Percent bei uns 10tel Prozent) 553 nPercent *= nPercentFactor; 554 if ( nRelCount ) 555 { 556 long nRelPercentBase = 1000; 557 while ( (nRelCount > nRelPercentBase) && (nPercentFactor < 100000) ) 558 { 559 nRelPercentBase *= 10; 560 nPercentFactor *= 10; 561 } 562 if ( nPercent < nRelPercentBase ) 563 { 564 nRelPercent = (nRelPercentBase-nPercent)/nRelCount; 565 nPercent += nRelPercent*nRelCount; 566 } 567 else 568 nRelPercent = 0; 569 } 570 if ( !nPercent ) 571 nPercent = 1; 572 nSizeDelta = nCalcSize-nAbsSize; 573 for ( i = 0; i < nItems; i++ ) 574 { 575 if ( pItems[i].mnBits & SWIB_INVISIBLE ) 576 pItems[i].mnPixSize = 0; 577 else if ( pItems[i].mnBits & SWIB_RELATIVESIZE ) 578 { 579 if ( nSizeDelta <= 0 ) 580 pItems[i].mnPixSize = 0; 581 else 582 pItems[i].mnPixSize = (nSizeDelta*pItems[i].mnSize*nRelPercent)/nPercent; 583 } 584 else if ( pItems[i].mnBits & SWIB_PERCENTSIZE ) 585 { 586 if ( nSizeDelta <= 0 ) 587 pItems[i].mnPixSize = 0; 588 else 589 pItems[i].mnPixSize = (nSizeDelta*pItems[i].mnSize*nPercentFactor)/nPercent; 590 } 591 else 592 pItems[i].mnPixSize = pItems[i].mnSize; 593 nCurSize += pItems[i].mnPixSize; 594 } 595 596 pSet->mbCalcPix = sal_False; 597 pSet->mnLastSize = nCalcSize; 598 599 // Fenster einpassen 600 nSizeDelta = nCalcSize-nCurSize; 601 if ( nSizeDelta ) 602 { 603 nAbsItems = 0; 604 nSizeWinSize = 0; 605 nNewSizeWinSize = 0; 606 607 // Zuerst die absoluten Items relativ resizen 608 for ( i = 0; i < nItems; i++ ) 609 { 610 if ( !(pItems[i].mnBits & SWIB_INVISIBLE) ) 611 { 612 if ( !(pItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE)) ) 613 { 614 nAbsItems++; 615 nSizeWinSize += pItems[i].mnPixSize; 616 } 617 } 618 } 619 // Rundungsfehler werden hier nicht ausgelichen 620 if ( (nAbsItems < (sal_uInt16)(Abs( nSizeDelta ))) && nSizeWinSize ) 621 { 622 for ( i = 0; i < nItems; i++ ) 623 { 624 if ( !(pItems[i].mnBits & SWIB_INVISIBLE) ) 625 { 626 if ( !(pItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE)) ) 627 { 628 pItems[i].mnPixSize += (nSizeDelta*pItems[i].mnPixSize)/nSizeWinSize; 629 nNewSizeWinSize += pItems[i].mnPixSize; 630 } 631 } 632 } 633 nSizeDelta -= nNewSizeWinSize-nSizeWinSize; 634 } 635 636 // Jetzt die Rundunsfehler ausgleichen 637 j = 0; 638 nMins = 0; 639 while ( nSizeDelta && (nItems != nMins) ) 640 { 641 // Feststellen, welche Items berechnet werden duerfen 642 nCalcItems = 0; 643 while ( !nCalcItems ) 644 { 645 for ( i = 0; i < nItems; i++ ) 646 { 647 pItems[i].mbSubSize = sal_False; 648 649 if ( j >= 2 ) 650 pItems[i].mbSubSize = sal_True; 651 else 652 { 653 if ( !(pItems[i].mnBits & SWIB_INVISIBLE) ) 654 { 655 if ( (nSizeDelta > 0) || pItems[i].mnPixSize ) 656 { 657 if ( j >= 1 ) 658 pItems[i].mbSubSize = sal_True; 659 else 660 { 661 if ( (j == 0) && (pItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE)) ) 662 pItems[i].mbSubSize = sal_True; 663 } 664 } 665 } 666 } 667 668 if ( pItems[i].mbSubSize ) 669 nCalcItems++; 670 } 671 672 j++; 673 } 674 675 // Groessen von den einzelnen Items abziehen 676 nErrorSum = nSizeDelta % nCalcItems; 677 nCurSizeDelta = nSizeDelta / nCalcItems; 678 nMins = 0; 679 for ( i = 0; i < nItems; i++ ) 680 { 681 if ( pItems[i].mnBits & SWIB_INVISIBLE ) 682 nMins++; 683 else if ( pItems[i].mbSubSize ) 684 { 685 pSize = &(pItems[i].mnPixSize); 686 687 if ( nErrorSum ) 688 { 689 if ( nErrorSum < 0 ) 690 nTempErr = -1; 691 else 692 nTempErr = 1; 693 } 694 else 695 nTempErr = 0; 696 697 if ( (*pSize+nCurSizeDelta+nTempErr) <= 0 ) 698 { 699 nTemp = *pSize; 700 if ( nTemp ) 701 { 702 *pSize -= nTemp; 703 nSizeDelta += nTemp; 704 } 705 nMins++; 706 } 707 else 708 { 709 *pSize += nCurSizeDelta; 710 nSizeDelta -= nCurSizeDelta; 711 if ( nTempErr && (*pSize || (nTempErr > 0)) ) 712 { 713 *pSize += nTempErr; 714 nSizeDelta -= nTempErr; 715 nErrorSum -= nTempErr; 716 } 717 } 718 } 719 } 720 } 721 } 722 } 723 else 724 { 725 for ( i = 0; i < nItems; i++ ) 726 { 727 if ( !(pItems[i].mnBits & SWIB_INVISIBLE) ) 728 nCurSize += pItems[i].mnPixSize; 729 } 730 } 731 732 // Maximale Groesse berechnen 733 if ( bRows ) 734 { 735 nPos = nSetTop; 736 if ( !bDown ) 737 nMaxPos = nSetTop-nSetHeight; 738 else 739 nMaxPos = nSetTop+nSetHeight; 740 } 741 else 742 { 743 nPos = nSetLeft; 744 if ( !bDown ) 745 nMaxPos = nSetLeft-nSetWidth; 746 else 747 nMaxPos = nSetLeft+nSetWidth; 748 } 749 750 // Fenster anordnen und Werte anpassen 751 for ( i = 0; i < nItems; i++ ) 752 { 753 pItems[i].mnOldSplitPos = pItems[i].mnSplitPos; 754 pItems[i].mnOldSplitSize = pItems[i].mnSplitSize; 755 pItems[i].mnOldWidth = pItems[i].mnWidth; 756 pItems[i].mnOldHeight = pItems[i].mnHeight; 757 758 if ( pItems[i].mnBits & SWIB_INVISIBLE ) 759 bEmpty = sal_True; 760 else 761 { 762 bEmpty = sal_False; 763 if ( bDown ) 764 { 765 if ( nPos+pItems[i].mnPixSize > nMaxPos ) 766 bEmpty = sal_True; 767 } 768 else 769 { 770 nPos -= pItems[i].mnPixSize; 771 if ( nPos < nMaxPos ) 772 bEmpty = sal_True; 773 } 774 } 775 776 if ( bEmpty ) 777 { 778 pItems[i].mnWidth = 0; 779 pItems[i].mnHeight = 0; 780 pItems[i].mnSplitSize = 0; 781 } 782 else 783 { 784 if ( bRows ) 785 { 786 pItems[i].mnLeft = nSetLeft; 787 pItems[i].mnTop = nPos; 788 pItems[i].mnWidth = nSetWidth; 789 pItems[i].mnHeight = pItems[i].mnPixSize; 790 } 791 else 792 { 793 pItems[i].mnLeft = nPos; 794 pItems[i].mnTop = nSetTop; 795 pItems[i].mnWidth = pItems[i].mnPixSize; 796 pItems[i].mnHeight = nSetHeight; 797 } 798 799 if ( i > nItems-1 ) 800 pItems[i].mnSplitSize = 0; 801 else 802 { 803 pItems[i].mnSplitSize = pSet->mnSplitSize; 804 if ( bDown ) 805 { 806 pItems[i].mnSplitPos = nPos+pItems[i].mnPixSize; 807 if ( pItems[i].mnSplitPos+pItems[i].mnSplitSize > nMaxPos ) 808 pItems[i].mnSplitSize = nMaxPos-pItems[i].mnSplitPos; 809 } 810 else 811 { 812 pItems[i].mnSplitPos = nPos-pSet->mnSplitSize; 813 if ( pItems[i].mnSplitPos < nMaxPos ) 814 pItems[i].mnSplitSize = pItems[i].mnSplitPos+pSet->mnSplitSize-nMaxPos; 815 } 816 } 817 } 818 819 if ( !(pItems[i].mnBits & SWIB_INVISIBLE) ) 820 { 821 if ( !bDown ) 822 nPos -= pSet->mnSplitSize; 823 else 824 nPos += pItems[i].mnPixSize+pSet->mnSplitSize; 825 } 826 } 827 828 // Sub-Set's berechnen 829 for ( i = 0; i < nItems; i++ ) 830 { 831 if ( pItems[i].mpSet && pItems[i].mnWidth && pItems[i].mnHeight ) 832 { 833 ImplCalcSet( pItems[i].mpSet, 834 pItems[i].mnLeft, pItems[i].mnTop, 835 pItems[i].mnWidth, pItems[i].mnHeight, 836 ((pItems[i].mnBits & SWIB_COLSET) == 0) ); 837 } 838 } 839 840 // Fixed setzen 841 for ( i = 0; i < nItems; i++ ) 842 { 843 pItems[i].mbFixed = sal_False; 844 if ( pItems[i].mnBits & SWIB_FIXED ) 845 pItems[i].mbFixed = sal_True; 846 else 847 { 848 // Wenn Child-Set vorhanden, ist dieses Item auch Fixed, wenn 849 // ein Child fixed ist 850 if ( pItems[i].mpSet ) 851 { 852 for ( j = 0; j < pItems[i].mpSet->mnItems; j++ ) 853 { 854 if ( pItems[i].mpSet->mpItems[j].mbFixed ) 855 { 856 pItems[i].mbFixed = sal_True; 857 break; 858 } 859 } 860 } 861 } 862 } 863 } 864 865 // ----------------------------------------------------------------------- 866 867 void SplitWindow::ImplCalcSet2( SplitWindow* pWindow, ImplSplitSet* pSet, sal_Bool bHide, 868 sal_Bool bRows, sal_Bool /*bDown*/ ) 869 { 870 sal_uInt16 i; 871 sal_uInt16 nItems = pSet->mnItems; 872 ImplSplitItem* pItems = pSet->mpItems; 873 874 if ( pWindow->IsReallyVisible() && pWindow->IsUpdateMode() && pWindow->mbInvalidate ) 875 { 876 for ( i = 0; i < nItems; i++ ) 877 { 878 if ( pItems[i].mnSplitSize ) 879 { 880 // Evt. alles invalidieren oder nur einen kleinen Teil 881 if ( (pItems[i].mnOldSplitPos != pItems[i].mnSplitPos) || 882 (pItems[i].mnOldSplitSize != pItems[i].mnSplitSize) || 883 (pItems[i].mnOldWidth != pItems[i].mnWidth) || 884 (pItems[i].mnOldHeight != pItems[i].mnHeight) ) 885 { 886 Rectangle aRect; 887 888 // Old Rect invalidieren 889 if ( bRows ) 890 { 891 aRect.Left() = pItems[i].mnLeft; 892 aRect.Right() = pItems[i].mnLeft+pItems[i].mnOldWidth-1; 893 aRect.Top() = pItems[i].mnOldSplitPos; 894 aRect.Bottom() = aRect.Top() + pItems[i].mnOldSplitSize; 895 } 896 else 897 { 898 aRect.Top() = pItems[i].mnTop; 899 aRect.Bottom() = pItems[i].mnTop+pItems[i].mnOldHeight-1; 900 aRect.Left() = pItems[i].mnOldSplitPos; 901 aRect.Right() = aRect.Left() + pItems[i].mnOldSplitSize; 902 } 903 pWindow->Invalidate( aRect ); 904 // New Rect invalidieren 905 if ( bRows ) 906 { 907 aRect.Left() = pItems[i].mnLeft; 908 aRect.Right() = pItems[i].mnLeft+pItems[i].mnWidth-1; 909 aRect.Top() = pItems[i].mnSplitPos; 910 aRect.Bottom() = aRect.Top() + pItems[i].mnSplitSize; 911 } 912 else 913 { 914 aRect.Top() = pItems[i].mnTop; 915 aRect.Bottom() = pItems[i].mnTop+pItems[i].mnHeight-1; 916 aRect.Left() = pItems[i].mnSplitPos; 917 aRect.Right() = aRect.Left() + pItems[i].mnSplitSize; 918 } 919 pWindow->Invalidate( aRect ); 920 921 // Leere Sets komplett invalidieren, da diese Flaechen 922 // nicht von Fenstern ueberladen werden 923 if ( pItems[i].mpSet && !pItems[i].mpSet->mpItems ) 924 { 925 aRect.Left() = pItems[i].mnLeft; 926 aRect.Top() = pItems[i].mnTop; 927 aRect.Right() = pItems[i].mnLeft+pItems[i].mnWidth-1; 928 aRect.Bottom() = pItems[i].mnTop+pItems[i].mnHeight-1; 929 pWindow->Invalidate( aRect ); 930 } 931 } 932 } 933 } 934 } 935 936 // Fenster positionieren 937 for ( i = 0; i < nItems; i++ ) 938 { 939 if ( pItems[i].mpSet ) 940 { 941 sal_Bool bTempHide = bHide; 942 if ( !pItems[i].mnWidth || !pItems[i].mnHeight ) 943 bTempHide = sal_True; 944 ImplCalcSet2( pWindow, pItems[i].mpSet, bTempHide, 945 ((pItems[i].mnBits & SWIB_COLSET) == 0) ); 946 } 947 else 948 { 949 if ( pItems[i].mnWidth && pItems[i].mnHeight && !bHide ) 950 { 951 Point aPos( pItems[i].mnLeft, pItems[i].mnTop ); 952 Size aSize( pItems[i].mnWidth, pItems[i].mnHeight ); 953 pItems[i].mpWindow->SetPosSizePixel( aPos, aSize ); 954 } 955 else 956 pItems[i].mpWindow->Hide(); 957 } 958 } 959 960 // Fenster anzeigen und Flag zuruecksetzen 961 for ( i = 0; i < nItems; i++ ) 962 { 963 if ( pItems[i].mpWindow && pItems[i].mnWidth && pItems[i].mnHeight && !bHide ) 964 pItems[i].mpWindow->Show(); 965 } 966 } 967 968 // ----------------------------------------------------------------------- 969 970 static void ImplCalcLogSize( ImplSplitItem* pItems, sal_uInt16 nItems ) 971 { 972 // Original-Groessen updaten 973 sal_uInt16 i; 974 long nRelSize = 0; 975 long nPerSize = 0; 976 for ( i = 0; i < nItems; i++ ) 977 { 978 if ( pItems[i].mnBits & SWIB_RELATIVESIZE ) 979 nRelSize += pItems[i].mnPixSize; 980 else if ( pItems[i].mnBits & SWIB_PERCENTSIZE ) 981 nPerSize += pItems[i].mnPixSize; 982 } 983 nPerSize += nRelSize; 984 for ( i = 0; i < nItems; i++ ) 985 { 986 if ( pItems[i].mnBits & SWIB_RELATIVESIZE ) 987 { 988 if ( nRelSize ) 989 pItems[i].mnSize = (pItems[i].mnPixSize+(nRelSize/2))/nRelSize; 990 else 991 pItems[i].mnSize = 1; 992 } 993 else if ( pItems[i].mnBits & SWIB_PERCENTSIZE ) 994 { 995 if ( nPerSize ) 996 pItems[i].mnSize = (pItems[i].mnPixSize*100)/nPerSize; 997 else 998 pItems[i].mnSize = 1; 999 } 1000 else 1001 pItems[i].mnSize = pItems[i].mnPixSize; 1002 } 1003 } 1004 1005 // ----------------------------------------------------------------------- 1006 1007 void SplitWindow::ImplDrawBack( SplitWindow* pWindow, const Rectangle& rRect, 1008 const Wallpaper* pWall, const Bitmap* pBitmap ) 1009 { 1010 if ( pBitmap ) 1011 { 1012 Point aPos = rRect.TopLeft(); 1013 Size aBmpSize = pBitmap->GetSizePixel(); 1014 pWindow->Push( PUSH_CLIPREGION ); 1015 pWindow->IntersectClipRegion( rRect ); 1016 do 1017 { 1018 aPos.X() = rRect.Left(); 1019 do 1020 { 1021 pWindow->DrawBitmap( aPos, *pBitmap ); 1022 aPos.X() += aBmpSize.Width(); 1023 } 1024 while ( aPos.X() < rRect.Right() ); 1025 aPos.Y() += aBmpSize.Height(); 1026 } 1027 while ( aPos.Y() < rRect.Bottom() ); 1028 pWindow->Pop(); 1029 } 1030 else 1031 pWindow->DrawWallpaper( rRect, *pWall ); 1032 } 1033 1034 // ----------------------------------------------------------------------- 1035 1036 void SplitWindow::ImplDrawBack( SplitWindow* pWindow, ImplSplitSet* pSet ) 1037 { 1038 sal_uInt16 i; 1039 sal_uInt16 nItems = pSet->mnItems; 1040 ImplSplitItem* pItems = pSet->mpItems; 1041 1042 // Beim Mainset auch den Hintergrund zeichnen 1043 if ( pSet->mnId == 0 ) 1044 { 1045 if ( pSet->mpBitmap ) 1046 { 1047 Rectangle aRect( pWindow->mnLeftBorder, 1048 pWindow->mnTopBorder, 1049 pWindow->mnDX-pWindow->mnRightBorder-1, 1050 pWindow->mnDY-pWindow->mnBottomBorder-1 ); 1051 ImplDrawBack( pWindow, aRect, pSet->mpWallpaper, pSet->mpBitmap ); 1052 } 1053 } 1054 1055 for ( i = 0; i < nItems; i++ ) 1056 { 1057 pSet = pItems[i].mpSet; 1058 if ( pSet ) 1059 { 1060 if ( pSet->mpBitmap || pSet->mpWallpaper ) 1061 { 1062 // Wegen ICC auftrennen 1063 Point aPoint( pItems[i].mnLeft, pItems[i].mnTop ); 1064 Size aSize( pItems[i].mnWidth, pItems[i].mnHeight ); 1065 Rectangle aRect( aPoint, aSize ); 1066 ImplDrawBack( pWindow, aRect, pSet->mpWallpaper, pSet->mpBitmap ); 1067 } 1068 } 1069 } 1070 1071 for ( i = 0; i < nItems; i++ ) 1072 { 1073 if ( pItems[i].mpSet ) 1074 ImplDrawBack( pWindow, pItems[i].mpSet ); 1075 } 1076 } 1077 1078 // ----------------------------------------------------------------------- 1079 1080 static void ImplDrawSplit( SplitWindow* pWindow, ImplSplitSet* pSet, 1081 sal_Bool bRows, sal_Bool bDown = sal_True ) 1082 { 1083 if ( !pSet->mpItems ) 1084 return; 1085 1086 sal_uInt16 i; 1087 sal_uInt16 nItems = pSet->mnItems; 1088 long nPos; 1089 long nTop; 1090 long nBottom; 1091 ImplSplitItem* pItems = pSet->mpItems; 1092 const StyleSettings& rStyleSettings = pWindow->GetSettings().GetStyleSettings(); 1093 1094 sal_Bool bFlat = (pWindow->GetStyle() & WB_FLATSPLITDRAW) == WB_FLATSPLITDRAW; 1095 1096 for ( i = 0; i < nItems-1; i++ ) 1097 { 1098 if ( pItems[i].mnSplitSize ) 1099 { 1100 nPos = pItems[i].mnSplitPos; 1101 1102 long nItemSplitSize = pItems[i].mnSplitSize; 1103 long nSplitSize = pSet->mnSplitSize; 1104 if ( bRows ) 1105 { 1106 nTop = pItems[i].mnLeft; 1107 nBottom = pItems[i].mnLeft+pItems[i].mnWidth-1; 1108 1109 if ( bFlat ) nPos--; 1110 1111 if ( bDown || (nItemSplitSize >= nSplitSize) ) 1112 { 1113 pWindow->SetLineColor( rStyleSettings.GetLightColor() ); 1114 pWindow->DrawLine( Point( nTop, nPos+1 ), Point( nBottom, nPos+1 ) ); 1115 } 1116 nPos += nSplitSize-2; 1117 if ( bFlat ) nPos+=2; 1118 if ( (!bDown && (nItemSplitSize >= 2)) || 1119 (bDown && (nItemSplitSize >= nSplitSize-1)) ) 1120 { 1121 pWindow->SetLineColor( rStyleSettings.GetShadowColor() ); 1122 pWindow->DrawLine( Point( nTop, nPos ), Point( nBottom, nPos ) ); 1123 } 1124 if ( !bFlat ) 1125 { 1126 nPos++; 1127 if ( !bDown || (nItemSplitSize >= nSplitSize) ) 1128 { 1129 pWindow->SetLineColor( rStyleSettings.GetDarkShadowColor() ); 1130 pWindow->DrawLine( Point( nTop, nPos ), Point( nBottom, nPos ) ); 1131 } 1132 } 1133 } 1134 else 1135 { 1136 nTop = pItems[i].mnTop; 1137 nBottom = pItems[i].mnTop+pSet->mpItems[i].mnHeight-1; 1138 1139 if ( bFlat ) nPos--; 1140 if ( bDown || (nItemSplitSize >= nSplitSize) ) 1141 { 1142 pWindow->SetLineColor( rStyleSettings.GetLightColor() ); 1143 pWindow->DrawLine( Point( nPos+1, nTop ), Point( nPos+1, nBottom ) ); 1144 } 1145 nPos += pSet->mnSplitSize-2; 1146 if ( bFlat ) nPos+=2; 1147 if ( (!bDown && (nItemSplitSize >= 2)) || 1148 (bDown && (nItemSplitSize >= nSplitSize-1)) ) 1149 { 1150 pWindow->SetLineColor( rStyleSettings.GetShadowColor() ); 1151 pWindow->DrawLine( Point( nPos, nTop ), Point( nPos, nBottom ) ); 1152 } 1153 if( !bFlat ) 1154 { 1155 nPos++; 1156 if ( !bDown || (nItemSplitSize >= nSplitSize) ) 1157 { 1158 pWindow->SetLineColor( rStyleSettings.GetDarkShadowColor() ); 1159 pWindow->DrawLine( Point( nPos, nTop ), Point( nPos, nBottom ) ); 1160 } 1161 } 1162 } 1163 } 1164 } 1165 1166 for ( i = 0; i < nItems; i++ ) 1167 { 1168 if ( pItems[i].mpSet && pItems[i].mnWidth && pItems[i].mnHeight ) 1169 ImplDrawSplit( pWindow, pItems[i].mpSet, ((pItems[i].mnBits & SWIB_COLSET) == 0) ); 1170 } 1171 } 1172 1173 // ----------------------------------------------------------------------- 1174 1175 sal_uInt16 SplitWindow::ImplTestSplit( ImplSplitSet* pSet, const Point& rPos, 1176 long& rMouseOff, ImplSplitSet** ppFoundSet, sal_uInt16& rFoundPos, 1177 sal_Bool bRows, sal_Bool /*bDown*/ ) 1178 { 1179 if ( !pSet->mpItems ) 1180 return 0; 1181 1182 sal_uInt16 i; 1183 sal_uInt16 nSplitTest; 1184 sal_uInt16 nItems = pSet->mnItems; 1185 long nMPos1; 1186 long nMPos2; 1187 long nPos; 1188 long nTop; 1189 long nBottom; 1190 ImplSplitItem* pItems = pSet->mpItems; 1191 1192 if ( bRows ) 1193 { 1194 nMPos1 = rPos.X(); 1195 nMPos2 = rPos.Y(); 1196 } 1197 else 1198 { 1199 nMPos1 = rPos.Y(); 1200 nMPos2 = rPos.X(); 1201 } 1202 1203 for ( i = 0; i < nItems-1; i++ ) 1204 { 1205 if ( pItems[i].mnSplitSize ) 1206 { 1207 if ( bRows ) 1208 { 1209 nTop = pItems[i].mnLeft; 1210 nBottom = pItems[i].mnLeft+pItems[i].mnWidth-1; 1211 } 1212 else 1213 { 1214 nTop = pItems[i].mnTop; 1215 nBottom = pItems[i].mnTop+pItems[i].mnHeight-1; 1216 } 1217 nPos = pItems[i].mnSplitPos; 1218 1219 if ( (nMPos1 >= nTop) && (nMPos1 <= nBottom) && 1220 (nMPos2 >= nPos) && (nMPos2 <= nPos+pItems[i].mnSplitSize) ) 1221 { 1222 if ( !pItems[i].mbFixed && !pItems[i+1].mbFixed ) 1223 { 1224 rMouseOff = nMPos2-nPos; 1225 *ppFoundSet = pSet; 1226 rFoundPos = i; 1227 if ( bRows ) 1228 return SPLIT_VERT; 1229 else 1230 return SPLIT_HORZ; 1231 } 1232 else 1233 return SPLIT_NOSPLIT; 1234 } 1235 } 1236 } 1237 1238 for ( i = 0; i < nItems; i++ ) 1239 { 1240 if ( pItems[i].mpSet ) 1241 { 1242 nSplitTest = ImplTestSplit( pItems[i].mpSet, rPos, 1243 rMouseOff, ppFoundSet, rFoundPos, 1244 ((pItems[i].mnBits & SWIB_COLSET) == 0) ); 1245 if ( nSplitTest ) 1246 return nSplitTest; 1247 } 1248 } 1249 1250 return 0; 1251 } 1252 1253 // ----------------------------------------------------------------------- 1254 1255 sal_uInt16 SplitWindow::ImplTestSplit( SplitWindow* pWindow, const Point& rPos, 1256 long& rMouseOff, ImplSplitSet** ppFoundSet, sal_uInt16& rFoundPos ) 1257 { 1258 // Resizeable SplitWindow muss anders behandelt werden 1259 if ( pWindow->mnWinStyle & WB_SIZEABLE ) 1260 { 1261 long nTPos; 1262 long nPos; 1263 long nBorder; 1264 1265 if ( pWindow->mbHorz ) 1266 { 1267 if ( pWindow->mbBottomRight ) 1268 { 1269 nBorder = pWindow->mnBottomBorder; 1270 nPos = 0; 1271 } 1272 else 1273 { 1274 nBorder = pWindow->mnTopBorder; 1275 nPos = pWindow->mnDY-nBorder; 1276 } 1277 nTPos = rPos.Y(); 1278 } 1279 else 1280 { 1281 if ( pWindow->mbBottomRight ) 1282 { 1283 nBorder = pWindow->mnRightBorder; 1284 nPos = 0; 1285 } 1286 else 1287 { 1288 nBorder = pWindow->mnLeftBorder; 1289 nPos = pWindow->mnDX-nBorder; 1290 } 1291 nTPos = rPos.X(); 1292 } 1293 long nSplitSize = pWindow->mpMainSet->mnSplitSize-2; 1294 if ( pWindow->mbAutoHide || pWindow->mbFadeOut ) 1295 nSplitSize += SPLITWIN_SPLITSIZEEXLN; 1296 if ( !pWindow->mbBottomRight ) 1297 nPos -= nSplitSize; 1298 if ( (nTPos >= nPos) && (nTPos <= nPos+nSplitSize+nBorder) ) 1299 { 1300 rMouseOff = nTPos-nPos; 1301 *ppFoundSet = pWindow->mpMainSet; 1302 if ( pWindow->mpMainSet->mpItems ) 1303 rFoundPos = pWindow->mpMainSet->mnItems-1; 1304 else 1305 rFoundPos = 0; 1306 if ( pWindow->mbHorz ) 1307 return SPLIT_VERT | SPLIT_WINDOW; 1308 else 1309 return SPLIT_HORZ | SPLIT_WINDOW; 1310 } 1311 } 1312 1313 return ImplTestSplit( pWindow->mpMainSet, rPos, rMouseOff, ppFoundSet, rFoundPos, 1314 pWindow->mbHorz, !pWindow->mbBottomRight ); 1315 } 1316 1317 // ----------------------------------------------------------------------- 1318 1319 void SplitWindow::ImplDrawSplitTracking( SplitWindow* pThis, const Point& rPos ) 1320 { 1321 Rectangle aRect; 1322 1323 if ( pThis->mnSplitTest & SPLIT_HORZ ) 1324 { 1325 aRect.Top() = pThis->maDragRect.Top(); 1326 aRect.Bottom() = pThis->maDragRect.Bottom(); 1327 aRect.Left() = rPos.X(); 1328 aRect.Right() = aRect.Left()+pThis->mpSplitSet->mnSplitSize-1; 1329 if ( !(pThis->mnWinStyle & WB_NOSPLITDRAW) ) 1330 aRect.Right()--; 1331 if ( (pThis->mnSplitTest & SPLIT_WINDOW) && 1332 (pThis->mbAutoHide || pThis->mbFadeOut) ) 1333 { 1334 aRect.Left() += SPLITWIN_SPLITSIZEEXLN; 1335 aRect.Right() += SPLITWIN_SPLITSIZEEXLN; 1336 } 1337 } 1338 else 1339 { 1340 aRect.Left() = pThis->maDragRect.Left(); 1341 aRect.Right() = pThis->maDragRect.Right(); 1342 aRect.Top() = rPos.Y(); 1343 aRect.Bottom() = aRect.Top()+pThis->mpSplitSet->mnSplitSize-1; 1344 if ( !(pThis->mnWinStyle & WB_NOSPLITDRAW) ) 1345 aRect.Bottom()--; 1346 if ( (pThis->mnSplitTest & SPLIT_WINDOW) && 1347 (pThis->mbAutoHide || pThis->mbFadeOut) ) 1348 { 1349 aRect.Top() += SPLITWIN_SPLITSIZEEXLN; 1350 aRect.Bottom() += SPLITWIN_SPLITSIZEEXLN; 1351 } 1352 } 1353 pThis->ShowTracking( aRect, SHOWTRACK_SPLIT ); 1354 } 1355 1356 // ----------------------------------------------------------------------- 1357 1358 void SplitWindow::ImplInit( Window* pParent, WinBits nStyle ) 1359 { 1360 ImplSplitSet* pNewSet = new ImplSplitSet; 1361 pNewSet->mpItems = NULL; 1362 pNewSet->mpWallpaper = NULL; 1363 pNewSet->mpBitmap = NULL; 1364 pNewSet->mnLastSize = 0; 1365 pNewSet->mnItems = 0; 1366 pNewSet->mnId = 0; 1367 pNewSet->mnSplitSize = SPLITWIN_SPLITSIZE; 1368 pNewSet->mbCalcPix = sal_True; 1369 1370 mpMainSet = pNewSet; 1371 mpBaseSet = pNewSet; 1372 mpSplitSet = NULL; 1373 mpLastSizes = NULL; 1374 mnDX = 0; 1375 mnDY = 0; 1376 mnLeftBorder = 0; 1377 mnTopBorder = 0; 1378 mnRightBorder = 0; 1379 mnBottomBorder = 0; 1380 mnMaxSize = 0; 1381 mnMouseOff = 0; 1382 meAlign = WINDOWALIGN_TOP; 1383 mnWinStyle = nStyle; 1384 mnSplitTest = 0; 1385 mnSplitPos = 0; 1386 mnMouseModifier = 0; 1387 mnMStartPos = 0; 1388 mnMSplitPos = 0; 1389 mbDragFull = sal_False; 1390 mbHorz = sal_True; 1391 mbBottomRight = sal_False; 1392 mbCalc = sal_False; 1393 mbRecalc = sal_True; 1394 mbInvalidate = sal_True; 1395 mbAutoHide = sal_False; 1396 mbFadeIn = sal_False; 1397 mbFadeOut = sal_False; 1398 mbAutoHideIn = sal_False; 1399 mbAutoHideDown = sal_False; 1400 mbFadeInDown = sal_False; 1401 mbFadeOutDown = sal_False; 1402 mbAutoHidePressed = sal_False; 1403 mbFadeInPressed = sal_False; 1404 mbFadeOutPressed = sal_False; 1405 mbFadeNoButtonMode = sal_False; 1406 mbNoAlign = sal_False; 1407 1408 if ( nStyle & WB_NOSPLITDRAW ) 1409 { 1410 pNewSet->mnSplitSize -= 2; 1411 mbInvalidate = sal_False; 1412 } 1413 1414 if ( nStyle & WB_BORDER ) 1415 { 1416 ImplCalcBorder( meAlign, mbNoAlign, mnLeftBorder, mnTopBorder, 1417 mnRightBorder, mnBottomBorder ); 1418 } 1419 else 1420 { 1421 mnLeftBorder = 0; 1422 mnTopBorder = 0; 1423 mnRightBorder = 0; 1424 mnBottomBorder = 0; 1425 } 1426 1427 DockingWindow::ImplInit( pParent, (nStyle | WB_CLIPCHILDREN) & ~(WB_BORDER | WB_SIZEABLE) ); 1428 1429 ImplInitSettings(); 1430 } 1431 1432 // ----------------------------------------------------------------------- 1433 1434 void SplitWindow::ImplInitSettings() 1435 { 1436 // Wenn fuer das MainSet eine Bitmap gesetzt wird, dann 1437 // brauchen wir nicht mehr den Hintergrund loeschen 1438 // Wenn MainSet Wallpaper hat, dann ist das der Hintergrund, ansonsten 1439 // sind es die Standard-Farben 1440 if ( mpMainSet->mpBitmap ) 1441 SetBackground(); 1442 else if ( mpMainSet->mpWallpaper ) 1443 SetBackground( *mpMainSet->mpWallpaper ); 1444 else 1445 { 1446 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 1447 1448 Color aColor; 1449 if ( IsControlBackground() ) 1450 aColor = GetControlBackground(); 1451 else if ( Window::GetStyle() & WB_3DLOOK ) 1452 aColor = rStyleSettings.GetFaceColor(); 1453 else 1454 aColor = rStyleSettings.GetWindowColor(); 1455 SetBackground( aColor ); 1456 } 1457 } 1458 1459 // ======================================================================= 1460 1461 SplitWindow::SplitWindow( Window* pParent, WinBits nStyle ) : 1462 DockingWindow( WINDOW_SPLITWINDOW ) 1463 { 1464 ImplInit( pParent, nStyle ); 1465 } 1466 1467 // ----------------------------------------------------------------------- 1468 1469 SplitWindow::SplitWindow( Window* pParent, const ResId& rResId ) : 1470 DockingWindow( WINDOW_SPLITWINDOW ) 1471 { 1472 rResId.SetRT( RSC_SPLITWINDOW ); 1473 WinBits nStyle = ImplInitRes( rResId ); 1474 ImplInit( pParent, nStyle ); 1475 ImplLoadRes( rResId ); 1476 1477 if ( !(nStyle & WB_HIDE) ) 1478 Show(); 1479 } 1480 1481 // ----------------------------------------------------------------------- 1482 1483 SplitWindow::~SplitWindow() 1484 { 1485 // Sets loeschen 1486 ImplDeleteSet( mpMainSet ); 1487 } 1488 1489 // ----------------------------------------------------------------------- 1490 1491 void SplitWindow::ImplSetWindowSize( long nDelta ) 1492 { 1493 if ( !nDelta ) 1494 return; 1495 1496 Size aSize = GetSizePixel(); 1497 if ( meAlign == WINDOWALIGN_TOP ) 1498 { 1499 aSize.Height() += nDelta; 1500 SetSizePixel( aSize ); 1501 } 1502 else if ( meAlign == WINDOWALIGN_BOTTOM ) 1503 { 1504 maDragRect.Top() += nDelta; 1505 Point aPos = GetPosPixel(); 1506 aPos.Y() -= nDelta; 1507 aSize.Height() += nDelta; 1508 SetPosSizePixel( aPos, aSize ); 1509 } 1510 else if ( meAlign == WINDOWALIGN_LEFT ) 1511 { 1512 aSize.Width() += nDelta; 1513 SetSizePixel( aSize ); 1514 } 1515 else // meAlign == WINDOWALIGN_RIGHT 1516 { 1517 maDragRect.Left() += nDelta; 1518 Point aPos = GetPosPixel(); 1519 aPos.X() -= nDelta; 1520 aSize.Width() += nDelta; 1521 SetPosSizePixel( aPos, aSize ); 1522 } 1523 1524 SplitResize(); 1525 } 1526 1527 // ----------------------------------------------------------------------- 1528 1529 Size SplitWindow::CalcLayoutSizePixel( const Size& aNewSize ) 1530 { 1531 Size aSize( aNewSize ); 1532 long nSplitSize = mpMainSet->mnSplitSize-2; 1533 1534 if ( mbAutoHide || mbFadeOut ) 1535 nSplitSize += SPLITWIN_SPLITSIZEEXLN; 1536 1537 // Wenn Fenster sizeable ist, wird die groesse automatisch nach 1538 // dem MainSet festgelegt, wenn kein relatives Fenster enthalten 1539 // ist 1540 if ( mnWinStyle & WB_SIZEABLE ) 1541 { 1542 long nCurSize; 1543 long nCalcSize = 0; 1544 sal_uInt16 i; 1545 1546 for ( i = 0; i < mpMainSet->mnItems; i++ ) 1547 { 1548 if ( mpMainSet->mpItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE) ) 1549 break; 1550 else 1551 nCalcSize += mpMainSet->mpItems[i].mnSize; 1552 } 1553 1554 if ( i == mpMainSet->mnItems ) 1555 { 1556 long nDelta = 0; 1557 Point aPos = GetPosPixel(); 1558 1559 if ( mbHorz ) 1560 nCurSize = aNewSize.Height()-mnTopBorder-mnBottomBorder; 1561 else 1562 nCurSize = aNewSize.Width()-mnLeftBorder-mnRightBorder; 1563 nCurSize -= nSplitSize; 1564 nCurSize -= (mpMainSet->mnItems-1)*mpMainSet->mnSplitSize; 1565 1566 nDelta = nCalcSize-nCurSize; 1567 if ( !nDelta ) 1568 return aSize; 1569 1570 if ( meAlign == WINDOWALIGN_TOP ) 1571 { 1572 aSize.Height() += nDelta; 1573 } 1574 else if ( meAlign == WINDOWALIGN_BOTTOM ) 1575 { 1576 aPos.Y() -= nDelta; 1577 aSize.Height() += nDelta; 1578 } 1579 else if ( meAlign == WINDOWALIGN_LEFT ) 1580 { 1581 aSize.Width() += nDelta; 1582 } 1583 else // meAlign == WINDOWALIGN_RIGHT 1584 { 1585 aPos.X() -= nDelta; 1586 aSize.Width() += nDelta; 1587 } 1588 } 1589 } 1590 1591 return aSize; 1592 } 1593 1594 // ----------------------------------------------------------------------- 1595 1596 void SplitWindow::ImplCalcLayout() 1597 { 1598 if ( !mbCalc || !mbRecalc || !mpMainSet->mpItems ) 1599 return; 1600 1601 long nSplitSize = mpMainSet->mnSplitSize-2; 1602 if ( mbAutoHide || mbFadeOut ) 1603 nSplitSize += SPLITWIN_SPLITSIZEEXLN; 1604 1605 // Wenn Fenster sizeable ist, wird die groesse automatisch nach 1606 // dem MainSet festgelegt, wenn kein relatives Fenster enthalten 1607 // ist 1608 if ( mnWinStyle & WB_SIZEABLE ) 1609 { 1610 long nCurSize; 1611 long nCalcSize = 0; 1612 sal_uInt16 i; 1613 1614 for ( i = 0; i < mpMainSet->mnItems; i++ ) 1615 { 1616 if ( mpMainSet->mpItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE) ) 1617 break; 1618 else 1619 nCalcSize += mpMainSet->mpItems[i].mnSize; 1620 } 1621 1622 if ( i == mpMainSet->mnItems ) 1623 { 1624 if ( mbHorz ) 1625 nCurSize = mnDY-mnTopBorder-mnBottomBorder; 1626 else 1627 nCurSize = mnDX-mnLeftBorder-mnRightBorder; 1628 nCurSize -= nSplitSize; 1629 nCurSize -= (mpMainSet->mnItems-1)*mpMainSet->mnSplitSize; 1630 1631 mbRecalc = sal_False; 1632 ImplSetWindowSize( nCalcSize-nCurSize ); 1633 mbRecalc = sal_True; 1634 } 1635 } 1636 1637 if ( (mnDX <= 0) || (mnDY <= 0) ) 1638 return; 1639 1640 // Groessen/Position vorberechnen 1641 long nL; 1642 long nT; 1643 long nW; 1644 long nH; 1645 1646 if ( mbHorz ) 1647 { 1648 if ( mbBottomRight ) 1649 nT = mnDY-mnBottomBorder; 1650 else 1651 nT = mnTopBorder; 1652 nL = mnLeftBorder; 1653 } 1654 else 1655 { 1656 if ( mbBottomRight ) 1657 nL = mnDX-mnRightBorder; 1658 else 1659 nL = mnLeftBorder; 1660 nT = mnTopBorder; 1661 } 1662 nW = mnDX-mnLeftBorder-mnRightBorder; 1663 nH = mnDY-mnTopBorder-mnBottomBorder; 1664 if ( mnWinStyle & WB_SIZEABLE ) 1665 { 1666 if ( mbHorz ) 1667 nH -= nSplitSize; 1668 else 1669 nW -= nSplitSize; 1670 } 1671 1672 // Sets rekursiv berechnen 1673 ImplCalcSet( mpMainSet, nL, nT, nW, nH, mbHorz, !mbBottomRight ); 1674 ImplCalcSet2( this, mpMainSet, sal_False, mbHorz, !mbBottomRight ); 1675 mbCalc = sal_False; 1676 } 1677 1678 // ----------------------------------------------------------------------- 1679 1680 void SplitWindow::ImplUpdate() 1681 { 1682 mbCalc = sal_True; 1683 1684 if ( IsReallyShown() && IsUpdateMode() && mbRecalc ) 1685 { 1686 if ( mpMainSet->mpItems ) 1687 ImplCalcLayout(); 1688 else 1689 Invalidate(); 1690 } 1691 } 1692 1693 // ----------------------------------------------------------------------- 1694 1695 void SplitWindow::ImplUpdateSet( ImplSplitSet* pSet ) 1696 { 1697 if ( IsReallyShown() && IsUpdateMode() && mbRecalc ) 1698 { 1699 // Wenn wir noch berechnen muessen, dann alles invalidieren. 1700 if ( mbCalc ) 1701 { 1702 // Wenn nicht NOSPLITDRAW gesetzt ist, koennen wir uns das 1703 // invalidieren sparen, da bei ImplCalcSet2() die freien flaechen 1704 // sowieso invalidiert werden 1705 if ( !mpMainSet->mpItems || (mnWinStyle & WB_NOSPLITDRAW) ) 1706 pSet = mpMainSet; 1707 else 1708 return; 1709 } 1710 1711 Rectangle aRect; 1712 if ( pSet == mpMainSet ) 1713 { 1714 aRect.Left() = mnLeftBorder; 1715 aRect.Top() = mnTopBorder; 1716 aRect.Right() = mnDX-mnRightBorder-1; 1717 aRect.Bottom() = mnDY-mnBottomBorder-1; 1718 } 1719 else 1720 { 1721 ImplSplitItem* pItem; 1722 sal_uInt16 nPos; 1723 1724 pSet = ImplFindItem( mpMainSet, pSet->mnId, nPos ); 1725 pItem = &(pSet->mpItems[nPos]); 1726 aRect.Left() = pItem->mnLeft; 1727 aRect.Top() = pItem->mnTop; 1728 aRect.Right() = aRect.Left()+pItem->mnWidth; 1729 aRect.Bottom() = aRect.Top()+pItem->mnHeight; 1730 } 1731 Invalidate( aRect ); 1732 } 1733 } 1734 1735 // ----------------------------------------------------------------------- 1736 1737 void SplitWindow::ImplSplitMousePos( Point& rMousePos ) 1738 { 1739 if ( mnSplitTest & SPLIT_HORZ ) 1740 { 1741 rMousePos.X() -= mnMouseOff; 1742 if ( rMousePos.X() < maDragRect.Left() ) 1743 rMousePos.X() = maDragRect.Left(); 1744 else if ( rMousePos.X()+mpSplitSet->mnSplitSize+1 > maDragRect.Right() ) 1745 rMousePos.X() = maDragRect.Right()-mpSplitSet->mnSplitSize+1; 1746 // Wegen FullDrag in Screen-Koordinaaten merken 1747 mnMSplitPos = OutputToScreenPixel( rMousePos ).X(); 1748 } 1749 else 1750 { 1751 rMousePos.Y() -= mnMouseOff; 1752 if ( rMousePos.Y() < maDragRect.Top() ) 1753 rMousePos.Y() = maDragRect.Top(); 1754 else if ( rMousePos.Y()+mpSplitSet->mnSplitSize+1 > maDragRect.Bottom() ) 1755 rMousePos.Y() = maDragRect.Bottom()-mpSplitSet->mnSplitSize+1; 1756 mnMSplitPos = OutputToScreenPixel( rMousePos ).Y(); 1757 } 1758 } 1759 1760 // ----------------------------------------------------------------------- 1761 1762 void SplitWindow::ImplGetButtonRect( Rectangle& rRect, long nEx, sal_Bool bTest ) const 1763 { 1764 long nSplitSize = mpMainSet->mnSplitSize-2; 1765 if ( mbAutoHide || mbFadeOut || mbFadeIn ) 1766 nSplitSize += SPLITWIN_SPLITSIZEEX; 1767 1768 long nButtonSize = 0; 1769 if ( mbFadeIn ) 1770 nButtonSize += SPLITWIN_SPLITSIZEFADE+1; 1771 if ( mbFadeOut ) 1772 nButtonSize += SPLITWIN_SPLITSIZEFADE+1; 1773 if ( mbAutoHide ) 1774 nButtonSize += SPLITWIN_SPLITSIZEAUTOHIDE+1; 1775 long nCenterEx = 0; 1776 if ( mbHorz ) 1777 nCenterEx += ((mnDX-mnLeftBorder-mnRightBorder)-nButtonSize)/2; 1778 else 1779 nCenterEx += ((mnDY-mnTopBorder-mnBottomBorder)-nButtonSize)/2; 1780 if ( nCenterEx > 0 ) 1781 nEx += nCenterEx; 1782 1783 if ( meAlign == WINDOWALIGN_TOP ) 1784 { 1785 rRect.Left() = mnLeftBorder+nEx; 1786 rRect.Top() = mnDY-mnBottomBorder-nSplitSize; 1787 rRect.Right() = rRect.Left()+SPLITWIN_SPLITSIZEAUTOHIDE; 1788 rRect.Bottom() = mnDY-mnBottomBorder-1; 1789 if ( bTest ) 1790 { 1791 rRect.Top() -= mnTopBorder; 1792 rRect.Bottom() += mnBottomBorder; 1793 } 1794 } 1795 else if ( meAlign == WINDOWALIGN_BOTTOM ) 1796 { 1797 rRect.Left() = mnLeftBorder+nEx; 1798 rRect.Top() = mnTopBorder; 1799 rRect.Right() = rRect.Left()+SPLITWIN_SPLITSIZEAUTOHIDE; 1800 rRect.Bottom() = mnTopBorder+nSplitSize-1; 1801 if ( bTest ) 1802 { 1803 rRect.Top() -= mnTopBorder; 1804 rRect.Bottom() += mnBottomBorder; 1805 } 1806 } 1807 else if ( meAlign == WINDOWALIGN_LEFT ) 1808 { 1809 rRect.Left() = mnDX-mnRightBorder-nSplitSize; 1810 rRect.Top() = mnTopBorder+nEx; 1811 rRect.Right() = mnDX-mnRightBorder-1; 1812 rRect.Bottom() = rRect.Top()+SPLITWIN_SPLITSIZEAUTOHIDE; 1813 if ( bTest ) 1814 { 1815 rRect.Left() -= mnLeftBorder; 1816 rRect.Right() += mnRightBorder; 1817 } 1818 } 1819 else if ( meAlign == WINDOWALIGN_RIGHT ) 1820 { 1821 rRect.Left() = mnLeftBorder; 1822 rRect.Top() = mnTopBorder+nEx; 1823 rRect.Right() = mnLeftBorder+nSplitSize-1; 1824 rRect.Bottom() = rRect.Top()+SPLITWIN_SPLITSIZEAUTOHIDE; 1825 if ( bTest ) 1826 { 1827 rRect.Left() -= mnLeftBorder; 1828 rRect.Right() += mnRightBorder; 1829 } 1830 } 1831 } 1832 1833 // ----------------------------------------------------------------------- 1834 1835 void SplitWindow::ImplGetAutoHideRect( Rectangle& rRect, sal_Bool bTest ) const 1836 { 1837 Rectangle aRect; 1838 1839 if ( mbAutoHide ) 1840 { 1841 long nEx = 0; 1842 if ( mbFadeIn || mbFadeOut ) 1843 nEx = SPLITWIN_SPLITSIZEFADE+1; 1844 ImplGetButtonRect( aRect, nEx, bTest && mbFadeIn ); 1845 } 1846 1847 rRect = aRect; 1848 } 1849 1850 // ----------------------------------------------------------------------- 1851 1852 void SplitWindow::ImplGetFadeInRect( Rectangle& rRect, sal_Bool bTest ) const 1853 { 1854 Rectangle aRect; 1855 1856 if ( mbFadeIn ) 1857 ImplGetButtonRect( aRect, 0, bTest ); 1858 1859 rRect = aRect; 1860 } 1861 1862 // ----------------------------------------------------------------------- 1863 1864 void SplitWindow::ImplGetFadeOutRect( Rectangle& rRect, sal_Bool ) const 1865 { 1866 Rectangle aRect; 1867 1868 if ( mbFadeOut ) 1869 ImplGetButtonRect( aRect, 0, sal_False ); 1870 1871 rRect = aRect; 1872 } 1873 1874 // ----------------------------------------------------------------------- 1875 1876 void SplitWindow::ImplDrawButtonRect( const Rectangle& rRect, long nSize ) 1877 { 1878 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 1879 1880 if ( mbHorz ) 1881 { 1882 long nLeft = rRect.Left(); 1883 long nRight = rRect.Right(); 1884 long nCenter = rRect.Center().Y(); 1885 long nEx1 = nLeft+((rRect.GetWidth()-nSize)/2)-2; 1886 long nEx2 = nEx1+nSize+3; 1887 SetLineColor( rStyleSettings.GetLightColor() ); 1888 DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Left(), rRect.Bottom() ) ); 1889 DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Right(), rRect.Top() ) ); 1890 SetLineColor( rStyleSettings.GetShadowColor() ); 1891 DrawLine( Point( rRect.Right(), rRect.Top() ), Point( rRect.Right(), rRect.Bottom() ) ); 1892 DrawLine( Point( rRect.Left(), rRect.Bottom() ), Point( rRect.Right(), rRect.Bottom() ) ); 1893 long i = nLeft+2; 1894 while ( i < nRight-3 ) 1895 { 1896 if ( (i < nEx1) || (i > nEx2 ) ) 1897 { 1898 DrawPixel( Point( i, nCenter-2 ), rStyleSettings.GetLightColor() ); 1899 DrawPixel( Point( i+1, nCenter-2+1 ), rStyleSettings.GetShadowColor() ); 1900 } 1901 i++; 1902 if ( (i < nEx1) || ((i > nEx2 ) && (i < nRight-3)) ) 1903 { 1904 DrawPixel( Point( i, nCenter+2 ), rStyleSettings.GetLightColor() ); 1905 DrawPixel( Point( i+1, nCenter+2+1 ), rStyleSettings.GetShadowColor() ); 1906 } 1907 i += 2; 1908 } 1909 } 1910 else 1911 { 1912 long nTop = rRect.Top(); 1913 long nBottom = rRect.Bottom(); 1914 long nCenter = rRect.Center().X(); 1915 long nEx1 = nTop+((rRect.GetHeight()-nSize)/2)-2; 1916 long nEx2 = nEx1+nSize+3; 1917 SetLineColor( rStyleSettings.GetLightColor() ); 1918 DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Right(), rRect.Top() ) ); 1919 DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Left(), rRect.Bottom() ) ); 1920 SetLineColor( rStyleSettings.GetShadowColor() ); 1921 DrawLine( Point( rRect.Right(), rRect.Top() ), Point( rRect.Right(), rRect.Bottom() ) ); 1922 DrawLine( Point( rRect.Left(), rRect.Bottom() ), Point( rRect.Right(), rRect.Bottom() ) ); 1923 long i = nTop+2; 1924 while ( i < nBottom-3 ) 1925 { 1926 if ( (i < nEx1) || (i > nEx2 ) ) 1927 { 1928 DrawPixel( Point( nCenter-2, i ), rStyleSettings.GetLightColor() ); 1929 DrawPixel( Point( nCenter-2+1, i+1 ), rStyleSettings.GetShadowColor() ); 1930 } 1931 i++; 1932 if ( (i < nEx1) || ((i > nEx2 ) && (i < nBottom-3)) ) 1933 { 1934 DrawPixel( Point( nCenter+2, i ), rStyleSettings.GetLightColor() ); 1935 DrawPixel( Point( nCenter+2+1, i+1 ), rStyleSettings.GetShadowColor() ); 1936 } 1937 i += 2; 1938 } 1939 } 1940 } 1941 1942 // ----------------------------------------------------------------------- 1943 1944 void SplitWindow::ImplDrawAutoHide( sal_Bool bInPaint ) 1945 { 1946 if ( mbAutoHide ) 1947 { 1948 Rectangle aTempRect; 1949 ImplGetAutoHideRect( aTempRect ); 1950 1951 if ( !bInPaint ) 1952 Erase( aTempRect ); 1953 1954 // ImageListe laden, wenn noch nicht vorhanden 1955 ImplSVData* pSVData = ImplGetSVData(); 1956 ImageList* pImageList; 1957 if ( mbHorz ) 1958 { 1959 if ( !pSVData->maCtrlData.mpSplitHPinImgList ) 1960 { 1961 ResMgr* pResMgr = ImplGetResMgr(); 1962 if( pResMgr ) 1963 { 1964 Color aNonAlphaMask( 0x00, 0x00, 0xFF ); 1965 pSVData->maCtrlData.mpSplitHPinImgList = new ImageList(4); 1966 pSVData->maCtrlData.mpSplitHPinImgList->InsertFromHorizontalBitmap 1967 ( ResId( SV_RESID_BITMAP_SPLITHPIN, *pResMgr ), 4, &aNonAlphaMask ); 1968 } 1969 } 1970 pImageList = pSVData->maCtrlData.mpSplitHPinImgList; 1971 } 1972 else 1973 { 1974 if ( !pSVData->maCtrlData.mpSplitVPinImgList ) 1975 { 1976 ResMgr* pResMgr = ImplGetResMgr(); 1977 pSVData->maCtrlData.mpSplitVPinImgList = new ImageList(4); 1978 if( pResMgr ) 1979 { 1980 Color aNonAlphaMask( 0x00, 0x00, 0xFF ); 1981 pSVData->maCtrlData.mpSplitVPinImgList->InsertFromHorizontalBitmap 1982 ( ResId( SV_RESID_BITMAP_SPLITVPIN, *pResMgr ), 4, &aNonAlphaMask ); 1983 } 1984 } 1985 pImageList = pSVData->maCtrlData.mpSplitVPinImgList; 1986 } 1987 1988 // Image ermitteln und zurueckgeben 1989 sal_uInt16 nId; 1990 if ( mbAutoHidePressed ) 1991 { 1992 if ( mbAutoHideIn ) 1993 nId = 3; 1994 else 1995 nId = 4; 1996 } 1997 else 1998 { 1999 if ( mbAutoHideIn ) 2000 nId = 1; 2001 else 2002 nId = 2; 2003 } 2004 2005 Image aImage = pImageList->GetImage( nId ); 2006 Size aImageSize = aImage.GetSizePixel(); 2007 Point aPos( aTempRect.Left()+((aTempRect.GetWidth()-aImageSize.Width())/2), 2008 aTempRect.Top()+((aTempRect.GetHeight()-aImageSize.Height())/2) ); 2009 long nSize; 2010 if ( mbHorz ) 2011 nSize = aImageSize.Width(); 2012 else 2013 nSize = aImageSize.Height(); 2014 ImplDrawButtonRect( aTempRect, nSize ); 2015 DrawImage( aPos, aImage ); 2016 } 2017 } 2018 2019 // ----------------------------------------------------------------------- 2020 2021 void SplitWindow::ImplDrawFadeArrow( const Point& rPt, sal_Bool bHorz, sal_Bool bLeft ) 2022 { 2023 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 2024 2025 int x( rPt.X() ); 2026 int y( rPt.Y() ); 2027 2028 Color aCol; 2029 if( !bHorz ) 2030 { 2031 int dx = 1; 2032 if( bLeft ) 2033 { 2034 x ++; 2035 dx = -1; 2036 } 2037 2038 x++; y++; 2039 aCol = Color( COL_WHITE ); 2040 DrawPixel( Point(x, y), aCol ); 2041 DrawPixel( Point(x, y+1), aCol ); 2042 DrawPixel( Point(x, y+2), aCol ); 2043 DrawPixel( Point(x+dx, y+1), aCol ); 2044 2045 x--; y--; 2046 aCol = rStyleSettings.GetDarkShadowColor(); 2047 DrawPixel( Point(x, y), rStyleSettings.GetDarkShadowColor() ); 2048 DrawPixel( Point(x, y+1), rStyleSettings.GetDarkShadowColor() ); 2049 DrawPixel( Point(x, y+2), rStyleSettings.GetDarkShadowColor() ); 2050 DrawPixel( Point(x+dx, y+1), rStyleSettings.GetDarkShadowColor() ); 2051 } 2052 else 2053 { 2054 int dy = 1; 2055 if( bLeft ) 2056 { 2057 y ++; 2058 dy = -1; 2059 } 2060 2061 x++; y++; 2062 aCol = Color( COL_WHITE ); 2063 DrawPixel( Point(x, y), aCol ); 2064 DrawPixel( Point(x+1, y), aCol ); 2065 DrawPixel( Point(x+2, y), aCol ); 2066 DrawPixel( Point(x+1, y+dy), aCol ); 2067 2068 x--; y--; 2069 aCol = rStyleSettings.GetDarkShadowColor(); 2070 DrawPixel( Point(x, y), aCol ); 2071 DrawPixel( Point(x+1, y), aCol ); 2072 DrawPixel( Point(x+2, y), aCol ); 2073 DrawPixel( Point(x+1, y+dy), aCol ); 2074 } 2075 } 2076 2077 void SplitWindow::ImplDrawGrip( const Rectangle& rRect, sal_Bool bHorz, sal_Bool bLeft ) 2078 { 2079 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings(); 2080 2081 if( rRect.IsInside( GetPointerPosPixel() ) ) 2082 { 2083 DrawWallpaper( rRect, Wallpaper( Color( COL_WHITE ) ) ); 2084 DrawSelectionBackground( rRect, 2, sal_False, sal_False, sal_False ); 2085 } 2086 2087 if( bHorz ) 2088 { 2089 int width = (int) (0.5 * rRect.getWidth() + 0.5); 2090 int i = rRect.nLeft + (rRect.getWidth() - width) / 2; 2091 width += i; 2092 const int y = rRect.nTop + 1; 2093 ImplDrawFadeArrow( Point( i-8, y), bHorz, bLeft ); 2094 while( i <= width ) 2095 { 2096 2097 DrawPixel( Point(i, y), rStyleSettings.GetDarkShadowColor() ); 2098 DrawPixel( Point(i+1, y), rStyleSettings.GetShadowColor() ); 2099 2100 DrawPixel( Point(i, y+1), rStyleSettings.GetShadowColor() ); 2101 DrawPixel( Point(i+1, y+1), rStyleSettings.GetFaceColor() ); 2102 DrawPixel( Point(i+2, y+1), Color(COL_WHITE) ); 2103 2104 DrawPixel( Point(i+1, y+2), Color(COL_WHITE) ); 2105 DrawPixel( Point(i+2, y+2), Color(COL_WHITE) ); 2106 i+=4; 2107 } 2108 ImplDrawFadeArrow( Point( i+3, y), bHorz, bLeft ); 2109 } 2110 else 2111 { 2112 int height = (int) (0.5 * rRect.getHeight() + 0.5); 2113 int i = rRect.nTop + (rRect.getHeight() - height) / 2; 2114 height += i; 2115 const int x = rRect.nLeft + 1; 2116 ImplDrawFadeArrow( Point( x, i-8), bHorz, bLeft ); 2117 while( i <= height ) 2118 { 2119 2120 DrawPixel( Point(x, i), rStyleSettings.GetDarkShadowColor() ); 2121 DrawPixel( Point(x+1, i), rStyleSettings.GetShadowColor() ); 2122 2123 DrawPixel( Point(x, i+1), rStyleSettings.GetShadowColor() ); 2124 DrawPixel( Point(x+1, i+1), rStyleSettings.GetFaceColor() ); 2125 DrawPixel( Point(x+2, i+1), Color(COL_WHITE) ); 2126 2127 DrawPixel( Point(x+1, i+2), Color(COL_WHITE) ); 2128 DrawPixel( Point(x+2, i+2), Color(COL_WHITE) ); 2129 i+=4; 2130 } 2131 ImplDrawFadeArrow( Point( x, i+3), bHorz, bLeft ); 2132 } 2133 } 2134 2135 void SplitWindow::ImplDrawFadeIn( sal_Bool bInPaint ) 2136 { 2137 if ( mbFadeIn ) 2138 { 2139 Rectangle aTempRect; 2140 Image aImage; 2141 ImplGetFadeInRect( aTempRect ); 2142 2143 sal_Bool bLeft; 2144 if ( meAlign == WINDOWALIGN_TOP ) 2145 bLeft = sal_False; 2146 else if ( meAlign == WINDOWALIGN_BOTTOM ) 2147 bLeft = sal_True; 2148 else if ( meAlign == WINDOWALIGN_LEFT ) 2149 bLeft = sal_False; 2150 else if ( meAlign == WINDOWALIGN_RIGHT ) 2151 bLeft = sal_True; 2152 else 2153 bLeft = sal_True; 2154 2155 if ( !bInPaint ) 2156 Erase( aTempRect ); 2157 2158 ImplDrawGrip( aTempRect, (meAlign == WINDOWALIGN_TOP) || (meAlign == WINDOWALIGN_BOTTOM), bLeft ); 2159 } 2160 } 2161 2162 // ----------------------------------------------------------------------- 2163 2164 void SplitWindow::ImplDrawFadeOut( sal_Bool bInPaint ) 2165 { 2166 if ( mbFadeOut ) 2167 { 2168 Rectangle aTempRect; 2169 Image aImage; 2170 ImplGetFadeOutRect( aTempRect ); 2171 2172 sal_Bool bLeft; 2173 if ( meAlign == WINDOWALIGN_TOP ) 2174 bLeft = sal_True; 2175 else if ( meAlign == WINDOWALIGN_BOTTOM ) 2176 bLeft = sal_False; 2177 else if ( meAlign == WINDOWALIGN_LEFT ) 2178 bLeft = sal_True; 2179 else if ( meAlign == WINDOWALIGN_RIGHT ) 2180 bLeft = sal_False; 2181 else 2182 bLeft = sal_True; 2183 2184 if ( !bInPaint ) 2185 Erase( aTempRect ); 2186 2187 ImplDrawGrip( aTempRect, (meAlign == WINDOWALIGN_TOP) || (meAlign == WINDOWALIGN_BOTTOM), bLeft ); 2188 } 2189 } 2190 2191 // ----------------------------------------------------------------------- 2192 void SplitWindow::ImplStartSplit( const MouseEvent& rMEvt ) 2193 { 2194 Point aMousePosPixel = rMEvt.GetPosPixel(); 2195 mnSplitTest = ImplTestSplit( this, aMousePosPixel, mnMouseOff, &mpSplitSet, mnSplitPos ); 2196 2197 if ( mnSplitTest && !(mnSplitTest & SPLIT_NOSPLIT) ) 2198 { 2199 ImplSplitItem* pSplitItem; 2200 long nCurMaxSize; 2201 sal_uInt16 nTemp; 2202 sal_Bool bDown; 2203 sal_Bool bPropSmaller; 2204 2205 mnMouseModifier = rMEvt.GetModifier(); 2206 if ( !(mnMouseModifier & KEY_SHIFT) || (mnSplitPos+1 >= mpSplitSet->mnItems) ) 2207 bPropSmaller = sal_False; 2208 else 2209 bPropSmaller = sal_True; 2210 2211 // Hier kann noch die maximale Groesse gesetzt werden 2212 StartSplit(); 2213 2214 if ( mnMaxSize ) 2215 nCurMaxSize = mnMaxSize; 2216 else 2217 { 2218 Size aSize = GetParent()->GetOutputSizePixel(); 2219 if ( mbHorz ) 2220 nCurMaxSize = aSize.Height(); 2221 else 2222 nCurMaxSize = aSize.Width(); 2223 } 2224 2225 if ( mpSplitSet->mpItems ) 2226 { 2227 bDown = sal_True; 2228 if ( (mpSplitSet == mpMainSet) && mbBottomRight ) 2229 bDown = sal_False; 2230 2231 pSplitItem = &(mpSplitSet->mpItems[mnSplitPos]); 2232 maDragRect.Left() = pSplitItem->mnLeft; 2233 maDragRect.Top() = pSplitItem->mnTop; 2234 maDragRect.Right() = pSplitItem->mnLeft+pSplitItem->mnWidth-1; 2235 maDragRect.Bottom() = pSplitItem->mnTop+pSplitItem->mnHeight-1; 2236 2237 if ( mnSplitTest & SPLIT_HORZ ) 2238 { 2239 if ( bDown ) 2240 maDragRect.Right() += mpSplitSet->mnSplitSize; 2241 else 2242 maDragRect.Left() -= mpSplitSet->mnSplitSize; 2243 } 2244 else 2245 { 2246 if ( bDown ) 2247 maDragRect.Bottom() += mpSplitSet->mnSplitSize; 2248 else 2249 maDragRect.Top() -= mpSplitSet->mnSplitSize; 2250 } 2251 2252 if ( mnSplitPos ) 2253 { 2254 nTemp = mnSplitPos; 2255 while ( nTemp ) 2256 { 2257 pSplitItem = &(mpSplitSet->mpItems[nTemp-1]); 2258 if ( pSplitItem->mbFixed ) 2259 break; 2260 else 2261 { 2262 if ( mnSplitTest & SPLIT_HORZ ) 2263 { 2264 if ( bDown ) 2265 maDragRect.Left() -= pSplitItem->mnPixSize; 2266 else 2267 maDragRect.Right() += pSplitItem->mnPixSize; 2268 } 2269 else 2270 { 2271 if ( bDown ) 2272 maDragRect.Top() -= pSplitItem->mnPixSize; 2273 else 2274 maDragRect.Bottom() += pSplitItem->mnPixSize; 2275 } 2276 } 2277 nTemp--; 2278 } 2279 } 2280 2281 if ( (mpSplitSet == mpMainSet) && (mnWinStyle & WB_SIZEABLE) && !bPropSmaller ) 2282 { 2283 if ( bDown ) 2284 { 2285 if ( mbHorz ) 2286 maDragRect.Bottom() += nCurMaxSize-mnDY-mnTopBorder; 2287 else 2288 maDragRect.Right() += nCurMaxSize-mnDX-mnLeftBorder; 2289 } 2290 else 2291 { 2292 if ( mbHorz ) 2293 maDragRect.Top() -= nCurMaxSize-mnDY-mnBottomBorder; 2294 else 2295 maDragRect.Left() -= nCurMaxSize-mnDX-mnRightBorder; 2296 } 2297 } 2298 else 2299 { 2300 nTemp = mnSplitPos+1; 2301 while ( nTemp < mpSplitSet->mnItems ) 2302 { 2303 pSplitItem = &(mpSplitSet->mpItems[nTemp]); 2304 if ( pSplitItem->mbFixed ) 2305 break; 2306 else 2307 { 2308 if ( mnSplitTest & SPLIT_HORZ ) 2309 { 2310 if ( bDown ) 2311 maDragRect.Right() += pSplitItem->mnPixSize; 2312 else 2313 maDragRect.Left() -= pSplitItem->mnPixSize; 2314 } 2315 else 2316 { 2317 if ( bDown ) 2318 maDragRect.Bottom() += pSplitItem->mnPixSize; 2319 else 2320 maDragRect.Top() -= pSplitItem->mnPixSize; 2321 } 2322 } 2323 nTemp++; 2324 } 2325 } 2326 } 2327 else 2328 { 2329 maDragRect.Left() = mnLeftBorder; 2330 maDragRect.Top() = mnTopBorder; 2331 maDragRect.Right() = mnDX-mnRightBorder-1; 2332 maDragRect.Bottom() = mnDY-mnBottomBorder-1; 2333 if ( mbHorz ) 2334 { 2335 if ( mbBottomRight ) 2336 maDragRect.Top() -= nCurMaxSize-mnDY-mnBottomBorder; 2337 else 2338 maDragRect.Bottom() += nCurMaxSize-mnDY-mnTopBorder; 2339 } 2340 else 2341 { 2342 if ( mbBottomRight ) 2343 maDragRect.Left() -= nCurMaxSize-mnDX-mnRightBorder; 2344 else 2345 maDragRect.Right() += nCurMaxSize-mnDX-mnLeftBorder; 2346 } 2347 } 2348 2349 StartTracking(); 2350 2351 mbDragFull = (GetSettings().GetStyleSettings().GetDragFullOptions() & DRAGFULL_OPTION_SPLIT) != 0; 2352 2353 ImplSplitMousePos( aMousePosPixel ); 2354 2355 if ( !mbDragFull ) 2356 ImplDrawSplitTracking( this, aMousePosPixel ); 2357 else 2358 { 2359 ImplSplitItem* pItems = mpSplitSet->mpItems; 2360 sal_uInt16 nItems = mpSplitSet->mnItems; 2361 mpLastSizes = new long[nItems*2]; 2362 for ( sal_uInt16 i = 0; i < nItems; i++ ) 2363 { 2364 mpLastSizes[i*2] = pItems[i].mnSize; 2365 mpLastSizes[i*2+1] = pItems[i].mnPixSize; 2366 } 2367 } 2368 mnMStartPos = mnMSplitPos; 2369 2370 PointerStyle eStyle = POINTER_ARROW; 2371 if ( mnSplitTest & SPLIT_HORZ ) 2372 eStyle = POINTER_HSPLIT; 2373 else if ( mnSplitTest & SPLIT_VERT ) 2374 eStyle = POINTER_VSPLIT; 2375 2376 Pointer aPtr( eStyle ); 2377 SetPointer( aPtr ); 2378 } 2379 } 2380 2381 2382 // ----------------------------------------------------------------------- 2383 2384 void SplitWindow::StartSplit() 2385 { 2386 maStartSplitHdl.Call( this ); 2387 } 2388 2389 // ----------------------------------------------------------------------- 2390 2391 void SplitWindow::Split() 2392 { 2393 maSplitHdl.Call( this ); 2394 } 2395 2396 // ----------------------------------------------------------------------- 2397 2398 void SplitWindow::SplitResize() 2399 { 2400 maSplitResizeHdl.Call( this ); 2401 } 2402 2403 // ----------------------------------------------------------------------- 2404 2405 void SplitWindow::AutoHide() 2406 { 2407 maAutoHideHdl.Call( this ); 2408 } 2409 2410 // ----------------------------------------------------------------------- 2411 2412 void SplitWindow::FadeIn() 2413 { 2414 maFadeInHdl.Call( this ); 2415 } 2416 2417 // ----------------------------------------------------------------------- 2418 2419 void SplitWindow::FadeOut() 2420 { 2421 maFadeOutHdl.Call( this ); 2422 } 2423 2424 // ----------------------------------------------------------------------- 2425 2426 void SplitWindow::MouseButtonDown( const MouseEvent& rMEvt ) 2427 { 2428 if ( !rMEvt.IsLeft() || rMEvt.IsMod2() ) 2429 { 2430 DockingWindow::MouseButtonDown( rMEvt ); 2431 return; 2432 } 2433 2434 Point aMousePosPixel = rMEvt.GetPosPixel(); 2435 Rectangle aTestRect; 2436 2437 mbFadeNoButtonMode = sal_False; 2438 ImplGetAutoHideRect( aTestRect, sal_True ); 2439 if ( aTestRect.IsInside( aMousePosPixel ) ) 2440 { 2441 mbAutoHideDown = sal_True; 2442 mbAutoHidePressed = sal_True; 2443 ImplDrawAutoHide( sal_False ); 2444 } 2445 else 2446 { 2447 ImplGetFadeOutRect( aTestRect, sal_True ); 2448 if ( aTestRect.IsInside( aMousePosPixel ) ) 2449 { 2450 mbFadeOutDown = sal_True; 2451 mbFadeOutPressed = sal_True; 2452 ImplDrawFadeOut( sal_False ); 2453 } 2454 else 2455 { 2456 ImplGetFadeInRect( aTestRect, sal_True ); 2457 if ( aTestRect.IsInside( aMousePosPixel ) ) 2458 { 2459 mbFadeInDown = sal_True; 2460 mbFadeInPressed = sal_True; 2461 ImplDrawFadeIn( sal_False ); 2462 } 2463 else if ( !aTestRect.IsEmpty() && !(mnWinStyle & WB_SIZEABLE) ) 2464 { 2465 mbFadeNoButtonMode = sal_True; 2466 FadeIn(); 2467 return; 2468 } 2469 } 2470 } 2471 2472 if ( mbAutoHideDown || mbFadeInDown || mbFadeOutDown ) 2473 StartTracking(); 2474 else 2475 ImplStartSplit( rMEvt ); 2476 } 2477 2478 // ----------------------------------------------------------------------- 2479 2480 void SplitWindow::MouseMove( const MouseEvent& rMEvt ) 2481 { 2482 if ( !IsTracking() ) 2483 { 2484 Point aPos = rMEvt.GetPosPixel(); 2485 long nTemp; 2486 ImplSplitSet* pTempSplitSet; 2487 sal_uInt16 nTempSplitPos; 2488 sal_uInt16 nSplitTest = ImplTestSplit( this, aPos, nTemp, &pTempSplitSet, nTempSplitPos ); 2489 PointerStyle eStyle = POINTER_ARROW; 2490 Rectangle aAutoHideRect; 2491 Rectangle aFadeInRect; 2492 Rectangle aFadeOutRect; 2493 2494 ImplGetAutoHideRect( aAutoHideRect ); 2495 ImplGetFadeInRect( aFadeInRect ); 2496 ImplGetFadeOutRect( aFadeOutRect ); 2497 if ( !aAutoHideRect.IsInside( aPos ) && 2498 !aFadeInRect.IsInside( aPos ) && 2499 !aFadeOutRect.IsInside( aPos ) ) 2500 { 2501 if ( nSplitTest && !(nSplitTest & SPLIT_NOSPLIT) ) 2502 { 2503 if ( nSplitTest & SPLIT_HORZ ) 2504 eStyle = POINTER_HSPLIT; 2505 else if ( nSplitTest & SPLIT_VERT ) 2506 eStyle = POINTER_VSPLIT; 2507 } 2508 } 2509 2510 Pointer aPtr( eStyle ); 2511 SetPointer( aPtr ); 2512 } 2513 } 2514 2515 // ----------------------------------------------------------------------- 2516 2517 void SplitWindow::Tracking( const TrackingEvent& rTEvt ) 2518 { 2519 Point aMousePosPixel = rTEvt.GetMouseEvent().GetPosPixel(); 2520 2521 if ( mbAutoHideDown ) 2522 { 2523 if ( rTEvt.IsTrackingEnded() ) 2524 { 2525 mbAutoHideDown = sal_False; 2526 if ( mbAutoHidePressed ) 2527 { 2528 mbAutoHidePressed = sal_False; 2529 2530 if ( !rTEvt.IsTrackingCanceled() ) 2531 { 2532 mbAutoHideIn = !mbAutoHideIn; 2533 ImplDrawAutoHide( sal_False ); 2534 AutoHide(); 2535 } 2536 else 2537 ImplDrawAutoHide( sal_False ); 2538 } 2539 } 2540 else 2541 { 2542 Rectangle aTestRect; 2543 ImplGetAutoHideRect( aTestRect, sal_True ); 2544 sal_Bool bNewPressed = aTestRect.IsInside( aMousePosPixel ); 2545 if ( bNewPressed != mbAutoHidePressed ) 2546 { 2547 mbAutoHidePressed = bNewPressed; 2548 ImplDrawAutoHide( sal_False ); 2549 } 2550 } 2551 } 2552 else if ( mbFadeInDown ) 2553 { 2554 if ( rTEvt.IsTrackingEnded() ) 2555 { 2556 mbFadeInDown = sal_False; 2557 if ( mbFadeInPressed ) 2558 { 2559 mbFadeInPressed = sal_False; 2560 ImplDrawFadeIn( sal_False ); 2561 2562 if ( !rTEvt.IsTrackingCanceled() ) 2563 FadeIn(); 2564 } 2565 } 2566 else 2567 { 2568 Rectangle aTestRect; 2569 ImplGetFadeInRect( aTestRect, sal_True ); 2570 sal_Bool bNewPressed = aTestRect.IsInside( aMousePosPixel ); 2571 if ( bNewPressed != mbFadeInPressed ) 2572 { 2573 mbFadeInPressed = bNewPressed; 2574 ImplDrawFadeIn( sal_False ); 2575 } 2576 } 2577 } 2578 else if ( mbFadeOutDown ) 2579 { 2580 if ( rTEvt.IsTrackingEnded() ) 2581 { 2582 mbFadeOutDown = sal_False; 2583 if ( mbFadeOutPressed ) 2584 { 2585 mbFadeOutPressed = sal_False; 2586 ImplDrawFadeOut( sal_False ); 2587 2588 if ( !rTEvt.IsTrackingCanceled() ) 2589 FadeOut(); 2590 } 2591 } 2592 else 2593 { 2594 Rectangle aTestRect; 2595 ImplGetFadeOutRect( aTestRect, sal_True ); 2596 sal_Bool bNewPressed = aTestRect.IsInside( aMousePosPixel ); 2597 if ( bNewPressed == sal_False ) 2598 { 2599 mbFadeOutPressed = bNewPressed; 2600 ImplDrawFadeOut( sal_False ); 2601 2602 // We need a mouseevent with a position inside the button for the 2603 // ImplStartSplit function! 2604 MouseEvent aOrgMEvt = rTEvt.GetMouseEvent(); 2605 MouseEvent aNewMEvt = MouseEvent( aTestRect.Center(), aOrgMEvt.GetClicks(), 2606 aOrgMEvt.GetMode(), aOrgMEvt.GetButtons(), 2607 aOrgMEvt.GetModifier() ); 2608 2609 ImplStartSplit( aNewMEvt ); 2610 mbFadeOutDown = sal_False; 2611 } 2612 } 2613 } 2614 else 2615 { 2616 ImplSplitMousePos( aMousePosPixel ); 2617 sal_Bool bSplit = sal_True; 2618 if ( mbDragFull ) 2619 { 2620 if ( rTEvt.IsTrackingEnded() ) 2621 { 2622 if ( rTEvt.IsTrackingCanceled() ) 2623 { 2624 ImplSplitItem* pItems = mpSplitSet->mpItems; 2625 sal_uInt16 nItems = mpSplitSet->mnItems; 2626 for ( sal_uInt16 i = 0; i < nItems; i++ ) 2627 { 2628 pItems[i].mnSize = mpLastSizes[i*2]; 2629 pItems[i].mnPixSize = mpLastSizes[i*2+1]; 2630 } 2631 ImplUpdate(); 2632 Split(); 2633 } 2634 bSplit = sal_False; 2635 } 2636 } 2637 else 2638 { 2639 if ( rTEvt.IsTrackingEnded() ) 2640 { 2641 HideTracking(); 2642 bSplit = !rTEvt.IsTrackingCanceled(); 2643 } 2644 else 2645 { 2646 ImplDrawSplitTracking( this, aMousePosPixel ); 2647 bSplit = sal_False; 2648 } 2649 } 2650 2651 if ( bSplit ) 2652 { 2653 sal_Bool bPropSmaller = (mnMouseModifier & KEY_SHIFT) ? sal_True : sal_False; 2654 sal_Bool bPropGreater = (mnMouseModifier & KEY_MOD1) ? sal_True : sal_False; 2655 long nDelta = mnMSplitPos-mnMStartPos; 2656 2657 if ( (mnSplitTest & SPLIT_WINDOW) && !mpMainSet->mpItems ) 2658 { 2659 if ( (mpSplitSet == mpMainSet) && mbBottomRight ) 2660 nDelta *= -1; 2661 ImplSetWindowSize( nDelta ); 2662 } 2663 else 2664 { 2665 long nNewSize = mpSplitSet->mpItems[mnSplitPos].mnPixSize; 2666 if ( (mpSplitSet == mpMainSet) && mbBottomRight ) 2667 nNewSize -= nDelta; 2668 else 2669 nNewSize += nDelta; 2670 SplitItem( mpSplitSet->mpItems[mnSplitPos].mnId, nNewSize, 2671 bPropSmaller, bPropGreater ); 2672 } 2673 2674 Split(); 2675 2676 if ( mbDragFull ) 2677 { 2678 Update(); 2679 mnMStartPos = mnMSplitPos; 2680 } 2681 } 2682 2683 if ( rTEvt.IsTrackingEnded() ) 2684 { 2685 if ( mpLastSizes ) 2686 delete mpLastSizes; 2687 mpLastSizes = NULL; 2688 mpSplitSet = NULL; 2689 mnMouseOff = 0; 2690 mnMStartPos = 0; 2691 mnMSplitPos = 0; 2692 mnMouseModifier = 0; 2693 mnSplitTest = 0; 2694 mnSplitPos = 0; 2695 } 2696 } 2697 } 2698 2699 // ----------------------------------------------------------------------- 2700 2701 long SplitWindow::PreNotify( NotifyEvent& rNEvt ) 2702 { 2703 const MouseEvent* pMouseEvt = NULL; 2704 2705 if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL ) 2706 { 2707 if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() ) 2708 { 2709 // trigger redraw if mouse over state has changed 2710 Rectangle aFadeInRect; 2711 Rectangle aFadeOutRect; 2712 ImplGetFadeInRect( aFadeInRect ); 2713 ImplGetFadeOutRect( aFadeOutRect ); 2714 2715 if ( aFadeInRect.IsInside( GetPointerPosPixel() ) != aFadeInRect.IsInside( GetLastPointerPosPixel() ) ) 2716 Invalidate( aFadeInRect ); 2717 if ( aFadeOutRect.IsInside( GetPointerPosPixel() ) != aFadeOutRect.IsInside( GetLastPointerPosPixel() ) ) 2718 Invalidate( aFadeOutRect ); 2719 2720 if( pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow() ) 2721 { 2722 Invalidate( aFadeInRect ); 2723 Invalidate( aFadeOutRect ); 2724 } 2725 } 2726 } 2727 return Window::PreNotify( rNEvt ); 2728 } 2729 2730 // ----------------------------------------------------------------------- 2731 2732 void SplitWindow::Paint( const Rectangle& ) 2733 { 2734 if ( mnWinStyle & WB_BORDER ) 2735 ImplDrawBorder( this ); 2736 2737 ImplDrawBorderLine( this ); 2738 ImplDrawFadeOut( sal_True ); 2739 ImplDrawFadeIn( sal_True ); 2740 ImplDrawAutoHide( sal_True ); 2741 2742 // FrameSet-Hintergruende zeichnen 2743 ImplDrawBack( this, mpMainSet ); 2744 2745 // Splitter zeichnen 2746 if ( !(mnWinStyle & WB_NOSPLITDRAW) ) 2747 ImplDrawSplit( this, mpMainSet, mbHorz, !mbBottomRight ); 2748 } 2749 2750 // ----------------------------------------------------------------------- 2751 2752 void SplitWindow::Move() 2753 { 2754 DockingWindow::Move(); 2755 } 2756 2757 // ----------------------------------------------------------------------- 2758 2759 void SplitWindow::Resize() 2760 { 2761 Size aSize = GetOutputSizePixel(); 2762 mnDX = aSize.Width(); 2763 mnDY = aSize.Height(); 2764 2765 ImplUpdate(); 2766 Invalidate(); 2767 } 2768 2769 // ----------------------------------------------------------------------- 2770 2771 void SplitWindow::RequestHelp( const HelpEvent& rHEvt ) 2772 { 2773 // no keyboard help for splitwin 2774 if ( rHEvt.GetMode() & (HELPMODE_BALLOON | HELPMODE_QUICK) && !rHEvt.KeyboardActivated() ) 2775 { 2776 Point aMousePosPixel = ScreenToOutputPixel( rHEvt.GetMousePosPixel() ); 2777 Rectangle aHelpRect; 2778 sal_uInt16 nHelpResId = 0; 2779 2780 ImplGetAutoHideRect( aHelpRect, sal_True ); 2781 if ( aHelpRect.IsInside( aMousePosPixel ) ) 2782 { 2783 if ( mbAutoHideIn ) 2784 nHelpResId = SV_HELPTEXT_SPLITFIXED; 2785 else 2786 nHelpResId = SV_HELPTEXT_SPLITFLOATING; 2787 } 2788 else 2789 { 2790 ImplGetFadeInRect( aHelpRect, sal_True ); 2791 if ( aHelpRect.IsInside( aMousePosPixel ) ) 2792 nHelpResId = SV_HELPTEXT_FADEIN; 2793 else 2794 { 2795 ImplGetFadeOutRect( aHelpRect, sal_True ); 2796 if ( aHelpRect.IsInside( aMousePosPixel ) ) 2797 nHelpResId = SV_HELPTEXT_FADEOUT; 2798 } 2799 } 2800 2801 // Rechteck ermitteln 2802 if ( nHelpResId ) 2803 { 2804 Point aPt = OutputToScreenPixel( aHelpRect.TopLeft() ); 2805 aHelpRect.Left() = aPt.X(); 2806 aHelpRect.Top() = aPt.Y(); 2807 aPt = OutputToScreenPixel( aHelpRect.BottomRight() ); 2808 aHelpRect.Right() = aPt.X(); 2809 aHelpRect.Bottom() = aPt.Y(); 2810 2811 // Text ermitteln und anzeigen 2812 XubString aStr; 2813 ResMgr* pResMgr = ImplGetResMgr(); 2814 if( pResMgr ) 2815 aStr = XubString( ResId( nHelpResId, *pResMgr ) ); 2816 if ( rHEvt.GetMode() & HELPMODE_BALLOON ) 2817 Help::ShowBalloon( this, aHelpRect.Center(), aHelpRect, aStr ); 2818 else 2819 Help::ShowQuickHelp( this, aHelpRect, aStr ); 2820 return; 2821 } 2822 } 2823 2824 DockingWindow::RequestHelp( rHEvt ); 2825 } 2826 2827 // ----------------------------------------------------------------------- 2828 2829 void SplitWindow::StateChanged( StateChangedType nType ) 2830 { 2831 if ( nType == STATE_CHANGE_INITSHOW ) 2832 { 2833 if ( IsUpdateMode() ) 2834 ImplCalcLayout(); 2835 } 2836 else if ( nType == STATE_CHANGE_UPDATEMODE ) 2837 { 2838 if ( IsUpdateMode() && IsReallyShown() ) 2839 ImplCalcLayout(); 2840 } 2841 else if ( nType == STATE_CHANGE_CONTROLBACKGROUND ) 2842 { 2843 ImplInitSettings(); 2844 Invalidate(); 2845 } 2846 2847 DockingWindow::StateChanged( nType ); 2848 } 2849 2850 // ----------------------------------------------------------------------- 2851 2852 void SplitWindow::DataChanged( const DataChangedEvent& rDCEvt ) 2853 { 2854 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) && 2855 (rDCEvt.GetFlags() & SETTINGS_STYLE) ) 2856 { 2857 ImplInitSettings(); 2858 Invalidate(); 2859 } 2860 else 2861 DockingWindow::DataChanged( rDCEvt ); 2862 } 2863 2864 // ----------------------------------------------------------------------- 2865 2866 void SplitWindow::InsertItem( sal_uInt16 nId, Window* pWindow, long nSize, 2867 sal_uInt16 nPos, sal_uInt16 nSetId, 2868 SplitWindowItemBits nBits ) 2869 { 2870 #ifdef DBG_UTIL 2871 sal_uInt16 nDbgDummy; 2872 DBG_ASSERT( ImplFindSet( mpMainSet, nSetId ), "SplitWindow::InsertItem() - Set not exists" ); 2873 DBG_ASSERT( !ImplFindItem( mpMainSet, nId, nDbgDummy ), "SplitWindow::InsertItem() - Id already exists" ); 2874 #endif 2875 2876 // Size has to be at least 1. 2877 if ( nSize < 1 ) 2878 nSize = 1; 2879 2880 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId ); 2881 ImplSplitSet* pNewSet; 2882 ImplSplitItem* pItem; 2883 2884 // Make room for the new item. 2885 if ( nPos > pSet->mnItems ) 2886 nPos = pSet->mnItems; 2887 ImplSplitItem* pNewItems = new ImplSplitItem[pSet->mnItems+1]; 2888 if ( nPos ) 2889 memcpy( pNewItems, pSet->mpItems, sizeof( ImplSplitItem )*nPos ); 2890 if ( nPos < pSet->mnItems ) 2891 memcpy( pNewItems+nPos+1, pSet->mpItems+nPos, sizeof( ImplSplitItem )*(pSet->mnItems-nPos) ); 2892 delete[] pSet->mpItems; 2893 pSet->mpItems = pNewItems; 2894 pSet->mnItems++; 2895 pSet->mbCalcPix = sal_True; 2896 2897 // Create and initialize item. 2898 pItem = &(pSet->mpItems[nPos]); 2899 memset( pItem, 0, sizeof( ImplSplitItem ) ); 2900 pItem->mnSize = nSize; 2901 pItem->mnId = nId; 2902 pItem->mnBits = nBits; 2903 pItem->mnMinSize=-1; 2904 pItem->mnMaxSize=-1; 2905 2906 if ( pWindow ) 2907 { 2908 pItem->mpWindow = pWindow; 2909 pItem->mpOrgParent = pWindow->GetParent(); 2910 2911 // Attach window to SplitWindow. 2912 pWindow->Hide(); 2913 pWindow->SetParent( this ); 2914 } 2915 else 2916 { 2917 pNewSet = new ImplSplitSet; 2918 pNewSet->mpItems = NULL; 2919 pNewSet->mpWallpaper = NULL; 2920 pNewSet->mpBitmap = NULL; 2921 pNewSet->mnLastSize = 0; 2922 pNewSet->mnItems = 0; 2923 pNewSet->mnId = nId; 2924 pNewSet->mnSplitSize = pSet->mnSplitSize; 2925 pNewSet->mbCalcPix = sal_True; 2926 2927 pItem->mpSet = pNewSet; 2928 } 2929 2930 ImplUpdate(); 2931 } 2932 2933 // ----------------------------------------------------------------------- 2934 2935 void SplitWindow::InsertItem( sal_uInt16 nId, long nSize, 2936 sal_uInt16 nPos, sal_uInt16 nSetId, 2937 SplitWindowItemBits nBits ) 2938 { 2939 InsertItem( nId, NULL, nSize, nPos, nSetId, nBits ); 2940 } 2941 2942 // ----------------------------------------------------------------------- 2943 2944 void SplitWindow::MoveItem( sal_uInt16 nId, sal_uInt16 nNewPos, sal_uInt16 nNewSetId ) 2945 { 2946 #ifdef DBG_UTIL 2947 sal_uInt16 nDbgDummy; 2948 DBG_ASSERT( ImplFindItem( mpMainSet, nId, nDbgDummy ), "SplitWindow::MoveItem() - Id not found" ); 2949 DBG_ASSERT( ImplFindSet( mpMainSet, nNewSetId ), "SplitWindow::MoveItem() - Set not exists" ); 2950 #endif 2951 2952 sal_uInt16 nPos; 2953 ImplSplitSet* pNewSet = ImplFindSet( mpMainSet, nNewSetId ); 2954 ImplSplitSet* pSet = ImplFindItem( mpMainSet, nId, nPos ); 2955 ImplSplitItem aTempItem; 2956 2957 if ( pNewSet == pSet ) 2958 { 2959 if ( nNewPos >= pNewSet->mnItems ) 2960 nNewPos = pNewSet->mnItems-1; 2961 if ( nPos != nNewPos ) 2962 { 2963 memcpy( &aTempItem, &(pSet->mpItems[nPos]), sizeof( aTempItem ) ); 2964 if ( nPos < nNewPos ) 2965 { 2966 memmove( pSet->mpItems+nPos, pSet->mpItems+nPos+1, 2967 (nNewPos-nPos)*sizeof( ImplSplitItem ) ); 2968 } 2969 else 2970 { 2971 memmove( pSet->mpItems+nNewPos+1, pSet->mpItems+nNewPos, 2972 (nPos-nNewPos)*sizeof( ImplSplitItem ) ); 2973 } 2974 memcpy( &(pSet->mpItems[nNewPos]), &aTempItem, sizeof( aTempItem ) ); 2975 2976 ImplUpdate(); 2977 } 2978 } 2979 else 2980 { 2981 if ( nNewPos >= pNewSet->mnItems ) 2982 nNewPos = pNewSet->mnItems; 2983 memcpy( &aTempItem, &(pSet->mpItems[nPos]), sizeof( aTempItem ) ); 2984 pSet->mnItems--; 2985 pSet->mbCalcPix = sal_True; 2986 if ( pSet->mnItems ) 2987 { 2988 memmove( pSet->mpItems+nPos, pSet->mpItems+nPos+1, 2989 (pSet->mnItems-nPos)*sizeof( ImplSplitItem ) ); 2990 } 2991 else 2992 { 2993 delete[] pSet->mpItems; 2994 pSet->mpItems = NULL; 2995 } 2996 ImplSplitItem* pNewItems = new ImplSplitItem[pNewSet->mnItems+1]; 2997 if ( nNewPos ) 2998 memcpy( pNewItems, pNewSet->mpItems, sizeof( ImplSplitItem )*nNewPos ); 2999 if ( nNewPos < pNewSet->mnItems ) 3000 { 3001 memcpy( pNewItems+nNewPos+1, pNewSet->mpItems+nNewPos, 3002 sizeof( ImplSplitItem )*(pNewSet->mnItems-nNewPos) ); 3003 } 3004 delete[] pNewSet->mpItems; 3005 pNewSet->mpItems = pNewItems; 3006 pNewSet->mnItems++; 3007 pNewSet->mbCalcPix = sal_True; 3008 memcpy( &(pNewSet->mpItems[nNewPos]), &aTempItem, sizeof( aTempItem ) ); 3009 ImplUpdate(); 3010 } 3011 } 3012 3013 // ----------------------------------------------------------------------- 3014 3015 void SplitWindow::RemoveItem( sal_uInt16 nId, sal_Bool bHide ) 3016 { 3017 #ifdef DBG_UTIL 3018 sal_uInt16 nDbgDummy; 3019 DBG_ASSERT( ImplFindItem( mpMainSet, nId, nDbgDummy ), "SplitWindow::RemoveItem() - Id not found" ); 3020 #endif 3021 3022 // Set suchen 3023 sal_uInt16 nPos; 3024 ImplSplitSet* pSet = ImplFindItem( mpMainSet, nId, nPos ); 3025 ImplSplitItem* pItem = &(pSet->mpItems[nPos]); 3026 Window* pWindow = pItem->mpWindow; 3027 Window* pOrgParent = pItem->mpOrgParent; 3028 3029 // Evt. Set loeschen 3030 if ( !pWindow ) 3031 ImplDeleteSet( pItem->mpSet ); 3032 3033 // Item entfernen 3034 pSet->mnItems--; 3035 pSet->mbCalcPix = sal_True; 3036 if ( pSet->mnItems ) 3037 { 3038 memmove( pSet->mpItems+nPos, pSet->mpItems+nPos+1, 3039 (pSet->mnItems-nPos)*sizeof( ImplSplitItem ) ); 3040 } 3041 else 3042 { 3043 delete[] pSet->mpItems; 3044 pSet->mpItems = NULL; 3045 } 3046 3047 ImplUpdate(); 3048 3049 // Window erst hier loeschen, um weniger Paints zu haben 3050 if ( pWindow ) 3051 { 3052 // Fenster wieder herstellen 3053 if ( bHide || (pOrgParent != this) ) 3054 { 3055 pWindow->Hide(); 3056 pWindow->SetParent( pOrgParent ); 3057 } 3058 } 3059 } 3060 3061 // ----------------------------------------------------------------------- 3062 3063 void SplitWindow::Clear() 3064 { 3065 // Alle Sets loeschen 3066 ImplDeleteSet( mpMainSet ); 3067 3068 // Main-Set wieder anlegen 3069 mpMainSet = new ImplSplitSet; 3070 mpMainSet->mpItems = NULL; 3071 mpMainSet->mpWallpaper = NULL; 3072 mpMainSet->mpBitmap = NULL; 3073 mpMainSet->mnLastSize = 0; 3074 mpMainSet->mnItems = 0; 3075 mpMainSet->mnId = 0; 3076 mpMainSet->mnSplitSize = SPLITWIN_SPLITSIZE; 3077 mpMainSet->mbCalcPix = sal_True; 3078 if ( mnWinStyle & WB_NOSPLITDRAW ) 3079 mpMainSet->mnSplitSize -= 2; 3080 mpBaseSet = mpMainSet; 3081 3082 // Und neu invalidieren 3083 ImplUpdate(); 3084 } 3085 3086 // ----------------------------------------------------------------------- 3087 3088 void SplitWindow::SetBaseSet( sal_uInt16 nSetId ) 3089 { 3090 mpBaseSet = ImplFindSet( mpMainSet, nSetId ); 3091 } 3092 3093 // ----------------------------------------------------------------------- 3094 3095 sal_uInt16 SplitWindow::GetBaseSet() const 3096 { 3097 return mpBaseSet->mnId; 3098 } 3099 3100 // ----------------------------------------------------------------------- 3101 3102 void SplitWindow::SetSplitSize( sal_uInt16 nSetId, long nSplitSize, 3103 sal_Bool bWithChilds ) 3104 { 3105 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId ); 3106 if ( pSet ) 3107 { 3108 if ( bWithChilds ) 3109 ImplSetSplitSize( pSet, nSplitSize ); 3110 else 3111 pSet->mnSplitSize = nSplitSize; 3112 } 3113 ImplUpdate(); 3114 } 3115 3116 // ----------------------------------------------------------------------- 3117 3118 long SplitWindow::GetSplitSize( sal_uInt16 nSetId ) const 3119 { 3120 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId ); 3121 if ( pSet ) 3122 return pSet->mnSplitSize; 3123 else 3124 return 0; 3125 } 3126 3127 // ----------------------------------------------------------------------- 3128 3129 void SplitWindow::SetItemBackground( sal_uInt16 nSetId ) 3130 { 3131 Wallpaper aWall; 3132 SetItemBackground( nSetId, aWall ); 3133 } 3134 3135 // ----------------------------------------------------------------------- 3136 3137 void SplitWindow::SetItemBackground( sal_uInt16 nSetId, const Wallpaper& rWallpaper ) 3138 { 3139 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId ); 3140 3141 if ( pSet ) 3142 { 3143 sal_Bool bUpdate = sal_True; 3144 3145 if ( rWallpaper.GetStyle() == WALLPAPER_NULL ) 3146 { 3147 if ( pSet->mpWallpaper ) 3148 { 3149 delete pSet->mpWallpaper; 3150 pSet->mpWallpaper = NULL; 3151 } 3152 else 3153 bUpdate = sal_False; 3154 } 3155 else 3156 { 3157 // Ab jetzt muss immer invalidiert werden 3158 mbInvalidate = sal_True; 3159 3160 if ( !pSet->mpWallpaper ) 3161 pSet->mpWallpaper = new Wallpaper( rWallpaper ); 3162 else 3163 *(pSet->mpWallpaper) = rWallpaper; 3164 } 3165 3166 // Beim MainSet koennen wir den Background umsetzen 3167 if ( pSet == mpMainSet ) 3168 ImplInitSettings(); 3169 3170 if ( bUpdate ) 3171 ImplUpdateSet( pSet ); 3172 } 3173 } 3174 3175 // ----------------------------------------------------------------------- 3176 3177 Wallpaper SplitWindow::GetItemBackground( sal_uInt16 nSetId ) const 3178 { 3179 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId ); 3180 3181 if ( pSet && pSet->mpWallpaper ) 3182 return *(pSet->mpWallpaper); 3183 else 3184 { 3185 Wallpaper aWall; 3186 return aWall; 3187 } 3188 } 3189 3190 // ----------------------------------------------------------------------- 3191 3192 sal_Bool SplitWindow::IsItemBackground( sal_uInt16 nSetId ) const 3193 { 3194 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId ); 3195 3196 if ( pSet && pSet->mpWallpaper ) 3197 return sal_True; 3198 else 3199 return sal_False; 3200 } 3201 3202 // ----------------------------------------------------------------------- 3203 3204 void SplitWindow::SetItemBitmap( sal_uInt16 nSetId, const Bitmap& rBitmap ) 3205 { 3206 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId ); 3207 3208 if ( pSet ) 3209 { 3210 sal_Bool bUpdate = sal_True; 3211 3212 if ( !rBitmap ) 3213 { 3214 if ( pSet->mpBitmap ) 3215 { 3216 delete pSet->mpBitmap; 3217 pSet->mpBitmap = NULL; 3218 } 3219 else 3220 bUpdate = sal_False; 3221 } 3222 else 3223 { 3224 // Ab jetzt muss immer invalidiert werden 3225 mbInvalidate = sal_True; 3226 3227 if ( !pSet->mpBitmap ) 3228 pSet->mpBitmap = new Bitmap( rBitmap ); 3229 else 3230 *(pSet->mpBitmap) = rBitmap; 3231 } 3232 3233 // Beim MainSet koennen wir den Background umsetzen 3234 if ( pSet == mpMainSet ) 3235 ImplInitSettings(); 3236 3237 if ( bUpdate ) 3238 ImplUpdateSet( pSet ); 3239 } 3240 } 3241 3242 // ----------------------------------------------------------------------- 3243 3244 Bitmap SplitWindow::GetItemBitmap( sal_uInt16 nSetId ) const 3245 { 3246 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId ); 3247 3248 if ( pSet && pSet->mpBitmap ) 3249 return *(pSet->mpBitmap); 3250 else 3251 { 3252 Bitmap aBitmap; 3253 return aBitmap; 3254 } 3255 } 3256 3257 // ----------------------------------------------------------------------- 3258 3259 void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize, 3260 sal_Bool bPropSmall, sal_Bool bPropGreat ) 3261 { 3262 sal_uInt16 nItems; 3263 sal_uInt16 nPos; 3264 sal_uInt16 nMin; 3265 sal_uInt16 nMax; 3266 sal_uInt16 i; 3267 sal_uInt16 n; 3268 long nDelta; 3269 long nTempDelta; 3270 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3271 ImplSplitItem* pItems; 3272 3273 if ( !pSet ) 3274 return; 3275 3276 nItems = pSet->mnItems; 3277 pItems = pSet->mpItems; 3278 3279 // When there is an explicit minimum or maximum size then move nNewSize 3280 // into that range (when it is not yet already in it.) 3281 nNewSize = ValidateSize(nNewSize, pItems[nPos]); 3282 3283 if ( mbCalc ) 3284 { 3285 pItems[nPos].mnSize = nNewSize; 3286 return; 3287 } 3288 3289 nDelta = nNewSize-pItems[nPos].mnPixSize; 3290 if ( !nDelta ) 3291 return; 3292 3293 // Bereich berechnen, der beim Splitten betroffen sein kann 3294 nMin = 0; 3295 nMax = nItems; 3296 for ( i = 0; i < nItems; i++ ) 3297 { 3298 if ( pItems[i].mbFixed ) 3299 { 3300 if ( i < nPos ) 3301 nMin = i+1; 3302 else 3303 nMax = i; 3304 } 3305 } 3306 3307 // Wenn das Fenster sizeable ist, wird das TopSet anders behandelt 3308 sal_Bool bSmall = sal_True; 3309 sal_Bool bGreat = sal_True; 3310 if ( (pSet == mpMainSet) && (mnWinStyle & WB_SIZEABLE) ) 3311 { 3312 if ( nPos < pSet->mnItems-1 ) 3313 { 3314 if ( !((bPropSmall && bPropGreat) || 3315 ((nDelta > 0) && bPropSmall) || 3316 ((nDelta < 0) && bPropGreat)) ) 3317 { 3318 if ( nDelta < 0 ) 3319 bGreat = sal_False; 3320 else 3321 bSmall = sal_False; 3322 } 3323 } 3324 else 3325 { 3326 if ( nDelta < 0 ) 3327 bGreat = sal_False; 3328 else 3329 bSmall = sal_False; 3330 } 3331 } 3332 else if ( nPos >= nMax ) 3333 { 3334 bSmall = sal_False; 3335 bGreat = sal_False; 3336 } 3337 else if ( nPos && (nPos >= pSet->mnItems-1) ) 3338 { 3339 nPos--; 3340 nDelta *= -1; 3341 sal_Bool bTemp = bPropSmall; 3342 bPropSmall = bPropGreat; 3343 bPropGreat = bTemp; 3344 } 3345 3346 // Jetzt die Fenster splitten 3347 if ( nDelta < 0 ) 3348 { 3349 if ( bGreat ) 3350 { 3351 if ( bPropGreat ) 3352 { 3353 nTempDelta = nDelta; 3354 do 3355 { 3356 n = nPos+1; 3357 do 3358 { 3359 if ( nTempDelta ) 3360 { 3361 pItems[n].mnPixSize++; 3362 nTempDelta++; 3363 } 3364 n++; 3365 } 3366 while ( n < nMax ); 3367 } 3368 while ( nTempDelta ); 3369 } 3370 else 3371 pItems[nPos+1].mnPixSize -= nDelta; 3372 } 3373 3374 if ( bSmall ) 3375 { 3376 if ( bPropSmall ) 3377 { 3378 do 3379 { 3380 n = nPos+1; 3381 do 3382 { 3383 if ( nDelta && pItems[n-1].mnPixSize ) 3384 { 3385 pItems[n-1].mnPixSize--; 3386 nDelta++; 3387 } 3388 3389 n--; 3390 } 3391 while ( n > nMin ); 3392 } 3393 while ( nDelta ); 3394 } 3395 else 3396 { 3397 n = nPos+1; 3398 do 3399 { 3400 if ( pItems[n-1].mnPixSize+nDelta < 0 ) 3401 { 3402 nDelta += pItems[n-1].mnPixSize; 3403 pItems[n-1].mnPixSize = 0; 3404 } 3405 else 3406 { 3407 pItems[n-1].mnPixSize += nDelta; 3408 break; 3409 } 3410 n--; 3411 } 3412 while ( n > nMin ); 3413 } 3414 } 3415 } 3416 else 3417 { 3418 if ( bGreat ) 3419 { 3420 if ( bPropGreat ) 3421 { 3422 nTempDelta = nDelta; 3423 do 3424 { 3425 n = nPos+1; 3426 do 3427 { 3428 if ( nTempDelta ) 3429 { 3430 pItems[n-1].mnPixSize++; 3431 nTempDelta--; 3432 } 3433 n--; 3434 } 3435 while ( n > nMin ); 3436 } 3437 while ( nTempDelta ); 3438 } 3439 else 3440 pItems[nPos].mnPixSize += nDelta; 3441 } 3442 3443 if ( bSmall ) 3444 { 3445 if ( bPropSmall ) 3446 { 3447 do 3448 { 3449 n = nPos+1; 3450 do 3451 { 3452 if ( nDelta && pItems[n].mnPixSize ) 3453 { 3454 pItems[n].mnPixSize--; 3455 nDelta--; 3456 } 3457 3458 n++; 3459 } 3460 while ( n < nMax ); 3461 } 3462 while ( nDelta ); 3463 } 3464 else 3465 { 3466 n = nPos+1; 3467 do 3468 { 3469 if ( pItems[n].mnPixSize-nDelta < 0 ) 3470 { 3471 nDelta -= pItems[n].mnPixSize; 3472 pItems[n].mnPixSize = 0; 3473 } 3474 else 3475 { 3476 pItems[n].mnPixSize -= nDelta; 3477 break; 3478 } 3479 n++; 3480 } 3481 while ( n < nMax ); 3482 } 3483 } 3484 } 3485 3486 // Original-Groessen updaten 3487 ImplCalcLogSize( pItems, nItems ); 3488 3489 ImplUpdate(); 3490 } 3491 3492 // ----------------------------------------------------------------------- 3493 3494 void SplitWindow::SetItemSize( sal_uInt16 nId, long nNewSize ) 3495 { 3496 sal_uInt16 nPos; 3497 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3498 ImplSplitItem* pItem; 3499 3500 if ( !pSet ) 3501 return; 3502 3503 // Testen, ob sich Groesse aendert 3504 pItem = &(pSet->mpItems[nPos]); 3505 if ( pItem->mnSize != nNewSize ) 3506 { 3507 // Neue Groesse setzen und neu durchrechnen 3508 pItem->mnSize = nNewSize; 3509 pSet->mbCalcPix = sal_True; 3510 ImplUpdate(); 3511 } 3512 } 3513 3514 // ----------------------------------------------------------------------- 3515 3516 long SplitWindow::GetItemSize( sal_uInt16 nId ) const 3517 { 3518 sal_uInt16 nPos; 3519 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3520 3521 if ( pSet ) 3522 return pSet->mpItems[nPos].mnSize; 3523 else 3524 return 0; 3525 } 3526 3527 // ----------------------------------------------------------------------- 3528 3529 long SplitWindow::GetItemSize( sal_uInt16 nId, SplitWindowItemBits nBits ) const 3530 { 3531 sal_uInt16 nPos; 3532 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3533 3534 if ( pSet ) 3535 { 3536 if ( nBits == pSet->mpItems[nPos].mnBits ) 3537 return pSet->mpItems[nPos].mnSize; 3538 else 3539 { 3540 ((SplitWindow*)this)->ImplCalcLayout(); 3541 3542 long nRelSize = 0; 3543 long nPerSize = 0; 3544 ImplSplitItem* pItems; 3545 sal_uInt16 nItems; 3546 SplitWindowItemBits nTempBits; 3547 sal_uInt16 i; 3548 nItems = pSet->mnItems; 3549 pItems = pSet->mpItems; 3550 for ( i = 0; i < nItems; i++ ) 3551 { 3552 if ( i == nPos ) 3553 nTempBits = nBits; 3554 else 3555 nTempBits = pItems[i].mnBits; 3556 if ( nTempBits & SWIB_RELATIVESIZE ) 3557 nRelSize += pItems[i].mnPixSize; 3558 else if ( nTempBits & SWIB_PERCENTSIZE ) 3559 nPerSize += pItems[i].mnPixSize; 3560 } 3561 nPerSize += nRelSize; 3562 if ( nBits & SWIB_RELATIVESIZE ) 3563 { 3564 if ( nRelSize ) 3565 return (pItems[nPos].mnPixSize+(nRelSize/2))/nRelSize; 3566 else 3567 return 1; 3568 } 3569 else if ( nBits & SWIB_PERCENTSIZE ) 3570 { 3571 if ( nPerSize ) 3572 return (pItems[nPos].mnPixSize*100)/nPerSize; 3573 else 3574 return 1; 3575 } 3576 else 3577 return pItems[nPos].mnPixSize; 3578 } 3579 } 3580 else 3581 return 0; 3582 } 3583 3584 3585 3586 3587 void SplitWindow::SetItemSizeRange (sal_uInt16 nId, const Range aRange) 3588 { 3589 sal_uInt16 nPos; 3590 ImplSplitSet* pSet = ImplFindItem(mpBaseSet, nId, nPos); 3591 3592 if (pSet != NULL) 3593 { 3594 pSet->mpItems[nPos].mnMinSize = aRange.Min(); 3595 pSet->mpItems[nPos].mnMaxSize = aRange.Max(); 3596 } 3597 } 3598 3599 3600 3601 3602 Range SplitWindow::GetItemSizeRange (sal_uInt16 nId) const 3603 { 3604 sal_uInt16 nPos; 3605 ImplSplitSet* pSet = ImplFindItem(mpBaseSet, nId, nPos); 3606 3607 if (pSet != NULL) 3608 return Range (pSet->mpItems[nPos].mnMinSize, pSet->mpItems[nPos].mnMaxSize); 3609 else 3610 return Range(-1,-1); 3611 } 3612 3613 3614 // ----------------------------------------------------------------------- 3615 3616 void SplitWindow::SetItemBits( sal_uInt16 nId, SplitWindowItemBits nNewBits ) 3617 { 3618 sal_uInt16 nPos; 3619 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3620 ImplSplitItem* pItem; 3621 3622 if ( !pSet ) 3623 return; 3624 3625 pItem = &(pSet->mpItems[nPos]); 3626 if ( pItem->mpWindow ) 3627 nNewBits &= ~SWIB_COLSET; 3628 3629 if ( pItem->mnBits != nNewBits ) 3630 { 3631 // Neue Bits setzen und neu durchrechnen 3632 pItem->mnBits = nNewBits; 3633 pSet->mbCalcPix = sal_True; 3634 ImplUpdate(); 3635 } 3636 } 3637 3638 // ----------------------------------------------------------------------- 3639 3640 SplitWindowItemBits SplitWindow::GetItemBits( sal_uInt16 nId ) const 3641 { 3642 sal_uInt16 nPos; 3643 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3644 3645 if ( pSet ) 3646 return pSet->mpItems[nPos].mnBits; 3647 else 3648 return 0; 3649 } 3650 3651 // ----------------------------------------------------------------------- 3652 3653 Window* SplitWindow::GetItemWindow( sal_uInt16 nId ) const 3654 { 3655 sal_uInt16 nPos; 3656 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3657 3658 if ( pSet ) 3659 return pSet->mpItems[nPos].mpWindow; 3660 else 3661 return NULL; 3662 } 3663 3664 // ----------------------------------------------------------------------- 3665 3666 sal_uInt16 SplitWindow::GetSet( sal_uInt16 nId ) const 3667 { 3668 sal_uInt16 nPos; 3669 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3670 3671 if ( pSet ) 3672 return pSet->mnId; 3673 else 3674 return 0; 3675 } 3676 3677 // ----------------------------------------------------------------------- 3678 3679 sal_Bool SplitWindow::GetSet( sal_uInt16 nId, sal_uInt16& rSetId, sal_uInt16& rPos ) const 3680 { 3681 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, rPos ); 3682 if ( pSet ) 3683 { 3684 rSetId = pSet->mnId; 3685 return sal_True; 3686 } 3687 else 3688 return sal_False; 3689 } 3690 3691 // ----------------------------------------------------------------------- 3692 3693 sal_Bool SplitWindow::IsItemValid( sal_uInt16 nId ) const 3694 { 3695 sal_uInt16 nPos; 3696 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos ); 3697 3698 if ( pSet ) 3699 return sal_True; 3700 else 3701 return sal_False; 3702 } 3703 3704 // ----------------------------------------------------------------------- 3705 3706 sal_uInt16 SplitWindow::GetItemId( Window* pWindow ) const 3707 { 3708 return ImplFindItem( mpBaseSet, pWindow ); 3709 } 3710 3711 // ----------------------------------------------------------------------- 3712 3713 sal_uInt16 SplitWindow::GetItemId( const Point& rPos ) const 3714 { 3715 return ImplFindItem( mpBaseSet, rPos, mbHorz, !mbBottomRight ); 3716 } 3717 3718 // ----------------------------------------------------------------------- 3719 3720 sal_uInt16 SplitWindow::GetItemPos( sal_uInt16 nId, sal_uInt16 nSetId ) const 3721 { 3722 ImplSplitSet* pSet = ImplFindSet( mpBaseSet, nSetId ); 3723 sal_uInt16 nPos = SPLITWINDOW_ITEM_NOTFOUND; 3724 3725 if ( pSet ) 3726 { 3727 for ( sal_uInt16 i = 0; i < pSet->mnItems; i++ ) 3728 { 3729 if ( pSet->mpItems[i].mnId == nId ) 3730 { 3731 nPos = i; 3732 break; 3733 } 3734 } 3735 } 3736 3737 return nPos; 3738 } 3739 3740 // ----------------------------------------------------------------------- 3741 3742 sal_uInt16 SplitWindow::GetItemId( sal_uInt16 nPos, sal_uInt16 nSetId ) const 3743 { 3744 ImplSplitSet* pSet = ImplFindSet( mpBaseSet, nSetId ); 3745 if ( pSet && (nPos < pSet->mnItems) ) 3746 return pSet->mpItems[nPos].mnId; 3747 else 3748 return 0; 3749 } 3750 3751 // ----------------------------------------------------------------------- 3752 3753 sal_uInt16 SplitWindow::GetItemCount( sal_uInt16 nSetId ) const 3754 { 3755 ImplSplitSet* pSet = ImplFindSet( mpBaseSet, nSetId ); 3756 if ( pSet ) 3757 return pSet->mnItems; 3758 else 3759 return 0; 3760 } 3761 3762 // ----------------------------------------------------------------------- 3763 3764 void SplitWindow::ImplNewAlign() 3765 { 3766 if ( mbNoAlign ) 3767 { 3768 mbHorz = sal_False; 3769 mbBottomRight = sal_False; 3770 } 3771 else if ( meAlign == WINDOWALIGN_TOP ) 3772 { 3773 mbHorz = sal_True; 3774 mbBottomRight = sal_False; 3775 } 3776 else if ( meAlign == WINDOWALIGN_BOTTOM ) 3777 { 3778 mbHorz = sal_True; 3779 mbBottomRight = sal_True; 3780 } 3781 else if ( meAlign == WINDOWALIGN_LEFT ) 3782 { 3783 mbHorz = sal_False; 3784 mbBottomRight = sal_False; 3785 } 3786 else if ( meAlign == WINDOWALIGN_RIGHT ) 3787 { 3788 mbHorz = sal_False; 3789 mbBottomRight = sal_True; 3790 } 3791 3792 if ( mnWinStyle & WB_BORDER ) 3793 { 3794 ImplCalcBorder( meAlign, mbNoAlign, mnLeftBorder, mnTopBorder, 3795 mnRightBorder, mnBottomBorder ); 3796 } 3797 3798 if ( IsReallyVisible() && IsUpdateMode() ) 3799 Invalidate(); 3800 ImplUpdate(); 3801 } 3802 3803 // ----------------------------------------------------------------------- 3804 3805 void SplitWindow::SetNoAlign( sal_Bool bNoAlign ) 3806 { 3807 bNoAlign = bNoAlign != 0; 3808 if ( mbNoAlign != bNoAlign ) 3809 { 3810 mbNoAlign = bNoAlign; 3811 ImplNewAlign(); 3812 } 3813 } 3814 3815 // ----------------------------------------------------------------------- 3816 3817 void SplitWindow::SetAlign( WindowAlign eNewAlign ) 3818 { 3819 if ( meAlign != eNewAlign ) 3820 { 3821 meAlign = eNewAlign; 3822 ImplNewAlign(); 3823 } 3824 } 3825 3826 // ----------------------------------------------------------------------- 3827 3828 Size SplitWindow::CalcWindowSizePixel( const Size& rSize, WindowAlign eAlign, 3829 WinBits nWinStyle, sal_Bool bExtra ) 3830 { 3831 long nLeft; 3832 long nTop; 3833 long nRight; 3834 long nBottom; 3835 Size aSize = rSize; 3836 3837 ImplCalcBorder( eAlign, sal_False, nLeft, nTop, nRight, nBottom ); 3838 aSize.Width() += nLeft+nRight; 3839 aSize.Height() += nTop+nBottom; 3840 3841 if ( nWinStyle & WB_SIZEABLE ) 3842 { 3843 if ( (eAlign == WINDOWALIGN_TOP) || (eAlign == WINDOWALIGN_BOTTOM) ) 3844 { 3845 aSize.Height() += SPLITWIN_SPLITSIZE-2; 3846 if ( bExtra ) 3847 aSize.Height() += SPLITWIN_SPLITSIZEEXLN; 3848 } 3849 else 3850 { 3851 aSize.Width() += SPLITWIN_SPLITSIZE-2; 3852 if ( bExtra ) 3853 aSize.Width() += SPLITWIN_SPLITSIZEEXLN; 3854 } 3855 } 3856 3857 return aSize; 3858 } 3859 3860 // ----------------------------------------------------------------------- 3861 3862 void SplitWindow::ShowAutoHideButton( sal_Bool bShow ) 3863 { 3864 mbAutoHide = bShow; 3865 ImplUpdate(); 3866 } 3867 3868 // ----------------------------------------------------------------------- 3869 3870 void SplitWindow::ShowFadeInHideButton( sal_Bool bShow ) 3871 { 3872 mbFadeIn = bShow; 3873 ImplUpdate(); 3874 } 3875 3876 // ----------------------------------------------------------------------- 3877 3878 void SplitWindow::ShowFadeOutButton( sal_Bool bShow ) 3879 { 3880 mbFadeOut = bShow; 3881 ImplUpdate(); 3882 } 3883 3884 // ----------------------------------------------------------------------- 3885 3886 void SplitWindow::SetAutoHideState( sal_Bool bAutoHide ) 3887 { 3888 mbAutoHideIn = bAutoHide; 3889 if ( IsReallyVisible() ) 3890 { 3891 Rectangle aRect; 3892 ImplGetAutoHideRect( aRect ); 3893 Invalidate( aRect ); 3894 } 3895 } 3896 3897 // ----------------------------------------------------------------------- 3898 3899 long SplitWindow::GetFadeInSize() const 3900 { 3901 long n = 0; 3902 3903 if ( mbHorz ) 3904 n = mnTopBorder+mnBottomBorder; 3905 else 3906 n = mnLeftBorder+mnRightBorder; 3907 3908 return n+SPLITWIN_SPLITSIZE+SPLITWIN_SPLITSIZEEX-2; 3909 } 3910 3911 // ----------------------------------------------------------------------- 3912 3913 Rectangle SplitWindow::GetAutoHideRect() const 3914 { 3915 Rectangle aRect; 3916 ImplGetAutoHideRect( aRect, sal_True ); 3917 return aRect; 3918 } 3919 3920 // ----------------------------------------------------------------------- 3921 3922 Rectangle SplitWindow::GetFadeInRect() const 3923 { 3924 Rectangle aRect; 3925 ImplGetFadeInRect( aRect, sal_True ); 3926 return aRect; 3927 } 3928 3929 // ----------------------------------------------------------------------- 3930 3931 Rectangle SplitWindow::GetFadeOutRect() const 3932 { 3933 Rectangle aRect; 3934 ImplGetFadeOutRect( aRect, sal_True ); 3935 return aRect; 3936 } 3937