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