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