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