?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
build fix: no comphelper/profilezone.hxx in this branch
[LibreOffice.git] / vcl / source / window / splitwin.cxx
blobe1582cd96d1e481fb9d512f2656eeb2f23b443d4
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include <string.h>
21
22 #include <tools/debug.hxx>
23 #include <tools/rcid.h>
24
25 #include <vcl/event.hxx>
26 #include <vcl/wall.hxx>
27 #include <vcl/bitmap.hxx>
28 #include <vcl/decoview.hxx>
29 #include <vcl/image.hxx>
30 #include <vcl/help.hxx>
31 #include <vcl/splitwin.hxx>
32 #include <vcl/settings.hxx>
33
34 #include <rsc/rsc-vcl-shared-types.hxx>
35
36 #include <svdata.hxx>
37 #include <svids.hrc>
38
39
40 #define SPLITWIN_SPLITSIZE 4
41 #define SPLITWIN_SPLITSIZEEX 4
42 #define SPLITWIN_SPLITSIZEEXLN 7
43 #define SPLITWIN_SPLITSIZEAUTOHIDE 72
44 #define SPLITWIN_SPLITSIZEFADE 72
45
46 #define SPLIT_HORZ ((sal_uInt16)0x0001)
47 #define SPLIT_VERT ((sal_uInt16)0x0002)
48 #define SPLIT_WINDOW ((sal_uInt16)0x0004)
49 #define SPLIT_NOSPLIT ((sal_uInt16)0x8000)
50
51 class ImplSplitItem
52 {
53 public:
54 ImplSplitItem();
55 ~ImplSplitItem();
56 void dispose();
57
58 long mnSize;
59 long mnPixSize;
60 long mnLeft;
61 long mnTop;
62 long mnWidth;
63 long mnHeight;
64 long mnSplitPos;
65 long mnSplitSize;
66 long mnOldSplitPos;
67 long mnOldSplitSize;
68 long mnOldWidth;
69 long mnOldHeight;
70 ImplSplitSet* mpSet;
71 VclPtr<vcl::Window> mpWindow;
72 VclPtr<vcl::Window> mpOrgParent;
73 sal_uInt16 mnId;
74 SplitWindowItemFlags mnBits;
75 bool mbFixed;
76 bool mbSubSize;
77 /// Minimal width or height of the item. -1 means no restriction.
78 long mnMinSize;
79 /// Maximal width or height of the item. -1 means no restriction.
80 long mnMaxSize;
81 };
82
83
84 class ImplSplitSet
85 {
86 public:
87 ImplSplitSet();
88 ~ImplSplitSet();
89 void dispose();
90
91 std::vector< ImplSplitItem* > mpItems;
92 Wallpaper* mpWallpaper;
93 Bitmap* mpBitmap;
94 long mnLastSize;
95 long mnSplitSize;
96 sal_uInt16 mnId;
97 bool mbCalcPix;
98 };
99
100 ImplSplitItem::ImplSplitItem()
101 : mnSize(0)
102 , mnPixSize(0)
103 , mnLeft(0)
104 , mnTop(0)
105 , mnWidth(0)
106 , mnHeight(0)
107 , mnSplitPos(0)
108 , mnSplitSize(0)
109 , mnOldSplitPos(0)
110 , mnOldSplitSize(0)
111 , mnOldWidth(0)
112 , mnOldHeight(0)
113 , mpSet(nullptr)
114 , mnId(0)
115 , mnBits(SplitWindowItemFlags::NONE)
116 , mbFixed(false)
117 , mbSubSize(false)
118 , mnMinSize(-1)
119 , mnMaxSize(-1)
120 {
121 }
122
123 ImplSplitItem::~ImplSplitItem()
124 {
125 dispose();
126 }
127
128 void ImplSplitItem::dispose()
129 {
130 if (mpSet) {
131 delete mpSet ;
132 mpSet = nullptr;
133 }
134 mpWindow.clear();
135 mpOrgParent.clear();
136 }
137
138 ImplSplitSet::ImplSplitSet() :
139 mpWallpaper( nullptr ),
140 mpBitmap( nullptr ),
141 mnLastSize( 0 ),
142 mnSplitSize( SPLITWIN_SPLITSIZE ),
143 mnId( 0 ),
144 mbCalcPix( true )
145 {
146 }
147
148 ImplSplitSet::~ImplSplitSet()
149 {
150 dispose();
151 }
152
153 void ImplSplitSet::dispose()
154 {
155 size_t nItems = mpItems.size();
156
157 for ( size_t i = 0; i < nItems; i++ )
158 delete mpItems[i];
159 mpItems.clear();
160
161 if ( mpWallpaper ) {
162 delete mpWallpaper;
163 mpWallpaper = nullptr;
164 }
165
166 if ( mpBitmap ) {
167 delete mpBitmap;
168 mpBitmap = nullptr;
169 }
170 }
171
172 /** Check whether the given size is inside the valid range defined by
173 [rItem.mnMinSize,rItem.mnMaxSize]. When it is not inside it then return
174 the upper or lower bound, respectively. Otherwise return the given size
175 unmodified.
176 Note that either mnMinSize and/or mnMaxSize can be -1 in which case the
177 size has not lower or upper bound.
178 */
179 namespace {
180 long ValidateSize (const long nSize, const ImplSplitItem* pItem)
181 {
182 if (pItem->mnMinSize>=0 && nSize<pItem->mnMinSize)
183 return pItem->mnMinSize;
184 else if (pItem->mnMaxSize>0 && nSize>pItem->mnMaxSize)
185 return pItem->mnMaxSize;
186 else
187 return nSize;
188 }
189 }
190
191 static void ImplCalcBorder( WindowAlign eAlign, bool bNoAlign,
192 long& rLeft, long& rTop,
193 long& rRight, long& rBottom )
194 {
195 if ( bNoAlign )
196 {
197 rLeft = 2;
198 rTop = 2;
199 rRight = 2;
200 rBottom = 2;
201 }
202 else
203 {
204 switch ( eAlign )
205 {
206 case WindowAlign::Top:
207 rLeft = 2;
208 rTop = 2;
209 rRight = 2;
210 rBottom = 0;
211 break;
212 case WindowAlign::Left:
213 rLeft = 0;
214 rTop = 2;
215 rRight = 2;
216 rBottom = 2;
217 break;
218 case WindowAlign::Bottom:
219 rLeft = 2;
220 rTop = 0;
221 rRight = 2;
222 rBottom = 2;
223 break;
224 default:
225 rLeft = 0;
226 rTop = 2;
227 rRight = 2;
228 rBottom = 2;
229 break;
230 }
231 }
232 }
233
234 void SplitWindow::ImplDrawBorder(vcl::RenderContext& rRenderContext)
235 {
236 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
237 long nDX = mnDX;
238 long nDY = mnDY;
239
240 switch (meAlign)
241 {
242 case WindowAlign::Bottom:
243 rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
244 rRenderContext.DrawLine(Point(0, 0), Point(nDX - 1, 0));
245 rRenderContext.DrawLine(Point(0, nDY - 2), Point(nDX - 1, nDY - 2));
246
247 rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
248 rRenderContext.DrawLine(Point(0, 1), Point(nDX - 1, 1));
249 rRenderContext.DrawLine(Point(0, nDY - 1), Point(nDX - 1, nDY - 1));
250 break;
251 case WindowAlign::Top:
252 rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
253 rRenderContext.DrawLine(Point(0, nDY - 2), Point(nDX - 1, nDY - 2));
254 rRenderContext.DrawLine(Point(0, 0), Point(nDX - 1, 0));
255
256 rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
257 rRenderContext.DrawLine(Point(0, nDY - 1), Point(nDX - 1, nDY - 1));
258 rRenderContext.DrawLine(Point(0, 1), Point(nDX - 1, 1));
259 break;
260 case WindowAlign::Left:
261 rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
262 rRenderContext.DrawLine(Point(nDX - 2, 0), Point(nDX - 2, nDY - 2));
263 rRenderContext.DrawLine(Point(0, 0), Point(nDX - 1, 0));
264 rRenderContext.DrawLine(Point(0, nDY - 2), Point(nDX - 2, nDY - 2));
265
266 rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
267 rRenderContext.DrawLine(Point(nDX - 1, 0), Point(nDX - 1, nDY - 1));
268 rRenderContext.DrawLine(Point(0, 1), Point(nDX - 3, 1));
269 rRenderContext.DrawLine(Point(0, nDY - 1), Point(nDX - 2, nDY - 1));
270 break;
271 default:
272 rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
273 rRenderContext.DrawLine(Point(0, 0), Point( 0, nDY - 2));
274 rRenderContext.DrawLine(Point(0, 0), Point( nDX - 1, 0));
275 rRenderContext.DrawLine(Point(0, nDY - 2), Point(nDX - 1, nDY - 2));
276
277 rRenderContext.SetLineColor( rStyleSettings.GetLightColor());
278 rRenderContext.DrawLine(Point(1, 1), Point(1, nDY - 3));
279 rRenderContext.DrawLine(Point(1, 1), Point(nDX - 1, 1));
280 rRenderContext.DrawLine(Point(0, nDY - 1), Point(nDX - 1, nDY - 1));
281 }
282 }
283
284 void SplitWindow::ImplDrawBorderLine(vcl::RenderContext& rRenderContext)
285 {
286 if (mbFadeOut || mbAutoHide)
287 {
288 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
289 long nDX = mnDX;
290 long nDY = mnDY;
291
292 switch (meAlign)
293 {
294 case WindowAlign::Left:
295 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
296 rRenderContext.DrawLine( Point( nDX-SPLITWIN_SPLITSIZEEXLN-1, 1 ), Point( nDX-SPLITWIN_SPLITSIZEEXLN-1, nDY-2 ) );
297
298 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
299 rRenderContext.DrawLine( Point( nDX-SPLITWIN_SPLITSIZEEXLN, 1 ), Point( nDX-SPLITWIN_SPLITSIZEEXLN, nDY-3 ) );
300 break;
301 case WindowAlign::Right:
302 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
303 rRenderContext.DrawLine( Point( SPLITWIN_SPLITSIZEEXLN-1, 0 ), Point( SPLITWIN_SPLITSIZEEXLN-1, nDY-2 ) );
304
305 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
306 rRenderContext.DrawLine( Point( SPLITWIN_SPLITSIZEEXLN, 1 ), Point( SPLITWIN_SPLITSIZEEXLN, nDY-3 ) );
307 break;
308 case WindowAlign::Top:
309 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
310 rRenderContext.DrawLine( Point( 0, nDY-SPLITWIN_SPLITSIZEEXLN-1 ), Point( nDX-1, nDY-SPLITWIN_SPLITSIZEEXLN-1 ) );
311
312 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
313 rRenderContext.DrawLine( Point( 0, nDY-SPLITWIN_SPLITSIZEEXLN ), Point( nDX-1, nDY-SPLITWIN_SPLITSIZEEXLN ) );
314 break;
315 case WindowAlign::Bottom:
316 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
317 rRenderContext.DrawLine( Point( 0, 5 ), Point( nDX-1, 5 ) );
318
319 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
320 rRenderContext.DrawLine( Point( 0, SPLITWIN_SPLITSIZEEXLN ), Point( nDX-1, SPLITWIN_SPLITSIZEEXLN ) );
321 break;
322 }
323 }
324 }
325
326 static ImplSplitSet* ImplFindSet( ImplSplitSet* pSet, sal_uInt16 nId )
327 {
328 if ( pSet->mnId == nId )
329 return pSet;
330
331 sal_uInt16 i;
332 size_t nItems = pSet->mpItems.size();
333 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
334
335 for ( i = 0; i < nItems; i++ )
336 {
337 if ( rItems[i]->mnId == nId )
338 return rItems[i]->mpSet;
339 }
340
341 for ( i = 0; i < nItems; i++ )
342 {
343 if ( rItems[i]->mpSet )
344 {
345 ImplSplitSet* pFindSet = ImplFindSet( rItems[i]->mpSet, nId );
346 if ( pFindSet )
347 return pFindSet;
348 }
349 }
350
351 return nullptr;
352 }
353
354 static ImplSplitSet* ImplFindItem( ImplSplitSet* pSet, sal_uInt16 nId, sal_uInt16& rPos )
355 {
356 sal_uInt16 i;
357 size_t nItems = pSet->mpItems.size();
358 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
359
360 for ( i = 0; i < nItems; i++ )
361 {
362 if ( rItems[i]->mnId == nId )
363 {
364 rPos = i;
365 return pSet;
366 }
367 }
368
369 for ( i = 0; i < nItems; i++ )
370 {
371 if ( rItems[i]->mpSet )
372 {
373 ImplSplitSet* pFindSet = ImplFindItem( rItems[i]->mpSet, nId, rPos );
374 if ( pFindSet )
375 return pFindSet;
376 }
377 }
378
379 return nullptr;
380 }
381
382 static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, vcl::Window* pWindow )
383 {
384 sal_uInt16 i;
385 size_t nItems = pSet->mpItems.size();
386 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
387
388 for ( i = 0; i < nItems; i++ )
389 {
390 if ( rItems[i]->mpWindow == pWindow )
391 return rItems[i]->mnId;
392 else
393 {
394 if ( rItems[i]->mpSet )
395 {
396 sal_uInt16 nId = ImplFindItem( rItems[i]->mpSet, pWindow );
397 if ( nId )
398 return nId;
399 }
400 }
401 }
402
403 return 0;
404 }
405
406 static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, const Point& rPos,
407 bool bRows, bool bDown = true )
408 {
409 sal_uInt16 i;
410 size_t nItems = pSet->mpItems.size();
411 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
412
413 for ( i = 0; i < nItems; i++ )
414 {
415 if ( rItems[i]->mnWidth && rItems[i]->mnHeight )
416 {
417 Point aPoint( rItems[i]->mnLeft, rItems[i]->mnTop );
418 Size aSize( rItems[i]->mnWidth, rItems[i]->mnHeight );
419 Rectangle aRect( aPoint, aSize );
420 if ( bRows )
421 {
422 if ( bDown )
423 aRect.Bottom() += pSet->mnSplitSize;
424 else
425 aRect.Top() -= pSet->mnSplitSize;
426 }
427 else
428 {
429 if ( bDown )
430 aRect.Right() += pSet->mnSplitSize;
431 else
432 aRect.Left() -= pSet->mnSplitSize;
433 }
434
435 if ( aRect.IsInside( rPos ) )
436 {
437 if ( rItems[i]->mpSet && !rItems[i]->mpSet->mpItems.empty() )
438 {
439 return ImplFindItem( rItems[i]->mpSet, rPos,
440 !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
441 }
442 else
443 return rItems[i]->mnId;
444 }
445 }
446 }
447
448 return 0;
449 }
450
451 static void ImplCalcSet( ImplSplitSet* pSet,
452 long nSetLeft, long nSetTop,
453 long nSetWidth, long nSetHeight,
454 bool bRows, bool bDown = true )
455 {
456 if ( pSet->mpItems.empty() )
457 return;
458
459 sal_uInt16 i;
460 sal_uInt16 j;
461 sal_uInt16 nMins;
462 sal_uInt16 nCalcItems;
463 size_t nItems = pSet->mpItems.size();
464 sal_uInt16 nVisItems;
465 sal_uInt16 nAbsItems;
466 long nCalcSize;
467 long nPos;
468 long nMaxPos;
469 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
470 bool bEmpty;
471
472 // get number of visible items
473 nVisItems = 0;
474 for ( i = 0; i < nItems; i++ )
475 {
476 if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
477 nVisItems++;
478 }
479
480 // calculate sizes
481 if ( bRows )
482 nCalcSize = nSetHeight;
483 else
484 nCalcSize = nSetWidth;
485 nCalcSize -= (nVisItems-1)*pSet->mnSplitSize;
486 if ( pSet->mbCalcPix || (pSet->mnLastSize != nCalcSize) )
487 {
488 long nPercentFactor = 10;
489 long nRelCount = 0;
490 long nPercent = 0;
491 long nRelPercent = 0;
492 long nAbsSize = 0;
493 long nCurSize = 0;
494 for ( i = 0; i < nItems; i++ )
495 {
496 if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
497 {
498 if ( rItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
499 nRelCount += rItems[i]->mnSize;
500 else if ( rItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
501 nPercent += rItems[i]->mnSize;
502 else
503 nAbsSize += rItems[i]->mnSize;
504 }
505 }
506 // map relative values to percentages (percentage here one tenth of a procent)
507 nPercent *= nPercentFactor;
508 if ( nRelCount )
509 {
510 long nRelPercentBase = 1000;
511 while ( (nRelCount > nRelPercentBase) && (nPercentFactor < 100000) )
512 {
513 nRelPercentBase *= 10;
514 nPercentFactor *= 10;
515 }
516 if ( nPercent < nRelPercentBase )
517 {
518 nRelPercent = (nRelPercentBase-nPercent)/nRelCount;
519 nPercent += nRelPercent*nRelCount;
520 }
521 else
522 nRelPercent = 0;
523 }
524 if ( !nPercent )
525 nPercent = 1;
526 long nSizeDelta = nCalcSize-nAbsSize;
527 for ( i = 0; i < nItems; i++ )
528 {
529 if ( rItems[i]->mnBits & SplitWindowItemFlags::Invisible )
530 rItems[i]->mnPixSize = 0;
531 else if ( rItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
532 {
533 if ( nSizeDelta <= 0 )
534 rItems[i]->mnPixSize = 0;
535 else
536 rItems[i]->mnPixSize = (nSizeDelta*rItems[i]->mnSize*nRelPercent)/nPercent;
537 }
538 else if ( rItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
539 {
540 if ( nSizeDelta <= 0 )
541 rItems[i]->mnPixSize = 0;
542 else
543 rItems[i]->mnPixSize = (nSizeDelta*rItems[i]->mnSize*nPercentFactor)/nPercent;
544 }
545 else
546 rItems[i]->mnPixSize = rItems[i]->mnSize;
547 nCurSize += rItems[i]->mnPixSize;
548 }
549
550 pSet->mbCalcPix = false;
551 pSet->mnLastSize = nCalcSize;
552
553 // adapt window
554 nSizeDelta = nCalcSize-nCurSize;
555 if ( nSizeDelta )
556 {
557 nAbsItems = 0;
558 long nSizeWinSize = 0;
559
560 // first resize absolute items relative
561 for ( i = 0; i < nItems; i++ )
562 {
563 if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
564 {
565 if ( !(rItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
566 {
567 nAbsItems++;
568 nSizeWinSize += rItems[i]->mnPixSize;
569 }
570 }
571 }
572 // do not compensate rounding errors here
573 if ( (nAbsItems < (sal_uInt16)(std::abs( nSizeDelta ))) && nSizeWinSize )
574 {
575 long nNewSizeWinSize = 0;
576
577 for ( i = 0; i < nItems; i++ )
578 {
579 if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
580 {
581 if ( !(rItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
582 {
583 rItems[i]->mnPixSize += (nSizeDelta*rItems[i]->mnPixSize)/nSizeWinSize;
584 nNewSizeWinSize += rItems[i]->mnPixSize;
585 }
586 }
587 }
588
589 nSizeDelta -= nNewSizeWinSize-nSizeWinSize;
590 }
591
592 // compensate rounding errors now
593 j = 0;
594 nMins = 0;
595 while ( nSizeDelta && (nItems != nMins) )
596 {
597 // determine which items we can calculate
598 nCalcItems = 0;
599 while ( !nCalcItems )
600 {
601 for ( i = 0; i < nItems; i++ )
602 {
603 rItems[i]->mbSubSize = false;
604
605 if ( j >= 2 )
606 rItems[i]->mbSubSize = true;
607 else
608 {
609 if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
610 {
611 if ( (nSizeDelta > 0) || rItems[i]->mnPixSize )
612 {
613 if ( j >= 1 )
614 rItems[i]->mbSubSize = true;
615 else
616 {
617 if ( (j == 0) && (rItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize)) )
618 rItems[i]->mbSubSize = true;
619 }
620 }
621 }
622 }
623
624 if ( rItems[i]->mbSubSize )
625 nCalcItems++;
626 }
627
628 j++;
629 }
630
631 // subtract size of individual items
632 long nErrorSum = nSizeDelta % nCalcItems;
633 long nCurSizeDelta = nSizeDelta / nCalcItems;
634 nMins = 0;
635 for ( i = 0; i < nItems; i++ )
636 {
637 if ( rItems[i]->mnBits & SplitWindowItemFlags::Invisible )
638 nMins++;
639 else if ( rItems[i]->mbSubSize )
640 {
641 long* pSize = &(rItems[i]->mnPixSize);
642 long nTempErr;
643
644 if ( nErrorSum )
645 {
646 if ( nErrorSum < 0 )
647 nTempErr = -1;
648 else
649 nTempErr = 1;
650 }
651 else
652 nTempErr = 0;
653
654 if ( (*pSize+nCurSizeDelta+nTempErr) <= 0 )
655 {
656 long nTemp = *pSize;
657 if ( nTemp )
658 {
659 *pSize -= nTemp;
660 nSizeDelta += nTemp;
661 }
662 nMins++;
663 }
664 else
665 {
666 *pSize += nCurSizeDelta;
667 nSizeDelta -= nCurSizeDelta;
668 if ( nTempErr && (*pSize || (nTempErr > 0)) )
669 {
670 *pSize += nTempErr;
671 nSizeDelta -= nTempErr;
672 nErrorSum -= nTempErr;
673 }
674 }
675 }
676 }
677 }
678 }
679 }
680
681 // calculate maximum size
682 if ( bRows )
683 {
684 nPos = nSetTop;
685 if ( !bDown )
686 nMaxPos = nSetTop-nSetHeight;
687 else
688 nMaxPos = nSetTop+nSetHeight;
689 }
690 else
691 {
692 nPos = nSetLeft;
693 if ( !bDown )
694 nMaxPos = nSetLeft-nSetWidth;
695 else
696 nMaxPos = nSetLeft+nSetWidth;
697 }
698
699 // order windows and adept values
700 for ( i = 0; i < nItems; i++ )
701 {
702 rItems[i]->mnOldSplitPos = rItems[i]->mnSplitPos;
703 rItems[i]->mnOldSplitSize = rItems[i]->mnSplitSize;
704 rItems[i]->mnOldWidth = rItems[i]->mnWidth;
705 rItems[i]->mnOldHeight = rItems[i]->mnHeight;
706
707 if ( rItems[i]->mnBits & SplitWindowItemFlags::Invisible )
708 bEmpty = true;
709 else
710 {
711 bEmpty = false;
712 if ( bDown )
713 {
714 if ( nPos+rItems[i]->mnPixSize > nMaxPos )
715 bEmpty = true;
716 }
717 else
718 {
719 nPos -= rItems[i]->mnPixSize;
720 if ( nPos < nMaxPos )
721 bEmpty = true;
722 }
723 }
724
725 if ( bEmpty )
726 {
727 rItems[i]->mnWidth = 0;
728 rItems[i]->mnHeight = 0;
729 rItems[i]->mnSplitSize = 0;
730 }
731 else
732 {
733 if ( bRows )
734 {
735 rItems[i]->mnLeft = nSetLeft;
736 rItems[i]->mnTop = nPos;
737 rItems[i]->mnWidth = nSetWidth;
738 rItems[i]->mnHeight = rItems[i]->mnPixSize;
739 }
740 else
741 {
742 rItems[i]->mnLeft = nPos;
743 rItems[i]->mnTop = nSetTop;
744 rItems[i]->mnWidth = rItems[i]->mnPixSize;
745 rItems[i]->mnHeight = nSetHeight;
746 }
747
748 if ( i > nItems-1 )
749 rItems[i]->mnSplitSize = 0;
750 else
751 {
752 rItems[i]->mnSplitSize = pSet->mnSplitSize;
753 if ( bDown )
754 {
755 rItems[i]->mnSplitPos = nPos+rItems[i]->mnPixSize;
756 if ( rItems[i]->mnSplitPos+rItems[i]->mnSplitSize > nMaxPos )
757 rItems[i]->mnSplitSize = nMaxPos-rItems[i]->mnSplitPos;
758 }
759 else
760 {
761 rItems[i]->mnSplitPos = nPos-pSet->mnSplitSize;
762 if ( rItems[i]->mnSplitPos < nMaxPos )
763 rItems[i]->mnSplitSize = rItems[i]->mnSplitPos+pSet->mnSplitSize-nMaxPos;
764 }
765 }
766 }
767
768 if ( !(rItems[i]->mnBits & SplitWindowItemFlags::Invisible) )
769 {
770 if ( !bDown )
771 nPos -= pSet->mnSplitSize;
772 else
773 nPos += rItems[i]->mnPixSize+pSet->mnSplitSize;
774 }
775 }
776
777 // calculate Sub-Set's
778 for ( i = 0; i < nItems; i++ )
779 {
780 if ( rItems[i]->mpSet && rItems[i]->mnWidth && rItems[i]->mnHeight )
781 {
782 ImplCalcSet( rItems[i]->mpSet,
783 rItems[i]->mnLeft, rItems[i]->mnTop,
784 rItems[i]->mnWidth, rItems[i]->mnHeight,
785 !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
786 }
787 }
788
789 // set fixed
790 for ( i = 0; i < nItems; i++ )
791 {
792 rItems[i]->mbFixed = false;
793 if ( rItems[i]->mnBits & SplitWindowItemFlags::Fixed )
794 rItems[i]->mbFixed = true;
795 else
796 {
797 // this item is also fixed if Child-Set is available,
798 // if a child is fixed
799 if ( rItems[i]->mpSet )
800 {
801 for ( j = 0; j < rItems[i]->mpSet->mpItems.size(); j++ )
802 {
803 if ( rItems[i]->mpSet->mpItems[j]->mbFixed )
804 {
805 rItems[i]->mbFixed = true;
806 break;
807 }
808 }
809 }
810 }
811 }
812 }
813
814 void SplitWindow::ImplCalcSet2( SplitWindow* pWindow, ImplSplitSet* pSet, bool bHide,
815 bool bRows, bool /*bDown*/ )
816 {
817 sal_uInt16 i;
818 size_t nItems = pSet->mpItems.size();
819 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
820
821 if ( pWindow->IsReallyVisible() && pWindow->IsUpdateMode() && pWindow->mbInvalidate )
822 {
823 for ( i = 0; i < nItems; i++ )
824 {
825 if ( rItems[i]->mnSplitSize )
826 {
827 // invalidate all, if applicable or only a small part
828 if ( (rItems[i]->mnOldSplitPos != rItems[i]->mnSplitPos) ||
829 (rItems[i]->mnOldSplitSize != rItems[i]->mnSplitSize) ||
830 (rItems[i]->mnOldWidth != rItems[i]->mnWidth) ||
831 (rItems[i]->mnOldHeight != rItems[i]->mnHeight) )
832 {
833 Rectangle aRect;
834
835 // invalidate old rectangle
836 if ( bRows )
837 {
838 aRect.Left() = rItems[i]->mnLeft;
839 aRect.Right() = rItems[i]->mnLeft+rItems[i]->mnOldWidth-1;
840 aRect.Top() = rItems[i]->mnOldSplitPos;
841 aRect.Bottom() = aRect.Top() + rItems[i]->mnOldSplitSize;
842 }
843 else
844 {
845 aRect.Top() = rItems[i]->mnTop;
846 aRect.Bottom() = rItems[i]->mnTop+rItems[i]->mnOldHeight-1;
847 aRect.Left() = rItems[i]->mnOldSplitPos;
848 aRect.Right() = aRect.Left() + rItems[i]->mnOldSplitSize;
849 }
850 pWindow->Invalidate( aRect );
851 // invalidate new rectangle
852 if ( bRows )
853 {
854 aRect.Left() = rItems[i]->mnLeft;
855 aRect.Right() = rItems[i]->mnLeft+rItems[i]->mnWidth-1;
856 aRect.Top() = rItems[i]->mnSplitPos;
857 aRect.Bottom() = aRect.Top() + rItems[i]->mnSplitSize;
858 }
859 else
860 {
861 aRect.Top() = rItems[i]->mnTop;
862 aRect.Bottom() = rItems[i]->mnTop+rItems[i]->mnHeight-1;
863 aRect.Left() = rItems[i]->mnSplitPos;
864 aRect.Right() = aRect.Left() + rItems[i]->mnSplitSize;
865 }
866 pWindow->Invalidate( aRect );
867
868 // invalidate complete set, as these areas
869 // are not cluttered by windows
870 if ( rItems[i]->mpSet && rItems[i]->mpSet->mpItems.empty() )
871 {
872 aRect.Left() = rItems[i]->mnLeft;
873 aRect.Top() = rItems[i]->mnTop;
874 aRect.Right() = rItems[i]->mnLeft+rItems[i]->mnWidth-1;
875 aRect.Bottom() = rItems[i]->mnTop+rItems[i]->mnHeight-1;
876 pWindow->Invalidate( aRect );
877 }
878 }
879 }
880 }
881 }
882
883 // position windows
884 for ( i = 0; i < nItems; i++ )
885 {
886 if ( rItems[i]->mpSet )
887 {
888 bool bTempHide = bHide;
889 if ( !rItems[i]->mnWidth || !rItems[i]->mnHeight )
890 bTempHide = true;
891 ImplCalcSet2( pWindow, rItems[i]->mpSet, bTempHide,
892 !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
893 }
894 else
895 {
896 if ( rItems[i]->mnWidth && rItems[i]->mnHeight && !bHide )
897 {
898 Point aPos( rItems[i]->mnLeft, rItems[i]->mnTop );
899 Size aSize( rItems[i]->mnWidth, rItems[i]->mnHeight );
900 rItems[i]->mpWindow->SetPosSizePixel( aPos, aSize );
901 }
902 else
903 rItems[i]->mpWindow->Hide();
904 }
905 }
906
907 // show windows and reset flag
908 for ( i = 0; i < nItems; i++ )
909 {
910 if ( rItems[i]->mpWindow && rItems[i]->mnWidth && rItems[i]->mnHeight && !bHide )
911 rItems[i]->mpWindow->Show();
912 }
913 }
914
915 static void ImplCalcLogSize( std::vector< ImplSplitItem* > rItems, size_t nItems )
916 {
917 // update original sizes
918 size_t i;
919 long nRelSize = 0;
920 long nPerSize = 0;
921
922 for ( i = 0; i < nItems; i++ )
923 {
924 if ( rItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
925 nRelSize += rItems[i]->mnPixSize;
926 else if ( rItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
927 nPerSize += rItems[i]->mnPixSize;
928 }
929 nPerSize += nRelSize;
930 for ( i = 0; i < nItems; i++ )
931 {
932 if ( rItems[i]->mnBits & SplitWindowItemFlags::RelativeSize )
933 {
934 if ( nRelSize )
935 rItems[i]->mnSize = (rItems[i]->mnPixSize+(nRelSize/2))/nRelSize;
936 else
937 rItems[i]->mnSize = 1;
938 }
939 else if ( rItems[i]->mnBits & SplitWindowItemFlags::PercentSize )
940 {
941 if ( nPerSize )
942 rItems[i]->mnSize = (rItems[i]->mnPixSize*100)/nPerSize;
943 else
944 rItems[i]->mnSize = 1;
945 }
946 else
947 rItems[i]->mnSize = rItems[i]->mnPixSize;
948 }
949 }
950
951 void SplitWindow::ImplDrawBack(vcl::RenderContext& rRenderContext, const Rectangle& rRect,
952 const Wallpaper* pWall, const Bitmap* pBitmap)
953 {
954 if (pBitmap)
955 {
956 Point aPos = rRect.TopLeft();
957 Size aBmpSize = pBitmap->GetSizePixel();
958 rRenderContext.Push(PushFlags::CLIPREGION);
959 rRenderContext.IntersectClipRegion(rRect);
960 do
961 {
962 aPos.X() = rRect.Left();
963 do
964 {
965 rRenderContext.DrawBitmap(aPos, *pBitmap);
966 aPos.X() += aBmpSize.Width();
967 }
968 while (aPos.X() < rRect.Right());
969 aPos.Y() += aBmpSize.Height();
970 }
971 while (aPos.Y() < rRect.Bottom());
972 rRenderContext.Pop();
973 }
974 else
975 {
976 rRenderContext.DrawWallpaper(rRect, *pWall);
977 }
978 }
979
980 void SplitWindow::ImplDrawBack(vcl::RenderContext& rRenderContext, ImplSplitSet* pSet)
981 {
982 sal_uInt16 i;
983 size_t nItems = pSet->mpItems.size();
984 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
985
986 // also draw background for mainset
987 if (pSet->mnId == 0)
988 {
989 if (pSet->mpBitmap)
990 {
991 Rectangle aRect(mnLeftBorder, mnTopBorder,
992 mnDX - mnRightBorder - 1,
993 mnDY - mnBottomBorder - 1);
994
995 ImplDrawBack(rRenderContext, aRect, pSet->mpWallpaper, pSet->mpBitmap);
996 }
997 }
998
999 for (i = 0; i < nItems; i++)
1000 {
1001 pSet = rItems[i]->mpSet;
1002 if (pSet)
1003 {
1004 if (pSet->mpBitmap || pSet->mpWallpaper)
1005 {
1006 Point aPoint(rItems[i]->mnLeft, rItems[i]->mnTop);
1007 Size aSize(rItems[i]->mnWidth, rItems[i]->mnHeight);
1008 Rectangle aRect(aPoint, aSize);
1009 ImplDrawBack(rRenderContext, aRect, pSet->mpWallpaper, pSet->mpBitmap);
1010 }
1011 }
1012 }
1013
1014 for (i = 0; i < nItems; i++)
1015 {
1016 if (rItems[i]->mpSet)
1017 ImplDrawBack(rRenderContext, rItems[i]->mpSet);
1018 }
1019 }
1020
1021 static void ImplDrawSplit(vcl::RenderContext& rRenderContext, ImplSplitSet* pSet, bool bRows, bool bFlat, bool bDown = true)
1022 {
1023 if (pSet->mpItems.empty())
1024 return;
1025
1026 sal_uInt16 i;
1027 size_t nItems = pSet->mpItems.size();
1028 long nPos;
1029 long nTop;
1030 long nBottom;
1031 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
1032 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1033
1034 for (i = 0; i < nItems-1; i++)
1035 {
1036 if (rItems[i]->mnSplitSize)
1037 {
1038 nPos = rItems[i]->mnSplitPos;
1039
1040 long nItemSplitSize = rItems[i]->mnSplitSize;
1041 long nSplitSize = pSet->mnSplitSize;
1042 if (bRows)
1043 {
1044 nTop = rItems[i]->mnLeft;
1045 nBottom = rItems[i]->mnLeft+rItems[i]->mnWidth-1;
1046
1047 if (bFlat)
1048 nPos--;
1049
1050 if (bDown || (nItemSplitSize >= nSplitSize))
1051 {
1052 rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
1053 rRenderContext.DrawLine(Point(nTop, nPos + 1), Point(nBottom, nPos + 1));
1054 }
1055 nPos += nSplitSize-2;
1056 if (bFlat)
1057 nPos+=2;
1058 if ((!bDown && (nItemSplitSize >= 2)) ||
1059 (bDown && (nItemSplitSize >= nSplitSize - 1)))
1060 {
1061 rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
1062 rRenderContext.DrawLine(Point(nTop, nPos), Point(nBottom, nPos));
1063 }
1064 if (!bFlat)
1065 {
1066 nPos++;
1067 if (!bDown || (nItemSplitSize >= nSplitSize))
1068 {
1069 rRenderContext.SetLineColor(rStyleSettings.GetDarkShadowColor());
1070 rRenderContext.DrawLine(Point(nTop, nPos), Point(nBottom, nPos));
1071 }
1072 }
1073 }
1074 else
1075 {
1076 nTop = rItems[i]->mnTop;
1077 nBottom = rItems[i]->mnTop+pSet->mpItems[i]->mnHeight-1;
1078
1079 if (bFlat)
1080 nPos--;
1081 if (bDown || (nItemSplitSize >= nSplitSize))
1082 {
1083 rRenderContext.SetLineColor(rStyleSettings.GetLightColor());
1084 rRenderContext.DrawLine(Point(nPos + 1, nTop), Point(nPos+1, nBottom));
1085 }
1086 nPos += pSet->mnSplitSize - 2;
1087 if (bFlat)
1088 nPos += 2;
1089 if ((!bDown && (nItemSplitSize >= 2)) ||
1090 (bDown && (nItemSplitSize >= nSplitSize - 1)))
1091 {
1092 rRenderContext.SetLineColor(rStyleSettings.GetShadowColor());
1093 rRenderContext.DrawLine(Point(nPos, nTop), Point(nPos, nBottom));
1094 }
1095 if( !bFlat )
1096 {
1097 nPos++;
1098 if (!bDown || (nItemSplitSize >= nSplitSize))
1099 {
1100 rRenderContext.SetLineColor(rStyleSettings.GetDarkShadowColor());
1101 rRenderContext.DrawLine(Point(nPos, nTop), Point(nPos, nBottom));
1102 }
1103 }
1104 }
1105 }
1106 }
1107
1108 for (i = 0; i < nItems; i++)
1109 {
1110 if (rItems[i]->mpSet && rItems[i]->mnWidth && rItems[i]->mnHeight)
1111 {
1112 ImplDrawSplit(rRenderContext, rItems[i]->mpSet, !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet), bFlat);
1113 }
1114 }
1115 }
1116
1117 sal_uInt16 SplitWindow::ImplTestSplit( ImplSplitSet* pSet, const Point& rPos,
1118 long& rMouseOff, ImplSplitSet** ppFoundSet, sal_uInt16& rFoundPos,
1119 bool bRows, bool /*bDown*/ )
1120 {
1121 if ( pSet->mpItems.empty() )
1122 return 0;
1123
1124 sal_uInt16 i;
1125 sal_uInt16 nSplitTest;
1126 size_t nItems = pSet->mpItems.size();
1127 long nMPos1;
1128 long nMPos2;
1129 long nPos;
1130 long nTop;
1131 long nBottom;
1132 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
1133
1134 if ( bRows )
1135 {
1136 nMPos1 = rPos.X();
1137 nMPos2 = rPos.Y();
1138 }
1139 else
1140 {
1141 nMPos1 = rPos.Y();
1142 nMPos2 = rPos.X();
1143 }
1144
1145 for ( i = 0; i < nItems-1; i++ )
1146 {
1147 if ( rItems[i]->mnSplitSize )
1148 {
1149 if ( bRows )
1150 {
1151 nTop = rItems[i]->mnLeft;
1152 nBottom = rItems[i]->mnLeft+rItems[i]->mnWidth-1;
1153 }
1154 else
1155 {
1156 nTop = rItems[i]->mnTop;
1157 nBottom = rItems[i]->mnTop+rItems[i]->mnHeight-1;
1158 }
1159 nPos = rItems[i]->mnSplitPos;
1160
1161 if ( (nMPos1 >= nTop) && (nMPos1 <= nBottom) &&
1162 (nMPos2 >= nPos) && (nMPos2 <= nPos+rItems[i]->mnSplitSize) )
1163 {
1164 if ( !rItems[i]->mbFixed && !rItems[i+1]->mbFixed )
1165 {
1166 rMouseOff = nMPos2-nPos;
1167 *ppFoundSet = pSet;
1168 rFoundPos = i;
1169 if ( bRows )
1170 return SPLIT_VERT;
1171 else
1172 return SPLIT_HORZ;
1173 }
1174 else
1175 return SPLIT_NOSPLIT;
1176 }
1177 }
1178 }
1179
1180 for ( i = 0; i < nItems; i++ )
1181 {
1182 if ( rItems[i]->mpSet )
1183 {
1184 nSplitTest = ImplTestSplit( rItems[i]->mpSet, rPos,
1185 rMouseOff, ppFoundSet, rFoundPos,
1186 !(rItems[i]->mnBits & SplitWindowItemFlags::ColSet) );
1187 if ( nSplitTest )
1188 return nSplitTest;
1189 }
1190 }
1191
1192 return 0;
1193 }
1194
1195 sal_uInt16 SplitWindow::ImplTestSplit( SplitWindow* pWindow, const Point& rPos,
1196 long& rMouseOff, ImplSplitSet** ppFoundSet, sal_uInt16& rFoundPos )
1197 {
1198 // Resizable SplitWindow should be treated different
1199 if ( pWindow->mnWinStyle & WB_SIZEABLE )
1200 {
1201 long nTPos;
1202 long nPos;
1203 long nBorder;
1204
1205 if ( pWindow->mbHorz )
1206 {
1207 if ( pWindow->mbBottomRight )
1208 {
1209 nBorder = pWindow->mnBottomBorder;
1210 nPos = 0;
1211 }
1212 else
1213 {
1214 nBorder = pWindow->mnTopBorder;
1215 nPos = pWindow->mnDY-nBorder;
1216 }
1217 nTPos = rPos.Y();
1218 }
1219 else
1220 {
1221 if ( pWindow->mbBottomRight )
1222 {
1223 nBorder = pWindow->mnRightBorder;
1224 nPos = 0;
1225 }
1226 else
1227 {
1228 nBorder = pWindow->mnLeftBorder;
1229 nPos = pWindow->mnDX-nBorder;
1230 }
1231 nTPos = rPos.X();
1232 }
1233 long nSplitSize = pWindow->mpMainSet->mnSplitSize-2;
1234 if ( pWindow->mbAutoHide || pWindow->mbFadeOut )
1235 nSplitSize += SPLITWIN_SPLITSIZEEXLN;
1236 if ( !pWindow->mbBottomRight )
1237 nPos -= nSplitSize;
1238 if ( (nTPos >= nPos) && (nTPos <= nPos+nSplitSize+nBorder) )
1239 {
1240 rMouseOff = nTPos-nPos;
1241 *ppFoundSet = pWindow->mpMainSet;
1242 if ( !pWindow->mpMainSet->mpItems.empty() )
1243 rFoundPos = pWindow->mpMainSet->mpItems.size() - 1;
1244 else
1245 rFoundPos = 0;
1246 if ( pWindow->mbHorz )
1247 return SPLIT_VERT | SPLIT_WINDOW;
1248 else
1249 return SPLIT_HORZ | SPLIT_WINDOW;
1250 }
1251 }
1252
1253 return ImplTestSplit( pWindow->mpMainSet, rPos, rMouseOff, ppFoundSet, rFoundPos,
1254 pWindow->mbHorz, !pWindow->mbBottomRight );
1255 }
1256
1257 void SplitWindow::ImplDrawSplitTracking(const Point& rPos)
1258 {
1259 Rectangle aRect;
1260
1261 if (mnSplitTest & SPLIT_HORZ)
1262 {
1263 aRect.Top() = maDragRect.Top();
1264 aRect.Bottom() = maDragRect.Bottom();
1265 aRect.Left() = rPos.X();
1266 aRect.Right() = aRect.Left() + mpSplitSet->mnSplitSize - 1;
1267 if (!(mnWinStyle & WB_NOSPLITDRAW))
1268 aRect.Right()--;
1269 if ((mnSplitTest & SPLIT_WINDOW) && (mbAutoHide || mbFadeOut))
1270 {
1271 aRect.Left() += SPLITWIN_SPLITSIZEEXLN;
1272 aRect.Right() += SPLITWIN_SPLITSIZEEXLN;
1273 }
1274 }
1275 else
1276 {
1277 aRect.Left() = maDragRect.Left();
1278 aRect.Right() = maDragRect.Right();
1279 aRect.Top() = rPos.Y();
1280 aRect.Bottom() = aRect.Top() + mpSplitSet->mnSplitSize - 1;
1281 if (!(mnWinStyle & WB_NOSPLITDRAW))
1282 aRect.Bottom()--;
1283 if ((mnSplitTest & SPLIT_WINDOW) && (mbAutoHide || mbFadeOut))
1284 {
1285 aRect.Top() += SPLITWIN_SPLITSIZEEXLN;
1286 aRect.Bottom() += SPLITWIN_SPLITSIZEEXLN;
1287 }
1288 }
1289 ShowTracking(aRect, ShowTrackFlags::Split);
1290 }
1291
1292 void SplitWindow::ImplInit( vcl::Window* pParent, WinBits nStyle )
1293 {
1294 ImplSplitSet* pNewSet = new ImplSplitSet();
1295
1296 mpMainSet = pNewSet;
1297 mpBaseSet = pNewSet;
1298 mpSplitSet = nullptr;
1299 mpLastSizes = nullptr;
1300 mnDX = 0;
1301 mnDY = 0;
1302 mnLeftBorder = 0;
1303 mnTopBorder = 0;
1304 mnRightBorder = 0;
1305 mnBottomBorder = 0;
1306 mnMaxSize = 0;
1307 mnMouseOff = 0;
1308 meAlign = WindowAlign::Top;
1309 mnWinStyle = nStyle;
1310 mnSplitTest = 0;
1311 mnSplitPos = 0;
1312 mnMouseModifier = 0;
1313 mnMStartPos = 0;
1314 mnMSplitPos = 0;
1315 mbDragFull = false;
1316 mbHorz = true;
1317 mbBottomRight = false;
1318 mbCalc = false;
1319 mbRecalc = true;
1320 mbInvalidate = true;
1321 mbAutoHide = false;
1322 mbFadeIn = false;
1323 mbFadeOut = false;
1324 mbAutoHideIn = false;
1325 mbAutoHideDown = false;
1326 mbFadeInDown = false;
1327 mbFadeOutDown = false;
1328 mbAutoHidePressed = false;
1329 mbFadeInPressed = false;
1330 mbFadeOutPressed = false;
1331 mbFadeNoButtonMode = false;
1332
1333 if ( nStyle & WB_NOSPLITDRAW )
1334 {
1335 pNewSet->mnSplitSize -= 2;
1336 mbInvalidate = false;
1337 }
1338
1339 if ( nStyle & WB_BORDER )
1340 {
1341 ImplCalcBorder( meAlign, false/*bNoAlign*/, mnLeftBorder, mnTopBorder,
1342 mnRightBorder, mnBottomBorder );
1343 }
1344 else
1345 {
1346 mnLeftBorder = 0;
1347 mnTopBorder = 0;
1348 mnRightBorder = 0;
1349 mnBottomBorder = 0;
1350 }
1351
1352 DockingWindow::ImplInit( pParent, (nStyle | WB_CLIPCHILDREN) & ~(WB_BORDER | WB_SIZEABLE) );
1353
1354 ImplInitSettings();
1355 }
1356
1357 void SplitWindow::ImplInitSettings()
1358 {
1359 // If a bitmap was set for MainSet, we should not delete the background.
1360 // If MainSet has a Wallpaper, this is the background,
1361 // otherwise it is the standard colour
1362 if ( mpMainSet->mpBitmap )
1363 SetBackground();
1364 else if ( mpMainSet->mpWallpaper )
1365 SetBackground( *mpMainSet->mpWallpaper );
1366 else
1367 {
1368 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1369
1370 Color aColor;
1371 if ( IsControlBackground() )
1372 aColor = GetControlBackground();
1373 else if ( Window::GetStyle() & WB_3DLOOK )
1374 aColor = rStyleSettings.GetFaceColor();
1375 else
1376 aColor = rStyleSettings.GetWindowColor();
1377 SetBackground( aColor );
1378 }
1379 }
1380
1381 SplitWindow::SplitWindow( vcl::Window* pParent, WinBits nStyle ) :
1382 DockingWindow( WINDOW_SPLITWINDOW )
1383 {
1384 ImplInit( pParent, nStyle );
1385 DockingWindow::SetIdleDebugName( "vcl::SplitWindow maLayoutIdle" );
1386 }
1387
1388 SplitWindow::~SplitWindow()
1389 {
1390 disposeOnce();
1391 }
1392
1393 void SplitWindow::dispose()
1394 {
1395 // delete Sets
1396 if (mpMainSet) {
1397 delete mpMainSet ;
1398 mpMainSet = nullptr; //NULL for base-class callbacks during destruction
1399 }
1400 DockingWindow::dispose();
1401 }
1402
1403 void SplitWindow::ImplSetWindowSize( long nDelta )
1404 {
1405 if ( !nDelta )
1406 return;
1407
1408 Size aSize = GetSizePixel();
1409 switch ( meAlign )
1410 {
1411 case WindowAlign::Top:
1412 aSize.Height() += nDelta;
1413 SetSizePixel( aSize );
1414 break;
1415 case WindowAlign::Bottom:
1416 {
1417 maDragRect.Top() += nDelta;
1418 Point aPos = GetPosPixel();
1419 aPos.Y() -= nDelta;
1420 aSize.Height() += nDelta;
1421 SetPosSizePixel( aPos, aSize );
1422 break;
1423 }
1424 case WindowAlign::Left:
1425 aSize.Width() += nDelta;
1426 SetSizePixel( aSize );
1427 break;
1428 case WindowAlign::Right:
1429 default:
1430 {
1431 maDragRect.Left() += nDelta;
1432 Point aPos = GetPosPixel();
1433 aPos.X() -= nDelta;
1434 aSize.Width() += nDelta;
1435 SetPosSizePixel( aPos, aSize );
1436 break;
1437 }
1438 }
1439
1440 SplitResize();
1441 }
1442
1443 Size SplitWindow::CalcLayoutSizePixel( const Size& aNewSize )
1444 {
1445 Size aSize( aNewSize );
1446 long nSplitSize = mpMainSet->mnSplitSize-2;
1447
1448 if ( mbAutoHide || mbFadeOut )
1449 nSplitSize += SPLITWIN_SPLITSIZEEXLN;
1450
1451 // if the window is sizeable and if it does not contain a relative window,
1452 // the size is determined according to MainSet
1453 if ( mnWinStyle & WB_SIZEABLE )
1454 {
1455 long nCalcSize = 0;
1456 sal_uInt16 i;
1457
1458 for ( i = 0; i < mpMainSet->mpItems.size(); i++ )
1459 {
1460 if ( mpMainSet->mpItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize) )
1461 break;
1462 else
1463 nCalcSize += mpMainSet->mpItems[i]->mnSize;
1464 }
1465
1466 if ( i == mpMainSet->mpItems.size() )
1467 {
1468 long nDelta = 0;
1469 Point aPos = GetPosPixel();
1470 long nCurSize;
1471
1472 if ( mbHorz )
1473 nCurSize = aNewSize.Height()-mnTopBorder-mnBottomBorder;
1474 else
1475 nCurSize = aNewSize.Width()-mnLeftBorder-mnRightBorder;
1476 nCurSize -= nSplitSize;
1477 nCurSize -= (mpMainSet->mpItems.size()-1)*mpMainSet->mnSplitSize;
1478
1479 nDelta = nCalcSize-nCurSize;
1480 if ( !nDelta )
1481 return aSize;
1482
1483 switch ( meAlign )
1484 {
1485 case WindowAlign::Top:
1486 aSize.Height() += nDelta;
1487 break;
1488 case WindowAlign::Bottom:
1489 aPos.Y() -= nDelta;
1490 aSize.Height() += nDelta;
1491 break;
1492 case WindowAlign::Left:
1493 aSize.Width() += nDelta;
1494 break;
1495 case WindowAlign::Right:
1496 default:
1497 aPos.X() -= nDelta;
1498 aSize.Width() += nDelta;
1499 break;
1500 }
1501 }
1502 }
1503
1504 return aSize;
1505 }
1506
1507 void SplitWindow::ImplCalcLayout()
1508 {
1509 if ( !mbCalc || !mbRecalc || mpMainSet->mpItems.empty() )
1510 return;
1511
1512 long nSplitSize = mpMainSet->mnSplitSize-2;
1513 if ( mbAutoHide || mbFadeOut )
1514 nSplitSize += SPLITWIN_SPLITSIZEEXLN;
1515
1516 // if the window is sizeable and if it does not contain a relative window,
1517 // the size is determined according to MainSet
1518 if ( mnWinStyle & WB_SIZEABLE )
1519 {
1520 long nCalcSize = 0;
1521 sal_uInt16 i;
1522
1523 for ( i = 0; i < mpMainSet->mpItems.size(); i++ )
1524 {
1525 if ( mpMainSet->mpItems[i]->mnBits & (SplitWindowItemFlags::RelativeSize | SplitWindowItemFlags::PercentSize) )
1526 break;
1527 else
1528 nCalcSize += mpMainSet->mpItems[i]->mnSize;
1529 }
1530
1531 if ( i == mpMainSet->mpItems.size() )
1532 {
1533 long nCurSize;
1534 if ( mbHorz )
1535 nCurSize = mnDY-mnTopBorder-mnBottomBorder;
1536 else
1537 nCurSize = mnDX-mnLeftBorder-mnRightBorder;
1538 nCurSize -= nSplitSize;
1539 nCurSize -= (mpMainSet->mpItems.size()-1)*mpMainSet->mnSplitSize;
1540
1541 mbRecalc = false;
1542 ImplSetWindowSize( nCalcSize-nCurSize );
1543 mbRecalc = true;
1544 }
1545 }
1546
1547 if ( (mnDX <= 0) || (mnDY <= 0) )
1548 return;
1549
1550 // pre-calculate sizes/position
1551 long nL;
1552 long nT;
1553 long nW;
1554 long nH;
1555
1556 if ( mbHorz )
1557 {
1558 if ( mbBottomRight )
1559 nT = mnDY-mnBottomBorder;
1560 else
1561 nT = mnTopBorder;
1562 nL = mnLeftBorder;
1563 }
1564 else
1565 {
1566 if ( mbBottomRight )
1567 nL = mnDX-mnRightBorder;
1568 else
1569 nL = mnLeftBorder;
1570 nT = mnTopBorder;
1571 }
1572 nW = mnDX-mnLeftBorder-mnRightBorder;
1573 nH = mnDY-mnTopBorder-mnBottomBorder;
1574 if ( mnWinStyle & WB_SIZEABLE )
1575 {
1576 if ( mbHorz )
1577 nH -= nSplitSize;
1578 else
1579 nW -= nSplitSize;
1580 }
1581
1582 // calculate sets recursive
1583 ImplCalcSet( mpMainSet, nL, nT, nW, nH, mbHorz, !mbBottomRight );
1584 ImplCalcSet2( this, mpMainSet, false, mbHorz, !mbBottomRight );
1585 mbCalc = false;
1586 }
1587
1588 void SplitWindow::ImplUpdate()
1589 {
1590 mbCalc = true;
1591
1592 if ( IsReallyShown() && IsUpdateMode() && mbRecalc )
1593 {
1594 if ( !mpMainSet->mpItems.empty() )
1595 ImplCalcLayout();
1596 else
1597 Invalidate();
1598 }
1599 }
1600
1601 void SplitWindow::ImplSplitMousePos( Point& rMousePos )
1602 {
1603 if ( mnSplitTest & SPLIT_HORZ )
1604 {
1605 rMousePos.X() -= mnMouseOff;
1606 if ( rMousePos.X() < maDragRect.Left() )
1607 rMousePos.X() = maDragRect.Left();
1608 else if ( rMousePos.X()+mpSplitSet->mnSplitSize+1 > maDragRect.Right() )
1609 rMousePos.X() = maDragRect.Right()-mpSplitSet->mnSplitSize+1;
1610 // store in screen coordinates due to FullDrag
1611 mnMSplitPos = OutputToScreenPixel( rMousePos ).X();
1612 }
1613 else
1614 {
1615 rMousePos.Y() -= mnMouseOff;
1616 if ( rMousePos.Y() < maDragRect.Top() )
1617 rMousePos.Y() = maDragRect.Top();
1618 else if ( rMousePos.Y()+mpSplitSet->mnSplitSize+1 > maDragRect.Bottom() )
1619 rMousePos.Y() = maDragRect.Bottom()-mpSplitSet->mnSplitSize+1;
1620 mnMSplitPos = OutputToScreenPixel( rMousePos ).Y();
1621 }
1622 }
1623
1624 void SplitWindow::ImplGetButtonRect( Rectangle& rRect, long nEx, bool bTest ) const
1625 {
1626 long nSplitSize = mpMainSet->mnSplitSize-1;
1627 if ( mbAutoHide || mbFadeOut || mbFadeIn )
1628 nSplitSize += SPLITWIN_SPLITSIZEEX;
1629
1630 long nButtonSize = 0;
1631 if ( mbFadeIn )
1632 nButtonSize += SPLITWIN_SPLITSIZEFADE+1;
1633 if ( mbFadeOut )
1634 nButtonSize += SPLITWIN_SPLITSIZEFADE+1;
1635 if ( mbAutoHide )
1636 nButtonSize += SPLITWIN_SPLITSIZEAUTOHIDE+1;
1637 long nCenterEx = 0;
1638 if ( mbHorz )
1639 nCenterEx += ((mnDX-mnLeftBorder-mnRightBorder)-nButtonSize)/2;
1640 else
1641 nCenterEx += ((mnDY-mnTopBorder-mnBottomBorder)-nButtonSize)/2;
1642 if ( nCenterEx > 0 )
1643 nEx += nCenterEx;
1644
1645 switch ( meAlign )
1646 {
1647 case WindowAlign::Top:
1648 rRect.Left() = mnLeftBorder+nEx;
1649 rRect.Top() = mnDY-mnBottomBorder-nSplitSize;
1650 rRect.Right() = rRect.Left()+SPLITWIN_SPLITSIZEAUTOHIDE;
1651 rRect.Bottom() = mnDY-mnBottomBorder-1;
1652 if ( bTest )
1653 {
1654 rRect.Top() -= mnTopBorder;
1655 rRect.Bottom() += mnBottomBorder;
1656 }
1657 break;
1658 case WindowAlign::Bottom:
1659 rRect.Left() = mnLeftBorder+nEx;
1660 rRect.Top() = mnTopBorder;
1661 rRect.Right() = rRect.Left()+SPLITWIN_SPLITSIZEAUTOHIDE;
1662 rRect.Bottom() = mnTopBorder+nSplitSize-1;
1663 if ( bTest )
1664 {
1665 rRect.Top() -= mnTopBorder;
1666 rRect.Bottom() += mnBottomBorder;
1667 }
1668 break;
1669 case WindowAlign::Left:
1670 rRect.Left() = mnDX-mnRightBorder-nSplitSize;
1671 rRect.Top() = mnTopBorder+nEx;
1672 rRect.Right() = mnDX-mnRightBorder-1;
1673 rRect.Bottom() = rRect.Top()+SPLITWIN_SPLITSIZEAUTOHIDE;
1674 if ( bTest )
1675 {
1676 rRect.Left() -= mnLeftBorder;
1677 rRect.Right() += mnRightBorder;
1678 }
1679 break;
1680 case WindowAlign::Right:
1681 rRect.Left() = mnLeftBorder;
1682 rRect.Top() = mnTopBorder+nEx;
1683 rRect.Right() = mnLeftBorder+nSplitSize-1;
1684 rRect.Bottom() = rRect.Top()+SPLITWIN_SPLITSIZEAUTOHIDE;
1685 if ( bTest )
1686 {
1687 rRect.Left() -= mnLeftBorder;
1688 rRect.Right() += mnRightBorder;
1689 }
1690 break;
1691 }
1692 }
1693
1694 void SplitWindow::ImplGetAutoHideRect( Rectangle& rRect, bool bTest ) const
1695 {
1696 Rectangle aRect;
1697
1698 if ( mbAutoHide )
1699 {
1700 long nEx = 0;
1701 if ( mbFadeIn || mbFadeOut )
1702 nEx = SPLITWIN_SPLITSIZEFADE+1;
1703 ImplGetButtonRect( aRect, nEx, bTest && mbFadeIn );
1704 }
1705
1706 rRect = aRect;
1707 }
1708
1709 void SplitWindow::ImplGetFadeInRect( Rectangle& rRect, bool bTest ) const
1710 {
1711 Rectangle aRect;
1712
1713 if ( mbFadeIn )
1714 ImplGetButtonRect( aRect, 0, bTest );
1715
1716 rRect = aRect;
1717 }
1718
1719 void SplitWindow::ImplGetFadeOutRect( Rectangle& rRect, bool ) const
1720 {
1721 Rectangle aRect;
1722
1723 if ( mbFadeOut )
1724 ImplGetButtonRect( aRect, 0, false );
1725
1726 rRect = aRect;
1727 }
1728
1729 void SplitWindow::ImplDrawButtonRect(vcl::RenderContext& rRenderContext, const Rectangle& rRect, long nSize)
1730 {
1731 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1732
1733 if ( mbHorz )
1734 {
1735 long nLeft = rRect.Left();
1736 long nRight = rRect.Right();
1737 long nCenter = rRect.Center().Y();
1738 long nEx1 = nLeft+((rRect.GetWidth()-nSize)/2)-2;
1739 long nEx2 = nEx1+nSize+3;
1740 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
1741 rRenderContext.DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Left(), rRect.Bottom() ) );
1742 rRenderContext.DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Right(), rRect.Top() ) );
1743 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
1744 rRenderContext.DrawLine( Point( rRect.Right(), rRect.Top() ), Point( rRect.Right(), rRect.Bottom() ) );
1745 rRenderContext.DrawLine( Point( rRect.Left(), rRect.Bottom() ), Point( rRect.Right(), rRect.Bottom() ) );
1746 long i = nLeft+2;
1747 while ( i < nRight-3 )
1748 {
1749 if ( (i < nEx1) || (i > nEx2 ) )
1750 {
1751 rRenderContext.DrawPixel( Point( i, nCenter-2 ), rStyleSettings.GetLightColor() );
1752 rRenderContext.DrawPixel( Point( i+1, nCenter-2+1 ), rStyleSettings.GetShadowColor() );
1753 }
1754 i++;
1755 if ( (i < nEx1) || ((i > nEx2 ) && (i < nRight-3)) )
1756 {
1757 rRenderContext.DrawPixel( Point( i, nCenter+2 ), rStyleSettings.GetLightColor() );
1758 rRenderContext.DrawPixel( Point( i+1, nCenter+2+1 ), rStyleSettings.GetShadowColor() );
1759 }
1760 i += 2;
1761 }
1762 }
1763 else
1764 {
1765 long nTop = rRect.Top();
1766 long nBottom = rRect.Bottom();
1767 long nCenter = rRect.Center().X();
1768 long nEx1 = nTop+((rRect.GetHeight()-nSize)/2)-2;
1769 long nEx2 = nEx1+nSize+3;
1770 rRenderContext.SetLineColor( rStyleSettings.GetLightColor() );
1771 rRenderContext.DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Right(), rRect.Top() ) );
1772 rRenderContext.DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Left(), rRect.Bottom() ) );
1773 rRenderContext.SetLineColor( rStyleSettings.GetShadowColor() );
1774 rRenderContext.DrawLine( Point( rRect.Right(), rRect.Top() ), Point( rRect.Right(), rRect.Bottom() ) );
1775 rRenderContext.DrawLine( Point( rRect.Left(), rRect.Bottom() ), Point( rRect.Right(), rRect.Bottom() ) );
1776 long i = nTop+2;
1777 while ( i < nBottom-3 )
1778 {
1779 if ( (i < nEx1) || (i > nEx2 ) )
1780 {
1781 rRenderContext.DrawPixel( Point( nCenter-2, i ), rStyleSettings.GetLightColor() );
1782 rRenderContext.DrawPixel( Point( nCenter-2+1, i+1 ), rStyleSettings.GetShadowColor() );
1783 }
1784 i++;
1785 if ( (i < nEx1) || ((i > nEx2 ) && (i < nBottom-3)) )
1786 {
1787 rRenderContext.DrawPixel( Point( nCenter+2, i ), rStyleSettings.GetLightColor() );
1788 rRenderContext.DrawPixel( Point( nCenter+2+1, i+1 ), rStyleSettings.GetShadowColor() );
1789 }
1790 i += 2;
1791 }
1792 }
1793 }
1794
1795 void SplitWindow::ImplDrawAutoHide(vcl::RenderContext& rRenderContext)
1796 {
1797 if (mbAutoHide)
1798 {
1799 Rectangle aTempRect;
1800 ImplGetAutoHideRect( aTempRect );
1801
1802 // load ImageListe, if not available
1803 ImplSVData* pSVData = ImplGetSVData();
1804 ImageList* pImageList;
1805 if (mbHorz)
1806 {
1807 if (!pSVData->maCtrlData.mpSplitHPinImgList)
1808 {
1809 ResMgr* pResMgr = ImplGetResMgr();
1810 if (pResMgr)
1811 {
1812 Color aNonAlphaMask( 0x00, 0x00, 0xFF );
1813 pSVData->maCtrlData.mpSplitHPinImgList = new ImageList;
1814 pSVData->maCtrlData.mpSplitHPinImgList->InsertFromHorizontalBitmap
1815 ( ResId( SV_RESID_BITMAP_SPLITHPIN, *pResMgr ), 4, &aNonAlphaMask );
1816 }
1817 }
1818 pImageList = pSVData->maCtrlData.mpSplitHPinImgList;
1819 }
1820 else
1821 {
1822 if (!pSVData->maCtrlData.mpSplitVPinImgList)
1823 {
1824 ResMgr* pResMgr = ImplGetResMgr();
1825 pSVData->maCtrlData.mpSplitVPinImgList = new ImageList;
1826 if (pResMgr)
1827 {
1828 Color aNonAlphaMask( 0x00, 0x00, 0xFF );
1829 pSVData->maCtrlData.mpSplitVPinImgList->InsertFromHorizontalBitmap(
1830 ResId( SV_RESID_BITMAP_SPLITVPIN, *pResMgr ), 4, &aNonAlphaMask);
1831 }
1832 }
1833 pImageList = pSVData->maCtrlData.mpSplitVPinImgList;
1834 }
1835
1836 if (!pImageList)
1837 return;
1838
1839 // retrieve and return image
1840 sal_uInt16 nId;
1841 if (mbAutoHidePressed)
1842 {
1843 if (mbAutoHideIn)
1844 nId = 3;
1845 else
1846 nId = 4;
1847 }
1848 else
1849 {
1850 if (mbAutoHideIn)
1851 nId = 1;
1852 else
1853 nId = 2;
1854 }
1855
1856 Image aImage = pImageList->GetImage( nId );
1857 Size aImageSize = aImage.GetSizePixel();
1858 Point aPos(aTempRect.Left() + ((aTempRect.GetWidth() - aImageSize.Width()) / 2),
1859 aTempRect.Top() + ((aTempRect.GetHeight() - aImageSize.Height()) / 2));
1860 long nSize;
1861 if (mbHorz)
1862 nSize = aImageSize.Width();
1863 else
1864 nSize = aImageSize.Height();
1865 ImplDrawButtonRect(rRenderContext, aTempRect, nSize);
1866 rRenderContext.DrawImage(aPos, aImage);
1867 }
1868 }
1869
1870 void SplitWindow::ImplDrawGrip(vcl::RenderContext& rRenderContext, const Rectangle& rRect, bool bHorizontal, bool bLeft)
1871 {
1872 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
1873
1874 Color aColor;
1875
1876 if (rRect.IsInside(GetPointerPosPixel()))
1877 {
1878 vcl::RenderTools::DrawSelectionBackground(rRenderContext, *this, rRect, 2, false, false, false);
1879
1880 aColor = rStyleSettings.GetDarkShadowColor();
1881 }
1882 else
1883 {
1884 rRenderContext.SetLineColor(rStyleSettings.GetDarkShadowColor());
1885 rRenderContext.SetFillColor(rStyleSettings.GetDarkShadowColor());
1886
1887 rRenderContext.DrawRect(rRect);
1888
1889 aColor = rStyleSettings.GetFaceColor();
1890 }
1891
1892 AntialiasingFlags nAA = rRenderContext.GetAntialiasing();
1893 rRenderContext.SetAntialiasing(nAA | AntialiasingFlags::PixelSnapHairline | AntialiasingFlags::EnableB2dDraw);
1894
1895 long nWidth = rRect.getWidth();
1896 long nWidthHalf = nWidth / 2;
1897 long nHeight = rRect.getHeight();
1898 long nHeightHalf = nHeight / 2;
1899
1900 long nLeft = rRect.Left();
1901 long nRight = rRect.Right();
1902 long nTop = rRect.Top();
1903 long nBottom = rRect.Bottom();
1904 long nMargin = 1;
1905
1906 rRenderContext.SetLineColor(aColor);
1907 rRenderContext.SetFillColor(aColor);
1908
1909 tools::Polygon aPoly(3);
1910
1911 if (bHorizontal)
1912 {
1913 long nCenter = nLeft + nWidthHalf;
1914
1915 if (bLeft)
1916 {
1917 aPoly.SetPoint(Point(nCenter, nTop + nMargin), 0);
1918 aPoly.SetPoint(Point(nCenter - nHeightHalf, nBottom - nMargin), 1);
1919 aPoly.SetPoint(Point(nCenter - nHeightHalf, nBottom - nMargin), 2);
1920 }
1921 else
1922 {
1923 aPoly.SetPoint(Point(nCenter, nBottom - nMargin), 0);
1924 aPoly.SetPoint(Point(nCenter - nHeightHalf, nTop + nMargin), 1);
1925 aPoly.SetPoint(Point(nCenter + nHeightHalf, nTop + nMargin), 2);
1926 }
1927 rRenderContext.DrawPolygon(aPoly);
1928 }
1929 else
1930 {
1931 long nCenter = nTop + nHeightHalf;
1932
1933 if (bLeft)
1934 {
1935 aPoly.SetPoint(Point(nLeft + nMargin, nCenter), 0);
1936 aPoly.SetPoint(Point(nRight - nMargin, nCenter - nWidthHalf), 1);
1937 aPoly.SetPoint(Point(nRight - nMargin, nCenter + nWidthHalf), 2);
1938 }
1939 else
1940 {
1941 aPoly.SetPoint(Point(nRight - nMargin, nCenter), 0);
1942 aPoly.SetPoint(Point(nLeft + nMargin, nCenter - nWidthHalf), 1);
1943 aPoly.SetPoint(Point(nLeft + nMargin, nCenter + nWidthHalf), 2);
1944 }
1945 rRenderContext.DrawPolygon(aPoly);
1946 }
1947
1948 rRenderContext.SetAntialiasing(nAA);
1949 }
1950
1951 void SplitWindow::ImplDrawFadeIn(vcl::RenderContext& rRenderContext)
1952 {
1953 if (mbFadeIn)
1954 {
1955 Rectangle aTempRect;
1956 ImplGetFadeInRect(aTempRect);
1957
1958 bool bLeft = true;
1959 switch (meAlign)
1960 {
1961 case WindowAlign::Top:
1962 case WindowAlign::Left:
1963 bLeft = false;
1964 break;
1965 case WindowAlign::Bottom:
1966 case WindowAlign::Right:
1967 default:
1968 bLeft = true;
1969 break;
1970 }
1971
1972 ImplDrawGrip(rRenderContext, aTempRect, (meAlign == WindowAlign::Top) || (meAlign == WindowAlign::Bottom), bLeft);
1973 }
1974 }
1975
1976 void SplitWindow::ImplDrawFadeOut(vcl::RenderContext& rRenderContext)
1977 {
1978 if (mbFadeOut)
1979 {
1980 Rectangle aTempRect;
1981 ImplGetFadeOutRect(aTempRect);
1982
1983 bool bLeft = true;
1984 switch (meAlign)
1985 {
1986 case WindowAlign::Bottom:
1987 case WindowAlign::Right:
1988 bLeft = false;
1989 break;
1990 case WindowAlign::Top:
1991 case WindowAlign::Left:
1992 default:
1993 bLeft = true;
1994 break;
1995 }
1996
1997 ImplDrawGrip(rRenderContext, aTempRect, (meAlign == WindowAlign::Top) || (meAlign == WindowAlign::Bottom), bLeft);
1998 }
1999 }
2000
2001 void SplitWindow::ImplStartSplit( const MouseEvent& rMEvt )
2002 {
2003 Point aMousePosPixel = rMEvt.GetPosPixel();
2004 mnSplitTest = ImplTestSplit( this, aMousePosPixel, mnMouseOff, &mpSplitSet, mnSplitPos );
2005
2006 if ( mnSplitTest && !(mnSplitTest & SPLIT_NOSPLIT) )
2007 {
2008 ImplSplitItem* pSplitItem;
2009 long nCurMaxSize;
2010 sal_uInt16 nTemp;
2011 bool bPropSmaller;
2012
2013 mnMouseModifier = rMEvt.GetModifier();
2014 if ( !(mnMouseModifier & KEY_SHIFT) || (static_cast<sal_uInt16>(mnSplitPos+1) >= mpSplitSet->mpItems.size()) )
2015 bPropSmaller = false;
2016 else
2017 bPropSmaller = true;
2018
2019 // here we can set the maximum size
2020 StartSplit();
2021
2022 if ( mnMaxSize )
2023 nCurMaxSize = mnMaxSize;
2024 else
2025 {
2026 Size aSize = GetParent()->GetOutputSizePixel();
2027 if ( mbHorz )
2028 nCurMaxSize = aSize.Height();
2029 else
2030 nCurMaxSize = aSize.Width();
2031 }
2032
2033 if ( !mpSplitSet->mpItems.empty() )
2034 {
2035 bool bDown = true;
2036 if ( (mpSplitSet == mpMainSet) && mbBottomRight )
2037 bDown = false;
2038
2039 pSplitItem = mpSplitSet->mpItems[mnSplitPos];
2040 maDragRect.Left() = pSplitItem->mnLeft;
2041 maDragRect.Top() = pSplitItem->mnTop;
2042 maDragRect.Right() = pSplitItem->mnLeft+pSplitItem->mnWidth-1;
2043 maDragRect.Bottom() = pSplitItem->mnTop+pSplitItem->mnHeight-1;
2044
2045 if ( mnSplitTest & SPLIT_HORZ )
2046 {
2047 if ( bDown )
2048 maDragRect.Right() += mpSplitSet->mnSplitSize;
2049 else
2050 maDragRect.Left() -= mpSplitSet->mnSplitSize;
2051 }
2052 else
2053 {
2054 if ( bDown )
2055 maDragRect.Bottom() += mpSplitSet->mnSplitSize;
2056 else
2057 maDragRect.Top() -= mpSplitSet->mnSplitSize;
2058 }
2059
2060 if ( mnSplitPos )
2061 {
2062 nTemp = mnSplitPos;
2063 while ( nTemp )
2064 {
2065 pSplitItem = mpSplitSet->mpItems[nTemp-1];
2066 if ( pSplitItem->mbFixed )
2067 break;
2068 else
2069 {
2070 if ( mnSplitTest & SPLIT_HORZ )
2071 {
2072 if ( bDown )
2073 maDragRect.Left() -= pSplitItem->mnPixSize;
2074 else
2075 maDragRect.Right() += pSplitItem->mnPixSize;
2076 }
2077 else
2078 {
2079 if ( bDown )
2080 maDragRect.Top() -= pSplitItem->mnPixSize;
2081 else
2082 maDragRect.Bottom() += pSplitItem->mnPixSize;
2083 }
2084 }
2085 nTemp--;
2086 }
2087 }
2088
2089 if ( (mpSplitSet == mpMainSet) && (mnWinStyle & WB_SIZEABLE) && !bPropSmaller )
2090 {
2091 if ( bDown )
2092 {
2093 if ( mbHorz )
2094 maDragRect.Bottom() += nCurMaxSize-mnDY-mnTopBorder;
2095 else
2096 maDragRect.Right() += nCurMaxSize-mnDX-mnLeftBorder;
2097 }
2098 else
2099 {
2100 if ( mbHorz )
2101 maDragRect.Top() -= nCurMaxSize-mnDY-mnBottomBorder;
2102 else
2103 maDragRect.Left() -= nCurMaxSize-mnDX-mnRightBorder;
2104 }
2105 }
2106 else
2107 {
2108 nTemp = mnSplitPos+1;
2109 while ( nTemp < mpSplitSet->mpItems.size() )
2110 {
2111 pSplitItem = mpSplitSet->mpItems[nTemp];
2112 if ( pSplitItem->mbFixed )
2113 break;
2114 else
2115 {
2116 if ( mnSplitTest & SPLIT_HORZ )
2117 {
2118 if ( bDown )
2119 maDragRect.Right() += pSplitItem->mnPixSize;
2120 else
2121 maDragRect.Left() -= pSplitItem->mnPixSize;
2122 }
2123 else
2124 {
2125 if ( bDown )
2126 maDragRect.Bottom() += pSplitItem->mnPixSize;
2127 else
2128 maDragRect.Top() -= pSplitItem->mnPixSize;
2129 }
2130 }
2131 nTemp++;
2132 }
2133 }
2134 }
2135 else
2136 {
2137 maDragRect.Left() = mnLeftBorder;
2138 maDragRect.Top() = mnTopBorder;
2139 maDragRect.Right() = mnDX-mnRightBorder-1;
2140 maDragRect.Bottom() = mnDY-mnBottomBorder-1;
2141 if ( mbHorz )
2142 {
2143 if ( mbBottomRight )
2144 maDragRect.Top() -= nCurMaxSize-mnDY-mnBottomBorder;
2145 else
2146 maDragRect.Bottom() += nCurMaxSize-mnDY-mnTopBorder;
2147 }
2148 else
2149 {
2150 if ( mbBottomRight )
2151 maDragRect.Left() -= nCurMaxSize-mnDX-mnRightBorder;
2152 else
2153 maDragRect.Right() += nCurMaxSize-mnDX-mnLeftBorder;
2154 }
2155 }
2156
2157 StartTracking();
2158
2159 mbDragFull = bool(GetSettings().GetStyleSettings().GetDragFullOptions() & DragFullOptions::Split);
2160
2161 ImplSplitMousePos( aMousePosPixel );
2162
2163 if (!mbDragFull)
2164 {
2165 ImplDrawSplitTracking(aMousePosPixel);
2166 }
2167 else
2168 {
2169 std::vector< ImplSplitItem* >& rItems = mpSplitSet->mpItems;
2170 sal_uInt16 nItems = mpSplitSet->mpItems.size();
2171 mpLastSizes = new long[nItems*2];
2172 for ( sal_uInt16 i = 0; i < nItems; i++ )
2173 {
2174 mpLastSizes[i*2] = rItems[i]->mnSize;
2175 mpLastSizes[i*2+1] = rItems[i]->mnPixSize;
2176 }
2177 }
2178 mnMStartPos = mnMSplitPos;
2179
2180 PointerStyle eStyle = PointerStyle::Arrow;
2181 if ( mnSplitTest & SPLIT_HORZ )
2182 eStyle = PointerStyle::HSplit;
2183 else if ( mnSplitTest & SPLIT_VERT )
2184 eStyle = PointerStyle::VSplit;
2185
2186 Pointer aPtr( eStyle );
2187 SetPointer( aPtr );
2188 }
2189 }
2190
2191 void SplitWindow::StartSplit()
2192 {
2193 }
2194
2195 void SplitWindow::Split()
2196 {
2197 maSplitHdl.Call( this );
2198 }
2199
2200 void SplitWindow::SplitResize()
2201 {
2202 }
2203
2204 void SplitWindow::AutoHide()
2205 {
2206 }
2207
2208 void SplitWindow::FadeIn()
2209 {
2210 }
2211
2212 void SplitWindow::FadeOut()
2213 {
2214 }
2215
2216 void SplitWindow::MouseButtonDown( const MouseEvent& rMEvt )
2217 {
2218 if ( !rMEvt.IsLeft() || rMEvt.IsMod2() )
2219 {
2220 DockingWindow::MouseButtonDown( rMEvt );
2221 return;
2222 }
2223
2224 Point aMousePosPixel = rMEvt.GetPosPixel();
2225 Rectangle aTestRect;
2226
2227 mbFadeNoButtonMode = false;
2228 ImplGetAutoHideRect( aTestRect, true );
2229 if ( aTestRect.IsInside( aMousePosPixel ) )
2230 {
2231 mbAutoHideDown = true;
2232 mbAutoHidePressed = true;
2233 Invalidate();
2234 }
2235 else
2236 {
2237 ImplGetFadeOutRect( aTestRect, true );
2238 if ( aTestRect.IsInside( aMousePosPixel ) )
2239 {
2240 mbFadeOutDown = true;
2241 mbFadeOutPressed = true;
2242 Invalidate();
2243 }
2244 else
2245 {
2246 ImplGetFadeInRect( aTestRect, true );
2247 if ( aTestRect.IsInside( aMousePosPixel ) )
2248 {
2249 mbFadeInDown = true;
2250 mbFadeInPressed = true;
2251 Invalidate();
2252 }
2253 else if ( !aTestRect.IsEmpty() && !(mnWinStyle & WB_SIZEABLE) )
2254 {
2255 mbFadeNoButtonMode = true;
2256 FadeIn();
2257 return;
2258 }
2259 }
2260 }
2261
2262 if ( mbAutoHideDown || mbFadeInDown || mbFadeOutDown )
2263 StartTracking();
2264 else
2265 ImplStartSplit( rMEvt );
2266 }
2267
2268 void SplitWindow::MouseMove( const MouseEvent& rMEvt )
2269 {
2270 if ( !IsTracking() )
2271 {
2272 Point aPos = rMEvt.GetPosPixel();
2273 long nTemp;
2274 ImplSplitSet* pTempSplitSet;
2275 sal_uInt16 nTempSplitPos;
2276 sal_uInt16 nSplitTest = ImplTestSplit( this, aPos, nTemp, &pTempSplitSet, nTempSplitPos );
2277 PointerStyle eStyle = PointerStyle::Arrow;
2278 Rectangle aAutoHideRect;
2279 Rectangle aFadeInRect;
2280 Rectangle aFadeOutRect;
2281
2282 ImplGetAutoHideRect( aAutoHideRect );
2283 ImplGetFadeInRect( aFadeInRect );
2284 ImplGetFadeOutRect( aFadeOutRect );
2285 if ( !aAutoHideRect.IsInside( aPos ) &&
2286 !aFadeInRect.IsInside( aPos ) &&
2287 !aFadeOutRect.IsInside( aPos ) )
2288 {
2289 if ( nSplitTest && !(nSplitTest & SPLIT_NOSPLIT) )
2290 {
2291 if ( nSplitTest & SPLIT_HORZ )
2292 eStyle = PointerStyle::HSplit;
2293 else if ( nSplitTest & SPLIT_VERT )
2294 eStyle = PointerStyle::VSplit;
2295 }
2296 }
2297
2298 Pointer aPtr( eStyle );
2299 SetPointer( aPtr );
2300 }
2301 }
2302
2303 void SplitWindow::Tracking( const TrackingEvent& rTEvt )
2304 {
2305 Point aMousePosPixel = rTEvt.GetMouseEvent().GetPosPixel();
2306
2307 if ( mbAutoHideDown )
2308 {
2309 if ( rTEvt.IsTrackingEnded() )
2310 {
2311 mbAutoHideDown = false;
2312 if ( mbAutoHidePressed )
2313 {
2314 mbAutoHidePressed = false;
2315
2316 if ( !rTEvt.IsTrackingCanceled() )
2317 {
2318 mbAutoHideIn = !mbAutoHideIn;
2319 Invalidate();
2320 AutoHide();
2321 }
2322 else
2323 Invalidate();
2324 }
2325 }
2326 else
2327 {
2328 Rectangle aTestRect;
2329 ImplGetAutoHideRect( aTestRect, true );
2330 bool bNewPressed = aTestRect.IsInside( aMousePosPixel );
2331 if ( bNewPressed != mbAutoHidePressed )
2332 {
2333 mbAutoHidePressed = bNewPressed;
2334 Invalidate();
2335 }
2336 }
2337 }
2338 else if ( mbFadeInDown )
2339 {
2340 if ( rTEvt.IsTrackingEnded() )
2341 {
2342 mbFadeInDown = false;
2343 if ( mbFadeInPressed )
2344 {
2345 mbFadeInPressed = false;
2346 Invalidate();
2347
2348 if ( !rTEvt.IsTrackingCanceled() )
2349 FadeIn();
2350 }
2351 }
2352 else
2353 {
2354 Rectangle aTestRect;
2355 ImplGetFadeInRect( aTestRect, true );
2356 bool bNewPressed = aTestRect.IsInside( aMousePosPixel );
2357 if ( bNewPressed != mbFadeInPressed )
2358 {
2359 mbFadeInPressed = bNewPressed;
2360 Invalidate();
2361 }
2362 }
2363 }
2364 else if ( mbFadeOutDown )
2365 {
2366 if ( rTEvt.IsTrackingEnded() )
2367 {
2368 mbFadeOutDown = false;
2369 if ( mbFadeOutPressed )
2370 {
2371 mbFadeOutPressed = false;
2372 Invalidate();
2373
2374 if ( !rTEvt.IsTrackingCanceled() )
2375 FadeOut();
2376 }
2377 }
2378 else
2379 {
2380 Rectangle aTestRect;
2381 ImplGetFadeOutRect( aTestRect, true );
2382 bool bNewPressed = aTestRect.IsInside( aMousePosPixel );
2383 if ( !bNewPressed )
2384 {
2385 mbFadeOutPressed = bNewPressed;
2386 Invalidate();
2387
2388 // We need a mouseevent with a position inside the button for the
2389 // ImplStartSplit function!
2390 MouseEvent aOrgMEvt = rTEvt.GetMouseEvent();
2391 MouseEvent aNewMEvt = MouseEvent( aTestRect.Center(), aOrgMEvt.GetClicks(),
2392 aOrgMEvt.GetMode(), aOrgMEvt.GetButtons(),
2393 aOrgMEvt.GetModifier() );
2394
2395 ImplStartSplit( aNewMEvt );
2396 mbFadeOutDown = false;
2397 }
2398 }
2399 }
2400 else
2401 {
2402 ImplSplitMousePos( aMousePosPixel );
2403 bool bSplit = true;
2404 if ( mbDragFull )
2405 {
2406 if ( rTEvt.IsTrackingEnded() )
2407 {
2408 if ( rTEvt.IsTrackingCanceled() )
2409 {
2410 std::vector< ImplSplitItem* >& rItems = mpSplitSet->mpItems;
2411 size_t nItems = rItems.size();
2412 for ( size_t i = 0; i < nItems; i++ )
2413 {
2414 rItems[i]->mnSize = mpLastSizes[i*2];
2415 rItems[i]->mnPixSize = mpLastSizes[i*2+1];
2416 }
2417 ImplUpdate();
2418 Split();
2419 }
2420 bSplit = false;
2421 }
2422 }
2423 else
2424 {
2425 if ( rTEvt.IsTrackingEnded() )
2426 {
2427 HideTracking();
2428 bSplit = !rTEvt.IsTrackingCanceled();
2429 }
2430 else
2431 {
2432 ImplDrawSplitTracking(aMousePosPixel);
2433 bSplit = false;
2434 }
2435 }
2436
2437 if ( bSplit )
2438 {
2439 bool bPropSmaller = (mnMouseModifier & KEY_SHIFT) != 0;
2440 bool bPropGreater = (mnMouseModifier & KEY_MOD1) != 0;
2441 long nDelta = mnMSplitPos-mnMStartPos;
2442
2443 if ( (mnSplitTest & SPLIT_WINDOW) && mpMainSet->mpItems.empty() )
2444 {
2445 if ( (mpSplitSet == mpMainSet) && mbBottomRight )
2446 nDelta *= -1;
2447 ImplSetWindowSize( nDelta );
2448 }
2449 else
2450 {
2451 long nNewSize = mpSplitSet->mpItems[mnSplitPos]->mnPixSize;
2452 if ( (mpSplitSet == mpMainSet) && mbBottomRight )
2453 nNewSize -= nDelta;
2454 else
2455 nNewSize += nDelta;
2456 SplitItem( mpSplitSet->mpItems[mnSplitPos]->mnId, nNewSize,
2457 bPropSmaller, bPropGreater );
2458 }
2459
2460 Split();
2461
2462 if ( mbDragFull )
2463 {
2464 Update();
2465 mnMStartPos = mnMSplitPos;
2466 }
2467 }
2468
2469 if ( rTEvt.IsTrackingEnded() )
2470 {
2471 delete [] mpLastSizes;
2472 mpLastSizes = nullptr;
2473 mpSplitSet = nullptr;
2474 mnMouseOff = 0;
2475 mnMStartPos = 0;
2476 mnMSplitPos = 0;
2477 mnMouseModifier = 0;
2478 mnSplitTest = 0;
2479 mnSplitPos = 0;
2480 }
2481 }
2482 }
2483
2484 bool SplitWindow::PreNotify( NotifyEvent& rNEvt )
2485 {
2486 const MouseEvent* pMouseEvt = nullptr;
2487
2488 if( (rNEvt.GetType() == MouseNotifyEvent::MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != nullptr )
2489 {
2490 if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() )
2491 {
2492 // trigger redraw if mouse over state has changed
2493 Rectangle aFadeInRect;
2494 Rectangle aFadeOutRect;
2495 ImplGetFadeInRect( aFadeInRect );
2496 ImplGetFadeOutRect( aFadeOutRect );
2497
2498 if ( aFadeInRect.IsInside( GetPointerPosPixel() ) != aFadeInRect.IsInside( GetLastPointerPosPixel() ) )
2499 Invalidate( aFadeInRect );
2500 if ( aFadeOutRect.IsInside( GetPointerPosPixel() ) != aFadeOutRect.IsInside( GetLastPointerPosPixel() ) )
2501 Invalidate( aFadeOutRect );
2502
2503 if( pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow() )
2504 {
2505 Invalidate( aFadeInRect );
2506 Invalidate( aFadeOutRect );
2507 }
2508 }
2509 }
2510 return Window::PreNotify( rNEvt );
2511 }
2512
2513 void SplitWindow::Paint(vcl::RenderContext& rRenderContext, const Rectangle&)
2514 {
2515 if (mnWinStyle & WB_BORDER)
2516 ImplDrawBorder(rRenderContext);
2517
2518 ImplDrawBorderLine(rRenderContext);
2519 ImplDrawFadeOut(rRenderContext);
2520 ImplDrawFadeIn(rRenderContext);
2521 ImplDrawAutoHide(rRenderContext);
2522
2523 // draw FrameSet-backgrounds
2524 ImplDrawBack(rRenderContext, mpMainSet);
2525
2526 // draw splitter
2527 if (!(mnWinStyle & WB_NOSPLITDRAW))
2528 {
2529 bool bFlat = (GetStyle() & WB_FLATSPLITDRAW) == WB_FLATSPLITDRAW;
2530 ImplDrawSplit(rRenderContext, mpMainSet, mbHorz, bFlat, !mbBottomRight);
2531 }
2532 }
2533
2534 void SplitWindow::Resize()
2535 {
2536 Size aSize = GetOutputSizePixel();
2537 mnDX = aSize.Width();
2538 mnDY = aSize.Height();
2539
2540 ImplUpdate();
2541 Invalidate();
2542 }
2543
2544 void SplitWindow::RequestHelp( const HelpEvent& rHEvt )
2545 {
2546 // no keyboard help for splitwin
2547 if ( rHEvt.GetMode() & (HelpEventMode::BALLOON | HelpEventMode::QUICK) && !rHEvt.KeyboardActivated() )
2548 {
2549 Point aMousePosPixel = ScreenToOutputPixel( rHEvt.GetMousePosPixel() );
2550 Rectangle aHelpRect;
2551 sal_uInt16 nHelpResId = 0;
2552
2553 ImplGetAutoHideRect( aHelpRect, true );
2554 if ( aHelpRect.IsInside( aMousePosPixel ) )
2555 {
2556 if ( mbAutoHideIn )
2557 nHelpResId = SV_HELPTEXT_SPLITFIXED;
2558 else
2559 nHelpResId = SV_HELPTEXT_SPLITFLOATING;
2560 }
2561 else
2562 {
2563 ImplGetFadeInRect( aHelpRect, true );
2564 if ( aHelpRect.IsInside( aMousePosPixel ) )
2565 nHelpResId = SV_HELPTEXT_FADEIN;
2566 else
2567 {
2568 ImplGetFadeOutRect( aHelpRect, true );
2569 if ( aHelpRect.IsInside( aMousePosPixel ) )
2570 nHelpResId = SV_HELPTEXT_FADEOUT;
2571 }
2572 }
2573
2574 // get rectangle
2575 if ( nHelpResId )
2576 {
2577 Point aPt = OutputToScreenPixel( aHelpRect.TopLeft() );
2578 aHelpRect.Left() = aPt.X();
2579 aHelpRect.Top() = aPt.Y();
2580 aPt = OutputToScreenPixel( aHelpRect.BottomRight() );
2581 aHelpRect.Right() = aPt.X();
2582 aHelpRect.Bottom() = aPt.Y();
2583
2584 // get and draw text
2585 OUString aStr;
2586 ResMgr* pResMgr = ImplGetResMgr();
2587 if( pResMgr )
2588 aStr = ResId( nHelpResId, *pResMgr ).toString();
2589 if ( rHEvt.GetMode() & HelpEventMode::BALLOON )
2590 Help::ShowBalloon( this, aHelpRect.Center(), aHelpRect, aStr );
2591 else
2592 Help::ShowQuickHelp( this, aHelpRect, aStr );
2593 return;
2594 }
2595 }
2596
2597 DockingWindow::RequestHelp( rHEvt );
2598 }
2599
2600 void SplitWindow::StateChanged( StateChangedType nType )
2601 {
2602 switch ( nType )
2603 {
2604 case StateChangedType::InitShow:
2605 if ( IsUpdateMode() )
2606 ImplCalcLayout();
2607 break;
2608 case StateChangedType::UpdateMode:
2609 if ( IsUpdateMode() && IsReallyShown() )
2610 ImplCalcLayout();
2611 break;
2612 case StateChangedType::ControlBackground:
2613 ImplInitSettings();
2614 Invalidate();
2615 break;
2616 default:;
2617 }
2618
2619 DockingWindow::StateChanged( nType );
2620 }
2621
2622 void SplitWindow::DataChanged( const DataChangedEvent& rDCEvt )
2623 {
2624 if ( (rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
2625 (rDCEvt.GetFlags() & AllSettingsFlags::STYLE) )
2626 {
2627 ImplInitSettings();
2628 Invalidate();
2629 }
2630 else
2631 DockingWindow::DataChanged( rDCEvt );
2632 }
2633
2634 void SplitWindow::InsertItem( sal_uInt16 nId, vcl::Window* pWindow, long nSize,
2635 sal_uInt16 nPos, sal_uInt16 nIntoSetId,
2636 SplitWindowItemFlags nBits )
2637 {
2638 #ifdef DBG_UTIL
2639 sal_uInt16 nDbgDummy;
2640 SAL_WARN_IF( ImplFindItem( mpMainSet, nId, nDbgDummy ), "vcl", "SplitWindow::InsertItem() - Id already exists" );
2641 #endif
2642
2643 // Size has to be at least 1.
2644 if ( nSize < 1 )
2645 nSize = 1;
2646
2647 ImplSplitSet* pSet = ImplFindSet( mpMainSet, nIntoSetId );
2648 #ifdef DBG_UTIL
2649 SAL_WARN_IF( !pSet, "vcl", "SplitWindow::InsertItem() - Set not exists" );
2650 #endif
2651 if(!pSet)
2652 {
2653 return;
2654 }
2655
2656 // Don't insert further than the end
2657 if ( nPos > pSet->mpItems.size() )
2658 nPos = pSet->mpItems.size();
2659
2660 // Create new item
2661 ImplSplitItem* pItem = new ImplSplitItem();
2662 pItem->mnSize = nSize;
2663 pItem->mnPixSize = 0;
2664 pItem->mnId = nId;
2665 pItem->mnBits = nBits;
2666 pItem->mnMinSize=-1;
2667 pItem->mnMaxSize=-1;
2668
2669 if ( pWindow )
2670 {
2671 // New VclPtr reference
2672 pItem->mpWindow = pWindow;
2673 pItem->mpOrgParent = pWindow->GetParent();
2674
2675 // Attach window to SplitWindow.
2676 pWindow->Hide();
2677 pWindow->SetParent( this );
2678 }
2679 else
2680 {
2681 ImplSplitSet * pNewSet = new ImplSplitSet();
2682 pNewSet->mnId = nId;
2683 pNewSet->mnSplitSize = pSet->mnSplitSize;
2684
2685 pItem->mpSet = pNewSet;
2686 }
2687
2688 // Insert in set
2689 pSet->mpItems.insert( pSet->mpItems.begin() + nPos, pItem );
2690 pSet->mbCalcPix = true;
2691
2692 ImplUpdate();
2693 }
2694
2695 void SplitWindow::InsertItem( sal_uInt16 nId, long nSize,
2696 sal_uInt16 nPos, sal_uInt16 nIntoSetId,
2697 SplitWindowItemFlags nBits )
2698 {
2699 InsertItem( nId, nullptr, nSize, nPos, nIntoSetId, nBits );
2700 }
2701
2702 void SplitWindow::RemoveItem( sal_uInt16 nId )
2703 {
2704 #ifdef DBG_UTIL
2705 sal_uInt16 nDbgDummy;
2706 SAL_WARN_IF( !ImplFindItem( mpMainSet, nId, nDbgDummy ), "vcl", "SplitWindow::RemoveItem() - Id not found" );
2707 #endif
2708
2709 // search set
2710 sal_uInt16 nPos;
2711 ImplSplitSet* pSet = ImplFindItem( mpMainSet, nId, nPos );
2712
2713 if (!pSet)
2714 return;
2715
2716 ImplSplitItem* pItem = pSet->mpItems[nPos];
2717 VclPtr<vcl::Window> pWindow = pItem->mpWindow;
2718 VclPtr<vcl::Window> pOrgParent = pItem->mpOrgParent;
2719
2720 // delete set if required
2721 if ( !pWindow ) {
2722 delete pItem->mpSet ;
2723 pItem->mpSet = nullptr;
2724 }
2725
2726 // remove item
2727 pSet->mbCalcPix = true;
2728 pSet->mpItems.erase( pSet->mpItems.begin() + nPos );
2729
2730 ImplUpdate();
2731
2732 // to have the least amounts of paints delete window only here
2733 if ( pWindow )
2734 {
2735 // restore window
2736 pWindow->Hide();
2737 pWindow->SetParent( pOrgParent );
2738 }
2739
2740 // Clear and delete
2741 delete pItem;
2742 pWindow.clear();
2743 pOrgParent.clear();
2744 }
2745
2746 void SplitWindow::Clear()
2747 {
2748 // delete all sets
2749 delete mpMainSet ;
2750
2751 // create Main-Set again
2752 mpMainSet = new ImplSplitSet();
2753 if ( mnWinStyle & WB_NOSPLITDRAW )
2754 mpMainSet->mnSplitSize -= 2;
2755 mpBaseSet = mpMainSet;
2756
2757 // and invalidate again
2758 ImplUpdate();
2759 }
2760
2761 void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
2762 bool bPropSmall, bool bPropGreat )
2763 {
2764 sal_uInt16 nPos;
2765 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos );
2766
2767 if (!pSet)
2768 return;
2769
2770 size_t nItems = pSet->mpItems.size();
2771 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
2772
2773 // When there is an explicit minimum or maximum size then move nNewSize
2774 // into that range (when it is not yet already in it.)
2775 nNewSize = ValidateSize(nNewSize, rItems[nPos]);
2776
2777 if ( mbCalc )
2778 {
2779 rItems[nPos]->mnSize = nNewSize;
2780 return;
2781 }
2782
2783 long nDelta = nNewSize-rItems[nPos]->mnPixSize;
2784 if ( !nDelta )
2785 return;
2786
2787 // calculate area, which could be affected by splitting
2788 sal_uInt16 nMin = 0;
2789 sal_uInt16 nMax = nItems;
2790 for (size_t i = 0; i < nItems; ++i)
2791 {
2792 if ( rItems[i]->mbFixed )
2793 {
2794 if ( i < nPos )
2795 nMin = i+1;
2796 else
2797 nMax = i;
2798 }
2799 }
2800
2801 // treat TopSet different if the window is sizeable
2802 bool bSmall = true;
2803 bool bGreat = true;
2804 if ( (pSet == mpMainSet) && (mnWinStyle & WB_SIZEABLE) )
2805 {
2806 if ( nPos < pSet->mpItems.size()-1 )
2807 {
2808 if ( !((bPropSmall && bPropGreat) ||
2809 ((nDelta > 0) && bPropSmall) ||
2810 ((nDelta < 0) && bPropGreat)) )
2811 {
2812 if ( nDelta < 0 )
2813 bGreat = false;
2814 else
2815 bSmall = false;
2816 }
2817 }
2818 else
2819 {
2820 if ( nDelta < 0 )
2821 bGreat = false;
2822 else
2823 bSmall = false;
2824 }
2825 }
2826 else if ( nPos >= nMax )
2827 {
2828 bSmall = false;
2829 bGreat = false;
2830 }
2831 else if ( nPos && (nPos >= pSet->mpItems.size()-1) )
2832 {
2833 nPos--;
2834 nDelta *= -1;
2835 bool bTemp = bPropSmall;
2836 bPropSmall = bPropGreat;
2837 bPropGreat = bTemp;
2838 }
2839
2840 sal_uInt16 n;
2841 // now splitt the windows
2842 if ( nDelta < 0 )
2843 {
2844 if ( bGreat )
2845 {
2846 if ( bPropGreat )
2847 {
2848 long nTempDelta = nDelta;
2849 do
2850 {
2851 n = nPos+1;
2852 do
2853 {
2854 if ( nTempDelta )
2855 {
2856 rItems[n]->mnPixSize++;
2857 nTempDelta++;
2858 }
2859 n++;
2860 }
2861 while ( n < nMax );
2862 }
2863 while ( nTempDelta );
2864 }
2865 else
2866 rItems[nPos+1]->mnPixSize -= nDelta;
2867 }
2868
2869 if ( bSmall )
2870 {
2871 if ( bPropSmall )
2872 {
2873 do
2874 {
2875 n = nPos+1;
2876 do
2877 {
2878 if ( nDelta && rItems[n-1]->mnPixSize )
2879 {
2880 rItems[n-1]->mnPixSize--;
2881 nDelta++;
2882 }
2883
2884 n--;
2885 }
2886 while ( n > nMin );
2887 }
2888 while ( nDelta );
2889 }
2890 else
2891 {
2892 n = nPos+1;
2893 do
2894 {
2895 if ( rItems[n-1]->mnPixSize+nDelta < 0 )
2896 {
2897 nDelta += rItems[n-1]->mnPixSize;
2898 rItems[n-1]->mnPixSize = 0;
2899 }
2900 else
2901 {
2902 rItems[n-1]->mnPixSize += nDelta;
2903 break;
2904 }
2905 n--;
2906 }
2907 while ( n > nMin );
2908 }
2909 }
2910 }
2911 else
2912 {
2913 if ( bGreat )
2914 {
2915 if ( bPropGreat )
2916 {
2917 long nTempDelta = nDelta;
2918 do
2919 {
2920 n = nPos+1;
2921 do
2922 {
2923 if ( nTempDelta )
2924 {
2925 rItems[n-1]->mnPixSize++;
2926 nTempDelta--;
2927 }
2928 n--;
2929 }
2930 while ( n > nMin );
2931 }
2932 while ( nTempDelta );
2933 }
2934 else
2935 rItems[nPos]->mnPixSize += nDelta;
2936 }
2937
2938 if ( bSmall )
2939 {
2940 if ( bPropSmall )
2941 {
2942 do
2943 {
2944 n = nPos+1;
2945 do
2946 {
2947 if ( nDelta && rItems[n]->mnPixSize )
2948 {
2949 rItems[n]->mnPixSize--;
2950 nDelta--;
2951 }
2952
2953 n++;
2954 }
2955 while ( n < nMax );
2956 }
2957 while ( nDelta );
2958 }
2959 else
2960 {
2961 n = nPos+1;
2962 do
2963 {
2964 if ( rItems[n]->mnPixSize-nDelta < 0 )
2965 {
2966 nDelta -= rItems[n]->mnPixSize;
2967 rItems[n]->mnPixSize = 0;
2968 }
2969 else
2970 {
2971 rItems[n]->mnPixSize -= nDelta;
2972 break;
2973 }
2974 n++;
2975 }
2976 while ( n < nMax );
2977 }
2978 }
2979 }
2980
2981 // update original sizes
2982 ImplCalcLogSize( rItems, nItems );
2983
2984 ImplUpdate();
2985 }
2986
2987 void SplitWindow::SetItemSize( sal_uInt16 nId, long nNewSize )
2988 {
2989 sal_uInt16 nPos;
2990 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos );
2991 ImplSplitItem* pItem;
2992
2993 if ( !pSet )
2994 return;
2995
2996 // check if size is changed
2997 pItem = pSet->mpItems[nPos];
2998 if ( pItem->mnSize != nNewSize )
2999 {
3000 // set new size and re-calculate
3001 pItem->mnSize = nNewSize;
3002 pSet->mbCalcPix = true;
3003 ImplUpdate();
3004 }
3005 }
3006
3007 long SplitWindow::GetItemSize( sal_uInt16 nId ) const
3008 {
3009 sal_uInt16 nPos;
3010 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos );
3011
3012 if ( pSet )
3013 return pSet->mpItems[nPos]->mnSize;
3014 else
3015 return 0;
3016 }
3017
3018 long SplitWindow::GetItemSize( sal_uInt16 nId, SplitWindowItemFlags nBits ) const
3019 {
3020 sal_uInt16 nPos;
3021 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos );
3022
3023 if ( pSet )
3024 {
3025 if ( nBits == pSet->mpItems[nPos]->mnBits )
3026 return pSet->mpItems[nPos]->mnSize;
3027 else
3028 {
3029 const_cast<SplitWindow*>(this)->ImplCalcLayout();
3030
3031 long nRelSize = 0;
3032 long nPerSize = 0;
3033 size_t nItems;
3034 SplitWindowItemFlags nTempBits;
3035 sal_uInt16 i;
3036 nItems = pSet->mpItems.size();
3037 std::vector< ImplSplitItem* >& rItems = pSet->mpItems;
3038 for ( i = 0; i < nItems; i++ )
3039 {
3040 if ( i == nPos )
3041 nTempBits = nBits;
3042 else
3043 nTempBits = rItems[i]->mnBits;
3044 if ( nTempBits & SplitWindowItemFlags::RelativeSize )
3045 nRelSize += rItems[i]->mnPixSize;
3046 else if ( nTempBits & SplitWindowItemFlags::PercentSize )
3047 nPerSize += rItems[i]->mnPixSize;
3048 }
3049 nPerSize += nRelSize;
3050 if ( nBits & SplitWindowItemFlags::RelativeSize )
3051 {
3052 if ( nRelSize )
3053 return (rItems[nPos]->mnPixSize+(nRelSize/2))/nRelSize;
3054 else
3055 return 1;
3056 }
3057 else if ( nBits & SplitWindowItemFlags::PercentSize )
3058 {
3059 if ( nPerSize )
3060 return (rItems[nPos]->mnPixSize*100)/nPerSize;
3061 else
3062 return 1;
3063 }
3064 else
3065 return rItems[nPos]->mnPixSize;
3066 }
3067 }
3068 else
3069 return 0;
3070 }
3071
3072 void SplitWindow::SetItemSizeRange (sal_uInt16 nId, const Range& rRange)
3073 {
3074 sal_uInt16 nPos;
3075 ImplSplitSet* pSet = ImplFindItem(mpBaseSet, nId, nPos);
3076
3077 if (pSet != nullptr)
3078 {
3079 pSet->mpItems[nPos]->mnMinSize = rRange.Min();
3080 pSet->mpItems[nPos]->mnMaxSize = rRange.Max();
3081 }
3082 }
3083
3084 sal_uInt16 SplitWindow::GetSet( sal_uInt16 nId ) const
3085 {
3086 sal_uInt16 nPos;
3087 ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, nPos );
3088
3089 if ( pSet )
3090 return pSet->mnId;
3091 else
3092 return 0;
3093 }
3094
3095 bool SplitWindow::IsItemValid( sal_uInt16 nId ) const
3096 {
3097 sal_uInt16 nPos;
3098 ImplSplitSet* pSet = mpBaseSet ? ImplFindItem(mpBaseSet, nId, nPos) : nullptr;
3099
3100 if ( pSet )
3101 return true;
3102 else
3103 return false;
3104 }
3105
3106 sal_uInt16 SplitWindow::GetItemId( vcl::Window* pWindow ) const
3107 {
3108 return ImplFindItem( mpBaseSet, pWindow );
3109 }
3110
3111 sal_uInt16 SplitWindow::GetItemId( const Point& rPos ) const
3112 {
3113 return ImplFindItem( mpBaseSet, rPos, mbHorz, !mbBottomRight );
3114 }
3115
3116 sal_uInt16 SplitWindow::GetItemPos( sal_uInt16 nId, sal_uInt16 nSetId ) const
3117 {
3118 ImplSplitSet* pSet = ImplFindSet( mpBaseSet, nSetId );
3119 sal_uInt16 nPos = SPLITWINDOW_ITEM_NOTFOUND;
3120
3121 if ( pSet )
3122 {
3123 for ( size_t i = 0; i < pSet->mpItems.size(); i++ )
3124 {
3125 if ( pSet->mpItems[i]->mnId == nId )
3126 {
3127 nPos = i;
3128 break;
3129 }
3130 }
3131 }
3132
3133 return nPos;
3134 }
3135
3136 sal_uInt16 SplitWindow::GetItemId( sal_uInt16 nPos ) const
3137 {
3138 ImplSplitSet* pSet = ImplFindSet( mpBaseSet, 0/*nSetId*/ );
3139 if ( pSet && (nPos < pSet->mpItems.size()) )
3140 return pSet->mpItems[nPos]->mnId;
3141 else
3142 return 0;
3143 }
3144
3145 sal_uInt16 SplitWindow::GetItemCount( sal_uInt16 nSetId ) const
3146 {
3147 ImplSplitSet* pSet = ImplFindSet( mpBaseSet, nSetId );
3148 if ( pSet )
3149 return pSet->mpItems.size();
3150 else
3151 return 0;
3152 }
3153
3154 void SplitWindow::ImplNewAlign()
3155 {
3156 switch ( meAlign )
3157 {
3158 case WindowAlign::Top:
3159 mbHorz = true;
3160 mbBottomRight = false;
3161 break;
3162 case WindowAlign::Bottom:
3163 mbHorz = true;
3164 mbBottomRight = true;
3165 break;
3166 case WindowAlign::Left:
3167 mbHorz = false;
3168 mbBottomRight = false;
3169 break;
3170 case WindowAlign::Right:
3171 mbHorz = false;
3172 mbBottomRight = true;
3173 break;
3174 }
3175
3176 if ( mnWinStyle & WB_BORDER )
3177 {
3178 ImplCalcBorder( meAlign, false/*bNoAlign*/, mnLeftBorder, mnTopBorder,
3179 mnRightBorder, mnBottomBorder );
3180 }
3181
3182 if ( IsReallyVisible() && IsUpdateMode() )
3183 Invalidate();
3184 ImplUpdate();
3185 }
3186
3187 void SplitWindow::SetAlign( WindowAlign eNewAlign )
3188 {
3189 if ( meAlign != eNewAlign )
3190 {
3191 meAlign = eNewAlign;
3192 ImplNewAlign();
3193 }
3194 }
3195
3196 void SplitWindow::ShowAutoHideButton( bool bShow )
3197 {
3198 mbAutoHide = bShow;
3199 ImplUpdate();
3200 }
3201
3202 void SplitWindow::ShowFadeInHideButton()
3203 {
3204 mbFadeIn = true;
3205 ImplUpdate();
3206 }
3207
3208 void SplitWindow::ShowFadeOutButton()
3209 {
3210 mbFadeOut = true;
3211 ImplUpdate();
3212 }
3213
3214 void SplitWindow::SetAutoHideState( bool bAutoHide )
3215 {
3216 mbAutoHideIn = bAutoHide;
3217 if ( IsReallyVisible() )
3218 {
3219 Rectangle aRect;
3220 ImplGetAutoHideRect( aRect );
3221 Invalidate( aRect );
3222 }
3223 }
3224
3225 long SplitWindow::GetFadeInSize() const
3226 {
3227 long n = 0;
3228
3229 if ( mbHorz )
3230 n = mnTopBorder+mnBottomBorder;
3231 else
3232 n = mnLeftBorder+mnRightBorder;
3233
3234 return n+SPLITWIN_SPLITSIZE+SPLITWIN_SPLITSIZEEX-2;
3235 }
3236
3237 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE