/**************************************************************
 *
 * 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_sfx2.hxx"

#ifdef SOLARIS
// HACK: prevent conflict between STLPORT and Workshop headers on Solaris 8
#include <ctime>
#endif

#include <string> // HACK: prevent conflict between STLPORT and Workshop headers

#ifndef _WRKWIN_HXX //autogen
#include <vcl/wrkwin.hxx>
#endif
#include <unotools/viewoptions.hxx>
#ifndef GCC
#endif

#include <vcl/timer.hxx>

#include "splitwin.hxx"
#include "workwin.hxx"
#include <sfx2/dockwin.hxx>
#include <sfx2/app.hxx>
#include "dialog.hrc"
#include "sfx2/sfxresid.hxx"
#include <sfx2/mnumgr.hxx>
#include "virtmenu.hxx"
#include <sfx2/msgpool.hxx>
#include <sfx2/viewfrm.hxx>

#include <vector>
#include <utility>

using namespace ::com::sun::star::uno;
using namespace ::rtl;

#define VERSION	1
#define nPixel	30L
#define USERITEM_NAME			OUString::createFromAscii( "UserItem" )

namespace {
    // helper class to deactivate UpdateMode, if needed, for the life time of an instance
    class DeactivateUpdateMode
    {
    public:
        explicit DeactivateUpdateMode( SfxSplitWindow& rSplitWindow )
            : mrSplitWindow( rSplitWindow )
            , mbUpdateMode( rSplitWindow.IsUpdateMode() )
        {
            if ( mbUpdateMode )
            {
                mrSplitWindow.SetUpdateMode( sal_False );
            }
        }

        ~DeactivateUpdateMode( void )
        {
            if ( mbUpdateMode )
            {
                mrSplitWindow.SetUpdateMode( sal_True );
            }
        }

    private:
        SfxSplitWindow& mrSplitWindow;
        const sal_Bool mbUpdateMode;
    };
}

struct SfxDock_Impl
{
	sal_uInt16 				nType;
	SfxDockingWindow*	pWin;			// SplitWindow hat dieses Fenster
	sal_Bool				bNewLine;
	sal_Bool				bHide;			// SplitWindow hatte dieses Fenster
	long				nSize;
};

typedef SfxDock_Impl* SfxDockPtr;
SV_DECL_PTRARR_DEL( SfxDockArr_Impl, SfxDockPtr, 4, 4)
SV_IMPL_PTRARR( SfxDockArr_Impl, SfxDockPtr);

class SfxEmptySplitWin_Impl : public SplitWindow
{
/*  [Beschreibung]

	Das SfxEmptySplitWin_Impldow ist ein leeres SplitWindow, das das SfxSplitWindow
	im AutoHide-Modus ersetzt. Es dient nur als Platzhalter, um MouseMoves
	zu empfangen und ggf. das eigentlichte SplitWindow einzublenden
*/
friend class SfxSplitWindow;

	SfxSplitWindow* 	pOwner;
	sal_Bool				bFadeIn;
	sal_Bool				bAutoHide;
	sal_Bool				bSplit;
	sal_Bool				bEndAutoHide;
	Timer				aTimer;
	Point				aLastPos;
	sal_uInt16				nState;

						SfxEmptySplitWin_Impl( SfxSplitWindow *pParent )
							: SplitWindow( pParent->GetParent(), WinBits( WB_BORDER | WB_3DLOOK ) )
							, pOwner( pParent )
							, bFadeIn( sal_False )
							, bAutoHide( sal_False )
							, bSplit( sal_False )
							, bEndAutoHide( sal_False )
							, nState( 1 )
						{
							aTimer.SetTimeoutHdl(
								LINK(pOwner, SfxSplitWindow, TimerHdl ) );
							aTimer.SetTimeout( 200 );
//                            EnableDrop( sal_True );
							SetAlign( pOwner->GetAlign() );
							Actualize();
							ShowAutoHideButton( pOwner->IsAutoHideButtonVisible() );
							ShowFadeInHideButton( sal_True );
						}

						~SfxEmptySplitWin_Impl()
						{
							aTimer.Stop();
						}

	virtual void		MouseMove( const MouseEvent& );
	virtual void		AutoHide();
	virtual void		FadeIn();
	void				Actualize();
};

void SfxEmptySplitWin_Impl::Actualize()
{
	Size aSize( pOwner->GetSizePixel() );
	switch ( pOwner->GetAlign() )
	{
		case WINDOWALIGN_LEFT:
		case WINDOWALIGN_RIGHT:
			aSize.Width() = GetFadeInSize();
			break;
		case WINDOWALIGN_TOP:
		case WINDOWALIGN_BOTTOM:
			aSize.Height() = GetFadeInSize();
			break;
	}

	SetSizePixel( aSize );
}

void SfxEmptySplitWin_Impl::AutoHide()
{
	pOwner->SetPinned_Impl( !pOwner->bPinned );
	pOwner->SaveConfig_Impl();
	bAutoHide = sal_True;
	FadeIn();
}

void SfxEmptySplitWin_Impl::FadeIn()
{
	if (!bAutoHide )
		bAutoHide = IsFadeNoButtonMode();
	pOwner->SetFadeIn_Impl( sal_True );
	pOwner->Show_Impl();
	if ( bAutoHide )
	{
		// Timer zum Schlie\sen aufsetzen; der Aufrufer mu\s selbst sicherstellen,
		// da\s das Window nicht gleich wieder zu geht ( z.B. durch Setzen des
		// Focus oder einen modal mode )
		aLastPos = GetPointerPosPixel();
		aTimer.Start();
	}
	else
		pOwner->SaveConfig_Impl();
}

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

void SfxSplitWindow::MouseButtonDown( const MouseEvent& rMEvt )
{
	if ( rMEvt.GetClicks() != 2 )
		SplitWindow::MouseButtonDown( rMEvt );
}

void SfxEmptySplitWin_Impl::MouseMove( const MouseEvent& rMEvt )
{
	SplitWindow::MouseMove( rMEvt );
}

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

SfxSplitWindow::SfxSplitWindow( Window* pParent, SfxChildAlignment eAl,
		SfxWorkWindow *pW, sal_Bool bWithButtons, WinBits nBits )

/*  [Beschreibung]

	Ein SfxSplitWindow verbirgt die rekursive Struktur des SV-Splitwindows
	nach au\sen, indem es einen tabellenartigen Aufbau mit Zeilen und Spalten
	( also maximale Rekursionstiefe 2 ) simuliert.
	Au\erdem sichert es die Persistenz der Anordnung der SfxDockingWindows.
*/

:	SplitWindow ( pParent, nBits | WB_HIDE ),
	eAlign(eAl),
	pWorkWin(pW),
	pDockArr( new SfxDockArr_Impl ),
	bLocked(sal_False),
	bPinned(sal_True),
	pEmptyWin(NULL),
	pActive(NULL)
{
	if ( bWithButtons )
	{
		ShowAutoHideButton( sal_False );    // no autohide button (pin) anymore
		ShowFadeOutButton( sal_True );
	}

	// SV-Alignment setzen
	WindowAlign eTbxAlign;
	switch ( eAlign )
	{
		case SFX_ALIGN_LEFT:
			eTbxAlign = WINDOWALIGN_LEFT;
			break;
		case SFX_ALIGN_RIGHT:
			eTbxAlign = WINDOWALIGN_RIGHT;
			break;
		case SFX_ALIGN_TOP:
			eTbxAlign = WINDOWALIGN_TOP;
			break;
		case SFX_ALIGN_BOTTOM:
			eTbxAlign = WINDOWALIGN_BOTTOM;
			bPinned = sal_True;
			break;
		default:
			eTbxAlign = WINDOWALIGN_TOP;  // some sort of default...
			break;  // -Wall lots not handled..
	}

	SetAlign (eTbxAlign);
	pEmptyWin = new SfxEmptySplitWin_Impl( this );
	if ( bPinned )
	{
		pEmptyWin->bFadeIn = sal_True;
		pEmptyWin->nState = 2;
	}

	if ( bWithButtons )
	{
		// Konfiguration einlesen
        String aWindowId = String::CreateFromAscii("SplitWindow");
        aWindowId += String::CreateFromInt32( (sal_Int32) eTbxAlign );
        SvtViewOptions aWinOpt( E_WINDOW, aWindowId );
        String aWinData;
		Any aUserItem = aWinOpt.GetUserItem( USERITEM_NAME );
		OUString aTemp;
		if ( aUserItem >>= aTemp )
			aWinData = String( aTemp );
        if ( aWinData.Len() && aWinData.GetChar( (sal_uInt16) 0 ) == 'V' )
        {
            pEmptyWin->nState = (sal_uInt16) aWinData.GetToken( 1, ',' ).ToInt32();
            if ( pEmptyWin->nState & 2 )
                pEmptyWin->bFadeIn = sal_True;
            //bPinned = !( pEmptyWin->nState & 1 );
            bPinned = sal_True; // always assume pinned - floating mode not used anymore

            sal_uInt16 i=2;
            sal_uInt16 nCount = (sal_uInt16) aWinData.GetToken(i++, ',').ToInt32();
            for ( sal_uInt16 n=0; n<nCount; n++ )
            {
                SfxDock_Impl *pDock = new SfxDock_Impl;
                pDock->pWin = 0;
                pDock->bNewLine = sal_False;
                pDock->bHide = sal_True;
                pDock->nType = (sal_uInt16) aWinData.GetToken(i++, ',').ToInt32();
                if ( !pDock->nType )
                {
                    // K"onnte NewLine bedeuten
                    pDock->nType = (sal_uInt16) aWinData.GetToken(i++, ',').ToInt32();
                    if ( !pDock->nType )
                    {
                        // Lesefehler
                        delete pDock;
                        break;
                    }
                    else
                        pDock->bNewLine = sal_True;
                }

                pDockArr->Insert(pDock,n);
            }
        }
	}
	else
	{
		bPinned = sal_True;
		pEmptyWin->bFadeIn = sal_True;
		pEmptyWin->nState = 2;
	}

	SetAutoHideState( !bPinned );
	pEmptyWin->SetAutoHideState( !bPinned );
}

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

SfxSplitWindow::~SfxSplitWindow()
{
	if ( !pWorkWin->GetParent_Impl() )
		SaveConfig_Impl();

	if ( pEmptyWin )
	{
		// pOwner auf NULL setzen, sonst versucht pEmptyWin, nochmal zu
		// l"oschen; es wird n"amlich von au\sen immer das Fenster deleted,
		// das gerade angedockt ist
		pEmptyWin->pOwner = NULL;
		delete pEmptyWin;
	}

	delete pDockArr;
}

void SfxSplitWindow::SaveConfig_Impl()
{
	// Konfiguration abspeichern
	String aWinData('V');
    aWinData += String::CreateFromInt32( VERSION );
	aWinData += ',';
    aWinData += String::CreateFromInt32( pEmptyWin->nState );
	aWinData += ',';

	sal_uInt16 nCount = 0;
	sal_uInt16 n;
	for ( n=0; n<pDockArr->Count(); n++ )
	{
		SfxDock_Impl *pDock = (*pDockArr)[n];
		if ( pDock->bHide || pDock->pWin )
			nCount++;
	}

    aWinData += String::CreateFromInt32( nCount );

	for ( n=0; n<pDockArr->Count(); n++ )
	{
		SfxDock_Impl *pDock = (*pDockArr)[n];
		if ( !pDock->bHide && !pDock->pWin )
			continue;
		if ( pDock->bNewLine )
			aWinData += DEFINE_CONST_UNICODE(",0");
		aWinData += ',';
        aWinData += String::CreateFromInt32( pDock->nType);
	}

    String aWindowId = String::CreateFromAscii("SplitWindow");
    aWindowId += String::CreateFromInt32( (sal_Int32) GetAlign() );
    SvtViewOptions aWinOpt( E_WINDOW, aWindowId );
	aWinOpt.SetUserItem( USERITEM_NAME, makeAny( OUString( aWinData ) ) );
}

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

void SfxSplitWindow::StartSplit()
{
	long nSize = 0;
	Size aSize = GetSizePixel();

	if ( pEmptyWin )
	{
		pEmptyWin->bFadeIn = sal_True;
		pEmptyWin->bSplit = sal_True;
	}

	Rectangle aRect = pWorkWin->GetFreeArea( !bPinned );
	switch ( GetAlign() )
	{
		case WINDOWALIGN_LEFT:
		case WINDOWALIGN_RIGHT:
			nSize = aSize.Width() + aRect.GetWidth();
			break;
		case WINDOWALIGN_TOP:
		case WINDOWALIGN_BOTTOM:
			nSize = aSize.Height() + aRect.GetHeight();
			break;
	}

	SetMaxSizePixel( nSize );
}

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

void SfxSplitWindow::SplitResize()
{
	if ( bPinned )
	{
		pWorkWin->ArrangeChilds_Impl();
		pWorkWin->ShowChilds_Impl();
	}
	else
		pWorkWin->ArrangeAutoHideWindows( this );
}

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

void SfxSplitWindow::Split()
{
    if ( pEmptyWin )
        pEmptyWin->bSplit = sal_False;

    SplitWindow::Split();

    std::vector< std::pair< sal_uInt16, long > > aNewOrgSizes;

    sal_uInt16 nCount = pDockArr->Count();
    for ( sal_uInt16 n=0; n<nCount; n++ )
    {
        SfxDock_Impl *pD = (*pDockArr)[n];
        if ( pD->pWin )
        {
            const sal_uInt16 nId = pD->nType;
            const long nSize    = GetItemSize( nId, SWIB_FIXED );
            const long nSetSize = GetItemSize( GetSet( nId ) );
            Size aSize;

            if ( IsHorizontal() )
            {
                aSize.Width()  = nSize;
                aSize.Height() = nSetSize;
            }
            else
            {
                aSize.Width()  = nSetSize;
                aSize.Height() = nSize;
            }

            pD->pWin->SetItemSize_Impl( aSize );

            aNewOrgSizes.push_back( std::pair< sal_uInt16, long >( nId, nSize ) );
        }
    }

    // workaround insuffiency of <SplitWindow> regarding dock layouting:
    // apply FIXED item size as 'original' item size to improve layouting of undock-dock-cycle of a window
    {
        DeactivateUpdateMode aDeactivateUpdateMode( *this );
        for ( sal_uInt16 i = 0; i < aNewOrgSizes.size(); ++i )
        {
            SetItemSize( aNewOrgSizes[i].first, aNewOrgSizes[i].second );
        }
    }

    SaveConfig_Impl();
}

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

void SfxSplitWindow::InsertWindow( SfxDockingWindow* pDockWin, const Size& rSize)

/*  [Beschreibung]

	Zum Einf"ugen von SfxDockingWindows kann auch keine Position "ubergeben
	werden. Das SfxSplitWindow sucht dann die zuletzt gemerkte zu dem
	"ubergebenen SfxDockingWindow heraus oder h"angt es als letztes neu an.

*/
{
	short nLine = -1;    	// damit erstes Fenster nLine auf 0 hochsetzen kann
	sal_uInt16 nL;
	sal_uInt16 nPos = 0;
	sal_Bool bNewLine = sal_True;
	sal_Bool bSaveConfig = sal_False;
	SfxDock_Impl *pFoundDock=0;
	sal_uInt16 nCount = pDockArr->Count();
	for ( sal_uInt16 n=0; n<nCount; n++ )
	{
		SfxDock_Impl *pDock = (*pDockArr)[n];
		if ( pDock->bNewLine )
		{
			// Das Fenster er"offnet eine neue Zeile
			if ( pFoundDock )
				// Aber hinter dem gerade eingef"ugten Fenster
				break;

			// Neue Zeile
			nPos = 0;
			bNewLine = sal_True;
		}

		if ( pDock->pWin )
		{
			// Es gibt an dieser Stelle gerade ein Fenster
			if ( bNewLine && !pFoundDock )
			{
				// Bisher ist nicht bekannt, in welcher realen Zeile es liegt
				GetWindowPos( pDock->pWin, nL, nPos );
				nLine = (short) nL;
			}

			if ( !pFoundDock )
			{
				// Fenster liegt vor dem eingef"ugten
				nPos++;
			}

			// Zeile ist schon er"offnet
			bNewLine = sal_False;
			if ( pFoundDock )
				break;
		}

		if ( pDock->nType == pDockWin->GetType() )
		{
			DBG_ASSERT( !pFoundDock && !pDock->pWin, "Fenster ist schon vorhanden!");
			pFoundDock = pDock;
			if ( !bNewLine )
				break;
			else
			{
				// Es wurde zuletzt eine neue Reihe gestartet, aber noch kein
				// darin liegendes Fenster gefunden; daher weitersuchen, ob noch
				// ein Fenster in dieser Zeile folgt, um bNewLine korrekt zu setzen.
				// Dabei darf aber nLine oder nPos nicht mehr ver"andert werden!
				nLine++;
			}
		}
	}

	if ( !pFoundDock )
	{
		// Nicht gefunden, am Ende einf"ugen
		pFoundDock = new SfxDock_Impl;
		pFoundDock->bHide = sal_True;
		pDockArr->Insert( pFoundDock, nCount );
		pFoundDock->nType = pDockWin->GetType();
		nLine++;
		nPos = 0;
		bNewLine = sal_True;
		pFoundDock->bNewLine = bNewLine;
		bSaveConfig = sal_True;
	}

	pFoundDock->pWin = pDockWin;
	pFoundDock->bHide = sal_False;
	InsertWindow_Impl( pFoundDock, rSize, nLine, nPos, bNewLine );
	if ( bSaveConfig )
		SaveConfig_Impl();
}

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

void SfxSplitWindow::ReleaseWindow_Impl(SfxDockingWindow *pDockWin, sal_Bool bSave)

/*  [Beschreibung]

	Das DockingWindow wird nicht mehr in den internen Daten gespeichert.
*/

{
	SfxDock_Impl *pDock=0;
	sal_uInt16 nCount = pDockArr->Count();
	sal_Bool bFound = sal_False;
	for ( sal_uInt16 n=0; n<nCount; n++ )
	{
		pDock = (*pDockArr)[n];
		if ( pDock->nType == pDockWin->GetType() )
		{
			if ( pDock->bNewLine && n<nCount-1 )
				(*pDockArr)[n+1]->bNewLine = sal_True;

			// Fenster hat schon eine Position, die vergessen wir
			bFound = sal_True;
			pDockArr->Remove(n);
			break;
		}
	}

	if ( bFound )
		delete pDock;

	if ( bSave )
		SaveConfig_Impl();
}

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

void SfxSplitWindow::MoveWindow( SfxDockingWindow* pDockWin, const Size& rSize,
						sal_uInt16 nLine, sal_uInt16 nPos, sal_Bool bNewLine)

/*  [Beschreibung]

	Das DockingWindow wird innerhalb des Splitwindows verschoben.

*/

{
	sal_uInt16 nL, nP;
	GetWindowPos( pDockWin, nL, nP );

	if ( nLine > nL && GetItemCount( GetItemId( nL, 0 ) ) == 1 )
	{
		// Wenn das letzte Fenster aus seiner Zeile entfernt wird, rutscht
		// alles eine Zeile nach vorne!
		nLine--;
	}
/*
	else if ( nLine == nL && nPos > nP )
	{
		nPos--;
	}
*/
	RemoveWindow( pDockWin );
	InsertWindow( pDockWin, rSize, nLine, nPos, bNewLine );
}

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

void SfxSplitWindow::InsertWindow( SfxDockingWindow* pDockWin, const Size& rSize,
						sal_uInt16 nLine, sal_uInt16 nPos, sal_Bool bNewLine)

/*  [Beschreibung]

	Das DockingWindow wird in dieses Splitwindow geschoben und soll die
	"ubergebene Position und Gr"o\se haben.

*/
{
	ReleaseWindow_Impl( pDockWin, sal_False );
	SfxDock_Impl *pDock = new SfxDock_Impl;
	pDock->bHide = sal_False;
	pDock->nType = pDockWin->GetType();
	pDock->bNewLine = bNewLine;
	pDock->pWin = pDockWin;

	DBG_ASSERT( nPos==0 || !bNewLine, "Falsche Paramenter!");
	if ( bNewLine )
		nPos = 0;

	// Das Fenster mu\s vor dem ersten Fenster eingef"ugt werden, das die
	// gleiche oder eine gr"o\sere Position hat als pDockWin.
	sal_uInt16 nCount = pDockArr->Count();

	// Wenn gar kein Fenster gefunden wird, wird als erstes eingef"ugt
	sal_uInt16 nInsertPos = 0;
	for ( sal_uInt16 n=0; n<nCount; n++ )
	{
		SfxDock_Impl *pD = (*pDockArr)[n];

		if (pD->pWin)
		{
			// Ein angedocktes Fenster wurde gefunden
			// Wenn kein geeignetes Fenster hinter der gew"unschten Einf"ugeposition
			// gefunden wird, wird am Ende eingef"ugt
			nInsertPos = nCount;
			sal_uInt16 nL=0, nP=0;
			GetWindowPos( pD->pWin, nL, nP );

			if ( (nL == nLine && nP == nPos) || nL > nLine )
			{
				DBG_ASSERT( nL == nLine || bNewLine || nPos > 0, "Falsche Parameter!" );
				if ( nL == nLine && nPos == 0 && !bNewLine )
				{
					DBG_ASSERT(pD->bNewLine, "Keine neue Zeile?");

					// Das Fenster wird auf nPos==0 eingeschoben
					pD->bNewLine = sal_False;
					pDock->bNewLine = sal_True;
				}

				nInsertPos = n;
				break;
			}
		}
	}

	pDockArr->Insert(pDock, nInsertPos);
	InsertWindow_Impl( pDock, rSize, nLine, nPos, bNewLine );
	SaveConfig_Impl();
}

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

void SfxSplitWindow::InsertWindow_Impl( SfxDock_Impl* pDock,
						const Size& rSize,
						sal_uInt16 nLine, sal_uInt16 nPos, sal_Bool bNewLine)

/*  [Beschreibung]

	F"ugt ein DockingWindow ein und veranla\st die Neuberechnung der Gr"o\se
	des Splitwindows.
*/

{
	SfxDockingWindow* pDockWin = pDock->pWin;

	sal_uInt16 nItemBits = pDockWin->GetWinBits_Impl();

	long nWinSize, nSetSize;
	if ( IsHorizontal() )
	{
		nWinSize = rSize.Width();
		nSetSize = rSize.Height();
	}
	else
	{
		nSetSize = rSize.Width();
		nWinSize = rSize.Height();
	}

	pDock->nSize = nWinSize;

    DeactivateUpdateMode* pDeactivateUpdateMode = new DeactivateUpdateMode( *this );

	if ( bNewLine || nLine == GetItemCount( 0 ) )
	{
		// Es soll nicht in eine vorhandene Zeile eingef"ugt werden, sondern
		// eine neue erzeugt werden

		sal_uInt16 nId = 1;
		for ( sal_uInt16 n=0; n<GetItemCount(0); n++ )
		{
			if ( GetItemId(n) >= nId )
				nId = GetItemId(n)+1;
		}

		// Eine neue nLine-te Zeile erzeugen
		sal_uInt16 nBits = nItemBits;
		if ( GetAlign() == WINDOWALIGN_TOP || GetAlign() == WINDOWALIGN_BOTTOM )
			nBits |= SWIB_COLSET;
		InsertItem( nId, nSetSize, nLine, 0, nBits );
	}

	// In Zeile mit Position nLine das Fenster einf"ugen
	// ItemWindowSize auf "Prozentual" setzen, da SV dann das Umgr"o\sern
	// so macht, wie man erwartet; "Pixel" macht eigentlich nur Sinn, wenn
	// auch Items mit prozentualen oder relativen Gr"o\sen dabei sind.
	nItemBits |= SWIB_PERCENTSIZE;
	bLocked = sal_True;
	sal_uInt16 nSet = GetItemId( nLine );
	InsertItem( pDockWin->GetType(), pDockWin, nWinSize, nPos, nSet, nItemBits );

	// Splitwindows werden im SFX einmal angelegt und beim Einf"ugen des ersten
	// DockingWindows sichtbar gemacht.
	if ( GetItemCount( 0 ) == 1 && GetItemCount( 1 ) == 1 )
	{
		// Das Neuarrangieren am WorkWindow und ein Show() auf das SplitWindow
		// wird vom SfxDockingwindow veranla\st (->SfxWorkWindow::ConfigChild_Impl)
		if ( !bPinned && !IsFloatingMode() )
		{
			bPinned = sal_True;
			sal_Bool bFadeIn = ( pEmptyWin->nState & 2 ) != 0;
			pEmptyWin->bFadeIn = sal_False;
			SetPinned_Impl( sal_False );
			pEmptyWin->Actualize();
            DBG_TRACE( "SfxSplitWindow::InsertWindow_Impl - registering empty Splitwindow" );
			pWorkWin->RegisterChild_Impl( *GetSplitWindow(), eAlign, sal_True )->nVisible = CHILD_VISIBLE;
			pWorkWin->ArrangeChilds_Impl();
			if ( bFadeIn )
				FadeIn();
		}
		else
		{
			sal_Bool bFadeIn = ( pEmptyWin->nState & 2 ) != 0;
			pEmptyWin->bFadeIn = sal_False;
			pEmptyWin->Actualize();
#ifdef DBG_UTIL
            if ( !bPinned || !pEmptyWin->bFadeIn )
            {
                DBG_TRACE( "SfxSplitWindow::InsertWindow_Impl - registering empty Splitwindow" );
            }
            else
            {
                DBG_TRACE( "SfxSplitWindow::InsertWindow_Impl - registering real Splitwindow" );
            }
#endif
			pWorkWin->RegisterChild_Impl( *GetSplitWindow(), eAlign, sal_True )->nVisible = CHILD_VISIBLE;
			pWorkWin->ArrangeChilds_Impl();
			if ( bFadeIn )
				FadeIn();
		}

		pWorkWin->ShowChilds_Impl();
	}

    delete pDeactivateUpdateMode;
    bLocked = sal_False;

    // workaround insuffiency of <SplitWindow> regarding dock layouting:
    // apply FIXED item size as 'original' item size to improve layouting of undock-dock-cycle of a window
    {
        std::vector< std::pair< sal_uInt16, long > > aNewOrgSizes;
        // get FIXED item sizes
        sal_uInt16 nCount = pDockArr->Count();
        for ( sal_uInt16 n=0; n<nCount; n++ )
        {
            SfxDock_Impl *pD = (*pDockArr)[n];
            if ( pD->pWin )
            {
                const sal_uInt16 nId = pD->nType;
                const long nSize    = GetItemSize( nId, SWIB_FIXED );
                aNewOrgSizes.push_back( std::pair< sal_uInt16, long >( nId, nSize ) );
            }
        }
        // apply new item sizes
        DeactivateUpdateMode aDeactivateUpdateMode( *this );
        for ( sal_uInt16 i = 0; i < aNewOrgSizes.size(); ++i )
        {
            SetItemSize( aNewOrgSizes[i].first, aNewOrgSizes[i].second );
        }
    }
}

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

void SfxSplitWindow::RemoveWindow( SfxDockingWindow* pDockWin, sal_Bool bHide )

/*  [Beschreibung]

	Entfernt ein DockingWindow. Wenn es das letzte war, wird das SplitWindow
	gehidet.
*/
{
	sal_uInt16 nSet = GetSet( pDockWin->GetType() );

	// Splitwindows werden im SFX einmal angelegt und nach dem Entfernen
	// des letzten DockingWindows unsichtbar gemacht.
	if ( GetItemCount( nSet ) == 1 && GetItemCount( 0 ) == 1 )
	{
		// Das Neuarrangieren am WorkWindow wird vom SfxDockingwindow
		// veranla\st!
		Hide();
		pEmptyWin->aTimer.Stop();
        sal_uInt16 nRealState = pEmptyWin->nState;
		FadeOut_Impl();
		pEmptyWin->Hide();
#ifdef DBG_UTIL
        if ( !bPinned || !pEmptyWin->bFadeIn )
        {
            DBG_TRACE( "SfxSplitWindow::RemoveWindow - releasing empty Splitwindow" );
        }
        else
        {
            DBG_TRACE( "SfxSplitWindow::RemoveWindow - releasing real Splitwindow" );
        }
#endif
		pWorkWin->ReleaseChild_Impl( *GetSplitWindow() );
		pEmptyWin->nState = nRealState;
		pWorkWin->ArrangeAutoHideWindows( this );
	}

	SfxDock_Impl *pDock=0;
	sal_uInt16 nCount = pDockArr->Count();
	for ( sal_uInt16 n=0; n<nCount; n++ )
	{
		pDock = (*pDockArr)[n];
		if ( pDock->nType == pDockWin->GetType() )
		{
			pDock->pWin = 0;
			pDock->bHide = bHide;
			break;
		}
	}

	// Fenster removen, und wenn es das letzte der Zeile war, auch die Zeile
	// ( Zeile = ItemSet )
    DeactivateUpdateMode* pDeactivateUpdateMode = new DeactivateUpdateMode( *this );
    bLocked = sal_True;

	RemoveItem( pDockWin->GetType() );

	if ( nSet && !GetItemCount( nSet ) )
		RemoveItem( nSet );

    delete pDeactivateUpdateMode;
    bLocked = sal_False;
};

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

sal_Bool SfxSplitWindow::GetWindowPos( const SfxDockingWindow* pWindow,
										sal_uInt16& rLine, sal_uInt16& rPos ) const
/*  [Beschreibung]

	Liefert die Id des Itemsets und die des Items f"ur das "ubergebene
	DockingWindow in der alten Zeilen/Spalten-Bezeichnung zur"uck.
*/

{
	sal_uInt16 nSet = GetSet ( pWindow->GetType() );
	if ( nSet == SPLITWINDOW_ITEM_NOTFOUND )
		return sal_False;

	rPos  = GetItemPos( pWindow->GetType(), nSet );
	rLine = GetItemPos( nSet );
	return sal_True;
}

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

sal_Bool SfxSplitWindow::GetWindowPos( const Point& rTestPos,
									  sal_uInt16& rLine, sal_uInt16& rPos ) const
/*  [Beschreibung]

	Liefert die Id des Itemsets und die des Items f"ur das DockingWindow
	an der "ubergebenen Position in der alten Zeilen/Spalten-Bezeichnung
	zur"uck.
*/

{
	sal_uInt16 nId = GetItemId( rTestPos );
	if ( nId == 0 )
		return sal_False;

	sal_uInt16 nSet = GetSet ( nId );
	rPos  = GetItemPos( nId, nSet );
	rLine = GetItemPos( nSet );
	return sal_True;
}

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

sal_uInt16 SfxSplitWindow::GetLineCount() const

/*  [Beschreibung]

	Liefert die Zeilenzahl = Zahl der Sub-Itemsets im Root-Set.
*/
{
	return GetItemCount( 0 );
}

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

long SfxSplitWindow::GetLineSize( sal_uInt16 nLine ) const

/*  [Beschreibung]

	Liefert die "Zeilenh"ohe" des nLine-ten Itemsets.
*/
{
	sal_uInt16 nId = GetItemId( nLine );
	return GetItemSize( nId );
}

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

sal_uInt16 SfxSplitWindow::GetWindowCount( sal_uInt16 nLine ) const

/*  [Beschreibung]

	Liefert die
*/
{
	sal_uInt16 nId = GetItemId( nLine );
	return GetItemCount( nId );
}

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

sal_uInt16 SfxSplitWindow::GetWindowCount() const

/*  [Beschreibung]

	Liefert die Gesamtzahl aller Fenstert
*/
{
	return GetItemCount( 0 );
}

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

void SfxSplitWindow::Command( const CommandEvent& rCEvt )
{
	SplitWindow::Command( rCEvt );
}

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

IMPL_LINK( SfxSplitWindow, TimerHdl, Timer*, pTimer)
{
	if ( pTimer )
		pTimer->Stop();

	if ( CursorIsOverRect( sal_False ) || !pTimer )
	{
		// Wenn der Mauszeiger innerhalb des Fensters liegt, SplitWindow anzeigen
		// und Timer zum Schlie\sen aufsetzen
		pEmptyWin->bAutoHide = sal_True;
		if ( !IsVisible() )
			pEmptyWin->FadeIn();

		pEmptyWin->aLastPos = GetPointerPosPixel();
		pEmptyWin->aTimer.Start();
	}
	else if ( pEmptyWin->bAutoHide )
	{
		if ( GetPointerPosPixel() != pEmptyWin->aLastPos )
		{
			// Die Maus wurd innerhalb der Timerlaugzeit bewegt, also erst einmal
			// nichts tun
			pEmptyWin->aLastPos = GetPointerPosPixel();
			pEmptyWin->aTimer.Start();
			return 0L;
		}

		// Speziell f"ur TF_AUTOSHOW_ON_MOUSEMOVE :
		// Wenn das Fenster nicht sichtbar ist, gibt es nichts zu tun
		// (Benutzer ist einfach mit der Maus "uber pEmptyWin gefahren)
		if ( IsVisible() )
		{
			pEmptyWin->bEndAutoHide = sal_False;
			if ( !Application::IsInModalMode() &&
				  !PopupMenu::IsInExecute() &&
				  !pEmptyWin->bSplit && !HasChildPathFocus( sal_True ) )
			{
				// W"ahrend ein modaler Dialog oder ein Popupmenu offen sind
				// oder w"ahrend des Splittens auf keinen Fall zumachen; auch
				// solange eines der Children den Focus hat, bleibt das
				// das Fenster offen
				pEmptyWin->bEndAutoHide = sal_True;
			}

			if ( pEmptyWin->bEndAutoHide )
			{
				// Von mir aus kann Schlu\s sein mit AutoShow
				// Aber vielleicht will noch ein anderes SfxSplitWindow offen bleiben,
				// dann bleiben auch alle anderen offen
				if ( !pWorkWin->IsAutoHideMode( this ) )
				{
					FadeOut_Impl();
					pWorkWin->ArrangeAutoHideWindows( this );
				}
				else
				{
					pEmptyWin->aLastPos = GetPointerPosPixel();
					pEmptyWin->aTimer.Start();
				}
			}
			else
			{
				pEmptyWin->aLastPos = GetPointerPosPixel();
				pEmptyWin->aTimer.Start();
			}
		}
	}

	return 0L;
}

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

sal_Bool SfxSplitWindow::CursorIsOverRect( sal_Bool bForceAdding ) const
{
	sal_Bool bVisible = IsVisible();

	// Auch das kollabierte SplitWindow ber"ucksichtigen
	Point aPos = pEmptyWin->GetParent()->OutputToScreenPixel( pEmptyWin->GetPosPixel() );
	Size aSize = pEmptyWin->GetSizePixel();

	if ( bForceAdding )
	{
		// Um +/- ein paar Pixel erweitern, sonst ist es zu nerv"os
		aPos.X() -= nPixel;
		aPos.Y() -= nPixel;
		aSize.Width() += 2 * nPixel;
		aSize.Height() += 2 * nPixel;
	}

	Rectangle aRect( aPos, aSize );

	if ( bVisible )
	{
		Point aVisPos = GetPosPixel();
		Size aVisSize = GetSizePixel();

		// Um +/- ein paar Pixel erweitern, sonst ist es zu nerv"os
		aVisPos.X() -= nPixel;
		aVisPos.Y() -= nPixel;
		aVisSize.Width() += 2 * nPixel;
		aVisSize.Height() += 2 * nPixel;

		Rectangle aVisRect( aVisPos, aVisSize );
		aRect = aRect.GetUnion( aVisRect );
	}

	if ( aRect.IsInside( OutputToScreenPixel( ((Window*)this)->GetPointerPosPixel() ) ) )
		return sal_True;
	return sal_False;
}

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

SplitWindow* SfxSplitWindow::GetSplitWindow()
{
	if ( !bPinned || !pEmptyWin->bFadeIn )
		return pEmptyWin;
	return this;
}

//-------------------------------------------------------------------------
sal_Bool SfxSplitWindow::IsFadeIn() const
{
	return pEmptyWin->bFadeIn;
}

sal_Bool SfxSplitWindow::IsAutoHide( sal_Bool bSelf ) const
{
	return bSelf ? pEmptyWin->bAutoHide && !pEmptyWin->bEndAutoHide : pEmptyWin->bAutoHide;
}

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

void SfxSplitWindow::SetPinned_Impl( sal_Bool bOn )
{
	if ( bPinned == bOn )
		return;

	bPinned = bOn;
	if ( GetItemCount( 0 ) == 0 )
		return;

	if ( !bOn )
	{
		pEmptyWin->nState |= 1;
		if ( pEmptyWin->bFadeIn )
		{
			// Ersatzfenster anmelden
            DBG_TRACE( "SfxSplitWindow::SetPinned_Impl - releasing real Splitwindow" );
			pWorkWin->ReleaseChild_Impl( *this );
			Hide();
			pEmptyWin->Actualize();
            DBG_TRACE( "SfxSplitWindow::SetPinned_Impl - registering empty Splitwindow" );
			pWorkWin->RegisterChild_Impl( *pEmptyWin, eAlign, sal_True )->nVisible = CHILD_VISIBLE;
		}

		Point aPos( GetPosPixel() );
		aPos = GetParent()->OutputToScreenPixel( aPos );
		SetFloatingPos( aPos );
		SetFloatingMode( sal_True );
		GetFloatingWindow()->SetOutputSizePixel( GetOutputSizePixel() );

		if ( pEmptyWin->bFadeIn )
			Show();
	}
	else
	{
		pEmptyWin->nState &= ~1;
		SetOutputSizePixel( GetFloatingWindow()->GetOutputSizePixel() );
		SetFloatingMode( sal_False );

		if ( pEmptyWin->bFadeIn )
		{
			// Ersatzfenster abmelden
            DBG_TRACE( "SfxSplitWindow::SetPinned_Impl - releasing empty Splitwindow" );
			pWorkWin->ReleaseChild_Impl( *pEmptyWin );
			pEmptyWin->Hide();
            DBG_TRACE( "SfxSplitWindow::SetPinned_Impl - registering real Splitwindow" );
			pWorkWin->RegisterChild_Impl( *this, eAlign, sal_True )->nVisible = CHILD_VISIBLE;
		}
	}

	SetAutoHideState( !bPinned );
	pEmptyWin->SetAutoHideState( !bPinned );
}

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

void SfxSplitWindow::SetFadeIn_Impl( sal_Bool bOn )
{
	if ( bOn == pEmptyWin->bFadeIn )
		return;

	if ( GetItemCount( 0 ) == 0 )
		return;

	pEmptyWin->bFadeIn = bOn;
	if ( bOn )
	{
		pEmptyWin->nState |= 2;
		if ( IsFloatingMode() )
		{
			// FloatingWindow ist nicht sichtbar, also anzeigen
			pWorkWin->ArrangeAutoHideWindows( this );
			Show();
		}
		else
		{
            DBG_TRACE( "SfxSplitWindow::SetFadeIn_Impl - releasing empty Splitwindow" );
			pWorkWin->ReleaseChild_Impl( *pEmptyWin );
			pEmptyWin->Hide();
            DBG_TRACE( "SfxSplitWindow::SetFadeIn_Impl - registering real Splitwindow" );
			pWorkWin->RegisterChild_Impl( *this, eAlign, sal_True )->nVisible = CHILD_VISIBLE;
			pWorkWin->ArrangeChilds_Impl();
			pWorkWin->ShowChilds_Impl();
		}
	}
	else
	{
		pEmptyWin->bAutoHide = sal_False;
		pEmptyWin->nState &= ~2;
		if ( !IsFloatingMode() )
		{
			// Das Fenster "schwebt" nicht, soll aber ausgeblendet werden,
            DBG_TRACE( "SfxSplitWindow::SetFadeIn_Impl - releasing real Splitwindow" );
			pWorkWin->ReleaseChild_Impl( *this );
			Hide();
			pEmptyWin->Actualize();
            DBG_TRACE( "SfxSplitWindow::SetFadeIn_Impl - registering empty Splitwindow" );
			pWorkWin->RegisterChild_Impl( *pEmptyWin, eAlign, sal_True )->nVisible = CHILD_VISIBLE;
			pWorkWin->ArrangeChilds_Impl();
			pWorkWin->ShowChilds_Impl();
			pWorkWin->ArrangeAutoHideWindows( this );
		}
		else
		{
			Hide();
			pWorkWin->ArrangeAutoHideWindows( this );
		}
	}
}

void SfxSplitWindow::AutoHide()
{
	// Wenn dieser Handler am "echten" SplitWindow aufgerufen wird, ist es
	// entweder angedockt und soll "schwebend" angezeigt werden oder umgekehrt
	if ( !bPinned )
	{
		// Es "schwebt", also wieder andocken
		SetPinned_Impl( sal_True );
		pWorkWin->ArrangeChilds_Impl();
	}
	else
	{
		// In den "Schwebezustand" bringen
		SetPinned_Impl( sal_False );
		pWorkWin->ArrangeChilds_Impl();
		pWorkWin->ArrangeAutoHideWindows( this );
	}

	pWorkWin->ShowChilds_Impl();
	SaveConfig_Impl();
}

void SfxSplitWindow::FadeOut_Impl()
{
    if ( pEmptyWin->aTimer.IsActive() )
    {
        pEmptyWin->bAutoHide = sal_False;
        pEmptyWin->aTimer.Stop();
    }

	SetFadeIn_Impl( sal_False );
	Show_Impl();
}

void SfxSplitWindow::FadeOut()
{
	FadeOut_Impl();
	SaveConfig_Impl();
}

void SfxSplitWindow::FadeIn()
{
	SetFadeIn_Impl( sal_True );
	Show_Impl();
}

void SfxSplitWindow::Show_Impl()
{
	sal_uInt16 nCount = pDockArr->Count();
	for ( sal_uInt16 n=0; n<nCount; n++ )
	{
		SfxDock_Impl *pDock = (*pDockArr)[n];
		if ( pDock->pWin )
			pDock->pWin->FadeIn( pEmptyWin->bFadeIn );
	}
}
/*
void SfxSplitWindow::Pin_Impl( sal_Bool bPin )
{
	if ( bPinned != bPin )
		AutoHide();
}
*/
sal_Bool SfxSplitWindow::ActivateNextChild_Impl( sal_Bool bForward )
{
	// Wenn kein pActive, auf erstes bzw. letztes Fenster gehen ( bei !bForward wird erst in der loop dekrementiert )
	sal_uInt16 nCount = pDockArr->Count();
	sal_uInt16 n = bForward ? 0 : nCount;

	// Wenn Focus innerhalb, dann ein Fenster vor oder zur"uck, wenn m"oglich
	if ( pActive )
	{
		// Aktives Fenster ermitteln
		for ( n=0; n<nCount; n++ )
		{
			SfxDock_Impl *pD = (*pDockArr)[n];
			if ( pD->pWin && pD->pWin->HasChildPathFocus() )
				break;
		}

		if ( bForward )
			// ein Fenster weiter ( wenn dann n>nCount, wird die Schleife unten gar nicht durchlaufen )
			n++;
	}

	if ( bForward )
	{
		// N"achstes Fenster suchen
		for ( sal_uInt16 nNext=n; nNext<nCount; nNext++ )
		{
			SfxDock_Impl *pD = (*pDockArr)[nNext];
			if ( pD->pWin )
			{
				pD->pWin->GrabFocus();
				return sal_True;
			}
		}
	}
	else
	{
		// Vorheriges Fenster suchen
		for ( sal_uInt16 nNext=n; nNext--; )
		{
			SfxDock_Impl *pD = (*pDockArr)[nNext];
			if ( pD->pWin )
			{
				pD->pWin->GrabFocus();
				return sal_True;
			}
		}
	}

	return sal_False;
}

void SfxSplitWindow::SetActiveWindow_Impl( SfxDockingWindow* pWin )
{
	pActive = pWin;
	pWorkWin->SetActiveChild_Impl( this );
}