xref: /aoo41x/main/vcl/source/window/splitwin.cxx (revision 682030f5)

/**************************************************************
 *
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 *
 *************************************************************/



// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_vcl.hxx"

#include <string.h>

#include <tools/list.hxx>
#include <tools/debug.hxx>
#include <tools/rcid.h>

#include <vcl/event.hxx>
#include <vcl/wall.hxx>
#include <vcl/bitmap.hxx>
#include <vcl/decoview.hxx>
#include <vcl/symbol.hxx>
#include <vcl/image.hxx>
#include <vcl/help.hxx>
#include <vcl/splitwin.hxx>

#include <svdata.hxx>
#include <svids.hrc>


// =======================================================================

// Attention: Must not contain non-PODs because array is enlarged/copied
// with the use of memmove/memcpy.
struct ImplSplitItem
{
	long				mnSize;
	long				mnPixSize;
	long				mnLeft;
	long				mnTop;
	long				mnWidth;
	long				mnHeight;
	long				mnSplitPos;
	long				mnSplitSize;
	long				mnOldSplitPos;
	long				mnOldSplitSize;
	long				mnOldWidth;
	long				mnOldHeight;
	ImplSplitSet*		mpSet;
	Window* 			mpWindow;
	Window* 			mpOrgParent;
	sal_uInt16				mnId;
	SplitWindowItemBits mnBits;
	sal_Bool				mbFixed;
	sal_Bool				mbSubSize;
    /// Minimal width or height of the item.  -1 means no restriction.
    long                mnMinSize;
    /// Maximal width or height of the item.  -1 means no restriction.
    long                mnMaxSize;
};

struct ImplSplitSet
{
	ImplSplitItem*		mpItems;
	Wallpaper*			mpWallpaper;
	Bitmap* 			mpBitmap;
	long				mnLastSize;
	long				mnSplitSize;
	sal_uInt16				mnItems;
	sal_uInt16				mnId;
	sal_Bool				mbCalcPix;
};



/** Check whether the given size is inside the valid range defined by
    [rItem.mnMinSize,rItem.mnMaxSize].  When it is not inside it then return
    the upper or lower bound, respectively. Otherwise return the given size
    unmodified.
    Note that either mnMinSize and/or mnMaxSize can be -1 in which case the
    size has not lower or upper bound.
*/
namespace {
    long ValidateSize (const long nSize, const ImplSplitItem& rItem)
    {
        if (rItem.mnMinSize>=0 && nSize<rItem.mnMinSize)
            return rItem.mnMinSize;
        else if (rItem.mnMaxSize>0 && nSize>rItem.mnMaxSize)
            return rItem.mnMaxSize;
        else
            return nSize;
    }
}


#define SPLITWIN_SPLITSIZE				3
#define SPLITWIN_SPLITSIZEEX			4
#define SPLITWIN_SPLITSIZEEXLN			6
#define SPLITWIN_SPLITSIZEAUTOHIDE		36
#define SPLITWIN_SPLITSIZEFADE			36

#define SPLIT_HORZ				((sal_uInt16)0x0001)
#define SPLIT_VERT				((sal_uInt16)0x0002)
#define SPLIT_WINDOW			((sal_uInt16)0x0004)
#define SPLIT_NOSPLIT			((sal_uInt16)0x8000)

// -----------------------------------------------------------------------

DECLARE_LIST( ImplSplitList, SplitWindow* )

// =======================================================================

static void ImplCalcBorder( WindowAlign eAlign, sal_Bool bNoAlign,
							long& rLeft, long& rTop,
							long& rRight, long& rBottom )
{
	if ( bNoAlign )
	{
		rLeft	= 2;
		rTop	= 2;
		rRight	= 2;
		rBottom = 2;
	}
	else
	{
		if ( eAlign == WINDOWALIGN_TOP )
		{
			rLeft	= 2;
			rTop	= 2;
			rRight	= 2;
			rBottom = 0;
		}
		else if ( eAlign == WINDOWALIGN_LEFT )
		{
			rLeft	= 2;
			rTop	= 2;
			rRight	= 0;
			rBottom = 2;
		}
		else if ( eAlign == WINDOWALIGN_BOTTOM )
		{
			rLeft	= 2;
			rTop	= 0;
			rRight	= 2;
			rBottom = 2;
		}
		else
		{
			rLeft	= 0;
			rTop	= 2;
			rRight	= 2;
			rBottom = 2;
		}
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawBorder( SplitWindow* pWin )
{
	const StyleSettings&	rStyleSettings = pWin->GetSettings().GetStyleSettings();
	long					nDX = pWin->mnDX;
	long					nDY = pWin->mnDY;

	if ( pWin->mbNoAlign )
	{
		DecorationView	aDecoView( pWin );
		Point			aTmpPoint;
		Rectangle		aRect( aTmpPoint, Size( nDX, nDY ) );
		aDecoView.DrawFrame( aRect, FRAME_DRAW_DOUBLEIN );
	}
	else
	{/*
		if ( pWin->meAlign == WINDOWALIGN_BOTTOM )
		{
			pWin->SetLineColor( rStyleSettings.GetShadowColor() );
			pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) );
			pWin->SetLineColor( rStyleSettings.GetLightColor() );
			pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) );
		}
		else
		{
			pWin->SetLineColor( rStyleSettings.GetShadowColor() );
			pWin->DrawLine( Point( 0, 0 ), Point( nDX-1, 0 ) );
			pWin->SetLineColor( rStyleSettings.GetLightColor() );
			pWin->DrawLine( Point( 0, 1 ), Point( nDX-1, 1 ) );
			if ( (pWin->meAlign == WINDOWALIGN_LEFT) || (pWin->meAlign == WINDOWALIGN_RIGHT) )
			{
				if ( pWin->meAlign == WINDOWALIGN_LEFT )
				{
					pWin->SetLineColor( rStyleSettings.GetShadowColor() );
					pWin->DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) );
					pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) );
					pWin->SetLineColor( rStyleSettings.GetLightColor() );
					pWin->DrawLine( Point( 1, 1 ), Point( 1, nDY-3 ) );
					pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) );
				}
				else
				{
					pWin->SetLineColor( rStyleSettings.GetShadowColor() );
					pWin->DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-3 ) );
					pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-2, nDY-2 ) );
					pWin->SetLineColor( rStyleSettings.GetLightColor() );
					pWin->DrawLine( Point( nDX-1, 0 ), Point( nDX-1, nDY-1 ) );
					pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) );
				}
			}
		}*/
		if ( pWin->meAlign == WINDOWALIGN_BOTTOM )
		{
			pWin->SetLineColor( rStyleSettings.GetShadowColor() );
			pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) );
			pWin->DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) );
    		pWin->DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-3 ) );

            pWin->SetLineColor( rStyleSettings.GetLightColor() );
			pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) );
			pWin->DrawLine( Point( 1, 1 ), Point( 1, nDY-3 ) );
			pWin->DrawLine( Point( nDX-1, 0 ), Point( nDX-1, nDY-1 ) );
		}
		else if ( pWin->meAlign == WINDOWALIGN_TOP )
		{
			pWin->SetLineColor( rStyleSettings.GetShadowColor() );
			pWin->DrawLine( Point( 0, 0 ), Point( nDX-1, 0 ) );
			pWin->DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) );
    		pWin->DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-1 ) );

            pWin->SetLineColor( rStyleSettings.GetLightColor() );
			pWin->DrawLine( Point( 1, 1 ), Point( nDX-3, 1 ) );
			pWin->DrawLine( Point( 1, 1 ), Point( 1, nDY-1 ) );
			pWin->DrawLine( Point( nDX-1, 1 ), Point( nDX-1, nDY-1 ) );
        }
        else if ( pWin->meAlign == WINDOWALIGN_LEFT )
        {
            pWin->SetLineColor( rStyleSettings.GetShadowColor() );
			pWin->DrawLine( Point( 0, 0 ), Point( nDX-1, 0 ) );
			pWin->DrawLine( Point( 0, 0 ), Point( 0, nDY-1 ) );
			pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-1, nDY-2 ) );

            pWin->SetLineColor( rStyleSettings.GetLightColor() );
			pWin->DrawLine( Point( 1, 1 ), Point( nDX-1, 1 ) );
			pWin->DrawLine( Point( 1, 1 ), Point( 1, nDY-3 ) );
			pWin->DrawLine( Point( 1, nDY-1 ), Point( nDX-1, nDY-1 ) );
		}
        else
        {
            pWin->SetLineColor( rStyleSettings.GetShadowColor() );
			pWin->DrawLine( Point( 0, 0 ), Point( nDX-2, 0 ) );
			pWin->DrawLine( Point( nDX-2, 0 ), Point( nDX-2, nDY-3 ) );
			pWin->DrawLine( Point( 0, nDY-2 ), Point( nDX-2, nDY-2 ) );

            pWin->SetLineColor( rStyleSettings.GetLightColor() );
			pWin->DrawLine( Point( 0, 1 ), Point( nDX-3, 1 ) );
			pWin->DrawLine( Point( nDX-1, 0 ), Point( nDX-1, nDY-1 ) );
			pWin->DrawLine( Point( 0, nDY-1 ), Point( nDX-1, nDY-1 ) );
		}
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawBorderLine( SplitWindow* pWin )
{
    if ( pWin->mbFadeOut || pWin->mbAutoHide )
    {
        const StyleSettings&	rStyleSettings = pWin->GetSettings().GetStyleSettings();
        long					nDX = pWin->mnDX;
        long					nDY = pWin->mnDY;

        if ( pWin->meAlign == WINDOWALIGN_LEFT )
        {
            pWin->SetLineColor( rStyleSettings.GetShadowColor() );
            pWin->DrawLine( Point( nDX-SPLITWIN_SPLITSIZEEXLN-1, 0 ), Point( nDX-SPLITWIN_SPLITSIZEEXLN-1, nDY-3 ) );
            pWin->SetLineColor( rStyleSettings.GetLightColor() );
            pWin->DrawLine( Point( nDX-SPLITWIN_SPLITSIZEEXLN, 1 ), Point( nDX-SPLITWIN_SPLITSIZEEXLN, nDY-4 ) );
        }
        else if ( pWin->meAlign == WINDOWALIGN_RIGHT )
        {
            pWin->SetLineColor( rStyleSettings.GetShadowColor() );
            pWin->DrawLine( Point( SPLITWIN_SPLITSIZEEXLN-1, 0 ), Point( SPLITWIN_SPLITSIZEEXLN-1, nDY-3 ) );
            pWin->SetLineColor( rStyleSettings.GetLightColor() );
            pWin->DrawLine( Point( SPLITWIN_SPLITSIZEEXLN, 1 ), Point( SPLITWIN_SPLITSIZEEXLN, nDY-4 ) );
        }
        else if ( pWin->meAlign == WINDOWALIGN_TOP )
        {
            pWin->SetLineColor( rStyleSettings.GetShadowColor() );
            pWin->DrawLine( Point( 0, nDY-SPLITWIN_SPLITSIZEEXLN-1 ), Point( nDX-3, nDY-SPLITWIN_SPLITSIZEEXLN-1 ) );
            pWin->SetLineColor( rStyleSettings.GetLightColor() );
            pWin->DrawLine( Point( 1, nDY-SPLITWIN_SPLITSIZEEXLN ), Point( nDX-4, nDY-SPLITWIN_SPLITSIZEEXLN ) );
        }
        else if ( pWin->meAlign == WINDOWALIGN_BOTTOM )
        {
            pWin->SetLineColor( rStyleSettings.GetShadowColor() );
            pWin->DrawLine( Point( 0, SPLITWIN_SPLITSIZEEXLN-1 ), Point( nDX-3, SPLITWIN_SPLITSIZEEXLN-1 ) );
            pWin->SetLineColor( rStyleSettings.GetLightColor() );
            pWin->DrawLine( Point( 1, SPLITWIN_SPLITSIZEEXLN ), Point( nDX-4, SPLITWIN_SPLITSIZEEXLN ) );
        }
    }
}

// -----------------------------------------------------------------------

static ImplSplitSet* ImplFindSet( ImplSplitSet* pSet, sal_uInt16 nId )
{
	if ( pSet->mnId == nId )
		return pSet;

	sal_uInt16			i;
	sal_uInt16			nItems = pSet->mnItems;
	ImplSplitItem*	pItems = pSet->mpItems;

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mnId == nId )
			return pItems[i].mpSet;
	}

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpSet )
		{
			ImplSplitSet* pFindSet = ImplFindSet( pItems[i].mpSet, nId );
			if ( pFindSet )
				return pFindSet;
		}
	}

	return NULL;
}

// -----------------------------------------------------------------------

static ImplSplitSet* ImplFindItem( ImplSplitSet* pSet, sal_uInt16 nId, sal_uInt16& rPos )
{
	sal_uInt16			i;
	sal_uInt16			nItems = pSet->mnItems;
	ImplSplitItem*	pItems = pSet->mpItems;

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mnId == nId )
		{
			rPos = i;
			return pSet;
		}
	}

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpSet )
		{
			ImplSplitSet* pFindSet = ImplFindItem( pItems[i].mpSet, nId, rPos );
			if ( pFindSet )
				return pFindSet;
		}
	}

	return NULL;
}

// -----------------------------------------------------------------------

static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, Window* pWindow )
{
	sal_uInt16			i;
	sal_uInt16			nItems = pSet->mnItems;
	ImplSplitItem*	pItems = pSet->mpItems;

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpWindow == pWindow )
			return pItems[i].mnId;
		else
		{
			if ( pItems[i].mpSet )
			{
				sal_uInt16 nId = ImplFindItem( pItems[i].mpSet, pWindow );
				if ( nId )
					return nId;
			}
		}
	}

	return 0;
}

// -----------------------------------------------------------------------

static sal_uInt16 ImplFindItem( ImplSplitSet* pSet, const Point& rPos,
							sal_Bool bRows, sal_Bool bDown = sal_True )
{
	sal_uInt16			i;
	sal_uInt16			nItems = pSet->mnItems;
	ImplSplitItem*	pItems = pSet->mpItems;

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mnWidth && pItems[i].mnHeight )
		{
			// Wegen ICC auftrennen
			Point		aPoint( pItems[i].mnLeft, pItems[i].mnTop );
			Size		aSize( pItems[i].mnWidth, pItems[i].mnHeight );
			Rectangle	aRect( aPoint, aSize );
			if ( bRows )
			{
				if ( bDown )
					aRect.Bottom() += pSet->mnSplitSize;
				else
					aRect.Top() -= pSet->mnSplitSize;
			}
			else
			{
				if ( bDown )
					aRect.Right() += pSet->mnSplitSize;
				else
					aRect.Left() -= pSet->mnSplitSize;
			}

			if ( aRect.IsInside( rPos ) )
			{
				if ( pItems[i].mpSet && pItems[i].mpSet->mpItems )
				{
					return ImplFindItem( pItems[i].mpSet, rPos,
										((pItems[i].mnBits & SWIB_COLSET) == 0) );
				}
				else
					return pItems[i].mnId;
			}
		}
	}

	return 0;
}

// -----------------------------------------------------------------------

static void ImplDeleteSet( ImplSplitSet* pSet )
{
	sal_uInt16			i;
	sal_uInt16			nItems = pSet->mnItems;
	ImplSplitItem*	pItems = pSet->mpItems;

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpSet )
			ImplDeleteSet( pItems[i].mpSet );
	}

	if ( pSet->mpWallpaper )
		delete pSet->mpWallpaper;

	if ( pSet->mpBitmap )
		delete pSet->mpBitmap;

	delete [] pItems;
	delete pSet;
}

// -----------------------------------------------------------------------

static void ImplSetSplitSize( ImplSplitSet* pSet, long nNewSize )
{
	pSet->mnSplitSize = nNewSize;
	for ( sal_uInt16 i = 0; i < pSet->mnItems; i++ )
	{
		if ( pSet->mpItems[i].mpSet )
			ImplSetSplitSize( pSet->mpItems[i].mpSet, nNewSize );
	}
}

// -----------------------------------------------------------------------

static void ImplCalcSet( ImplSplitSet* pSet,
						 long nSetLeft, long nSetTop,
						 long nSetWidth, long nSetHeight,
						 sal_Bool bRows, sal_Bool bDown = sal_True )
{
	if ( !pSet->mpItems )
		return;

	sal_uInt16				i;
	sal_uInt16				j;
	sal_uInt16				nMins;
	sal_uInt16				nCalcItems;
	sal_uInt16				nItems = pSet->mnItems;
	sal_uInt16				nVisItems;
	sal_uInt16				nAbsItems;
	long				nCalcSize;
	long				nSizeDelta;
	long				nCurSize;
	long				nSizeWinSize;
	long				nNewSizeWinSize;
	long				nTemp;
	long				nTempErr;
	long				nErrorSum;
	long				nCurSizeDelta;
	long				nPos;
	long				nMaxPos;
	long*				pSize;
	ImplSplitItem*		pItems = pSet->mpItems;
	sal_Bool				bEmpty;

	// Anzahl sichtbarer Items ermitteln
	nVisItems = 0;
	for ( i = 0; i < nItems; i++ )
	{
		if ( !(pItems[i].mnBits & SWIB_INVISIBLE) )
			nVisItems++;
	}

	// Groessen berechnen
	if ( bRows )
		nCalcSize = nSetHeight;
	else
		nCalcSize = nSetWidth;
	nCalcSize -= (nVisItems-1)*pSet->mnSplitSize;
	nCurSize   = 0;
	if ( pSet->mbCalcPix || (pSet->mnLastSize != nCalcSize) )
	{
		long nPercentFactor = 10;
		long nRelCount		= 0;
		long nPercent		= 0;
		long nRelPercent	= 0;
		long nAbsSize		= 0;
		for ( i = 0; i < nItems; i++ )
		{
			if ( !(pItems[i].mnBits & SWIB_INVISIBLE) )
			{
				if ( pItems[i].mnBits & SWIB_RELATIVESIZE )
					nRelCount += pItems[i].mnSize;
				else if ( pItems[i].mnBits & SWIB_PERCENTSIZE )
					nPercent += pItems[i].mnSize;
				else
					nAbsSize += pItems[i].mnSize;
			}
		}
		// Relative-Werte auf prozentual mappen (Percent bei uns 10tel Prozent)
		nPercent *= nPercentFactor;
		if ( nRelCount )
		{
			long nRelPercentBase = 1000;
			while ( (nRelCount > nRelPercentBase) && (nPercentFactor < 100000) )
			{
				nRelPercentBase *= 10;
				nPercentFactor *= 10;
			}
			if ( nPercent < nRelPercentBase )
			{
				nRelPercent = (nRelPercentBase-nPercent)/nRelCount;
				nPercent += nRelPercent*nRelCount;
			}
			else
				nRelPercent = 0;
		}
		if ( !nPercent )
			nPercent = 1;
		nSizeDelta = nCalcSize-nAbsSize;
		for ( i = 0; i < nItems; i++ )
		{
			if ( pItems[i].mnBits & SWIB_INVISIBLE )
				pItems[i].mnPixSize = 0;
			else if ( pItems[i].mnBits & SWIB_RELATIVESIZE )
			{
				if ( nSizeDelta <= 0 )
					pItems[i].mnPixSize = 0;
				else
					pItems[i].mnPixSize = (nSizeDelta*pItems[i].mnSize*nRelPercent)/nPercent;
			}
			else if ( pItems[i].mnBits & SWIB_PERCENTSIZE )
			{
				if ( nSizeDelta <= 0 )
					pItems[i].mnPixSize = 0;
				else
					pItems[i].mnPixSize = (nSizeDelta*pItems[i].mnSize*nPercentFactor)/nPercent;
			}
			else
				pItems[i].mnPixSize = pItems[i].mnSize;
			nCurSize += pItems[i].mnPixSize;
		}

		pSet->mbCalcPix  = sal_False;
		pSet->mnLastSize = nCalcSize;

		// Fenster einpassen
		nSizeDelta	= nCalcSize-nCurSize;
		if ( nSizeDelta )
		{
			nAbsItems		= 0;
			nSizeWinSize	= 0;
			nNewSizeWinSize = 0;

			// Zuerst die absoluten Items relativ resizen
			for ( i = 0; i < nItems; i++ )
			{
				if ( !(pItems[i].mnBits & SWIB_INVISIBLE) )
				{
					if ( !(pItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE)) )
					{
						nAbsItems++;
						nSizeWinSize += pItems[i].mnPixSize;
					}
				}
			}
			// Rundungsfehler werden hier nicht ausgelichen
			if ( (nAbsItems < (sal_uInt16)(Abs( nSizeDelta ))) && nSizeWinSize )
			{
				for ( i = 0; i < nItems; i++ )
				{
					if ( !(pItems[i].mnBits & SWIB_INVISIBLE) )
					{
						if ( !(pItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE)) )
						{
							pItems[i].mnPixSize += (nSizeDelta*pItems[i].mnPixSize)/nSizeWinSize;
							nNewSizeWinSize += pItems[i].mnPixSize;
						}
					}
				}
				nSizeDelta -= nNewSizeWinSize-nSizeWinSize;
			}

			// Jetzt die Rundunsfehler ausgleichen
			j			= 0;
			nMins		= 0;
			while ( nSizeDelta && (nItems != nMins) )
			{
				// Feststellen, welche Items berechnet werden duerfen
				nCalcItems = 0;
				while ( !nCalcItems )
				{
					for ( i = 0; i < nItems; i++ )
					{
						pItems[i].mbSubSize = sal_False;

						if ( j >= 2 )
							pItems[i].mbSubSize = sal_True;
						else
						{
							if ( !(pItems[i].mnBits & SWIB_INVISIBLE) )
							{
								if ( (nSizeDelta > 0) || pItems[i].mnPixSize )
								{
									if ( j >= 1 )
										pItems[i].mbSubSize = sal_True;
									else
									{
										if ( (j == 0) && (pItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE)) )
											pItems[i].mbSubSize = sal_True;
									}
								}
							}
						}

						if ( pItems[i].mbSubSize )
							nCalcItems++;
					}

					j++;
				}

				// Groessen von den einzelnen Items abziehen
				nErrorSum		= nSizeDelta % nCalcItems;
				nCurSizeDelta	= nSizeDelta / nCalcItems;
				nMins			= 0;
				for ( i = 0; i < nItems; i++ )
				{
					if ( pItems[i].mnBits & SWIB_INVISIBLE )
						nMins++;
					else if ( pItems[i].mbSubSize )
					{
						pSize = &(pItems[i].mnPixSize);

						if ( nErrorSum )
						{
							if ( nErrorSum < 0 )
								nTempErr = -1;
							else
								nTempErr = 1;
						}
						else
							nTempErr = 0;

						if ( (*pSize+nCurSizeDelta+nTempErr) <= 0 )
						{
							nTemp = *pSize;
							if ( nTemp )
							{
								*pSize -= nTemp;
								nSizeDelta += nTemp;
							}
							nMins++;
						}
						else
						{
							*pSize += nCurSizeDelta;
							nSizeDelta -= nCurSizeDelta;
							if ( nTempErr && (*pSize || (nTempErr > 0)) )
							{
								*pSize += nTempErr;
								nSizeDelta -= nTempErr;
								nErrorSum -= nTempErr;
							}
						}
					}
				}
			}
		}
	}
	else
	{
		for ( i = 0; i < nItems; i++ )
		{
			if ( !(pItems[i].mnBits & SWIB_INVISIBLE) )
				nCurSize += pItems[i].mnPixSize;
		}
	}

	// Maximale Groesse berechnen
	if ( bRows )
	{
		nPos = nSetTop;
		if ( !bDown )
			nMaxPos = nSetTop-nSetHeight;
		else
			nMaxPos = nSetTop+nSetHeight;
	}
	else
	{
		nPos = nSetLeft;
		if ( !bDown )
			nMaxPos = nSetLeft-nSetWidth;
		else
			nMaxPos = nSetLeft+nSetWidth;
	}

	// Fenster anordnen und Werte anpassen
	for ( i = 0; i < nItems; i++ )
	{
		pItems[i].mnOldSplitPos    = pItems[i].mnSplitPos;
		pItems[i].mnOldSplitSize   = pItems[i].mnSplitSize;
		pItems[i].mnOldWidth	   = pItems[i].mnWidth;
		pItems[i].mnOldHeight	   = pItems[i].mnHeight;

		if ( pItems[i].mnBits & SWIB_INVISIBLE )
			bEmpty = sal_True;
		else
		{
			bEmpty = sal_False;
			if ( bDown )
			{
				if ( nPos+pItems[i].mnPixSize > nMaxPos )
					bEmpty = sal_True;
			}
			else
			{
				nPos -= pItems[i].mnPixSize;
				if ( nPos < nMaxPos )
					bEmpty = sal_True;
			}
		}

		if ( bEmpty )
		{
			pItems[i].mnWidth	  = 0;
			pItems[i].mnHeight	  = 0;
			pItems[i].mnSplitSize = 0;
		}
		else
		{
			if ( bRows )
			{
				pItems[i].mnLeft   = nSetLeft;
				pItems[i].mnTop    = nPos;
				pItems[i].mnWidth  = nSetWidth;
				pItems[i].mnHeight = pItems[i].mnPixSize;
			}
			else
			{
				pItems[i].mnLeft   = nPos;
				pItems[i].mnTop    = nSetTop;
				pItems[i].mnWidth  = pItems[i].mnPixSize;
				pItems[i].mnHeight = nSetHeight;
			}

			if ( i > nItems-1 )
				pItems[i].mnSplitSize = 0;
			else
			{
				pItems[i].mnSplitSize = pSet->mnSplitSize;
				if ( bDown )
				{
					pItems[i].mnSplitPos  = nPos+pItems[i].mnPixSize;
					if ( pItems[i].mnSplitPos+pItems[i].mnSplitSize > nMaxPos )
						pItems[i].mnSplitSize = nMaxPos-pItems[i].mnSplitPos;
				}
				else
				{
					pItems[i].mnSplitPos = nPos-pSet->mnSplitSize;
					if ( pItems[i].mnSplitPos < nMaxPos )
						pItems[i].mnSplitSize = pItems[i].mnSplitPos+pSet->mnSplitSize-nMaxPos;
				}
			}
		}

		if ( !(pItems[i].mnBits & SWIB_INVISIBLE) )
		{
			if ( !bDown )
				nPos -= pSet->mnSplitSize;
			else
				nPos += pItems[i].mnPixSize+pSet->mnSplitSize;
		}
	}

	// Sub-Set's berechnen
	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpSet && pItems[i].mnWidth && pItems[i].mnHeight )
		{
			ImplCalcSet( pItems[i].mpSet,
						 pItems[i].mnLeft, pItems[i].mnTop,
						 pItems[i].mnWidth, pItems[i].mnHeight,
						 ((pItems[i].mnBits & SWIB_COLSET) == 0) );
		}
	}

	// Fixed setzen
	for ( i = 0; i < nItems; i++ )
	{
		pItems[i].mbFixed = sal_False;
		if ( pItems[i].mnBits & SWIB_FIXED )
			pItems[i].mbFixed = sal_True;
		else
		{
			// Wenn Child-Set vorhanden, ist dieses Item auch Fixed, wenn
			// ein Child fixed ist
			if ( pItems[i].mpSet )
			{
				for ( j = 0; j < pItems[i].mpSet->mnItems; j++ )
				{
					if ( pItems[i].mpSet->mpItems[j].mbFixed )
					{
						pItems[i].mbFixed = sal_True;
						break;
					}
				}
			}
		}
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplCalcSet2( SplitWindow* pWindow, ImplSplitSet* pSet, sal_Bool bHide,
						        sal_Bool bRows, sal_Bool /*bDown*/ )
{
	sal_uInt16			i;
	sal_uInt16			nItems = pSet->mnItems;
	ImplSplitItem*	pItems = pSet->mpItems;

	if ( pWindow->IsReallyVisible() && pWindow->IsUpdateMode() && pWindow->mbInvalidate )
	{
		for ( i = 0; i < nItems; i++ )
		{
			if ( pItems[i].mnSplitSize )
			{
				// Evt. alles invalidieren oder nur einen kleinen Teil
				if ( (pItems[i].mnOldSplitPos  != pItems[i].mnSplitPos)  ||
					 (pItems[i].mnOldSplitSize != pItems[i].mnSplitSize) ||
					 (pItems[i].mnOldWidth	   != pItems[i].mnWidth)	 ||
					 (pItems[i].mnOldHeight    != pItems[i].mnHeight) )
				{
					Rectangle aRect;

					// Old Rect invalidieren
					if ( bRows )
					{
						aRect.Left()	= pItems[i].mnLeft;
						aRect.Right()	= pItems[i].mnLeft+pItems[i].mnOldWidth-1;
						aRect.Top() 	= pItems[i].mnOldSplitPos;
						aRect.Bottom()	= aRect.Top() + pItems[i].mnOldSplitSize;
					}
					else
					{
						aRect.Top() 	= pItems[i].mnTop;
						aRect.Bottom()	= pItems[i].mnTop+pItems[i].mnOldHeight-1;
						aRect.Left()	= pItems[i].mnOldSplitPos;
						aRect.Right()	= aRect.Left() + pItems[i].mnOldSplitSize;
					}
					pWindow->Invalidate( aRect );
					// New Rect invalidieren
					if ( bRows )
					{
						aRect.Left()	= pItems[i].mnLeft;
						aRect.Right()	= pItems[i].mnLeft+pItems[i].mnWidth-1;
						aRect.Top() 	= pItems[i].mnSplitPos;
						aRect.Bottom()	= aRect.Top() + pItems[i].mnSplitSize;
					}
					else
					{
						aRect.Top() 	= pItems[i].mnTop;
						aRect.Bottom()	= pItems[i].mnTop+pItems[i].mnHeight-1;
						aRect.Left()	= pItems[i].mnSplitPos;
						aRect.Right()	= aRect.Left() + pItems[i].mnSplitSize;
					}
					pWindow->Invalidate( aRect );

					// Leere Sets komplett invalidieren, da diese Flaechen
					// nicht von Fenstern ueberladen werden
					if ( pItems[i].mpSet && !pItems[i].mpSet->mpItems )
					{
						aRect.Left()	= pItems[i].mnLeft;
						aRect.Top() 	= pItems[i].mnTop;
						aRect.Right()	= pItems[i].mnLeft+pItems[i].mnWidth-1;
						aRect.Bottom()	= pItems[i].mnTop+pItems[i].mnHeight-1;
						pWindow->Invalidate( aRect );
					}
				}
			}
		}
	}

	// Fenster positionieren
	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpSet )
		{
			sal_Bool bTempHide = bHide;
			if ( !pItems[i].mnWidth || !pItems[i].mnHeight )
				bTempHide = sal_True;
			ImplCalcSet2( pWindow, pItems[i].mpSet, bTempHide,
						  ((pItems[i].mnBits & SWIB_COLSET) == 0) );
		}
		else
		{
			if ( pItems[i].mnWidth && pItems[i].mnHeight && !bHide )
			{
				Point aPos( pItems[i].mnLeft, pItems[i].mnTop );
				Size  aSize( pItems[i].mnWidth, pItems[i].mnHeight );
				pItems[i].mpWindow->SetPosSizePixel( aPos, aSize );
			}
			else
				pItems[i].mpWindow->Hide();
		}
	}

	// Fenster anzeigen und Flag zuruecksetzen
	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpWindow && pItems[i].mnWidth && pItems[i].mnHeight && !bHide )
			pItems[i].mpWindow->Show();
	}
}

// -----------------------------------------------------------------------

static void ImplCalcLogSize( ImplSplitItem* pItems, sal_uInt16 nItems )
{
	// Original-Groessen updaten
	sal_uInt16	i;
	long	nRelSize = 0;
	long	nPerSize = 0;
	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mnBits & SWIB_RELATIVESIZE )
			nRelSize += pItems[i].mnPixSize;
		else if ( pItems[i].mnBits & SWIB_PERCENTSIZE )
			nPerSize += pItems[i].mnPixSize;
	}
	nPerSize += nRelSize;
	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mnBits & SWIB_RELATIVESIZE )
		{
			if ( nRelSize )
				pItems[i].mnSize = (pItems[i].mnPixSize+(nRelSize/2))/nRelSize;
			else
				pItems[i].mnSize = 1;
		}
		else if ( pItems[i].mnBits & SWIB_PERCENTSIZE )
		{
			if ( nPerSize )
				pItems[i].mnSize = (pItems[i].mnPixSize*100)/nPerSize;
			else
				pItems[i].mnSize = 1;
		}
		else
			pItems[i].mnSize = pItems[i].mnPixSize;
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawBack( SplitWindow* pWindow, const Rectangle& rRect,
                                const Wallpaper* pWall, const Bitmap* pBitmap )
{
	if ( pBitmap )
	{
		Point	aPos = rRect.TopLeft();
		Size	aBmpSize = pBitmap->GetSizePixel();
		pWindow->Push( PUSH_CLIPREGION );
		pWindow->IntersectClipRegion( rRect );
		do
		{
			aPos.X() = rRect.Left();
			do
			{
				pWindow->DrawBitmap( aPos, *pBitmap );
				aPos.X() += aBmpSize.Width();
			}
			while ( aPos.X() < rRect.Right() );
			aPos.Y() += aBmpSize.Height();
		}
		while ( aPos.Y() < rRect.Bottom() );
		pWindow->Pop();
	}
	else
		pWindow->DrawWallpaper( rRect, *pWall );
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawBack( SplitWindow* pWindow, ImplSplitSet* pSet )
{
	sal_uInt16			i;
	sal_uInt16			nItems = pSet->mnItems;
	ImplSplitItem*	pItems = pSet->mpItems;

	// Beim Mainset auch den Hintergrund zeichnen
	if ( pSet->mnId == 0 )
	{
		if ( pSet->mpBitmap )
		{
			Rectangle aRect( pWindow->mnLeftBorder,
							 pWindow->mnTopBorder,
							 pWindow->mnDX-pWindow->mnRightBorder-1,
							 pWindow->mnDY-pWindow->mnBottomBorder-1 );
			ImplDrawBack( pWindow, aRect, pSet->mpWallpaper, pSet->mpBitmap );
		}
	}

	for ( i = 0; i < nItems; i++ )
	{
		pSet = pItems[i].mpSet;
		if ( pSet )
		{
			if ( pSet->mpBitmap || pSet->mpWallpaper )
			{
				// Wegen ICC auftrennen
				Point		aPoint( pItems[i].mnLeft, pItems[i].mnTop );
				Size		aSize( pItems[i].mnWidth, pItems[i].mnHeight );
				Rectangle	aRect( aPoint, aSize );
				ImplDrawBack( pWindow, aRect, pSet->mpWallpaper, pSet->mpBitmap );
			}
		}
	}

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpSet )
			ImplDrawBack( pWindow, pItems[i].mpSet );
	}
}

// -----------------------------------------------------------------------

static void ImplDrawSplit( SplitWindow* pWindow, ImplSplitSet* pSet,
						   sal_Bool bRows, sal_Bool bDown = sal_True )
{
	if ( !pSet->mpItems )
		return;

	sal_uInt16					i;
	sal_uInt16					nItems = pSet->mnItems;
	long					nPos;
	long					nTop;
	long					nBottom;
	ImplSplitItem*			pItems = pSet->mpItems;
	const StyleSettings&	rStyleSettings = pWindow->GetSettings().GetStyleSettings();

	sal_Bool bFlat = (pWindow->GetStyle() & WB_FLATSPLITDRAW) == WB_FLATSPLITDRAW;

	for ( i = 0; i < nItems-1; i++ )
	{
		if ( pItems[i].mnSplitSize )
		{
			nPos = pItems[i].mnSplitPos;

			long nItemSplitSize = pItems[i].mnSplitSize;
			long nSplitSize = pSet->mnSplitSize;
			if ( bRows )
			{
				nTop	= pItems[i].mnLeft;
				nBottom = pItems[i].mnLeft+pItems[i].mnWidth-1;

				if ( bFlat ) nPos--;

				if ( bDown || (nItemSplitSize >= nSplitSize) )
				{
					pWindow->SetLineColor( rStyleSettings.GetLightColor() );
					pWindow->DrawLine( Point( nTop, nPos+1 ), Point( nBottom, nPos+1 ) );
				}
				nPos += nSplitSize-2;
				if ( bFlat ) nPos+=2;
				if ( (!bDown && (nItemSplitSize >= 2)) ||
					 (bDown  && (nItemSplitSize >= nSplitSize-1)) )
				{
					pWindow->SetLineColor( rStyleSettings.GetShadowColor() );
					pWindow->DrawLine( Point( nTop, nPos ), Point( nBottom, nPos ) );
				}
				if ( !bFlat )
				{
					nPos++;
					if ( !bDown || (nItemSplitSize >= nSplitSize) )
					{
						pWindow->SetLineColor( rStyleSettings.GetDarkShadowColor() );
						pWindow->DrawLine( Point( nTop, nPos ), Point( nBottom, nPos ) );
					}
				}
			}
			else
			{
				nTop	= pItems[i].mnTop;
				nBottom = pItems[i].mnTop+pSet->mpItems[i].mnHeight-1;

				if ( bFlat ) nPos--;
				if ( bDown || (nItemSplitSize >= nSplitSize) )
				{
					pWindow->SetLineColor( rStyleSettings.GetLightColor() );
					pWindow->DrawLine( Point( nPos+1, nTop ), Point( nPos+1, nBottom ) );
				}
				nPos += pSet->mnSplitSize-2;
				if ( bFlat ) nPos+=2;
				if ( (!bDown && (nItemSplitSize >= 2)) ||
					 (bDown  && (nItemSplitSize >= nSplitSize-1)) )
				{
					pWindow->SetLineColor( rStyleSettings.GetShadowColor() );
					pWindow->DrawLine( Point( nPos, nTop ), Point( nPos, nBottom ) );
				}
				if( !bFlat )
				{
					nPos++;
					if ( !bDown || (nItemSplitSize >= nSplitSize) )
					{
						pWindow->SetLineColor( rStyleSettings.GetDarkShadowColor() );
						pWindow->DrawLine( Point( nPos, nTop ), Point( nPos, nBottom ) );
					}
				}
			}
		}
	}

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpSet && pItems[i].mnWidth && pItems[i].mnHeight )
			ImplDrawSplit( pWindow, pItems[i].mpSet, ((pItems[i].mnBits & SWIB_COLSET) == 0) );
	}
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::ImplTestSplit( ImplSplitSet* pSet, const Point& rPos,
                                   long& rMouseOff, ImplSplitSet** ppFoundSet, sal_uInt16& rFoundPos,
                                   sal_Bool bRows, sal_Bool /*bDown*/ )
{
	if ( !pSet->mpItems )
		return 0;

	sal_uInt16			i;
	sal_uInt16			nSplitTest;
	sal_uInt16			nItems = pSet->mnItems;
	long			nMPos1;
	long			nMPos2;
	long			nPos;
	long			nTop;
	long			nBottom;
	ImplSplitItem*	 pItems = pSet->mpItems;

	if ( bRows )
	{
		nMPos1 = rPos.X();
		nMPos2 = rPos.Y();
	}
	else
	{
		nMPos1 = rPos.Y();
		nMPos2 = rPos.X();
	}

	for ( i = 0; i < nItems-1; i++ )
	{
		if ( pItems[i].mnSplitSize )
		{
			if ( bRows )
			{
				nTop	= pItems[i].mnLeft;
				nBottom = pItems[i].mnLeft+pItems[i].mnWidth-1;
			}
			else
			{
				nTop	= pItems[i].mnTop;
				nBottom = pItems[i].mnTop+pItems[i].mnHeight-1;
			}
			nPos = pItems[i].mnSplitPos;

			if ( (nMPos1 >= nTop) && (nMPos1 <= nBottom) &&
				 (nMPos2 >= nPos) && (nMPos2 <= nPos+pItems[i].mnSplitSize) )
			{
				if ( !pItems[i].mbFixed && !pItems[i+1].mbFixed )
				{
					rMouseOff = nMPos2-nPos;
					*ppFoundSet = pSet;
					rFoundPos = i;
					if ( bRows )
						return SPLIT_VERT;
					else
						return SPLIT_HORZ;
				}
				else
					return SPLIT_NOSPLIT;
			}
		}
	}

	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mpSet )
		{
			nSplitTest = ImplTestSplit( pItems[i].mpSet, rPos,
									   rMouseOff, ppFoundSet, rFoundPos,
									   ((pItems[i].mnBits & SWIB_COLSET) == 0) );
			if ( nSplitTest )
				return nSplitTest;
		}
	}

	return 0;
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::ImplTestSplit( SplitWindow* pWindow, const Point& rPos,
                                   long& rMouseOff, ImplSplitSet** ppFoundSet, sal_uInt16& rFoundPos )
{
	// Resizeable SplitWindow muss anders behandelt werden
	if ( pWindow->mnWinStyle & WB_SIZEABLE )
	{
		long	nTPos;
		long	nPos;
		long	nBorder;

		if ( pWindow->mbHorz )
		{
			if ( pWindow->mbBottomRight )
			{
				nBorder = pWindow->mnBottomBorder;
				nPos = 0;
			}
			else
			{
				nBorder = pWindow->mnTopBorder;
				nPos = pWindow->mnDY-nBorder;
			}
			nTPos = rPos.Y();
		}
		else
		{
			if ( pWindow->mbBottomRight )
			{
				nBorder = pWindow->mnRightBorder;
				nPos = 0;
			}
			else
			{
				nBorder = pWindow->mnLeftBorder;
				nPos = pWindow->mnDX-nBorder;
			}
			nTPos = rPos.X();
		}
		long nSplitSize = pWindow->mpMainSet->mnSplitSize-2;
		if ( pWindow->mbAutoHide || pWindow->mbFadeOut )
			nSplitSize += SPLITWIN_SPLITSIZEEXLN;
		if ( !pWindow->mbBottomRight )
			nPos -= nSplitSize;
		if ( (nTPos >= nPos) && (nTPos <= nPos+nSplitSize+nBorder) )
		{
			rMouseOff = nTPos-nPos;
			*ppFoundSet = pWindow->mpMainSet;
			if ( pWindow->mpMainSet->mpItems )
				rFoundPos = pWindow->mpMainSet->mnItems-1;
			else
				rFoundPos = 0;
			if ( pWindow->mbHorz )
				return SPLIT_VERT | SPLIT_WINDOW;
			else
				return SPLIT_HORZ | SPLIT_WINDOW;
		}
	}

	return ImplTestSplit( pWindow->mpMainSet, rPos, rMouseOff, ppFoundSet, rFoundPos,
						 pWindow->mbHorz, !pWindow->mbBottomRight );
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawSplitTracking( SplitWindow* pThis, const Point& rPos )
{
	Rectangle aRect;

	if ( pThis->mnSplitTest & SPLIT_HORZ )
	{
		aRect.Top()    = pThis->maDragRect.Top();
		aRect.Bottom() = pThis->maDragRect.Bottom();
		aRect.Left()   = rPos.X();
		aRect.Right()  = aRect.Left()+pThis->mpSplitSet->mnSplitSize-1;
		if ( !(pThis->mnWinStyle & WB_NOSPLITDRAW) )
			aRect.Right()--;
		if ( (pThis->mnSplitTest & SPLIT_WINDOW) &&
			 (pThis->mbAutoHide || pThis->mbFadeOut) )
		{
			aRect.Left()  += SPLITWIN_SPLITSIZEEXLN;
			aRect.Right() += SPLITWIN_SPLITSIZEEXLN;
		}
	}
	else
	{
		aRect.Left()	= pThis->maDragRect.Left();
		aRect.Right()	= pThis->maDragRect.Right();
		aRect.Top() 	= rPos.Y();
		aRect.Bottom()	= aRect.Top()+pThis->mpSplitSet->mnSplitSize-1;
		if ( !(pThis->mnWinStyle & WB_NOSPLITDRAW) )
			aRect.Bottom()--;
		if ( (pThis->mnSplitTest & SPLIT_WINDOW) &&
			 (pThis->mbAutoHide || pThis->mbFadeOut) )
		{
			aRect.Top()    += SPLITWIN_SPLITSIZEEXLN;
			aRect.Bottom() += SPLITWIN_SPLITSIZEEXLN;
		}
	}
	pThis->ShowTracking( aRect, SHOWTRACK_SPLIT );
}

// -----------------------------------------------------------------------

void SplitWindow::ImplInit( Window* pParent, WinBits nStyle )
{
	ImplSplitSet* pNewSet	= new ImplSplitSet;
	pNewSet->mpItems		= NULL;
	pNewSet->mpWallpaper	= NULL;
	pNewSet->mpBitmap		= NULL;
	pNewSet->mnLastSize 	= 0;
	pNewSet->mnItems		= 0;
	pNewSet->mnId			= 0;
	pNewSet->mnSplitSize	= SPLITWIN_SPLITSIZE;
	pNewSet->mbCalcPix		= sal_True;

	mpMainSet				= pNewSet;
	mpBaseSet				= pNewSet;
	mpSplitSet				= NULL;
	mpLastSizes 			= NULL;
	mnDX					= 0;
	mnDY					= 0;
	mnLeftBorder			= 0;
	mnTopBorder 			= 0;
	mnRightBorder			= 0;
	mnBottomBorder			= 0;
	mnMaxSize				= 0;
	mnMouseOff				= 0;
	meAlign 				= WINDOWALIGN_TOP;
	mnWinStyle				= nStyle;
	mnSplitTest 			= 0;
	mnSplitPos				= 0;
	mnMouseModifier 		= 0;
	mnMStartPos 			= 0;
	mnMSplitPos 			= 0;
	mbDragFull				= sal_False;
	mbHorz					= sal_True;
	mbBottomRight			= sal_False;
	mbCalc					= sal_False;
	mbRecalc				= sal_True;
	mbInvalidate			= sal_True;
	mbAutoHide				= sal_False;
	mbFadeIn				= sal_False;
	mbFadeOut				= sal_False;
	mbAutoHideIn			= sal_False;
	mbAutoHideDown			= sal_False;
	mbFadeInDown			= sal_False;
	mbFadeOutDown			= sal_False;
	mbAutoHidePressed		= sal_False;
	mbFadeInPressed 		= sal_False;
	mbFadeOutPressed		= sal_False;
	mbFadeNoButtonMode		= sal_False;
	mbNoAlign				= sal_False;

	if ( nStyle & WB_NOSPLITDRAW )
	{
		pNewSet->mnSplitSize -= 2;
		mbInvalidate = sal_False;
	}

	if ( nStyle & WB_BORDER )
	{
		ImplCalcBorder( meAlign, mbNoAlign, mnLeftBorder, mnTopBorder,
						mnRightBorder, mnBottomBorder );
	}
	else
	{
		mnLeftBorder   = 0;
		mnTopBorder    = 0;
		mnRightBorder  = 0;
		mnBottomBorder = 0;
	}

	DockingWindow::ImplInit( pParent, (nStyle | WB_CLIPCHILDREN) & ~(WB_BORDER | WB_SIZEABLE) );

	ImplInitSettings();
}

// -----------------------------------------------------------------------

void SplitWindow::ImplInitSettings()
{
	// Wenn fuer das MainSet eine Bitmap gesetzt wird, dann
	// brauchen wir nicht mehr den Hintergrund loeschen
	// Wenn MainSet Wallpaper hat, dann ist das der Hintergrund, ansonsten
	// sind es die Standard-Farben
	if ( mpMainSet->mpBitmap )
		SetBackground();
	else if ( mpMainSet->mpWallpaper )
		SetBackground( *mpMainSet->mpWallpaper );
	else
	{
		const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();

		Color aColor;
		if ( IsControlBackground() )
			aColor = GetControlBackground();
		else if ( Window::GetStyle() & WB_3DLOOK )
			aColor = rStyleSettings.GetFaceColor();
		else
			aColor = rStyleSettings.GetWindowColor();
		SetBackground( aColor );
	}
}

// =======================================================================

SplitWindow::SplitWindow( Window* pParent, WinBits nStyle ) :
	DockingWindow( WINDOW_SPLITWINDOW )
{
	ImplInit( pParent, nStyle );
}

// -----------------------------------------------------------------------

SplitWindow::SplitWindow( Window* pParent, const ResId& rResId ) :
	DockingWindow( WINDOW_SPLITWINDOW )
{
	rResId.SetRT( RSC_SPLITWINDOW );
	WinBits nStyle = ImplInitRes( rResId );
	ImplInit( pParent, nStyle );
	ImplLoadRes( rResId );

	if ( !(nStyle & WB_HIDE) )
		Show();
}

// -----------------------------------------------------------------------

SplitWindow::~SplitWindow()
{
	// Sets loeschen
	ImplDeleteSet( mpMainSet );
}

// -----------------------------------------------------------------------

void SplitWindow::ImplSetWindowSize( long nDelta )
{
	if ( !nDelta )
		return;

	Size aSize = GetSizePixel();
	if ( meAlign == WINDOWALIGN_TOP )
	{
		aSize.Height() += nDelta;
		SetSizePixel( aSize );
	}
	else if ( meAlign == WINDOWALIGN_BOTTOM )
	{
        maDragRect.Top() += nDelta;
		Point aPos = GetPosPixel();
		aPos.Y() -= nDelta;
		aSize.Height() += nDelta;
		SetPosSizePixel( aPos, aSize );
	}
	else if ( meAlign == WINDOWALIGN_LEFT )
	{
		aSize.Width() += nDelta;
		SetSizePixel( aSize );
	}
	else // meAlign == WINDOWALIGN_RIGHT
	{
        maDragRect.Left() += nDelta;
		Point aPos = GetPosPixel();
		aPos.X() -= nDelta;
		aSize.Width() += nDelta;
		SetPosSizePixel( aPos, aSize );
	}

	SplitResize();
}

// -----------------------------------------------------------------------

Size SplitWindow::CalcLayoutSizePixel( const Size& aNewSize )
{
	Size aSize( aNewSize );
	long nSplitSize = mpMainSet->mnSplitSize-2;

	if ( mbAutoHide || mbFadeOut )
		nSplitSize += SPLITWIN_SPLITSIZEEXLN;

	// Wenn Fenster sizeable ist, wird die groesse automatisch nach
	// dem MainSet festgelegt, wenn kein relatives Fenster enthalten
	// ist
	if ( mnWinStyle & WB_SIZEABLE )
	{
		long	nCurSize;
		long	nCalcSize = 0;
		sal_uInt16	i;

		for ( i = 0; i < mpMainSet->mnItems; i++ )
		{
			if ( mpMainSet->mpItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE) )
				break;
			else
				nCalcSize += mpMainSet->mpItems[i].mnSize;
		}

		if ( i == mpMainSet->mnItems )
		{
			long	nDelta = 0;
			Point	aPos = GetPosPixel();

			if ( mbHorz )
				nCurSize = aNewSize.Height()-mnTopBorder-mnBottomBorder;
			else
				nCurSize = aNewSize.Width()-mnLeftBorder-mnRightBorder;
			nCurSize -= nSplitSize;
			nCurSize -= (mpMainSet->mnItems-1)*mpMainSet->mnSplitSize;

			nDelta = nCalcSize-nCurSize;
			if ( !nDelta )
				return aSize;

			if ( meAlign == WINDOWALIGN_TOP )
			{
				aSize.Height() += nDelta;
			}
			else if ( meAlign == WINDOWALIGN_BOTTOM )
			{
				aPos.Y() -= nDelta;
				aSize.Height() += nDelta;
			}
			else if ( meAlign == WINDOWALIGN_LEFT )
			{
				aSize.Width() += nDelta;
			}
			else // meAlign == WINDOWALIGN_RIGHT
			{
				aPos.X() -= nDelta;
				aSize.Width() += nDelta;
			}
		}
	}

	return aSize;
}

// -----------------------------------------------------------------------

void SplitWindow::ImplCalcLayout()
{
	if ( !mbCalc || !mbRecalc || !mpMainSet->mpItems )
		return;

	long nSplitSize = mpMainSet->mnSplitSize-2;
	if ( mbAutoHide || mbFadeOut )
		nSplitSize += SPLITWIN_SPLITSIZEEXLN;

	// Wenn Fenster sizeable ist, wird die groesse automatisch nach
	// dem MainSet festgelegt, wenn kein relatives Fenster enthalten
	// ist
	if ( mnWinStyle & WB_SIZEABLE )
	{
		long	nCurSize;
		long	nCalcSize = 0;
		sal_uInt16	i;

		for ( i = 0; i < mpMainSet->mnItems; i++ )
		{
			if ( mpMainSet->mpItems[i].mnBits & (SWIB_RELATIVESIZE | SWIB_PERCENTSIZE) )
				break;
			else
				nCalcSize += mpMainSet->mpItems[i].mnSize;
		}

		if ( i == mpMainSet->mnItems )
		{
			if ( mbHorz )
				nCurSize = mnDY-mnTopBorder-mnBottomBorder;
			else
				nCurSize = mnDX-mnLeftBorder-mnRightBorder;
			nCurSize -= nSplitSize;
			nCurSize -= (mpMainSet->mnItems-1)*mpMainSet->mnSplitSize;

			mbRecalc = sal_False;
			ImplSetWindowSize( nCalcSize-nCurSize );
			mbRecalc = sal_True;
		}
	}

	if ( (mnDX <= 0) || (mnDY <= 0) )
		return;

	// Groessen/Position vorberechnen
	long	nL;
	long	nT;
	long	nW;
	long	nH;

	if ( mbHorz )
	{
		if ( mbBottomRight )
			nT = mnDY-mnBottomBorder;
		else
			nT = mnTopBorder;
		nL = mnLeftBorder;
	}
	else
	{
		if ( mbBottomRight )
			nL = mnDX-mnRightBorder;
		else
			nL = mnLeftBorder;
		nT = mnTopBorder;
	}
	nW = mnDX-mnLeftBorder-mnRightBorder;
	nH = mnDY-mnTopBorder-mnBottomBorder;
	if ( mnWinStyle & WB_SIZEABLE )
	{
		if ( mbHorz )
			nH -= nSplitSize;
		else
			nW -= nSplitSize;
	}

	// Sets rekursiv berechnen
	ImplCalcSet( mpMainSet, nL, nT, nW, nH, mbHorz, !mbBottomRight );
	ImplCalcSet2( this, mpMainSet, sal_False, mbHorz, !mbBottomRight );
	mbCalc = sal_False;
}

// -----------------------------------------------------------------------

void SplitWindow::ImplUpdate()
{
	mbCalc = sal_True;

	if ( IsReallyShown() && IsUpdateMode() && mbRecalc )
	{
		if ( mpMainSet->mpItems )
			ImplCalcLayout();
		else
			Invalidate();
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplUpdateSet( ImplSplitSet* pSet )
{
	if ( IsReallyShown() && IsUpdateMode() && mbRecalc )
	{
		// Wenn wir noch berechnen muessen, dann alles invalidieren.
		if ( mbCalc )
		{
			// Wenn nicht NOSPLITDRAW gesetzt ist, koennen wir uns das
			// invalidieren sparen, da bei ImplCalcSet2() die freien flaechen
			// sowieso invalidiert werden
			if ( !mpMainSet->mpItems || (mnWinStyle & WB_NOSPLITDRAW) )
				pSet = mpMainSet;
			else
				return;
		}

		Rectangle aRect;
		if ( pSet == mpMainSet )
		{
			aRect.Left()	= mnLeftBorder;
			aRect.Top() 	= mnTopBorder;
			aRect.Right()	= mnDX-mnRightBorder-1;
			aRect.Bottom()	= mnDY-mnBottomBorder-1;
		}
		else
		{
			ImplSplitItem*	pItem;
			sal_uInt16			nPos;

			pSet = ImplFindItem( mpMainSet, pSet->mnId, nPos );
			pItem = &(pSet->mpItems[nPos]);
			aRect.Left()	= pItem->mnLeft;
			aRect.Top() 	= pItem->mnTop;
			aRect.Right()	= aRect.Left()+pItem->mnWidth;
			aRect.Bottom()	= aRect.Top()+pItem->mnHeight;
		}
		Invalidate( aRect );
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplSplitMousePos( Point& rMousePos )
{
	if ( mnSplitTest & SPLIT_HORZ )
	{
		rMousePos.X() -= mnMouseOff;
		if ( rMousePos.X() < maDragRect.Left() )
			rMousePos.X() = maDragRect.Left();
		else if ( rMousePos.X()+mpSplitSet->mnSplitSize+1 > maDragRect.Right() )
			rMousePos.X() = maDragRect.Right()-mpSplitSet->mnSplitSize+1;
		// Wegen FullDrag in Screen-Koordinaaten merken
		mnMSplitPos = OutputToScreenPixel( rMousePos ).X();
	}
	else
	{
		rMousePos.Y() -= mnMouseOff;
		if ( rMousePos.Y() < maDragRect.Top() )
			rMousePos.Y() = maDragRect.Top();
		else if ( rMousePos.Y()+mpSplitSet->mnSplitSize+1 > maDragRect.Bottom() )
			rMousePos.Y() = maDragRect.Bottom()-mpSplitSet->mnSplitSize+1;
		mnMSplitPos = OutputToScreenPixel( rMousePos ).Y();
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplGetButtonRect( Rectangle& rRect, long nEx, sal_Bool bTest ) const
{
	long nSplitSize = mpMainSet->mnSplitSize-2;
	if ( mbAutoHide || mbFadeOut || mbFadeIn )
		nSplitSize += SPLITWIN_SPLITSIZEEX;

	long nButtonSize = 0;
	if ( mbFadeIn )
		nButtonSize += SPLITWIN_SPLITSIZEFADE+1;
	if ( mbFadeOut )
		nButtonSize += SPLITWIN_SPLITSIZEFADE+1;
	if ( mbAutoHide )
		nButtonSize += SPLITWIN_SPLITSIZEAUTOHIDE+1;
	long nCenterEx = 0;
	if ( mbHorz )
		nCenterEx += ((mnDX-mnLeftBorder-mnRightBorder)-nButtonSize)/2;
	else
		nCenterEx += ((mnDY-mnTopBorder-mnBottomBorder)-nButtonSize)/2;
	if ( nCenterEx > 0 )
		nEx += nCenterEx;

	if ( meAlign == WINDOWALIGN_TOP )
	{
		rRect.Left()	= mnLeftBorder+nEx;
		rRect.Top() 	= mnDY-mnBottomBorder-nSplitSize;
		rRect.Right()	= rRect.Left()+SPLITWIN_SPLITSIZEAUTOHIDE;
		rRect.Bottom()	= mnDY-mnBottomBorder-1;
		if ( bTest )
		{
			rRect.Top() 	-= mnTopBorder;
			rRect.Bottom()	+= mnBottomBorder;
		}
	}
	else if ( meAlign == WINDOWALIGN_BOTTOM )
	{
		rRect.Left()	= mnLeftBorder+nEx;
		rRect.Top() 	= mnTopBorder;
		rRect.Right()	= rRect.Left()+SPLITWIN_SPLITSIZEAUTOHIDE;
		rRect.Bottom()	= mnTopBorder+nSplitSize-1;
		if ( bTest )
		{
			rRect.Top() 	-= mnTopBorder;
			rRect.Bottom()	+= mnBottomBorder;
		}
	}
	else if ( meAlign == WINDOWALIGN_LEFT )
	{
		rRect.Left()	= mnDX-mnRightBorder-nSplitSize;
		rRect.Top() 	= mnTopBorder+nEx;
		rRect.Right()	= mnDX-mnRightBorder-1;
		rRect.Bottom()	= rRect.Top()+SPLITWIN_SPLITSIZEAUTOHIDE;
		if ( bTest )
		{
			rRect.Left()	-= mnLeftBorder;
			rRect.Right()	+= mnRightBorder;
		}
	}
	else if ( meAlign == WINDOWALIGN_RIGHT )
	{
		rRect.Left()	= mnLeftBorder;
		rRect.Top() 	= mnTopBorder+nEx;
		rRect.Right()	= mnLeftBorder+nSplitSize-1;
		rRect.Bottom()	= rRect.Top()+SPLITWIN_SPLITSIZEAUTOHIDE;
		if ( bTest )
		{
			rRect.Left()	-= mnLeftBorder;
			rRect.Right()	+= mnRightBorder;
		}
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplGetAutoHideRect( Rectangle& rRect, sal_Bool bTest ) const
{
	Rectangle aRect;

	if ( mbAutoHide )
	{
		long nEx = 0;
		if ( mbFadeIn || mbFadeOut )
			nEx = SPLITWIN_SPLITSIZEFADE+1;
		ImplGetButtonRect( aRect, nEx, bTest && mbFadeIn );
	}

	rRect = aRect;
}

// -----------------------------------------------------------------------

void SplitWindow::ImplGetFadeInRect( Rectangle& rRect, sal_Bool bTest ) const
{
	Rectangle aRect;

	if ( mbFadeIn )
		ImplGetButtonRect( aRect, 0, bTest );

	rRect = aRect;
}

// -----------------------------------------------------------------------

void SplitWindow::ImplGetFadeOutRect( Rectangle& rRect, sal_Bool ) const
{
	Rectangle aRect;

	if ( mbFadeOut )
		ImplGetButtonRect( aRect, 0, sal_False );

	rRect = aRect;
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawButtonRect( const Rectangle& rRect, long nSize )
{
	const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();

	if ( mbHorz )
	{
		long nLeft = rRect.Left();
		long nRight = rRect.Right();
		long nCenter = rRect.Center().Y();
		long nEx1 = nLeft+((rRect.GetWidth()-nSize)/2)-2;
		long nEx2 = nEx1+nSize+3;
		SetLineColor( rStyleSettings.GetLightColor() );
		DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Left(), rRect.Bottom() ) );
		DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Right(), rRect.Top() ) );
		SetLineColor( rStyleSettings.GetShadowColor() );
		DrawLine( Point( rRect.Right(), rRect.Top() ), Point( rRect.Right(), rRect.Bottom() ) );
		DrawLine( Point( rRect.Left(), rRect.Bottom() ), Point( rRect.Right(), rRect.Bottom() ) );
		long i = nLeft+2;
		while ( i < nRight-3 )
		{
			if ( (i < nEx1) || (i > nEx2 ) )
			{
				DrawPixel( Point( i, nCenter-2 ), rStyleSettings.GetLightColor() );
				DrawPixel( Point( i+1, nCenter-2+1 ), rStyleSettings.GetShadowColor() );
			}
			i++;
			if ( (i < nEx1) || ((i > nEx2 ) && (i < nRight-3)) )
			{
				DrawPixel( Point( i, nCenter+2 ), rStyleSettings.GetLightColor() );
				DrawPixel( Point( i+1, nCenter+2+1 ), rStyleSettings.GetShadowColor() );
			}
			i += 2;
		}
	}
	else
	{
		long nTop = rRect.Top();
		long nBottom = rRect.Bottom();
		long nCenter = rRect.Center().X();
		long nEx1 = nTop+((rRect.GetHeight()-nSize)/2)-2;
		long nEx2 = nEx1+nSize+3;
		SetLineColor( rStyleSettings.GetLightColor() );
		DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Right(), rRect.Top() ) );
		DrawLine( Point( rRect.Left(), rRect.Top() ), Point( rRect.Left(), rRect.Bottom() ) );
		SetLineColor( rStyleSettings.GetShadowColor() );
		DrawLine( Point( rRect.Right(), rRect.Top() ), Point( rRect.Right(), rRect.Bottom() ) );
		DrawLine( Point( rRect.Left(), rRect.Bottom() ), Point( rRect.Right(), rRect.Bottom() ) );
		long i = nTop+2;
		while ( i < nBottom-3 )
		{
			if ( (i < nEx1) || (i > nEx2 ) )
			{
				DrawPixel( Point( nCenter-2, i ), rStyleSettings.GetLightColor() );
				DrawPixel( Point( nCenter-2+1, i+1 ), rStyleSettings.GetShadowColor() );
			}
			i++;
			if ( (i < nEx1) || ((i > nEx2 ) && (i < nBottom-3)) )
			{
				DrawPixel( Point( nCenter+2, i ), rStyleSettings.GetLightColor() );
				DrawPixel( Point( nCenter+2+1, i+1 ), rStyleSettings.GetShadowColor() );
			}
			i += 2;
		}
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawAutoHide( sal_Bool bInPaint )
{
	if ( mbAutoHide )
	{
		Rectangle aTempRect;
		ImplGetAutoHideRect( aTempRect );

		if ( !bInPaint )
			Erase( aTempRect );

		// ImageListe laden, wenn noch nicht vorhanden
		ImplSVData* pSVData = ImplGetSVData();
		ImageList*	pImageList;
		if ( mbHorz )
		{
			if ( !pSVData->maCtrlData.mpSplitHPinImgList )
			{
                ResMgr* pResMgr = ImplGetResMgr();
                if( pResMgr )
				{
					Color aNonAlphaMask( 0x00, 0x00, 0xFF );
					pSVData->maCtrlData.mpSplitHPinImgList = new ImageList(4);
					pSVData->maCtrlData.mpSplitHPinImgList->InsertFromHorizontalBitmap
						( ResId( SV_RESID_BITMAP_SPLITHPIN, *pResMgr ), 4, &aNonAlphaMask );
				}
		        }
			pImageList = pSVData->maCtrlData.mpSplitHPinImgList;
		}
		else
		{
			if ( !pSVData->maCtrlData.mpSplitVPinImgList )
			{
                ResMgr* pResMgr = ImplGetResMgr();
				pSVData->maCtrlData.mpSplitVPinImgList = new ImageList(4);
                if( pResMgr )
				{
					Color aNonAlphaMask( 0x00, 0x00, 0xFF );
					pSVData->maCtrlData.mpSplitVPinImgList->InsertFromHorizontalBitmap
						( ResId( SV_RESID_BITMAP_SPLITVPIN, *pResMgr ), 4, &aNonAlphaMask );
				}
			}
			pImageList = pSVData->maCtrlData.mpSplitVPinImgList;
                }

		// Image ermitteln und zurueckgeben
		sal_uInt16 nId;
		if ( mbAutoHidePressed )
		{
			if ( mbAutoHideIn )
				nId = 3;
			else
				nId = 4;
		}
		else
		{
			if ( mbAutoHideIn )
				nId = 1;
			else
				nId = 2;
		}

		Image	aImage = pImageList->GetImage( nId );
		Size	aImageSize = aImage.GetSizePixel();
		Point	aPos( aTempRect.Left()+((aTempRect.GetWidth()-aImageSize.Width())/2),
					  aTempRect.Top()+((aTempRect.GetHeight()-aImageSize.Height())/2) );
		long	nSize;
		if ( mbHorz )
			nSize = aImageSize.Width();
		else
			nSize = aImageSize.Height();
		ImplDrawButtonRect( aTempRect, nSize );
		DrawImage( aPos, aImage );
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawFadeArrow( const Point& rPt, sal_Bool bHorz, sal_Bool bLeft )
{
    const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();

    int x( rPt.X() );
    int y( rPt.Y() );

    Color aCol;
    if( !bHorz )
    {
        int dx = 1;
        if( bLeft )
        {
            x ++;
            dx = -1;
        }

        x++; y++;
        aCol = Color( COL_WHITE );
        DrawPixel( Point(x, y), aCol );
        DrawPixel( Point(x, y+1), aCol );
        DrawPixel( Point(x, y+2), aCol );
        DrawPixel( Point(x+dx, y+1), aCol );

        x--; y--;
        aCol = rStyleSettings.GetDarkShadowColor();
        DrawPixel( Point(x, y), rStyleSettings.GetDarkShadowColor() );
        DrawPixel( Point(x, y+1), rStyleSettings.GetDarkShadowColor() );
        DrawPixel( Point(x, y+2), rStyleSettings.GetDarkShadowColor() );
        DrawPixel( Point(x+dx, y+1), rStyleSettings.GetDarkShadowColor() );
    }
    else
    {
        int dy = 1;
        if( bLeft )
        {
            y ++;
            dy = -1;
        }

        x++; y++;
        aCol = Color( COL_WHITE );
        DrawPixel( Point(x, y), aCol );
        DrawPixel( Point(x+1, y), aCol );
        DrawPixel( Point(x+2, y), aCol );
        DrawPixel( Point(x+1, y+dy), aCol );

        x--; y--;
        aCol = rStyleSettings.GetDarkShadowColor();
        DrawPixel( Point(x, y), aCol );
        DrawPixel( Point(x+1, y), aCol );
        DrawPixel( Point(x+2, y), aCol );
        DrawPixel( Point(x+1, y+dy), aCol );
    }
}

void SplitWindow::ImplDrawGrip( const Rectangle& rRect, sal_Bool bHorz, sal_Bool bLeft )
{
    const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();

    if( rRect.IsInside( GetPointerPosPixel() ) )
    {
        DrawWallpaper( rRect, Wallpaper( Color( COL_WHITE ) ) );
        DrawSelectionBackground( rRect, 2, sal_False, sal_False, sal_False );
    }

    if( bHorz )
    {
        int width = (int) (0.5 * rRect.getWidth() + 0.5);
        int i = rRect.nLeft + (rRect.getWidth() - width) / 2;
        width += i;
        const int y = rRect.nTop + 1;
        ImplDrawFadeArrow( Point( i-8, y), bHorz, bLeft );
        while( i <= width )
        {

            DrawPixel( Point(i, y), rStyleSettings.GetDarkShadowColor() );
            DrawPixel( Point(i+1, y), rStyleSettings.GetShadowColor() );

            DrawPixel( Point(i, y+1), rStyleSettings.GetShadowColor() );
            DrawPixel( Point(i+1, y+1), rStyleSettings.GetFaceColor() );
            DrawPixel( Point(i+2, y+1), Color(COL_WHITE) );

            DrawPixel( Point(i+1, y+2), Color(COL_WHITE) );
            DrawPixel( Point(i+2, y+2), Color(COL_WHITE) );
            i+=4;
        }
        ImplDrawFadeArrow( Point( i+3, y), bHorz, bLeft );
    }
    else
    {
        int height = (int) (0.5 * rRect.getHeight() + 0.5);
        int i = rRect.nTop + (rRect.getHeight() - height) / 2;
        height += i;
        const int x = rRect.nLeft + 1;
        ImplDrawFadeArrow( Point( x, i-8), bHorz, bLeft );
        while( i <= height )
        {

            DrawPixel( Point(x, i), rStyleSettings.GetDarkShadowColor() );
            DrawPixel( Point(x+1, i), rStyleSettings.GetShadowColor() );

            DrawPixel( Point(x, i+1), rStyleSettings.GetShadowColor() );
            DrawPixel( Point(x+1, i+1), rStyleSettings.GetFaceColor() );
            DrawPixel( Point(x+2, i+1), Color(COL_WHITE) );

            DrawPixel( Point(x+1, i+2), Color(COL_WHITE) );
            DrawPixel( Point(x+2, i+2), Color(COL_WHITE) );
            i+=4;
        }
        ImplDrawFadeArrow( Point( x, i+3), bHorz, bLeft );
    }
}

void SplitWindow::ImplDrawFadeIn( sal_Bool bInPaint )
{
	if ( mbFadeIn )
	{
		Rectangle		aTempRect;
		Image			aImage;
		ImplGetFadeInRect( aTempRect );

		sal_Bool bLeft;
		if ( meAlign == WINDOWALIGN_TOP )
			bLeft	= sal_False;
		else if ( meAlign == WINDOWALIGN_BOTTOM )
			bLeft	= sal_True;
		else if ( meAlign == WINDOWALIGN_LEFT )
			bLeft	= sal_False;
		else if ( meAlign == WINDOWALIGN_RIGHT )
			bLeft	= sal_True;
		else
			bLeft   = sal_True;

		if ( !bInPaint )
			Erase( aTempRect );

        ImplDrawGrip( aTempRect, (meAlign == WINDOWALIGN_TOP) || (meAlign == WINDOWALIGN_BOTTOM), bLeft );
	}
}

// -----------------------------------------------------------------------

void SplitWindow::ImplDrawFadeOut( sal_Bool bInPaint )
{
	if ( mbFadeOut )
	{
		Rectangle		aTempRect;
		Image			aImage;
		ImplGetFadeOutRect( aTempRect );

		sal_Bool bLeft;
		if ( meAlign == WINDOWALIGN_TOP )
			bLeft	= sal_True;
		else if ( meAlign == WINDOWALIGN_BOTTOM )
			bLeft	= sal_False;
		else if ( meAlign == WINDOWALIGN_LEFT )
			bLeft	= sal_True;
		else if ( meAlign == WINDOWALIGN_RIGHT )
			bLeft	= sal_False;
		else
			bLeft   = sal_True;

		if ( !bInPaint )
			Erase( aTempRect );

        ImplDrawGrip( aTempRect, (meAlign == WINDOWALIGN_TOP) || (meAlign == WINDOWALIGN_BOTTOM), bLeft );
	}
}

// -----------------------------------------------------------------------
void SplitWindow::ImplStartSplit( const MouseEvent& rMEvt )
{
    Point aMousePosPixel = rMEvt.GetPosPixel();
    mnSplitTest = ImplTestSplit( this, aMousePosPixel, mnMouseOff, &mpSplitSet, mnSplitPos );

    if ( mnSplitTest && !(mnSplitTest & SPLIT_NOSPLIT) )
    {
        ImplSplitItem*	pSplitItem;
        long			nCurMaxSize;
        sal_uInt16			nTemp;
        sal_Bool			bDown;
        sal_Bool			bPropSmaller;

        mnMouseModifier = rMEvt.GetModifier();
        if ( !(mnMouseModifier & KEY_SHIFT) || (mnSplitPos+1 >= mpSplitSet->mnItems) )
            bPropSmaller = sal_False;
        else
            bPropSmaller = sal_True;

        // Hier kann noch die maximale Groesse gesetzt werden
        StartSplit();

        if ( mnMaxSize )
            nCurMaxSize = mnMaxSize;
        else
        {
            Size aSize = GetParent()->GetOutputSizePixel();
            if ( mbHorz )
                nCurMaxSize = aSize.Height();
            else
                nCurMaxSize = aSize.Width();
        }

        if ( mpSplitSet->mpItems )
        {
            bDown = sal_True;
            if ( (mpSplitSet == mpMainSet) && mbBottomRight )
                bDown = sal_False;

            pSplitItem			= &(mpSplitSet->mpItems[mnSplitPos]);
            maDragRect.Left()	= pSplitItem->mnLeft;
            maDragRect.Top()	= pSplitItem->mnTop;
            maDragRect.Right()	= pSplitItem->mnLeft+pSplitItem->mnWidth-1;
            maDragRect.Bottom() = pSplitItem->mnTop+pSplitItem->mnHeight-1;

            if ( mnSplitTest & SPLIT_HORZ )
            {
                if ( bDown )
                    maDragRect.Right() += mpSplitSet->mnSplitSize;
                else
                    maDragRect.Left() -= mpSplitSet->mnSplitSize;
            }
            else
            {
                if ( bDown )
                    maDragRect.Bottom() += mpSplitSet->mnSplitSize;
                else
                    maDragRect.Top() -= mpSplitSet->mnSplitSize;
            }

            if ( mnSplitPos )
            {
                nTemp = mnSplitPos;
                while ( nTemp )
                {
                    pSplitItem = &(mpSplitSet->mpItems[nTemp-1]);
                    if ( pSplitItem->mbFixed )
                        break;
                    else
                    {
                        if ( mnSplitTest & SPLIT_HORZ )
                        {
                            if ( bDown )
                                maDragRect.Left() -= pSplitItem->mnPixSize;
                            else
                                maDragRect.Right() += pSplitItem->mnPixSize;
                        }
                        else
                        {
                            if ( bDown )
                                maDragRect.Top() -= pSplitItem->mnPixSize;
                            else
                                maDragRect.Bottom() += pSplitItem->mnPixSize;
                        }
                    }
                    nTemp--;
                }
            }

            if ( (mpSplitSet == mpMainSet) && (mnWinStyle & WB_SIZEABLE) && !bPropSmaller )
            {
                if ( bDown )
                {
                    if ( mbHorz )
                        maDragRect.Bottom() += nCurMaxSize-mnDY-mnTopBorder;
                    else
                        maDragRect.Right() += nCurMaxSize-mnDX-mnLeftBorder;
                }
                else
                {
                    if ( mbHorz )
                        maDragRect.Top() -= nCurMaxSize-mnDY-mnBottomBorder;
                    else
                        maDragRect.Left() -= nCurMaxSize-mnDX-mnRightBorder;
                }
            }
            else
            {
                nTemp = mnSplitPos+1;
                while ( nTemp < mpSplitSet->mnItems )
                {
                    pSplitItem = &(mpSplitSet->mpItems[nTemp]);
                    if ( pSplitItem->mbFixed )
                        break;
                    else
                    {
                        if ( mnSplitTest & SPLIT_HORZ )
                        {
                            if ( bDown )
                                maDragRect.Right() += pSplitItem->mnPixSize;
                            else
                                maDragRect.Left() -= pSplitItem->mnPixSize;
                        }
                        else
                        {
                            if ( bDown )
                                maDragRect.Bottom() += pSplitItem->mnPixSize;
                            else
                                maDragRect.Top() -= pSplitItem->mnPixSize;
                        }
                    }
                    nTemp++;
                }
            }
        }
        else
        {
            maDragRect.Left()	= mnLeftBorder;
            maDragRect.Top()	= mnTopBorder;
            maDragRect.Right()	= mnDX-mnRightBorder-1;
            maDragRect.Bottom() = mnDY-mnBottomBorder-1;
            if ( mbHorz )
            {
                if ( mbBottomRight )
                    maDragRect.Top() -= nCurMaxSize-mnDY-mnBottomBorder;
                else
                    maDragRect.Bottom() += nCurMaxSize-mnDY-mnTopBorder;
            }
            else
            {
                if ( mbBottomRight )
                    maDragRect.Left() -= nCurMaxSize-mnDX-mnRightBorder;
                else
                    maDragRect.Right() += nCurMaxSize-mnDX-mnLeftBorder;
            }
        }

        StartTracking();

        mbDragFull = (GetSettings().GetStyleSettings().GetDragFullOptions() & DRAGFULL_OPTION_SPLIT) != 0;

        ImplSplitMousePos( aMousePosPixel );

        if ( !mbDragFull )
            ImplDrawSplitTracking( this, aMousePosPixel );
        else
        {
            ImplSplitItem*	pItems = mpSplitSet->mpItems;
            sal_uInt16			nItems = mpSplitSet->mnItems;
            mpLastSizes = new long[nItems*2];
            for ( sal_uInt16 i = 0; i < nItems; i++ )
            {
                mpLastSizes[i*2]   = pItems[i].mnSize;
                mpLastSizes[i*2+1] = pItems[i].mnPixSize;
            }
        }
        mnMStartPos = mnMSplitPos;

		PointerStyle eStyle = POINTER_ARROW;
        if ( mnSplitTest & SPLIT_HORZ )
            eStyle = POINTER_HSPLIT;
        else if ( mnSplitTest & SPLIT_VERT )
            eStyle = POINTER_VSPLIT;

		Pointer aPtr( eStyle );
		SetPointer( aPtr );
    }
}


// -----------------------------------------------------------------------

void SplitWindow::StartSplit()
{
	maStartSplitHdl.Call( this );
}

// -----------------------------------------------------------------------

void SplitWindow::Split()
{
	maSplitHdl.Call( this );
}

// -----------------------------------------------------------------------

void SplitWindow::SplitResize()
{
	maSplitResizeHdl.Call( this );
}

// -----------------------------------------------------------------------

void SplitWindow::AutoHide()
{
	maAutoHideHdl.Call( this );
}

// -----------------------------------------------------------------------

void SplitWindow::FadeIn()
{
	maFadeInHdl.Call( this );
}

// -----------------------------------------------------------------------

void SplitWindow::FadeOut()
{
	maFadeOutHdl.Call( this );
}

// -----------------------------------------------------------------------

void SplitWindow::MouseButtonDown( const MouseEvent& rMEvt )
{
	if ( !rMEvt.IsLeft() || rMEvt.IsMod2() )
	{
		DockingWindow::MouseButtonDown( rMEvt );
		return;
	}

	Point			aMousePosPixel = rMEvt.GetPosPixel();
	Rectangle		aTestRect;

	mbFadeNoButtonMode = sal_False;
	ImplGetAutoHideRect( aTestRect, sal_True );
	if ( aTestRect.IsInside( aMousePosPixel ) )
	{
		mbAutoHideDown = sal_True;
		mbAutoHidePressed = sal_True;
		ImplDrawAutoHide( sal_False );
	}
	else
	{
		ImplGetFadeOutRect( aTestRect, sal_True );
		if ( aTestRect.IsInside( aMousePosPixel ) )
		{
			mbFadeOutDown = sal_True;
			mbFadeOutPressed = sal_True;
			ImplDrawFadeOut( sal_False );
		}
		else
		{
			ImplGetFadeInRect( aTestRect, sal_True );
			if ( aTestRect.IsInside( aMousePosPixel ) )
			{
				mbFadeInDown = sal_True;
				mbFadeInPressed = sal_True;
				ImplDrawFadeIn( sal_False );
			}
			else if ( !aTestRect.IsEmpty() && !(mnWinStyle & WB_SIZEABLE) )
			{
				mbFadeNoButtonMode = sal_True;
				FadeIn();
				return;
			}
		}
	}

	if ( mbAutoHideDown || mbFadeInDown || mbFadeOutDown )
		StartTracking();
	else
        ImplStartSplit( rMEvt );
}

// -----------------------------------------------------------------------

void SplitWindow::MouseMove( const MouseEvent& rMEvt )
{
	if ( !IsTracking() )
	{
		Point			aPos = rMEvt.GetPosPixel();
		long			nTemp;
		ImplSplitSet*	pTempSplitSet;
		sal_uInt16			nTempSplitPos;
		sal_uInt16			nSplitTest = ImplTestSplit( this, aPos, nTemp, &pTempSplitSet, nTempSplitPos );
		PointerStyle	eStyle = POINTER_ARROW;
		Rectangle		aAutoHideRect;
		Rectangle		aFadeInRect;
		Rectangle		aFadeOutRect;

		ImplGetAutoHideRect( aAutoHideRect );
		ImplGetFadeInRect( aFadeInRect );
		ImplGetFadeOutRect( aFadeOutRect );
		if ( !aAutoHideRect.IsInside( aPos ) &&
			 !aFadeInRect.IsInside( aPos ) &&
			 !aFadeOutRect.IsInside( aPos ) )
		{
			if ( nSplitTest && !(nSplitTest & SPLIT_NOSPLIT) )
			{
				if ( nSplitTest & SPLIT_HORZ )
					eStyle = POINTER_HSPLIT;
				else if ( nSplitTest & SPLIT_VERT )
					eStyle = POINTER_VSPLIT;
			}
		}

		Pointer aPtr( eStyle );
		SetPointer( aPtr );
	}
}

// -----------------------------------------------------------------------

void SplitWindow::Tracking( const TrackingEvent& rTEvt )
{
	Point aMousePosPixel = rTEvt.GetMouseEvent().GetPosPixel();

	if ( mbAutoHideDown )
	{
		if ( rTEvt.IsTrackingEnded() )
		{
			mbAutoHideDown = sal_False;
			if ( mbAutoHidePressed )
			{
				mbAutoHidePressed = sal_False;

				if ( !rTEvt.IsTrackingCanceled() )
				{
					mbAutoHideIn = !mbAutoHideIn;
					ImplDrawAutoHide( sal_False );
					AutoHide();
				}
				else
					ImplDrawAutoHide( sal_False );
			}
		}
		else
		{
			Rectangle aTestRect;
			ImplGetAutoHideRect( aTestRect, sal_True );
			sal_Bool bNewPressed = aTestRect.IsInside( aMousePosPixel );
			if ( bNewPressed != mbAutoHidePressed )
			{
				mbAutoHidePressed = bNewPressed;
				ImplDrawAutoHide( sal_False );
			}
		}
	}
	else if ( mbFadeInDown )
	{
		if ( rTEvt.IsTrackingEnded() )
		{
			mbFadeInDown = sal_False;
			if ( mbFadeInPressed )
			{
				mbFadeInPressed = sal_False;
				ImplDrawFadeIn( sal_False );

				if ( !rTEvt.IsTrackingCanceled() )
					FadeIn();
			}
		}
		else
		{
			Rectangle aTestRect;
			ImplGetFadeInRect( aTestRect, sal_True );
			sal_Bool bNewPressed = aTestRect.IsInside( aMousePosPixel );
			if ( bNewPressed != mbFadeInPressed )
			{
				mbFadeInPressed = bNewPressed;
				ImplDrawFadeIn( sal_False );
			}
		}
	}
	else if ( mbFadeOutDown )
	{
		if ( rTEvt.IsTrackingEnded() )
		{
			mbFadeOutDown = sal_False;
			if ( mbFadeOutPressed )
			{
				mbFadeOutPressed = sal_False;
				ImplDrawFadeOut( sal_False );

				if ( !rTEvt.IsTrackingCanceled() )
					FadeOut();
			}
		}
		else
		{
			Rectangle aTestRect;
			ImplGetFadeOutRect( aTestRect, sal_True );
			sal_Bool bNewPressed = aTestRect.IsInside( aMousePosPixel );
			if ( bNewPressed == sal_False )
			{
				mbFadeOutPressed = bNewPressed;
				ImplDrawFadeOut( sal_False );

                // We need a mouseevent with a position inside the button for the
                // ImplStartSplit function!
                MouseEvent aOrgMEvt = rTEvt.GetMouseEvent();
                MouseEvent aNewMEvt = MouseEvent( aTestRect.Center(), aOrgMEvt.GetClicks(),
                                                  aOrgMEvt.GetMode(), aOrgMEvt.GetButtons(),
                                                  aOrgMEvt.GetModifier() );

                ImplStartSplit( aNewMEvt );
                mbFadeOutDown = sal_False;
			}
		}
	}
	else
	{
		ImplSplitMousePos( aMousePosPixel );
		sal_Bool bSplit = sal_True;
		if ( mbDragFull )
		{
			if ( rTEvt.IsTrackingEnded() )
			{
				if ( rTEvt.IsTrackingCanceled() )
				{
					ImplSplitItem*	pItems = mpSplitSet->mpItems;
					sal_uInt16			nItems = mpSplitSet->mnItems;
					for ( sal_uInt16 i = 0; i < nItems; i++ )
					{
						pItems[i].mnSize	 = mpLastSizes[i*2];
						pItems[i].mnPixSize  = mpLastSizes[i*2+1];
					}
					ImplUpdate();
					Split();
				}
				bSplit = sal_False;
			}
		}
		else
		{
			if ( rTEvt.IsTrackingEnded() )
			{
				HideTracking();
				bSplit = !rTEvt.IsTrackingCanceled();
			}
			else
			{
				ImplDrawSplitTracking( this, aMousePosPixel );
				bSplit = sal_False;
			}
		}

		if ( bSplit )
		{
			sal_Bool	bPropSmaller = (mnMouseModifier & KEY_SHIFT) ? sal_True : sal_False;
			sal_Bool	bPropGreater = (mnMouseModifier & KEY_MOD1) ? sal_True : sal_False;
			long	nDelta = mnMSplitPos-mnMStartPos;

			if ( (mnSplitTest & SPLIT_WINDOW) && !mpMainSet->mpItems )
			{
				if ( (mpSplitSet == mpMainSet) && mbBottomRight )
					nDelta *= -1;
				ImplSetWindowSize( nDelta );
			}
			else
			{
				long nNewSize = mpSplitSet->mpItems[mnSplitPos].mnPixSize;
				if ( (mpSplitSet == mpMainSet) && mbBottomRight )
					nNewSize -= nDelta;
				else
					nNewSize += nDelta;
				SplitItem( mpSplitSet->mpItems[mnSplitPos].mnId, nNewSize,
						   bPropSmaller, bPropGreater );
			}

			Split();

			if ( mbDragFull )
			{
				Update();
				mnMStartPos = mnMSplitPos;
			}
		}

		if ( rTEvt.IsTrackingEnded() )
		{
			if ( mpLastSizes )
				delete mpLastSizes;
			mpLastSizes 	= NULL;
			mpSplitSet		= NULL;
			mnMouseOff		= 0;
			mnMStartPos 	= 0;
			mnMSplitPos 	= 0;
			mnMouseModifier = 0;
			mnSplitTest 	= 0;
			mnSplitPos		= 0;
		}
	}
}

// -----------------------------------------------------------------------

long SplitWindow::PreNotify( NotifyEvent& rNEvt )
{
    const MouseEvent* pMouseEvt = NULL;

    if( (rNEvt.GetType() == EVENT_MOUSEMOVE) && (pMouseEvt = rNEvt.GetMouseEvent()) != NULL )
    {
        if( !pMouseEvt->GetButtons() && !pMouseEvt->IsSynthetic() && !pMouseEvt->IsModifierChanged() )
        {
            // trigger redraw if mouse over state has changed
            Rectangle aFadeInRect;
            Rectangle aFadeOutRect;
		    ImplGetFadeInRect( aFadeInRect );
		    ImplGetFadeOutRect( aFadeOutRect );

		    if ( aFadeInRect.IsInside( GetPointerPosPixel() ) != aFadeInRect.IsInside( GetLastPointerPosPixel() ) )
                Invalidate( aFadeInRect );
		    if ( aFadeOutRect.IsInside( GetPointerPosPixel() ) != aFadeOutRect.IsInside( GetLastPointerPosPixel() ) )
                Invalidate( aFadeOutRect );

            if( pMouseEvt->IsLeaveWindow() || pMouseEvt->IsEnterWindow() )
            {
                Invalidate( aFadeInRect );
                Invalidate( aFadeOutRect );
            }
        }
    }
    return Window::PreNotify( rNEvt );
}

// -----------------------------------------------------------------------

void SplitWindow::Paint( const Rectangle& )
{
	if ( mnWinStyle & WB_BORDER )
		ImplDrawBorder( this );

	ImplDrawBorderLine( this );
    ImplDrawFadeOut( sal_True );
	ImplDrawFadeIn( sal_True );
	ImplDrawAutoHide( sal_True );

	// FrameSet-Hintergruende zeichnen
	ImplDrawBack( this, mpMainSet );

	// Splitter zeichnen
	if ( !(mnWinStyle & WB_NOSPLITDRAW) )
		ImplDrawSplit( this, mpMainSet, mbHorz, !mbBottomRight );
}

// -----------------------------------------------------------------------

void SplitWindow::Move()
{
	DockingWindow::Move();
}

// -----------------------------------------------------------------------

void SplitWindow::Resize()
{
	Size aSize = GetOutputSizePixel();
	mnDX = aSize.Width();
	mnDY = aSize.Height();

	ImplUpdate();
	Invalidate();
}

// -----------------------------------------------------------------------

void SplitWindow::RequestHelp( const HelpEvent& rHEvt )
{
	// no keyboard help for splitwin
	if ( rHEvt.GetMode() & (HELPMODE_BALLOON | HELPMODE_QUICK) && !rHEvt.KeyboardActivated() )
	{
		Point		aMousePosPixel = ScreenToOutputPixel( rHEvt.GetMousePosPixel() );
		Rectangle	aHelpRect;
		sal_uInt16		nHelpResId = 0;

		ImplGetAutoHideRect( aHelpRect, sal_True );
		if ( aHelpRect.IsInside( aMousePosPixel ) )
		{
			if ( mbAutoHideIn )
				nHelpResId = SV_HELPTEXT_SPLITFIXED;
			else
				nHelpResId = SV_HELPTEXT_SPLITFLOATING;
		}
		else
		{
			ImplGetFadeInRect( aHelpRect, sal_True );
			if ( aHelpRect.IsInside( aMousePosPixel ) )
				nHelpResId = SV_HELPTEXT_FADEIN;
			else
			{
				ImplGetFadeOutRect( aHelpRect, sal_True );
				if ( aHelpRect.IsInside( aMousePosPixel ) )
					nHelpResId = SV_HELPTEXT_FADEOUT;
			}
		}

		// Rechteck ermitteln
		if ( nHelpResId )
		{
			Point aPt = OutputToScreenPixel( aHelpRect.TopLeft() );
			aHelpRect.Left()   = aPt.X();
			aHelpRect.Top()    = aPt.Y();
			aPt = OutputToScreenPixel( aHelpRect.BottomRight() );
			aHelpRect.Right()  = aPt.X();
			aHelpRect.Bottom() = aPt.Y();

			// Text ermitteln und anzeigen
			XubString aStr;
            ResMgr* pResMgr = ImplGetResMgr();
            if( pResMgr )
                aStr = XubString( ResId( nHelpResId, *pResMgr ) );
			if ( rHEvt.GetMode() & HELPMODE_BALLOON )
				Help::ShowBalloon( this, aHelpRect.Center(), aHelpRect, aStr );
			else
				Help::ShowQuickHelp( this, aHelpRect, aStr );
			return;
		}
	}

	DockingWindow::RequestHelp( rHEvt );
}

// -----------------------------------------------------------------------

void SplitWindow::StateChanged( StateChangedType nType )
{
	if ( nType == STATE_CHANGE_INITSHOW )
	{
		if ( IsUpdateMode() )
			ImplCalcLayout();
	}
	else if ( nType == STATE_CHANGE_UPDATEMODE )
	{
		if ( IsUpdateMode() && IsReallyShown() )
			ImplCalcLayout();
	}
	else if ( nType == STATE_CHANGE_CONTROLBACKGROUND )
	{
		ImplInitSettings();
		Invalidate();
	}

	DockingWindow::StateChanged( nType );
}

// -----------------------------------------------------------------------

void SplitWindow::DataChanged( const DataChangedEvent& rDCEvt )
{
	if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
		 (rDCEvt.GetFlags() & SETTINGS_STYLE) )
	{
		ImplInitSettings();
		Invalidate();
	}
	else
		DockingWindow::DataChanged( rDCEvt );
}

// -----------------------------------------------------------------------

void SplitWindow::InsertItem( sal_uInt16 nId, Window* pWindow, long nSize,
							  sal_uInt16 nPos, sal_uInt16 nSetId,
							  SplitWindowItemBits nBits )
{
#ifdef DBG_UTIL
	sal_uInt16 nDbgDummy;
	DBG_ASSERT( ImplFindSet( mpMainSet, nSetId ), "SplitWindow::InsertItem() - Set not exists" );
	DBG_ASSERT( !ImplFindItem( mpMainSet, nId, nDbgDummy ), "SplitWindow::InsertItem() - Id already exists" );
#endif

	// Size has to be at least 1.
	if ( nSize < 1 )
		nSize = 1;

	ImplSplitSet* pSet		 = ImplFindSet( mpMainSet, nSetId );
	ImplSplitSet* pNewSet;
	ImplSplitItem* pItem;

	// Make room for the new item.
	if ( nPos > pSet->mnItems )
		nPos = pSet->mnItems;
	ImplSplitItem* pNewItems = new ImplSplitItem[pSet->mnItems+1];
	if ( nPos )
		memcpy( pNewItems, pSet->mpItems, sizeof( ImplSplitItem )*nPos );
	if ( nPos < pSet->mnItems )
		memcpy( pNewItems+nPos+1, pSet->mpItems+nPos, sizeof( ImplSplitItem )*(pSet->mnItems-nPos) );
	delete[] pSet->mpItems;
	pSet->mpItems = pNewItems;
	pSet->mnItems++;
	pSet->mbCalcPix = sal_True;

	// Create and initialize item.
	pItem			= &(pSet->mpItems[nPos]);
	memset( pItem, 0, sizeof( ImplSplitItem ) );
	pItem->mnSize	= nSize;
	pItem->mnId 	= nId;
	pItem->mnBits	= nBits;
    pItem->mnMinSize=-1;
    pItem->mnMaxSize=-1;

	if ( pWindow )
	{
		pItem->mpWindow 		= pWindow;
		pItem->mpOrgParent		= pWindow->GetParent();

		// Attach window to SplitWindow.
		pWindow->Hide();
		pWindow->SetParent( this );
	}
	else
	{
		pNewSet 				= new ImplSplitSet;
		pNewSet->mpItems		= NULL;
		pNewSet->mpWallpaper	= NULL;
		pNewSet->mpBitmap		= NULL;
		pNewSet->mnLastSize 	= 0;
		pNewSet->mnItems		= 0;
		pNewSet->mnId			= nId;
		pNewSet->mnSplitSize	= pSet->mnSplitSize;
		pNewSet->mbCalcPix		= sal_True;

		pItem->mpSet			= pNewSet;
	}

	ImplUpdate();
}

// -----------------------------------------------------------------------

void SplitWindow::InsertItem( sal_uInt16 nId, long nSize,
							  sal_uInt16 nPos, sal_uInt16 nSetId,
							  SplitWindowItemBits nBits )
{
	InsertItem( nId, NULL, nSize, nPos, nSetId, nBits );
}

// -----------------------------------------------------------------------

void SplitWindow::MoveItem( sal_uInt16 nId, sal_uInt16 nNewPos, sal_uInt16 nNewSetId )
{
#ifdef DBG_UTIL
	sal_uInt16 nDbgDummy;
	DBG_ASSERT( ImplFindItem( mpMainSet, nId, nDbgDummy ), "SplitWindow::MoveItem() - Id not found" );
	DBG_ASSERT( ImplFindSet( mpMainSet, nNewSetId ), "SplitWindow::MoveItem() - Set not exists" );
#endif

	sal_uInt16			nPos;
	ImplSplitSet*	 pNewSet = ImplFindSet( mpMainSet, nNewSetId );
	ImplSplitSet*	 pSet	 = ImplFindItem( mpMainSet, nId, nPos );
	ImplSplitItem	 aTempItem;

	if ( pNewSet == pSet )
	{
		if ( nNewPos >= pNewSet->mnItems )
			nNewPos = pNewSet->mnItems-1;
		if ( nPos != nNewPos )
		{
			memcpy( &aTempItem, &(pSet->mpItems[nPos]), sizeof( aTempItem ) );
			if ( nPos < nNewPos )
			{
				memmove( pSet->mpItems+nPos, pSet->mpItems+nPos+1,
						 (nNewPos-nPos)*sizeof( ImplSplitItem ) );
			}
			else
			{
				memmove( pSet->mpItems+nNewPos+1, pSet->mpItems+nNewPos,
						 (nPos-nNewPos)*sizeof( ImplSplitItem ) );
			}
			memcpy( &(pSet->mpItems[nNewPos]), &aTempItem, sizeof( aTempItem ) );

			ImplUpdate();
		}
	}
	else
	{
		if ( nNewPos >= pNewSet->mnItems )
			nNewPos = pNewSet->mnItems;
		memcpy( &aTempItem, &(pSet->mpItems[nPos]), sizeof( aTempItem ) );
		pSet->mnItems--;
		pSet->mbCalcPix = sal_True;
		if ( pSet->mnItems )
		{
			memmove( pSet->mpItems+nPos, pSet->mpItems+nPos+1,
					 (pSet->mnItems-nPos)*sizeof( ImplSplitItem ) );
		}
		else
		{
			delete[] pSet->mpItems;
			pSet->mpItems = NULL;
		}
		ImplSplitItem* pNewItems = new ImplSplitItem[pNewSet->mnItems+1];
		if ( nNewPos )
			memcpy( pNewItems, pNewSet->mpItems, sizeof( ImplSplitItem )*nNewPos );
		if ( nNewPos < pNewSet->mnItems )
		{
			memcpy( pNewItems+nNewPos+1, pNewSet->mpItems+nNewPos,
					sizeof( ImplSplitItem )*(pNewSet->mnItems-nNewPos) );
		}
		delete[] pNewSet->mpItems;
		pNewSet->mpItems = pNewItems;
		pNewSet->mnItems++;
		pNewSet->mbCalcPix = sal_True;
		memcpy( &(pNewSet->mpItems[nNewPos]), &aTempItem, sizeof( aTempItem ) );
		ImplUpdate();
	}
}

// -----------------------------------------------------------------------

void SplitWindow::RemoveItem( sal_uInt16 nId, sal_Bool bHide )
{
#ifdef DBG_UTIL
	sal_uInt16 nDbgDummy;
	DBG_ASSERT( ImplFindItem( mpMainSet, nId, nDbgDummy ), "SplitWindow::RemoveItem() - Id not found" );
#endif

	// Set suchen
	sal_uInt16			nPos;
	ImplSplitSet*	 pSet	 = ImplFindItem( mpMainSet, nId, nPos );
	ImplSplitItem*	 pItem	 = &(pSet->mpItems[nPos]);
	Window* 		pWindow = pItem->mpWindow;
	Window* 		pOrgParent = pItem->mpOrgParent;

	// Evt. Set loeschen
	if ( !pWindow )
		ImplDeleteSet( pItem->mpSet );

	// Item entfernen
	pSet->mnItems--;
	pSet->mbCalcPix = sal_True;
	if ( pSet->mnItems )
	{
		memmove( pSet->mpItems+nPos, pSet->mpItems+nPos+1,
				 (pSet->mnItems-nPos)*sizeof( ImplSplitItem ) );
	}
	else
	{
		delete[] pSet->mpItems;
		pSet->mpItems = NULL;
	}

	ImplUpdate();

	// Window erst hier loeschen, um weniger Paints zu haben
	if ( pWindow )
	{
		// Fenster wieder herstellen
		if ( bHide || (pOrgParent != this) )
		{
			pWindow->Hide();
			pWindow->SetParent( pOrgParent );
		}
	}
}

// -----------------------------------------------------------------------

void SplitWindow::Clear()
{
	// Alle Sets loeschen
	ImplDeleteSet( mpMainSet );

	// Main-Set wieder anlegen
	mpMainSet					= new ImplSplitSet;
	mpMainSet->mpItems			= NULL;
	mpMainSet->mpWallpaper		= NULL;
	mpMainSet->mpBitmap 		= NULL;
	mpMainSet->mnLastSize		= 0;
	mpMainSet->mnItems			= 0;
	mpMainSet->mnId 			= 0;
	mpMainSet->mnSplitSize		= SPLITWIN_SPLITSIZE;
	mpMainSet->mbCalcPix		= sal_True;
	if ( mnWinStyle & WB_NOSPLITDRAW )
		mpMainSet->mnSplitSize -= 2;
	mpBaseSet					= mpMainSet;

	// Und neu invalidieren
	ImplUpdate();
}

// -----------------------------------------------------------------------

void SplitWindow::SetBaseSet( sal_uInt16 nSetId )
{
	mpBaseSet = ImplFindSet( mpMainSet, nSetId );
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::GetBaseSet() const
{
	return mpBaseSet->mnId;
}

// -----------------------------------------------------------------------

void SplitWindow::SetSplitSize( sal_uInt16 nSetId, long nSplitSize,
								sal_Bool bWithChilds )
{
	ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId );
	if ( pSet )
	{
		if ( bWithChilds )
			ImplSetSplitSize( pSet, nSplitSize );
		else
			pSet->mnSplitSize = nSplitSize;
	}
	ImplUpdate();
}

// -----------------------------------------------------------------------

long SplitWindow::GetSplitSize( sal_uInt16 nSetId ) const
{
	ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId );
	if ( pSet )
		return pSet->mnSplitSize;
	else
		return 0;
}

// -----------------------------------------------------------------------

void SplitWindow::SetItemBackground( sal_uInt16 nSetId )
{
	Wallpaper aWall;
	SetItemBackground( nSetId, aWall );
}

// -----------------------------------------------------------------------

void SplitWindow::SetItemBackground( sal_uInt16 nSetId, const Wallpaper& rWallpaper )
{
	ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId );

	if ( pSet )
	{
		sal_Bool bUpdate = sal_True;

		if ( rWallpaper.GetStyle() == WALLPAPER_NULL )
		{
			if ( pSet->mpWallpaper )
			{
				delete pSet->mpWallpaper;
				pSet->mpWallpaper = NULL;
			}
			else
				bUpdate = sal_False;
		}
		else
		{
			// Ab jetzt muss immer invalidiert werden
			mbInvalidate = sal_True;

			if ( !pSet->mpWallpaper )
				pSet->mpWallpaper = new Wallpaper( rWallpaper );
			else
				*(pSet->mpWallpaper) = rWallpaper;
		}

		// Beim MainSet koennen wir den Background umsetzen
		if ( pSet == mpMainSet )
			ImplInitSettings();

		if ( bUpdate )
			ImplUpdateSet( pSet );
	}
}

// -----------------------------------------------------------------------

Wallpaper SplitWindow::GetItemBackground( sal_uInt16 nSetId ) const
{
	ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId );

	if ( pSet && pSet->mpWallpaper )
		return *(pSet->mpWallpaper);
	else
	{
		Wallpaper aWall;
		return aWall;
	}
}

// -----------------------------------------------------------------------

sal_Bool SplitWindow::IsItemBackground( sal_uInt16 nSetId ) const
{
	ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId );

	if ( pSet && pSet->mpWallpaper )
		return sal_True;
	else
		return sal_False;
}

// -----------------------------------------------------------------------

void SplitWindow::SetItemBitmap( sal_uInt16 nSetId, const Bitmap& rBitmap )
{
	ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId );

	if ( pSet )
	{
		sal_Bool bUpdate = sal_True;

		if ( !rBitmap )
		{
			if ( pSet->mpBitmap )
			{
				delete pSet->mpBitmap;
				pSet->mpBitmap = NULL;
			}
			else
				bUpdate = sal_False;
		}
		else
		{
			// Ab jetzt muss immer invalidiert werden
			mbInvalidate = sal_True;

			if ( !pSet->mpBitmap )
				pSet->mpBitmap = new Bitmap( rBitmap );
			else
				*(pSet->mpBitmap) = rBitmap;
		}

		// Beim MainSet koennen wir den Background umsetzen
		if ( pSet == mpMainSet )
			ImplInitSettings();

		if ( bUpdate )
			ImplUpdateSet( pSet );
	}
}

// -----------------------------------------------------------------------

Bitmap SplitWindow::GetItemBitmap( sal_uInt16 nSetId ) const
{
	ImplSplitSet* pSet = ImplFindSet( mpMainSet, nSetId );

	if ( pSet && pSet->mpBitmap )
		return *(pSet->mpBitmap);
	else
	{
		Bitmap aBitmap;
		return aBitmap;
	}
}

// -----------------------------------------------------------------------

void SplitWindow::SplitItem( sal_uInt16 nId, long nNewSize,
							 sal_Bool bPropSmall, sal_Bool bPropGreat )
{
	sal_uInt16			nItems;
	sal_uInt16			nPos;
	sal_uInt16			nMin;
	sal_uInt16			nMax;
	sal_uInt16			i;
	sal_uInt16			n;
	long			nDelta;
	long			nTempDelta;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );
	ImplSplitItem*	pItems;

	if ( !pSet )
		return;

	nItems = pSet->mnItems;
	pItems = pSet->mpItems;

    // When there is an explicit minimum or maximum size then move nNewSize
    // into that range (when it is not yet already in it.)
    nNewSize = ValidateSize(nNewSize, pItems[nPos]);

	if ( mbCalc )
	{
		pItems[nPos].mnSize = nNewSize;
		return;
	}

	nDelta = nNewSize-pItems[nPos].mnPixSize;
	if ( !nDelta )
		return;

	// Bereich berechnen, der beim Splitten betroffen sein kann
	nMin = 0;
	nMax = nItems;
	for ( i = 0; i < nItems; i++ )
	{
		if ( pItems[i].mbFixed )
		{
			if ( i < nPos )
				nMin = i+1;
			else
				nMax = i;
		}
	}

	// Wenn das Fenster sizeable ist, wird das TopSet anders behandelt
	sal_Bool bSmall  = sal_True;
	sal_Bool bGreat  = sal_True;
	if ( (pSet == mpMainSet) && (mnWinStyle & WB_SIZEABLE) )
	{
		if ( nPos < pSet->mnItems-1 )
		{
			if ( !((bPropSmall && bPropGreat) ||
				   ((nDelta > 0) && bPropSmall) ||
				   ((nDelta < 0) && bPropGreat)) )
			{
				if ( nDelta < 0 )
					bGreat = sal_False;
				else
					bSmall = sal_False;
			}
		}
		else
		{
			if ( nDelta < 0 )
				bGreat = sal_False;
			else
				bSmall = sal_False;
		}
	}
	else if ( nPos >= nMax )
	{
		bSmall = sal_False;
		bGreat = sal_False;
	}
	else if ( nPos && (nPos >= pSet->mnItems-1) )
	{
		nPos--;
		nDelta *= -1;
		sal_Bool bTemp = bPropSmall;
		bPropSmall = bPropGreat;
		bPropGreat = bTemp;
	}

	// Jetzt die Fenster splitten
	if ( nDelta < 0 )
	{
		if ( bGreat )
		{
			if ( bPropGreat )
			{
				nTempDelta = nDelta;
				do
				{
					n = nPos+1;
					do
					{
						if ( nTempDelta )
						{
							pItems[n].mnPixSize++;
							nTempDelta++;
						}
						n++;
					}
					while ( n < nMax );
				}
				while ( nTempDelta );
			}
			else
				pItems[nPos+1].mnPixSize -= nDelta;
		}

		if ( bSmall )
		{
			if ( bPropSmall )
			{
				do
				{
					n = nPos+1;
					do
					{
						if ( nDelta && pItems[n-1].mnPixSize )
						{
							pItems[n-1].mnPixSize--;
							nDelta++;
						}

						n--;
					}
					while ( n > nMin );
				}
				while ( nDelta );
			}
			else
			{
				n = nPos+1;
				do
				{
					if ( pItems[n-1].mnPixSize+nDelta < 0 )
					{
						nDelta += pItems[n-1].mnPixSize;
						pItems[n-1].mnPixSize = 0;
					}
					else
					{
						pItems[n-1].mnPixSize += nDelta;
						break;
					}
					n--;
				}
				while ( n > nMin );
			}
		}
	}
	else
	{
		if ( bGreat )
		{
			if ( bPropGreat )
			{
				nTempDelta = nDelta;
				do
				{
					n = nPos+1;
					do
					{
						if ( nTempDelta )
						{
							pItems[n-1].mnPixSize++;
							nTempDelta--;
						}
						n--;
					}
					while ( n > nMin );
				}
				while ( nTempDelta );
			}
			else
				pItems[nPos].mnPixSize += nDelta;
		}

		if ( bSmall )
		{
			if ( bPropSmall )
			{
				do
				{
					n = nPos+1;
					do
					{
						if ( nDelta && pItems[n].mnPixSize )
						{
							pItems[n].mnPixSize--;
							nDelta--;
						}

						n++;
					}
					while ( n < nMax );
				}
				while ( nDelta );
			}
			else
			{
				n = nPos+1;
				do
				{
					if ( pItems[n].mnPixSize-nDelta < 0 )
					{
						nDelta -= pItems[n].mnPixSize;
						pItems[n].mnPixSize = 0;
					}
					else
					{
						pItems[n].mnPixSize -= nDelta;
						break;
					}
					n++;
				}
				while ( n < nMax );
			}
		}
	}

	// Original-Groessen updaten
	ImplCalcLogSize( pItems, nItems );

	ImplUpdate();
}

// -----------------------------------------------------------------------

void SplitWindow::SetItemSize( sal_uInt16 nId, long nNewSize )
{
	sal_uInt16			nPos;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );
	ImplSplitItem*	pItem;

	if ( !pSet )
		return;

	// Testen, ob sich Groesse aendert
	pItem = &(pSet->mpItems[nPos]);
	if ( pItem->mnSize != nNewSize )
	{
		// Neue Groesse setzen und neu durchrechnen
		pItem->mnSize = nNewSize;
		pSet->mbCalcPix = sal_True;
		ImplUpdate();
	}
}

// -----------------------------------------------------------------------

long SplitWindow::GetItemSize( sal_uInt16 nId ) const
{
	sal_uInt16			nPos;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );

	if ( pSet )
		return pSet->mpItems[nPos].mnSize;
	else
		return 0;
}

// -----------------------------------------------------------------------

long SplitWindow::GetItemSize( sal_uInt16 nId, SplitWindowItemBits nBits ) const
{
	sal_uInt16			nPos;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );

	if ( pSet )
	{
		if ( nBits == pSet->mpItems[nPos].mnBits )
			return pSet->mpItems[nPos].mnSize;
		else
		{
			((SplitWindow*)this)->ImplCalcLayout();

			long				nRelSize = 0;
			long				nPerSize = 0;
			ImplSplitItem*		pItems;
			sal_uInt16				nItems;
			SplitWindowItemBits nTempBits;
			sal_uInt16				i;
			nItems = pSet->mnItems;
			pItems = pSet->mpItems;
			for ( i = 0; i < nItems; i++ )
			{
				if ( i == nPos )
					nTempBits = nBits;
				else
					nTempBits = pItems[i].mnBits;
				if ( nTempBits & SWIB_RELATIVESIZE )
					nRelSize += pItems[i].mnPixSize;
				else if ( nTempBits & SWIB_PERCENTSIZE )
					nPerSize += pItems[i].mnPixSize;
			}
			nPerSize += nRelSize;
			if ( nBits & SWIB_RELATIVESIZE )
			{
				if ( nRelSize )
					return (pItems[nPos].mnPixSize+(nRelSize/2))/nRelSize;
				else
					return 1;
			}
			else if ( nBits & SWIB_PERCENTSIZE )
			{
				if ( nPerSize )
					return (pItems[nPos].mnPixSize*100)/nPerSize;
				else
					return 1;
			}
			else
				return pItems[nPos].mnPixSize;
		}
	}
	else
		return 0;
}




void SplitWindow::SetItemSizeRange (sal_uInt16 nId, const Range aRange)
{
	sal_uInt16 nPos;
    ImplSplitSet* pSet = ImplFindItem(mpBaseSet, nId, nPos);

	if (pSet != NULL)
    {
		pSet->mpItems[nPos].mnMinSize = aRange.Min();
		pSet->mpItems[nPos].mnMaxSize = aRange.Max();
    }
}




Range SplitWindow::GetItemSizeRange (sal_uInt16 nId) const
{
	sal_uInt16 nPos;
    ImplSplitSet* pSet = ImplFindItem(mpBaseSet, nId, nPos);

	if (pSet != NULL)
        return Range (pSet->mpItems[nPos].mnMinSize, pSet->mpItems[nPos].mnMaxSize);
    else
        return Range(-1,-1);
}


// -----------------------------------------------------------------------

void SplitWindow::SetItemBits( sal_uInt16 nId, SplitWindowItemBits nNewBits )
{
	sal_uInt16			nPos;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );
	ImplSplitItem*	pItem;

	if ( !pSet )
		return;

	pItem = &(pSet->mpItems[nPos]);
	if ( pItem->mpWindow )
		nNewBits &= ~SWIB_COLSET;

	if ( pItem->mnBits != nNewBits )
	{
		// Neue Bits setzen und neu durchrechnen
		pItem->mnBits = nNewBits;
		pSet->mbCalcPix = sal_True;
		ImplUpdate();
	}
}

// -----------------------------------------------------------------------

SplitWindowItemBits SplitWindow::GetItemBits( sal_uInt16 nId ) const
{
	sal_uInt16			nPos;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );

	if ( pSet )
		return pSet->mpItems[nPos].mnBits;
	else
		return 0;
}

// -----------------------------------------------------------------------

Window* SplitWindow::GetItemWindow( sal_uInt16 nId ) const
{
	sal_uInt16			nPos;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );

	if ( pSet )
		return pSet->mpItems[nPos].mpWindow;
	else
		return NULL;
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::GetSet( sal_uInt16 nId ) const
{
	sal_uInt16			nPos;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );

	if ( pSet )
		return pSet->mnId;
	else
		return 0;
}

// -----------------------------------------------------------------------

sal_Bool SplitWindow::GetSet( sal_uInt16 nId, sal_uInt16& rSetId, sal_uInt16& rPos ) const
{
	ImplSplitSet* pSet = ImplFindItem( mpBaseSet, nId, rPos );
	if ( pSet )
	{
		rSetId = pSet->mnId;
		return sal_True;
	}
	else
		return sal_False;
}

// -----------------------------------------------------------------------

sal_Bool SplitWindow::IsItemValid( sal_uInt16 nId ) const
{
	sal_uInt16			nPos;
	ImplSplitSet*	pSet = ImplFindItem( mpBaseSet, nId, nPos );

	if ( pSet )
		return sal_True;
	else
		return sal_False;
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::GetItemId( Window* pWindow ) const
{
	return ImplFindItem( mpBaseSet, pWindow );
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::GetItemId( const Point& rPos ) const
{
	return ImplFindItem( mpBaseSet, rPos, mbHorz, !mbBottomRight );
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::GetItemPos( sal_uInt16 nId, sal_uInt16 nSetId ) const
{
	ImplSplitSet*	pSet = ImplFindSet( mpBaseSet, nSetId );
	sal_uInt16			nPos = SPLITWINDOW_ITEM_NOTFOUND;

	if ( pSet )
	{
		for ( sal_uInt16 i = 0; i < pSet->mnItems; i++ )
		{
			if ( pSet->mpItems[i].mnId == nId )
			{
				nPos = i;
				break;
			}
		}
	}

	return nPos;
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::GetItemId( sal_uInt16 nPos, sal_uInt16 nSetId ) const
{
	ImplSplitSet* pSet = ImplFindSet( mpBaseSet, nSetId );
	if ( pSet && (nPos < pSet->mnItems) )
		return pSet->mpItems[nPos].mnId;
	else
		return 0;
}

// -----------------------------------------------------------------------

sal_uInt16 SplitWindow::GetItemCount( sal_uInt16 nSetId ) const
{
	ImplSplitSet* pSet = ImplFindSet( mpBaseSet, nSetId );
	if ( pSet )
		return pSet->mnItems;
	else
		return 0;
}

// -----------------------------------------------------------------------

void SplitWindow::ImplNewAlign()
{
	if ( mbNoAlign )
	{
		mbHorz		  = sal_False;
		mbBottomRight = sal_False;
	}
	else if ( meAlign == WINDOWALIGN_TOP )
	{
		mbHorz		  = sal_True;
		mbBottomRight = sal_False;
	}
	else if ( meAlign == WINDOWALIGN_BOTTOM )
	{
		mbHorz		  = sal_True;
		mbBottomRight = sal_True;
	}
	else if ( meAlign == WINDOWALIGN_LEFT )
	{
		mbHorz		  = sal_False;
		mbBottomRight = sal_False;
	}
	else if ( meAlign == WINDOWALIGN_RIGHT )
	{
		mbHorz		  = sal_False;
		mbBottomRight = sal_True;
	}

	if ( mnWinStyle & WB_BORDER )
	{
		ImplCalcBorder( meAlign, mbNoAlign, mnLeftBorder, mnTopBorder,
						mnRightBorder, mnBottomBorder );
	}

	if ( IsReallyVisible() && IsUpdateMode() )
		Invalidate();
	ImplUpdate();
}

// -----------------------------------------------------------------------

void SplitWindow::SetNoAlign( sal_Bool bNoAlign )
{
	bNoAlign = bNoAlign != 0;
	if ( mbNoAlign != bNoAlign )
	{
		mbNoAlign = bNoAlign;
		ImplNewAlign();
	}
}

// -----------------------------------------------------------------------

void SplitWindow::SetAlign( WindowAlign eNewAlign )
{
	if ( meAlign != eNewAlign )
	{
		meAlign = eNewAlign;
		ImplNewAlign();
	}
}

// -----------------------------------------------------------------------

Size SplitWindow::CalcWindowSizePixel( const Size& rSize, WindowAlign eAlign,
									   WinBits nWinStyle, sal_Bool bExtra )
{
	long	nLeft;
	long	nTop;
	long	nRight;
	long	nBottom;
	Size	aSize = rSize;

	ImplCalcBorder( eAlign, sal_False, nLeft, nTop, nRight, nBottom );
	aSize.Width()	+= nLeft+nRight;
	aSize.Height()	+= nTop+nBottom;

	if ( nWinStyle & WB_SIZEABLE )
	{
		if ( (eAlign == WINDOWALIGN_TOP) || (eAlign == WINDOWALIGN_BOTTOM) )
		{
			aSize.Height() += SPLITWIN_SPLITSIZE-2;
			if ( bExtra )
				aSize.Height() += SPLITWIN_SPLITSIZEEXLN;
		}
		else
		{
			aSize.Width() += SPLITWIN_SPLITSIZE-2;
			if ( bExtra )
				aSize.Width() += SPLITWIN_SPLITSIZEEXLN;
		}
	}

	return aSize;
}

// -----------------------------------------------------------------------

void SplitWindow::ShowAutoHideButton( sal_Bool bShow )
{
	mbAutoHide = bShow;
	ImplUpdate();
}

// -----------------------------------------------------------------------

void SplitWindow::ShowFadeInHideButton( sal_Bool bShow )
{
	mbFadeIn = bShow;
	ImplUpdate();
}

// -----------------------------------------------------------------------

void SplitWindow::ShowFadeOutButton( sal_Bool bShow )
{
	mbFadeOut = bShow;
	ImplUpdate();
}

// -----------------------------------------------------------------------

void SplitWindow::SetAutoHideState( sal_Bool bAutoHide )
{
	mbAutoHideIn = bAutoHide;
	if ( IsReallyVisible() )
	{
		Rectangle aRect;
		ImplGetAutoHideRect( aRect );
		Invalidate( aRect );
	}
}

// -----------------------------------------------------------------------

long SplitWindow::GetFadeInSize() const
{
	long n = 0;

	if ( mbHorz )
		n = mnTopBorder+mnBottomBorder;
	else
		n = mnLeftBorder+mnRightBorder;

	return n+SPLITWIN_SPLITSIZE+SPLITWIN_SPLITSIZEEX-2;
}

// -----------------------------------------------------------------------

Rectangle SplitWindow::GetAutoHideRect() const
{
	Rectangle aRect;
	ImplGetAutoHideRect( aRect, sal_True );
	return aRect;
}

// -----------------------------------------------------------------------

Rectangle SplitWindow::GetFadeInRect() const
{
	Rectangle aRect;
	ImplGetFadeInRect( aRect, sal_True );
	return aRect;
}

// -----------------------------------------------------------------------

Rectangle SplitWindow::GetFadeOutRect() const
{
	Rectangle aRect;
	ImplGetFadeOutRect( aRect, sal_True );
	return aRect;
}