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