xref: /aoo4110/main/sfx2/source/control/dispatch.cxx (revision b1cdbd2c)

/**************************************************************
 *
 * 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"
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/frame/XDispatchRecorderSupplier.hpp>
#include <com/sun/star/frame/XLayoutManager.hpp>
#include <svl/itempool.hxx>
#include <svl/itemiter.hxx>
#include <svl/whiter.hxx>
#include <svl/intitem.hxx>
#ifndef _SFXEITEM_HXX //autogen
#include <svl/eitem.hxx>
#endif
#include <svl/undo.hxx>
#ifndef _WRKWIN_HXX //autogen
#include <vcl/wrkwin.hxx>
#endif
#include <svtools/ttprops.hxx>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>				// wg. bsearch

#define _SVSTDARR_ULONGS
#include <svl/svstdarr.hxx>
#include <svtools/helpopt.hxx>
#include <com/sun/star/frame/XLayoutManager.hpp>
#include <com/sun/star/beans/XPropertySet.hpp>

#ifndef GCC
#endif

// wg. nAutoPageID
#include "appdata.hxx"
#include "sfx2/sfxhelp.hxx"
#include <sfx2/dispatch.hxx>
#include <sfx2/minstack.hxx>
#include <sfx2/msg.hxx>
#include <sfx2/objface.hxx>
#include <sfx2/bindings.hxx>
#include <sfx2/request.hxx>
#include <sfx2/app.hxx>
#include <sfx2/hintpost.hxx>
#include "slotserv.hxx"
#include <sfx2/ipclient.hxx>
#include "sfxtypes.hxx"
#include <sfx2/viewfrm.hxx>
#include <sfx2/viewsh.hxx>
#include <sfx2/childwin.hxx>
#include <sfx2/docfac.hxx>
#include <sfx2/msgpool.hxx>
#include <sfx2/module.hxx>
#include <sfx2/viewfrm.hxx>
#include <sfx2/sfxuno.hxx>
#include <sfx2/docfile.hxx>
#include <sfx2/mnumgr.hxx>
#include "workwin.hxx"

namespace css = ::com::sun::star;

//==================================================================
DBG_NAME(SfxDispatcherFlush)
DBG_NAME(SfxDispatcherFillState)

//==================================================================
typedef SfxRequest* SfxRequestPtr;
SV_IMPL_PTRARR( SfxItemPtrArray, SfxPoolItemPtr );
SV_DECL_PTRARR_DEL( SfxRequestPtrArray, SfxRequestPtr, 4, 4 )
SV_IMPL_PTRARR( SfxRequestPtrArray, SfxRequestPtr );

DECL_PTRSTACK(SfxShellStack_Impl, SfxShell*, 8, 4 );
//==================================================================

struct SfxToDo_Impl
{
	SfxShell*			pCluster;
	bool               	bPush;
	bool    			bDelete;
	bool    			bUntil;

	SfxToDo_Impl()
		: pCluster(0)
		, bPush(false)
		, bDelete(false)
		, bUntil(false)
				{}
	SfxToDo_Impl( bool bOpPush, bool bOpDelete, bool bOpUntil, SfxShell& rCluster )
		: pCluster(&rCluster)
		, bPush(bOpPush)
		, bDelete(bOpDelete)
		, bUntil(bOpUntil)
				{}
	~SfxToDo_Impl(){}

	bool operator==( const SfxToDo_Impl& rWith ) const
	{ return pCluster==rWith.pCluster && bPush==rWith.bPush; }
};

DECL_OBJSTACK(SfxToDoStack_Impl, SfxToDo_Impl, 8, 4);
IMPL_OBJSTACK(SfxToDoStack_Impl, SfxToDo_Impl);

struct SfxObjectBars_Impl
{
	sal_uInt32          nResId;	// Resource - und ConfigId der Toolbox
	sal_uInt16          nMode;	// spezielle Sichtbarkeitsflags
	String   			aName;
	SfxInterface*		pIFace;

	SfxObjectBars_Impl() :
		nResId( 0 )
	{}
};

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

struct SfxDispatcher_Impl
{
    SfxRequestPtrArray      aReqArr;
	const SfxSlotServer* pCachedServ1;		 // zuletzt gerufene Message
	const SfxSlotServer* pCachedServ2;		 // vorletzt gerufene Message
	SfxShellStack_Impl		aStack; 			// aktive Funktionalitaet
	Timer					aTimer; 			// fuers flushen
	SfxToDoStack_Impl		aToDoStack; 		// nicht abgearb. Push/Pop
	SfxViewFrame*           pFrame;         	// 0 oder zugeh"or. Frame
	SfxDispatcher*			pParent;			// z.B. AppDispatcher, ggf. 0
	SfxHintPosterRef		xPoster;			// asynchrones Execute
	sal_Bool                    bFlushing;      	// sal_True waehrend Flush //?
	sal_Bool					bUpdated;			// Update_Impl gelaufen
	sal_Bool                    bLocked;        	// kein Execute
	sal_Bool					bInvalidateOnUnlock;// da fragte jemand
	sal_Bool					bActive;			// nicht verwechseln mit gesetzt!
	sal_Bool*   				pInCallAliveFlag;   // dem Stack den Dtor anzeigen
	SfxObjectBars_Impl		aObjBars[SFX_OBJECTBAR_MAX];
	SfxObjectBars_Impl		aFixedObjBars[SFX_OBJECTBAR_MAX];
	SvULongs				aChildWins;
	sal_uInt32					nEventId;			// EventId UserEvent
	sal_Bool					bUILocked;			// Update abgeklemmt (!zappeln)
	sal_Bool					bNoUI;				// UI nur vom Parent Dispatcher
	sal_Bool					bReadOnly;			// Dokument ist ReadOnly
	sal_Bool					bQuiet;             // nur parent dispatcher verwenden
	sal_Bool					bModal;             // nur Slots vom Parent-Dispatcher

	sal_Bool					bFilterEnabling;	// sal_True=filter enabled slots, 2==ReadOnlyDoc uebersteuert
	sal_uInt16					nFilterCount;		// Anzahl der SIDs in pFilterSIDs
	const sal_uInt16*			pFilterSIDs;		// sortiertes Array von SIDs
	sal_uInt16					nStandardMode;		// ExecuteMode f. PlugInDispatcher
	SvUShorts*				pDisableList;
	sal_uInt32					nDisableFlags;
};

#define NO_OBJECTBAR	0
#define OWN_OBJECTBAR	1
#define OTHER_OBJECTBAR 2

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

#define SFX_FLUSH_TIMEOUT    50

//====================================================================
sal_Bool SfxDispatcher::IsLocked( sal_uInt16 ) const

/*  [Beschreibung]

	Mit dieser Methode kann festgestellt werden, ob der SfxDispatcher
	gesperrt oder freigegeben ist. Ein gesperrter SfxDispatcher
	f"uhrt keine <SfxRequest>s mehr aus und liefert keine
	Status-Informationen mehr. Er verh"alt sich so als w"aren alle
	Slots disabled.

	Der Dispatcher gilt auch als gesperrt, wenn alle Dispatcher
	gelockt sind (<SfxApplication::LockDispatcher()>) oder der zugeh"orige
	Top-Frame im modal-mode ist und der angegebene Slot Frame-spezifisch
	(also nicht von der Application) bedient wird.
*/

{
    return pImp->bLocked;
}

//--------------------------------------------------------------------
sal_Bool SfxDispatcher::IsAppDispatcher() const

/*	[Beschreibung]

	Mit dieser Methode l"a\st sich festellen, ob der SfxDispacher der
	Applikations-Dispatcher ist.


	[R"uckgabewert]

	sal_Bool				sal_True
						Es ist der Applikations-Dispatcher.

						sal_False
						Es ist ein Dispatcher eines SfxViewFrame.
*/

{
    return !pImp->pFrame;
}

//--------------------------------------------------------------------
int SfxDispatcher::Call_Impl( SfxShell& rShell, const SfxSlot &rSlot, SfxRequest &rReq, sal_Bool bRecord )

/*	[Beschreibung]

	Hilfsfunktion zum pr"ufen, ob ein Slot executed werden darf und
	der Execution selbst.
*/

{
	SFX_STACK(SfxDispatcher::Call_Impl);

	// darf der Slot gerufen werden (i.S.v. enabled)
	if ( rSlot.IsMode(SFX_SLOT_FASTCALL) || rShell.CanExecuteSlot_Impl(rSlot) )
	{
        if ( GetFrame() )
        {
            // ggf. Recording anwerfen
            com::sun::star::uno::Reference< com::sun::star::frame::XFrame > xFrame(
                    GetFrame()->GetFrame().GetFrameInterface(),
                    com::sun::star::uno::UNO_QUERY);

            com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xSet(
                    xFrame,
                    com::sun::star::uno::UNO_QUERY);

			if ( xSet.is() )
			{
				com::sun::star::uno::Any aProp = xSet->getPropertyValue(::rtl::OUString::createFromAscii("DispatchRecorderSupplier"));
	            com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorderSupplier > xSupplier;
	            com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder;
	            aProp >>= xSupplier;
	            if(xSupplier.is())
	                xRecorder = xSupplier->getDispatchRecorder();

	            if ( bRecord && xRecorder.is() && !rSlot.IsMode(SFX_SLOT_NORECORD) )
	                rReq.Record_Impl( rShell, rSlot, xRecorder, GetFrame() );
			}
        }

		// Alles holen, was gebraucht wird, da der Slot den Execute evtl. nicht
		// "uberlebt, falls es ein 'Pseudoslot' f"ur Macros oder Verben ist
		sal_Bool bAutoUpdate = rSlot.IsMode(SFX_SLOT_AUTOUPDATE);

		// API-Call-Klammerung und Document-Lock w"ahrend des Calls
		{
			// 'this' mu\s im Dtor bescheid sagen
			sal_Bool bThisDispatcherAlive = sal_True;
			sal_Bool *pOldInCallAliveFlag = pImp->pInCallAliveFlag;
			pImp->pInCallAliveFlag = &bThisDispatcherAlive;

            SfxViewFrame* pView = GetFrame();
            if ( !pView )
                pView = SfxViewFrame::Current();
            if ( pView )
            {
                rtl::OString aCmd(".uno:");
                aCmd += rSlot.GetUnoName();
                SfxHelp::OpenHelpAgent( &pView->GetFrame(), aCmd );
            }

            SfxExecFunc pFunc = rSlot.GetExecFnc();
            rShell.CallExec( pFunc, rReq );

			// falls 'this' noch lebt
			if ( bThisDispatcherAlive )
				pImp->pInCallAliveFlag = pOldInCallAliveFlag;
			else
            {
                if ( pOldInCallAliveFlag )
                {
                    // auch verschachtelte Stack-Frames sch"utzen
                    *pOldInCallAliveFlag = sal_False;
                }

                // do nothing after this object is dead
                return rReq.IsDone();
            }
		}

		if ( rReq.IsDone() )
		{
            SfxBindings *pBindings = GetBindings();

			// bei AutoUpdate sofort updaten; "Pseudoslots" d"urfen nicht
			// Autoupdate sein!
            if ( bAutoUpdate && pBindings )
			{
				const SfxSlot* pSlave = rSlot.GetLinkedSlot();
				if (pSlave)
				{
					// bei Enum-Slots irgendeinen gebundenen Slave-Slot nehmen
					while (!pBindings->IsBound(pSlave->GetSlotId()) && pSlave != &rSlot )
						pSlave = pSlave->GetLinkedSlot();
					pBindings->Invalidate(pSlave->GetSlotId());
					pBindings->Update(pSlave->GetSlotId());
				}
				else
				{
					pBindings->Invalidate(rSlot.GetSlotId());
					pBindings->Update(rSlot.GetSlotId());
				}
			}

			return sal_True;
		}
	}

	return sal_False;
}

//====================================================================
void SfxDispatcher::Construct_Impl( SfxDispatcher* pParent )
{
	pImp = new SfxDispatcher_Impl;
	bFlushed = sal_True;
	SfxApplication *pSfxApp = SFX_APP();

	pImp->pCachedServ1 = 0;
	pImp->pCachedServ2 = 0;
	pImp->bFlushing = sal_False;
	pImp->bUpdated = sal_False;
	pImp->bLocked = sal_False;
	pImp->bActive = sal_False;
	pImp->pParent = NULL;
	pImp->bUILocked = sal_False;
	pImp->bNoUI = sal_False;
	pImp->bReadOnly = sal_False;
	pImp->bQuiet = sal_False;
	pImp->bModal = sal_False;
	pImp->pInCallAliveFlag = 0;
	pImp->bFilterEnabling = sal_False;
	pImp->nFilterCount = 0;
	pImp->pFilterSIDs = 0;
	pImp->nStandardMode = 0;
	pImp->pDisableList = pSfxApp->GetDisabledSlotList_Impl();
	pImp->nDisableFlags = 0;

	pImp->pParent = pParent;

	pImp->bInvalidateOnUnlock = sal_False;

	for (sal_uInt16 n=0; n<SFX_OBJECTBAR_MAX; n++)
		pImp->aObjBars[n].nResId = 0;

	GenLink aGenLink( LINK(this, SfxDispatcher, PostMsgHandler) );

	pImp->xPoster = new SfxHintPoster(aGenLink);

	pImp->aTimer.SetTimeout(SFX_FLUSH_TIMEOUT);
	pImp->aTimer.SetTimeoutHdl( LINK(this, SfxDispatcher, EventHdl_Impl ) );
}

SfxDispatcher::SfxDispatcher( SfxDispatcher* pParent )
{
	Construct_Impl( pParent );
	pImp->pFrame = 0;
}

SfxDispatcher::SfxDispatcher( SfxViewFrame *pViewFrame )

/*	[Beschreibung]

	Der Konstruktor der Klasse SfxDispatcher legt einen leeren Stack
	von <SfxShell>-Pointern an. Er ist initial nicht gelockt und gilt als
	geflusht.
*/

{
	if ( pViewFrame )
	{
		SfxViewFrame *pFrame = pViewFrame->GetParentViewFrame();
		if ( pFrame )
			Construct_Impl(  pFrame->GetDispatcher() );
        else
            Construct_Impl( 0 );
	}
	else
		Construct_Impl( 0 );
	pImp->pFrame = pViewFrame;
}

//====================================================================
SfxDispatcher::~SfxDispatcher()

/*	[Beschreibung]

	Der Destruktor der Klasse SfxDispatcher darf nicht gerufen werden,
	wenn die SfxDispatcher-Instanz aktiv ist. Es d"urfen sich allerdings
	noch <SfxShell>-Pointer auf dem Stack befinden.
*/

{
#ifdef DBG_UTIL
	ByteString sTemp( "Delete Dispatcher " );
	sTemp += ByteString::CreateFromInt64( (sal_uIntPtr)this );
	DBG_TRACE( sTemp.GetBuffer() );
	DBG_ASSERT( !pImp->bActive, "deleting active Dispatcher" );
#endif

	// Damit in LeaveRegistrations kein Timer per Reschedule in PlugComm
	// zuschlaegt
	pImp->aTimer.Stop();
	pImp->xPoster->SetEventHdl( Link() );

	// die Stack-Varialblem in Call_Impl benachrichtigen
	if ( pImp->pInCallAliveFlag )
		*pImp->pInCallAliveFlag = sal_False;

	// Bindings und App besorgen
	SfxApplication *pSfxApp = SFX_APP();
    SfxBindings* pBindings = GetBindings();

//	if (pImp->nEventId)
//		pSfxApp->RemoveEventHdl(pImp->nEventId);

	// wenn noch nicht flushed, die Bindings wiederbeleben
    if ( pBindings && !pSfxApp->IsDowning() && !bFlushed )
        pBindings->DLEAVEREGISTRATIONS();

	// ggf. bei den Bindings abmelden
    while ( pBindings )
	{
        if ( pBindings->GetDispatcher_Impl() == this)
            pBindings->SetDispatcher(0);
        pBindings = pBindings->GetSubBindings_Impl();
	}

	delete pImp;
}

//====================================================================
void SfxDispatcher::Pop
(
	SfxShell&   rShell,     /*  Die vom Stack zu nehmende SfxShell-Instanz. */

	sal_uInt16      nMode       /*  SFX_SHELL_POP_UNTIL
								Es werden auch alle "uber 'rShell' liegenenden
								SfxShell's vom Stack genommen.

								SFX_SHELL_POP_DELETE
								Alle tats"achlich vom Stack genommenen
								SfxShells werden gel"oscht.

								SFX_SHELL_PUSH (InPlace use only)
								Die Shell wird gepusht. */
)
/*  [Beschreibung]

	Mit dieser Methode wird eine oder mehrere <SfxShell> vom SfxDispatcher
	gepoppt. Die SfxShell wird zun"achst zum poppen vermerkt und
	es wird ein Timer aufgesetzt. Erst bei Ablauf des Timers wird
	tats"achlich gepoppt (<SfxDispatcher::Flush()>) und die <SfxBindings>
	werden invalidiert. W"ahrend der Timer l"auft gleichen sich
	entgegengesetzte Push und Pop Befehle mit derselben SfxShell aus.
*/

{
	DBG_MEMTEST();
	DBG_ASSERT( rShell.GetInterface(),
				"pushing SfxShell without previous RegisterInterface()" );

	bool bDelete = (nMode & SFX_SHELL_POP_DELETE) == SFX_SHELL_POP_DELETE;
	bool bUntil = (nMode & SFX_SHELL_POP_UNTIL) == SFX_SHELL_POP_UNTIL;
	bool bPush = (nMode & SFX_SHELL_PUSH) == SFX_SHELL_PUSH;

	SfxApplication *pSfxApp = SFX_APP();

#ifdef DBG_UTIL
	ByteString aMsg( "-SfxDispatcher(" );
	aMsg += ByteString::CreateFromInt64( (sal_uIntPtr) this );
	aMsg += bPush ? ")::Push(" : ")::Pop(";
	if ( rShell.GetInterface() )
		aMsg += rShell.GetInterface()->GetClassName();
	else
		aMsg += ByteString::CreateFromInt64( (sal_uIntPtr) &rShell );
	aMsg += bDelete ? ") with delete" : ")";
    if ( bUntil ) aMsg += " (up to)";
	DbgTrace( aMsg.GetBuffer() );
#endif

	// gleiche Shell wie on-Top des ToDo-Stacks?
	if ( pImp->aToDoStack.Count() && pImp->aToDoStack.Top().pCluster == &rShell )
	{
		// inverse Actions heben sich auf
		if ( pImp->aToDoStack.Top().bPush != bPush )
			pImp->aToDoStack.Pop();
		else
		{
			DBG_ASSERT( bPush, "SfxInterface pushed more than once" );
			DBG_ASSERT( !bPush, "SfxInterface popped more than once" );
		}
	}
	else
	{
		// ::com::sun::star::chaos::Action merken
		pImp->aToDoStack.Push( SfxToDo_Impl(bPush, bDelete, bUntil, rShell) );
		if ( bFlushed )
		{
			DBG_TRACE("Unflushed dispatcher!");
			bFlushed = sal_False;
			pImp->bUpdated = sal_False;

			// Bindings schlafen legen
            SfxBindings* pBindings = GetBindings();
            if ( pBindings )
                pBindings->DENTERREGISTRATIONS();
		}
	}

	if ( !pSfxApp->IsDowning() && pImp->aToDoStack.Count() )
	{
		//! if (SFX_APP()->AnyInput(INPUT_KEYBOARD | INPUT_MOUSE) )
		//! AnyInput haut nicht hin; hier muss noch ein Kriterium gefunden
		//! werden. Solange wieder immer mit Timer.

		if (sal_True)
		{
			// Kein sofortiges Update gewuenscht
			pImp->aTimer.SetTimeout(SFX_FLUSH_TIMEOUT);
			pImp->aTimer.SetTimeoutHdl( LINK(this, SfxDispatcher, EventHdl_Impl ) );
			pImp->aTimer.Start();
		}
		else
		{
			// Schnellstmoegliches Update (sollte Normalfall sein)
			pImp->aTimer.Stop();
			GetpApp()->PostUserEvent(pImp->nEventId, (void*)0);
		}
	}
	else
	{
		// doch nichts zu tun
		pImp->aTimer.Stop();

		// ggf. Bindings wieder aufwecken
		if ( !pImp->aToDoStack.Count() )
		{
            SfxBindings* pBindings = GetBindings();
            if ( pBindings )
                pBindings->DLEAVEREGISTRATIONS();
		}
	}
}

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

IMPL_LINK_INLINE_START( SfxDispatcher, EventHdl_Impl, void *, pvoid )

/*	[Beschreibung]

	Dieser Handler wird nach <SfxDispatcher::Invalidate()> oder Bewegungen
	auf dem Stack (<SfxDispatcher::Push()> und <SfxDispatcher::Pop()) gerufen.

	Er flusht den Stack, falls er dirty ist, f"uhrt also die ausstehenden
	Push und Pop Befehle tats"achlich aus.
*/

{
    (void)pvoid; // unused
    DBG_MEMTEST();

	Flush();
	Update_Impl();
    SfxBindings* pBindings = GetBindings();
    if ( pBindings )
        pBindings->StartUpdate_Impl(sal_False);
	return 0;
}
IMPL_LINK_INLINE_END( SfxDispatcher, EventHdl_Impl, void *, pvoid )

//--------------------------------------------------------------------
sal_Bool SfxDispatcher::CheckVirtualStack( const SfxShell& rShell, sal_Bool bDeep )

/*	[Beschreibung]

	Mit dieser Methode kann gepr"uft werden, ob sich die <SfxShell> rShell
	auf dem Stack befindet, wenn er geflusht w"are. Dabei wird der
	SfxDispatcher jedoch nicht tats"achlich geflusht.

	Diese Methode ist u.a. dazu gedacht, Assertions zu erm"oglichen, ohne
	als Seiteneffekt den SfxDispathcer flushen zu m"ussen.
*/

{
	DBG_MEMTEST();
	SFX_STACK(SfxDispatcher::CheckVirtualStack);

	SfxShellStack_Impl aStack( pImp->aStack );
	for ( short nToDo = pImp->aToDoStack.Count()-1; nToDo >= 0; --nToDo )
	{
		SfxToDo_Impl aToDo( pImp->aToDoStack.Top(nToDo) );
		if ( aToDo.bPush )
			aStack.Push( (SfxShell*) aToDo.pCluster );
		else
		{
			SfxShell* pPopped = 0;
			do
			{
				DBG_ASSERT( aStack.Count(), "popping from empty stack" );
				pPopped = aStack.Pop();
			}
			while ( aToDo.bUntil && pPopped != aToDo.pCluster );
			DBG_ASSERT( pPopped == aToDo.pCluster, "popping unpushed SfxInterface" );
		}
	}

	sal_Bool bReturn;
	if ( bDeep )
		bReturn = aStack.Contains(&rShell);
	else
		bReturn = aStack.Top() == &rShell;
	return bReturn;
}

//--------------------------------------------------------------------
sal_uInt16 SfxDispatcher::GetShellLevel( const SfxShell& rShell )

/*	[Beschreibung]

	Ermittelt die Position einer SfxShell im Stack des Dispatchers.
	Dazu wird dieser ggf. zuvor geflusht.


    [Rueckgabewert]

	sal_uInt16						== USRT_MAX
								Die SfxShell befindet sich nicht auf
								diesem SfxDispatcher.

								< USHRT_MAX
								Position der SfxShell auf dem Dispatcher
								von oben mit 0 beginnend gez"ahlt.
*/

{
	DBG_MEMTEST();
	SFX_STACK(SfxDispatcher::GetShellLevel);
	Flush();

	for ( sal_uInt16 n = 0; n < pImp->aStack.Count(); ++n )
		if ( pImp->aStack.Top( n ) == &rShell )
			return n;
	if ( pImp->pParent )
    {
        sal_uInt16 nRet = pImp->pParent->GetShellLevel(rShell);
        if ( nRet == USHRT_MAX )
            return nRet;
        return  nRet + pImp->aStack.Count();
    }

	return USHRT_MAX;
}

//--------------------------------------------------------------------
SfxShell *SfxDispatcher::GetShell(sal_uInt16 nIdx) const

/*	[Beschreibung]

	Liefert einen Pointer auf die <SfxShell>, welche sich an der Position
	nIdx (von oben, letzt-gepushte liegt bei 0) auf dem Stack befindet.

	Dabei wird der SfxDispatcher nicht geflusht.

	Ist der Stack nicht tief genug, wird ein 0-Pointer zur"uckgegeben.
*/

{
	DBG_MEMTEST();

	sal_uInt16 nShellCount = pImp->aStack.Count();
	if ( nIdx < nShellCount )
		return pImp->aStack.Top(nIdx);
	else if ( pImp->pParent )
		return pImp->pParent->GetShell(	nIdx - nShellCount );
	return 0;
}

//--------------------------------------------------------------------
SfxBindings* SfxDispatcher::GetBindings() const

/*	[Beschreibung]

	Diese Methode liefert einen Pointer auf die <SfxBindings> Instanz
	zur"uck, an die der SfxDispatcher gerade gebunden ist. Ein SfxDispatcher
	ist nur dann an SfxBindings gebunden, wenn er <UI-aktiv> ist. Ist
	er nicht UI-aktiv, wird ein 0-Pointer zur"uckgegeben.

	Der zur"uckgegebene Pointer ist nur im <unmittelbaren Kontext> des
	Methodenaufrufs g"ultig.
*/

{
	if ( pImp->pFrame )
		return &pImp->pFrame->GetBindings();
    else
        return NULL;
}

//--------------------------------------------------------------------
SfxViewFrame* SfxDispatcher::GetFrame() const

/*	[Beschreibung]

	Liefert einen Pointer auf die <SfxViewFrame> Instanz, der dieser
	SfxDispatcher geh"ort. Falls es sich um den Applikations-Dispatcher
	handelt, wird ein 0-Pointer zur"uckgegeben.
*/

{
	DBG_MEMTEST();
	return pImp->pFrame;
}

//--------------------------------------------------------------------
void SfxDispatcher::DoActivate_Impl( sal_Bool bMDI, SfxViewFrame* /* pOld */ )

/*	[Beschreibung]

	Diese Methode steuert das Aktivieren eines Dispatchers.

	Da der Applikations-Dispatcher immer aktiv ist, entweder als
	Unterdispatcher des <SfxViewFrame>-Dispatchers oder selbst, wird
	er nie als ganzes Aktiviert, sondern nur seine einzelnen <SfxShell>s
	bei <SfxDispatcher::Push(SfxShell&)>.

	Beim Aktivieren eines SfxDispatchers wird an allen auf seinem
	Stack befindlichen SfxShells, beginnend mit der untersten, der Handler
	<SfxShell::Activate(sal_Bool)> gerufen.
*/

{
	DBG_MEMTEST();
	SFX_STACK(SfxDispatcher::DoActivate);
	if ( bMDI )
	{
		#ifdef DBG_UTIL
		ByteString sTemp("Activate Dispatcher ");
		sTemp += ByteString::CreateFromInt64( (sal_uIntPtr) this );
		DBG_TRACE(sTemp.GetBuffer());
		DBG_ASSERT( !pImp->bActive, "Activate-Fehler" );
		#endif
		pImp->bActive = sal_True;
		pImp->bUpdated = sal_False;
        SfxBindings* pBindings = GetBindings();
        if ( pBindings )
        {
            pBindings->SetDispatcher(this);
            pBindings->SetActiveFrame( pImp->pFrame->GetFrame().GetFrameInterface() );
        }
	}
	else
	{
		#ifdef DBG_UTIL
		ByteString sTemp("Non-MDI-Activate Dispatcher");
		sTemp += ByteString::CreateFromInt64( (sal_uIntPtr) this );
		DBG_TRACE( sTemp.GetBuffer() );
		#endif
	}

	if ( IsAppDispatcher() )
		return;

	for ( int i = int(pImp->aStack.Count()) - 1; i >= 0; --i )
		pImp->aStack.Top( (sal_uInt16) i )->DoActivate_Impl(pImp->pFrame, bMDI);

    if ( bMDI && pImp->pFrame )
    {
        //SfxWorkWindow *pWorkWin = pImp->pFrame->GetFrame().GetWorkWindow_Impl();
        SfxBindings *pBind = GetBindings();
        while ( pBind )
        {
            pBind->HidePopupCtrls_Impl( sal_False );
            pBind = pBind->GetSubBindings_Impl();
        }

        pImp->pFrame->GetFrame().GetWorkWindow_Impl()->HidePopups_Impl( sal_False, sal_False, 1 );
    }

	if ( pImp->aToDoStack.Count() )
	{
		if (sal_True)
		{
			// Kein sofortiges Update gewuenscht
			pImp->aTimer.SetTimeout(SFX_FLUSH_TIMEOUT);
			pImp->aTimer.SetTimeoutHdl( LINK(this, SfxDispatcher, EventHdl_Impl ) );
			pImp->aTimer.Start();
		}
		else
		{
			// Schnellstmoegliches Update (sollte Normalfall sein)
			pImp->aTimer.Stop();
			GetpApp()->PostUserEvent(pImp->nEventId, (void*)0);
		}
	}
}

void SfxDispatcher::DoParentActivate_Impl()
{
	for ( int i = int(pImp->aStack.Count()) - 1; i >= 0; --i )
		pImp->aStack.Top( (sal_uInt16) i )->ParentActivate();
}

//--------------------------------------------------------------------
void SfxDispatcher::DoDeactivate_Impl( sal_Bool bMDI, SfxViewFrame* pNew )

/*  [Beschreibung]

	Diese Methode steuert das Deaktivieren eines Dispatchers.

	Da der Applikations-Dispatcher immer aktiv ist, entweder als
	Unterdispatcher des <SfxViewFrame>-Dispatchers oder selbst, wird
	er nie als ganzes Deaktiviert, sondern nur seine einzelnen <SfxShell>s
	bei <SfxDispatcher::Pop(SfxShell&)>.

	Beim Deaktivieren eines SfxDispatchers wird an allen auf seinem
	Stack befindlichen SfxShells, beginnend mit der obersten, der Handler
	<SfxShell::Deactivate(sal_Bool)> gerufen.
*/

{
	DBG_MEMTEST();
	SFX_STACK(SfxDispatcher::DoDeactivate);

	SfxApplication *pSfxApp = SFX_APP();

	if ( bMDI )
	{
		DBG_TRACE(ByteString("Deactivate Dispatcher ").Append(ByteString::CreateFromInt64( (sal_uIntPtr) this )).GetBuffer());
		DBG_ASSERT( pImp->bActive, "Deactivate-Fehler" );
		pImp->bActive = sal_False;

        if ( pImp->pFrame && !(pImp->pFrame->GetObjectShell()->IsInPlaceActive() ) )
		{
            SfxWorkWindow *pWorkWin = pImp->pFrame->GetFrame().GetWorkWindow_Impl();
            if ( pWorkWin )
            {
                for (sal_uInt16 n=0; n<pImp->aChildWins.Count();)
                {
                    SfxChildWindow *pWin = pWorkWin->GetChildWindow_Impl( (sal_uInt16) ( pImp->aChildWins[n] & 0xFFFF ) );
                    if (!pWin || (pWin && pWin->GetAlignment() == SFX_ALIGN_NOALIGNMENT))
                        pImp->aChildWins.Remove(n);
                    else
                        n++;
                }
            }
		}
	}
	else {
		DBG_TRACE( ByteString ("Non-MDI-DeActivate Dispatcher").Append(ByteString::CreateFromInt64( (sal_uIntPtr) this )).GetBuffer() );
    }

	if ( IsAppDispatcher() && !pSfxApp->IsDowning() )
		return;

	for ( sal_uInt16 i = 0; i < pImp->aStack.Count(); ++i )
		pImp->aStack.Top(i)->DoDeactivate_Impl(pImp->pFrame, bMDI);

    sal_Bool bHidePopups = bMDI && pImp->pFrame;
    if ( pNew && pImp->pFrame )
    {
        com::sun::star::uno::Reference< com::sun::star::frame::XFrame > xOldFrame(
            pNew->GetFrame().GetFrameInterface()->getCreator(), com::sun::star::uno::UNO_QUERY );

        com::sun::star::uno::Reference< com::sun::star::frame::XFrame > xMyFrame(
            GetFrame()->GetFrame().GetFrameInterface(), com::sun::star::uno::UNO_QUERY );

        if ( xOldFrame == xMyFrame )
            bHidePopups = sal_False;
    }

    if ( bHidePopups )
    {
        //SfxWorkWindow *pWorkWin = pImp->pFrame->GetFrame().GetWorkWindow_Impl();
        SfxBindings *pBind = GetBindings();
        while ( pBind )
        {
            pBind->HidePopupCtrls_Impl( sal_True );
            pBind = pBind->GetSubBindings_Impl();
        }

        pImp->pFrame->GetFrame().GetWorkWindow_Impl()->HidePopups_Impl( sal_True, sal_False, 1 );
    }

	Flush();
}

void SfxDispatcher::DoParentDeactivate_Impl()
{
	for ( int i = int(pImp->aStack.Count()) - 1; i >= 0; --i )
		pImp->aStack.Top( (sal_uInt16) i )->ParentDeactivate();
}

//--------------------------------------------------------------------
int SfxDispatcher::GetShellAndSlot_Impl
(
	sal_uInt16			nSlot,		// die zu suchende Slot-Id
	SfxShell**		ppShell,	// die SfxShell, welche nSlot z.Zt. bedient
	const SfxSlot** ppSlot, 	// der SfxSlot, welcher nSlot z.Zt. bedient
	sal_Bool			bOwnShellsOnly,
	sal_Bool			bModal,		// trotz ModalMode
	sal_Bool		bRealSlot
)

/*	[Beschreibung]

	Diese Methode sucht im SfxDispatcher nach der <SfxShell>, von der
	die Slot-Id nSlot zur Zeit bedient wird. Dazu wird der Dispatcher
	zuvor geflusht.


	[R"uckgabewert]

	int 				sal_True
						Die SfxShell wurde gefunden, ppShell und ppSlot
						sind g"ultig.

						sal_True
						Die SfxShell wurde nicht gefunden, ppShell und ppSlot
						sind ung"ultig.
*/

{
	SFX_STACK(SfxDispatcher::GetShellAndSlot_Impl);

	Flush();
	SfxSlotServer aSvr;
	if ( _FindServer(nSlot, aSvr, bModal) )
	{
		if ( bOwnShellsOnly && aSvr.GetShellLevel() >= pImp->aStack.Count() )
			return sal_False;

		*ppShell = GetShell(aSvr.GetShellLevel());
		*ppSlot = aSvr.GetSlot();
		if ( 0 == (*ppSlot)->GetExecFnc() && bRealSlot )
			*ppSlot = (*ppShell)->GetInterface()->GetRealSlot(*ppSlot);
		// Check only real slots as enum slots don't have an execute function!
        if ( bRealSlot && ((0 == *ppSlot) || (0 == (*ppSlot)->GetExecFnc()) ))
			return sal_False;

#ifdef DBG_UTILx
		ByteString aMsg( nSlot );
		aMsg += " found in ";
		aMsg += (*ppShell)->GetInterface()->GetClassName();
		DbgTrace( aMsg.GetBuffer() );
#endif

		return sal_True;
	}

#ifdef DBG_UTILx
	ByteString aMsg( nSlot );
	aMsg += " not found";
	DbgTrace( aMsg.GetBuffer() );
#endif

	return sal_False;
}

/*
struct Executer : public SfxHint
{
    SfxRequest *pRequest;
    const SfxSlot* pSlot;
    sal_uInt16 nLevel;

    Executer( SfxRequest* pReq, const SfxSlot* p, sal_uInt16 n )
        :  pRequest( pReq )
        , pSlot(p)
        , nLevel(n)
        {}
    ~Executer()
    {delete pRequest;}
};
*/

//--------------------------------------------------------------------
void SfxDispatcher::_Execute
(
	SfxShell&		rShell,		// zu rufende <SfxShell>
	const SfxSlot&	rSlot,		// zu rufender <SfxSlot>
	SfxRequest&		rReq,		// auszuf"uhrende Funktion (Id und optional Parameter)
	SfxCallMode 	eCallMode	// synchron, asynchron oder wie beim Slot angegeben
)

/*	[Beschreibung]

	Diese Methode f"uhrt einen Request "uber einen gecachten <Slot-Server>
	aus.
*/

{
	DBG_MEMTEST();
	DBG_ASSERT( !pImp->bFlushing, "recursive call to dispatcher" );
	DBG_ASSERT( !pImp->aToDoStack.Count(), "unprepared InPlace _Execute" );

	if ( IsLocked( rSlot.GetSlotId() ) )
		return;

	if ( (eCallMode & SFX_CALLMODE_ASYNCHRON) ||
		 ( !(eCallMode & SFX_CALLMODE_SYNCHRON) &&
		   rSlot.IsMode(SFX_SLOT_ASYNCHRON) ) )
	{
		SfxDispatcher *pDispat = this;
		while ( pDispat )
		{
			sal_uInt16 nShellCount = pDispat->pImp->aStack.Count();
			for ( sal_uInt16 n=0; n<nShellCount; n++ )
			{
				if ( &rShell == pDispat->pImp->aStack.Top(n) )
				{
                    if ( eCallMode & SFX_CALLMODE_RECORD )
                        rReq.AllowRecording( sal_True );
                    pDispat->pImp->xPoster->Post(new SfxRequest(rReq));
//                    pDispat->pImp->xPoster->Post(new Executer(new SfxRequest(rReq), &rSlot, n ));
					return;
				}
			}

			pDispat = pDispat->pImp->pParent;
		}
	}
	else
		Call_Impl( rShell, rSlot, rReq, SFX_CALLMODE_RECORD==(eCallMode&SFX_CALLMODE_RECORD) );
}

//--------------------------------------------------------------------
void MappedPut_Impl( SfxAllItemSet &rSet, const SfxPoolItem &rItem )

/*	[Beschreibung]

	Hilfsfunktion zum putten von rItem unter der im Pool des Item-Sets
	rSet geltenden Which-Id.
*/

{
	// mit ggf. gemappter Which-Id putten
	const SfxItemPool *pPool = rSet.GetPool();
	sal_uInt16 nWhich = rItem.Which();
#ifdef TF_POOLABLE
	if ( pPool->IsSlot(nWhich) )
#else
	if ( pPool->HasMap() && pPool->IsSlot(nWhich) )
#endif
		nWhich = pPool->GetWhich(nWhich);
	rSet.Put( rItem, nWhich );
}

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

#ifndef SFX_USE_BINDINGS
#define SFX_USE_BINDINGS 0x8000
#endif

sal_uInt16 SfxDispatcher::ExecuteFunction( sal_uInt16 nSlot, SfxPoolItem **pArgs,
									   sal_uInt16 nMode )
{
	if ( !nMode )
		nMode = pImp->nStandardMode;

	// via Bindings/Interceptor? (dann ist der Returnwert nicht exakt)
	sal_Bool bViaBindings = SFX_USE_BINDINGS == ( nMode & SFX_USE_BINDINGS );
	nMode &= ~sal_uInt16(SFX_USE_BINDINGS);
    if ( bViaBindings && GetBindings() )
		return GetBindings()->Execute( nSlot, (const SfxPoolItem **) pArgs, nMode )
				? EXECUTE_POSSIBLE
				: EXECUTE_NO;

	// sonst via Dispatcher
	if ( IsLocked(nSlot) )
		return 0;
	SfxShell *pShell = 0;
	SfxCallMode eCall = SFX_CALLMODE_SYNCHRON;
	sal_uInt16 nRet = EXECUTE_NO;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSlot, &pShell, &pSlot, sal_False, sal_False ) )
	{
		// Ausf"uhrbarkeit vorher testen
		if ( pSlot->IsMode( SFX_SLOT_FASTCALL ) ||
			pShell->CanExecuteSlot_Impl( *pSlot ) )
				nRet = EXECUTE_POSSIBLE;

		if ( nMode == EXECUTEMODE_ASYNCHRON )
			eCall = SFX_CALLMODE_ASYNCHRON;
		else if ( nMode == EXECUTEMODE_DIALOGASYNCHRON && pSlot->IsMode( SFX_SLOT_HASDIALOG ) )
			eCall = SFX_CALLMODE_ASYNCHRON;
		else if ( pSlot->GetMode() & SFX_SLOT_ASYNCHRON )
			eCall = SFX_CALLMODE_ASYNCHRON;
		sal_Bool bDone = sal_False;
		if ( pArgs && *pArgs )
		{
			SfxAllItemSet aSet( pShell->GetPool() );
			for ( SfxPoolItem **pArg = pArgs; *pArg; ++pArg )
				MappedPut_Impl( aSet, **pArg );
			SfxRequest aReq( nSlot, eCall, aSet );
			_Execute( *pShell, *pSlot, aReq, eCall );
			bDone = aReq.IsDone();
		}
		else
		{
			SfxRequest aReq( nSlot, eCall, pShell->GetPool() );
			_Execute( *pShell, *pSlot, aReq, eCall );
			bDone = aReq.IsDone();
		}
	}

	return nRet;
}

sal_uInt16 SfxDispatcher::ExecuteFunction( sal_uInt16 nSlot, const SfxItemSet& rArgs,
									   sal_uInt16 nMode )
{
	if ( !nMode )
		nMode = pImp->nStandardMode;

/*
    // at the moment not implemented
    // via Bindings/Interceptor? (dann ist der Returnwert nicht exakt)
	sal_Bool bViaBindings = SFX_USE_BINDINGS == ( nMode & SFX_USE_BINDINGS );
	nMode &= ~sal_uInt16(SFX_USE_BINDINGS);
    if ( bViaBindings && GetBindings() )
        return GetBindings()->Execute( nSlot, rArgs, nMode )
				? EXECUTE_POSSIBLE
				: EXECUTE_NO;
*/
	// sonst via Dispatcher
	if ( IsLocked(nSlot) )
		return 0;
	SfxShell *pShell = 0;
	SfxCallMode eCall = SFX_CALLMODE_SYNCHRON;
	sal_uInt16 nRet = EXECUTE_NO;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSlot, &pShell, &pSlot, sal_False, sal_False ) )
	{
		// Ausf"uhrbarkeit vorher testen
		if ( pSlot->IsMode( SFX_SLOT_FASTCALL ) ||
			pShell->CanExecuteSlot_Impl( *pSlot ) )
				nRet = EXECUTE_POSSIBLE;

		if ( nMode == EXECUTEMODE_ASYNCHRON )
			eCall = SFX_CALLMODE_ASYNCHRON;
		else if ( nMode == EXECUTEMODE_DIALOGASYNCHRON && pSlot->IsMode( SFX_SLOT_HASDIALOG ) )
			eCall = SFX_CALLMODE_ASYNCHRON;
		else if ( pSlot->GetMode() & SFX_SLOT_ASYNCHRON )
			eCall = SFX_CALLMODE_ASYNCHRON;
		sal_Bool bDone = sal_False;
            SfxRequest aReq( nSlot, eCall, rArgs );
			_Execute( *pShell, *pSlot, aReq, eCall );
			bDone = aReq.IsDone();
	}

	return nRet;
}

sal_uInt16 SfxDispatcher::GetSlotId( const String& rCommand )
{
    const SfxSlot *pSlot = GetSlot( rCommand );
    if ( pSlot )
        return pSlot->GetSlotId();
	return 0;
}

const SfxSlot* SfxDispatcher::GetSlot( const String& rCommand )
{
	// Anzahl der Shells auf den verkettenten Dispatchern z"ahlen
	Flush();
	sal_uInt16 nTotCount = pImp->aStack.Count();
	if ( pImp->pParent )
	{
		SfxDispatcher *pParent = pImp->pParent;
		while ( pParent )
		{
			nTotCount = nTotCount + pParent->pImp->aStack.Count();
			pParent = pParent->pImp->pParent;
		}
	}

	const SfxSlot *pSlot=NULL;
	sal_uInt16 nFirstShell = 0;
	for ( sal_uInt16 i = nFirstShell; i < nTotCount; ++i )
	{
		SfxShell *pObjShell = GetShell(i);
		SfxInterface *pIFace = pObjShell->GetInterface();
		pSlot = pIFace->GetSlot( rCommand );
        if ( pSlot )
            return pSlot;
	}

	return 0;
}

//--------------------------------------------------------------------
int SfxExecuteItem::operator==( const SfxPoolItem& rItem ) const
{
	SfxExecuteItem& rArg = (SfxExecuteItem& )rItem;
	sal_uInt16 nCount = Count();
	if( nCount != rArg.Count() )
		return sal_False;
	while( nCount -- )
		if( *GetObject( nCount ) != *rArg.GetObject( nCount ) )
			return sal_False;
	return  eCall == rArg.eCall;
}

//--------------------------------------------------------------------
SfxPoolItem* SfxExecuteItem::Clone( SfxItemPool* ) const
{
	return new SfxExecuteItem( *this );
}

//--------------------------------------------------------------------
SfxExecuteItem::SfxExecuteItem( const SfxExecuteItem& rArg )
	: SfxItemPtrArray(), SfxPoolItem( rArg ), nModifier( 0 )
{
	eCall = rArg.eCall;
	nSlot = rArg.nSlot;
	sal_uInt16 nCount = rArg.Count();
	for( sal_uInt16 nPos = 0; nPos < nCount; nPos++ )
		Insert( rArg[ nPos ]->Clone(), nPos );
}

//--------------------------------------------------------------------
SfxExecuteItem::SfxExecuteItem(
	sal_uInt16 nWhichId, sal_uInt16 nSlotP, SfxCallMode eModeP,
	const SfxPoolItem*	pArg1, ... ) :
	SfxPoolItem( nWhichId ), nSlot( nSlotP ), eCall( eModeP ), nModifier( 0 )
{
	va_list pVarArgs;
	va_start( pVarArgs, pArg1 );
	for ( const SfxPoolItem *pArg = pArg1; pArg;
		  pArg = va_arg( pVarArgs, const SfxPoolItem* ) )
		Insert( pArg->Clone(), Count() );
	va_end(pVarArgs);
}

//--------------------------------------------------------------------
SfxExecuteItem::SfxExecuteItem(
	sal_uInt16 nWhichId, sal_uInt16 nSlotP, SfxCallMode eModeP )
	: SfxPoolItem( nWhichId ), nSlot( nSlotP ), eCall( eModeP ), nModifier( 0 )
{
}

//--------------------------------------------------------------------
const SfxPoolItem* SfxDispatcher::Execute( const SfxExecuteItem& rItem )
{
	const SfxPoolItem** pPtr = new const SfxPoolItem*[ rItem.Count() + 1 ];
	for( sal_uInt16 nPos = rItem.Count(); nPos--; )
		pPtr[ nPos ] = rItem.GetObject( nPos );
	pPtr[ rItem.Count() ] = 0;
	const SfxPoolItem* pRet = Execute(
		rItem.GetSlot(), rItem.GetCallMode(), pPtr, rItem.GetModifier() );

	delete [] (SfxPoolItem**)pPtr;

	return pRet;
}

//--------------------------------------------------------------------
const SfxPoolItem*	SfxDispatcher::Execute(
    sal_uInt16 nSlot,
    SfxCallMode nCall,
    SfxItemSet* pArgs,
    SfxItemSet* pInternalArgs,
    sal_uInt16 nModi)
{
	if ( IsLocked(nSlot) )
		return 0;

	SfxShell *pShell = 0;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSlot,  &pShell, &pSlot, sal_False,
							   SFX_CALLMODE_MODAL==(nCall&SFX_CALLMODE_MODAL) ) )
	{
		SfxAllItemSet aSet( pShell->GetPool() );
		if ( pArgs )
		{
		    SfxItemIter aIter(*pArgs);
		    for ( const SfxPoolItem *pArg = aIter.FirstItem();
			    pArg;
			    pArg = aIter.NextItem() )
			    MappedPut_Impl( aSet, *pArg );
		}
		SfxRequest aReq( nSlot, nCall, aSet );
        if (pInternalArgs)
    		aReq.SetInternalArgs_Impl( *pInternalArgs );
        aReq.SetModifier( nModi );

		_Execute( *pShell, *pSlot, aReq, nCall );
		return aReq.GetReturnValue();
	}
	return 0;
}

//--------------------------------------------------------------------
const SfxPoolItem* SfxDispatcher::Execute
(
	sal_uInt16 nSlot,				// die Id der auszufuehrenden Funktion
	SfxCallMode eCall,			// SFX_CALLMODE_SYNCRHON, ..._ASYNCHRON oder ..._SLOT
	const SfxPoolItem **pArgs,	// 0-terminiertes C-Array von Parametern
	sal_uInt16 nModi,
	const SfxPoolItem **pInternalArgs // 0-terminiertes C-Array von Parametern
)

/*  [Beschreibung]

	Methode zum Ausf"uhren eines <SfxSlot>s "uber die Slot-Id.


	[R"uckgabewert]

	const SfxPoolItem*		Pointer auf ein bis zum n"achsten Durchlauf
							der Message-Loop g"ultiges SfxPoolItem,
							welches den R"uckgabewert enth"alt.

							Oder ein 0-Pointer, wenn die Funktion nicht
							ausgef"uhrt wurde (z.B. Abbruch durch den
							Benutzer).
*/

{
	if ( IsLocked(nSlot) )
		return 0;

	SfxShell *pShell = 0;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSlot,  &pShell, &pSlot, sal_False,
							   SFX_CALLMODE_MODAL==(eCall&SFX_CALLMODE_MODAL) ) )
	{
		SfxRequest* pReq;
		if ( pArgs && *pArgs )
		{
			SfxAllItemSet aSet( pShell->GetPool() );
			for ( const SfxPoolItem **pArg = pArgs; *pArg; ++pArg )
				MappedPut_Impl( aSet, **pArg );
			pReq = new SfxRequest( nSlot, eCall, aSet );
		}
		else
			pReq =  new SfxRequest( nSlot, eCall, pShell->GetPool() );
		pReq->SetModifier( nModi );
		if( pInternalArgs && *pInternalArgs)
		{
			SfxAllItemSet aSet( SFX_APP()->GetPool() );
			for ( const SfxPoolItem **pArg = pInternalArgs; *pArg; ++pArg )
				aSet.Put( **pArg );
			pReq->SetInternalArgs_Impl( aSet );
		}
		_Execute( *pShell, *pSlot, *pReq, eCall );
		const SfxPoolItem* pRet = pReq->GetReturnValue();
		delete pReq; return pRet;
	}
	return 0;
}

//--------------------------------------------------------------------
const SfxPoolItem* SfxDispatcher::Execute
(
	sal_uInt16 nSlot,				// die Id der auszufuehrenden Funktion
	SfxCallMode eCall,			// SFX_CALLMODE_SYNCRHON, ..._ASYNCHRON oder ..._SLOT
	const SfxItemSet &rArgs	    // <SfxItemSet> mit Parametern
)

/*  [Beschreibung]

	Methode zum Ausf"uhren eines <SfxSlot>s "uber die Slot-Id.


	[R"uckgabewert]

	const SfxPoolItem*		Pointer auf ein bis zum n"achsten Durchlauf
							der Message-Loop g"ultiges SfxPoolItem,
							welches den R"uckgabewert enth"alt.

							Oder ein 0-Pointer, wenn die Funktion nicht
							ausgef"uhrt wurde (z.B. Abbruch durch den
							Benutzer).
*/

{
    return Execute( nSlot, eCall, 0, rArgs );
}

//--------------------------------------------------------------------
const SfxPoolItem*  SfxDispatcher::Execute
(
    sal_uInt16 nSlot,
    SfxCallMode eCall,
    sal_uInt16 nModi,
    const SfxItemSet &rArgs
)
{
	if ( IsLocked(nSlot) )
		return 0;

	SfxShell *pShell = 0;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSlot,  &pShell, &pSlot, sal_False,
							   SFX_CALLMODE_MODAL==(eCall&SFX_CALLMODE_MODAL) ) )
	{
		SfxAllItemSet aSet( pShell->GetPool() );
		SfxItemIter aIter(rArgs);
		for ( const SfxPoolItem *pArg = aIter.FirstItem();
			  pArg;
			  pArg = aIter.NextItem() )
			MappedPut_Impl( aSet, *pArg );
		SfxRequest aReq( nSlot, eCall, aSet );
        aReq.SetModifier( nModi );
		_Execute( *pShell, *pSlot, aReq, eCall );
		return aReq.GetReturnValue();
	}
	return 0;
}

//--------------------------------------------------------------------
const SfxPoolItem* SfxDispatcher::_Execute
(
	sal_uInt16				nSlot,		// die Id der auszufuehrenden Funktion
	SfxCallMode 		eCall,		// SFX_CALLMODE_SYNCRHON, ..._ASYNCHRON oder ..._SLOT
	va_list 			pVarArgs,	// Parameterliste ab 2. Parameter
	const SfxPoolItem*	pArg1   	// erster Parameter
)

/*  [Beschreibung]

	Methode zum Ausf"uhren eines <SfxSlot>s "uber die Slot-Id.


	[R"uckgabewert]

	const SfxPoolItem*		Pointer auf ein bis zum n"achsten Durchlauf
							der Message-Loop g"ultiges SfxPoolItem,
							welches den R"uckgabewert enth"alt.

							Oder ein 0-Pointer, wenn die Funktion nicht
							ausgef"uhrt wurde (z.B. Abbruch durch den
							Benutzer).
*/

{
	if ( IsLocked(nSlot) )
		return 0;

	SfxShell *pShell = 0;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSlot, &pShell, &pSlot, sal_False,
							   SFX_CALLMODE_MODAL==(eCall&SFX_CALLMODE_MODAL) ) )
	{
	   SfxAllItemSet aSet( pShell->GetPool() );

	   for ( const SfxPoolItem *pArg = pArg1;
			 pArg;
			 pArg = va_arg( pVarArgs, const SfxPoolItem* ) )
		   MappedPut_Impl( aSet, *pArg );

	   SfxRequest aReq( nSlot, eCall, aSet );
	   _Execute( *pShell, *pSlot, aReq, eCall );
	   return aReq.GetReturnValue();
	}
	return 0;
}

//--------------------------------------------------------------------
const SfxPoolItem* SfxDispatcher::Execute
(
	sal_uInt16				nSlot,		// die Id der auszufuehrenden Funktion
	SfxCallMode 		eCall,		// SFX_CALLMODE_SYNCRHON, ..._ASYNCHRON oder ..._SLOT
	const SfxPoolItem*	pArg1,		// erster Parameter
	... 							// 0-terminiertes Liste Parametern
)

/*  [Beschreibung]

	Methode zum Ausf"uhren eines <SfxSlot>s "uber die Slot-Id.


	[Anmerkung]

	Die Parameter werden kopiert, k"onnen daher als Adresse von
	Stack-Objekten "ubergeben werden.


	[R"uckgabewert]

	const SfxPoolItem*		Pointer auf ein bis zum n"achsten Durchlauf
							der Message-Loop g"ultiges SfxPoolItem,
							welches den R"uckgabewert enth"alt.

							Oder ein 0-Pointer, wenn die Funktion nicht
							ausgef"uhrt wurde (z.B. Abbruch durch den
							Benutzer).


	[Beispiel]

    pDispatcher->Execute( SID_OPENDOCUMENT, SFX_CALLMODE_SYNCHRON,
		&SfxStringItem( SID_FILE_NAME, "\\tmp\\temp.sdd" ),
		&SfxStringItem( SID_FILTER_NAME, "StarDraw Presentation" ),
		&SfxBoolItem( SID_DOC_READONLY, sal_False ),
		0L );
*/

{
	if ( IsLocked(nSlot) )
		return 0;

	SfxShell *pShell = 0;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSlot, &pShell, &pSlot, sal_False,
							   SFX_CALLMODE_MODAL==(eCall&SFX_CALLMODE_MODAL) ) )
	{
	   SfxAllItemSet aSet( pShell->GetPool() );

	   va_list pVarArgs;
	   va_start( pVarArgs, pArg1 );
	   for ( const SfxPoolItem *pArg = pArg1;
			 pArg;
			 pArg = va_arg( pVarArgs, const SfxPoolItem* ) )
		   MappedPut_Impl( aSet, *pArg );
	   va_end(pVarArgs);

	   SfxRequest aReq( nSlot, eCall, aSet );
	   _Execute( *pShell, *pSlot, aReq, eCall );
	   return aReq.GetReturnValue();
	}
	return 0;
}

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

IMPL_LINK( SfxDispatcher, PostMsgHandler, SfxRequest*, pReq )

/*	[Beschreibung]

	Hilfsmethode zum Empfangen der asynchron auszuf"uhrenden <SfxRequest>s.
*/

{
	DBG_MEMTEST();
	DBG_ASSERT( !pImp->bFlushing, "recursive call to dispatcher" );
	SFX_STACK(SfxDispatcher::PostMsgHandler);

	// ist auch der Pool noch nicht gestorben?
//    SfxRequest* pReq = pExec->pRequest;
	if ( !pReq->IsCancelled() )
	{
		if ( !IsLocked(pReq->GetSlot()) )
		{
			Flush();
            SfxSlotServer aSvr;
            if ( _FindServer(pReq->GetSlot(), aSvr, HACK(x) sal_True ) )
//            SfxShell *pShell = GetShell(pExec->nLevel);
//            if ( pShell && pShell->GetInterface()->GetSlot( pExec->pSlot->GetSlotId() ) )
			{
                const SfxSlot *pSlot = aSvr.GetSlot();
                SfxShell *pSh = GetShell(aSvr.GetShellLevel());

				DBG( SfxApplication *pSfxApp = SFX_APP() );
				DBG( pSfxApp->EnterAsynchronCall_Impl() );

				// Wenn pSlot ein "Pseudoslot" f"ur Macros oder Verben ist, kann
				// er im Call_Impl zerst"ort werden, also nicht mehr benutzen!
				pReq->SetSynchronCall( sal_False );
                Call_Impl( *pSh, *pSlot, *pReq, pReq->AllowsRecording() ); //! woher bRecord?
//                Call_Impl( *pShell, *pExec->pSlot, *pReq, sal_True ); //! woher bRecord?
				DBG( pSfxApp->LeaveAsynchronCall_Impl() );
			}

//            delete pExec;
		}
		else
		{
//            pImp->xPoster->Post(pExec);
            if ( pImp->bLocked )
                pImp->aReqArr.Insert( new SfxRequest(*pReq), pImp->aReqArr.Count() );
            else
                pImp->xPoster->Post(new SfxRequest(*pReq));
		}
	}
//    else
//        delete pExec;

    delete pReq;
	return 0;
}
//--------------------------------------------------------------------
void SfxDispatcher::SetMenu_Impl()
{
	if ( pImp->pFrame )
	{
        SfxViewFrame* pTop = pImp->pFrame->GetTopViewFrame();
        if ( pTop && pTop->GetBindings().GetDispatcher() == this )
        {
			SfxFrame& rFrame = pTop->GetFrame();
            if ( rFrame.IsMenuBarOn_Impl() )
            {
                com::sun::star::uno::Reference < com::sun::star::beans::XPropertySet > xPropSet( rFrame.GetFrameInterface(), com::sun::star::uno::UNO_QUERY );
                if ( xPropSet.is() )
                {
                    com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
                    com::sun::star::uno::Any aValue = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )));
                    aValue >>= xLayoutManager;
                    if ( xLayoutManager.is() )
                    {
                        rtl::OUString aMenuBarURL( RTL_CONSTASCII_USTRINGPARAM( "private:resource/menubar/menubar" ));
						if ( !xLayoutManager->isElementVisible( aMenuBarURL ) )
                        	xLayoutManager->createElement( aMenuBarURL );
                    }
                }
            }
        }
    }
}

//--------------------------------------------------------------------
void SfxDispatcher::Update_Impl( sal_Bool bForce )
{
	SFX_STACK(SfxDispatcher::Update_Impl);

	Flush();

    if ( !pImp->pFrame || pImp->bUILocked )
		return;

	SFX_APP();  // -Wall is this required???
	SfxDispatcher *pDisp = this;
	sal_Bool bUpdate = bForce;
    while ( pDisp && pDisp->pImp->pFrame )
	{
        SfxWorkWindow *pWork = pDisp->pImp->pFrame->GetFrame().GetWorkWindow_Impl();
		SfxDispatcher *pAct = pWork->GetBindings().GetDispatcher_Impl();
		if ( pAct == pDisp || pAct == this )
		{
			if ( !bUpdate )
				bUpdate = !pDisp->pImp->bUpdated;
			pDisp->pImp->bUpdated = sal_True;
		}
		else
			break;

		pDisp = pDisp->pImp->pParent;
	}

    if ( !bUpdate || pImp->pFrame->GetFrame().IsClosing_Impl() )
		return;

    SfxViewFrame* pTop = pImp->pFrame ? pImp->pFrame->GetTopViewFrame() : NULL;
    sal_Bool bUIActive = pTop && pTop->GetBindings().GetDispatcher() == this;

    if ( !bUIActive && pTop && GetBindings() == &pTop->GetBindings() )
        // keep own tools internally for collecting
        GetBindings()->GetDispatcher()->pImp->bUpdated = sal_False;

    SfxBindings* pBindings = GetBindings();
    if ( pBindings )
        pBindings->DENTERREGISTRATIONS();

    com::sun::star::uno::Reference< com::sun::star::frame::XFrame > xFrame = pBindings->GetActiveFrame();
    com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xPropSet( xFrame, com::sun::star::uno::UNO_QUERY );
    com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
    if ( xPropSet.is() )
    {
        try
        {
            com::sun::star::uno::Any aValue = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )) );
	        aValue >>= xLayoutManager;
        }
        catch ( com::sun::star::uno::Exception& )
        {
        }
    }

    if ( xLayoutManager.is() )
        xLayoutManager->lock();

    sal_Bool bIsIPActive = pImp->pFrame && pImp->pFrame->GetObjectShell()->IsInPlaceActive();
    SfxInPlaceClient *pClient = pImp->pFrame ? pImp->pFrame->GetViewShell()->GetUIActiveClient() : NULL;
    if ( bUIActive && /* !bIsIPActive && */ ( !pClient || !pClient->IsObjectUIActive() ) )
		SetMenu_Impl();

    SfxWorkWindow *pWorkWin = pImp->pFrame->GetFrame().GetWorkWindow_Impl();
    SfxWorkWindow *pTaskWin = pImp->pFrame->GetTopFrame().GetWorkWindow_Impl();
    pTaskWin->ResetStatusBar_Impl();

	SfxDispatcher *pDispat = this;
	while ( pDispat )
	{
        SfxWorkWindow *pWork = pDispat->pImp->pFrame->GetFrame().GetWorkWindow_Impl();
		SfxDispatcher *pAct = pWork->GetBindings().GetDispatcher_Impl();
		if ( pAct == pDispat || pAct == this )
		{
			pWork->ResetObjectBars_Impl();
			pWork->ResetChildWindows_Impl();
		}

		pDispat = pDispat->pImp->pParent;
	}

	sal_Bool bIsActive = sal_False;
	SfxDispatcher *pActDispat = pWorkWin->GetBindings().GetDispatcher_Impl();
	pDispat = this;
	while ( pActDispat && !bIsActive )
	{
		if ( pDispat == pActDispat )
			bIsActive = sal_True;
		pActDispat = pActDispat->pImp->pParent;
	}

    _Update_Impl( bUIActive, !bIsIPActive, bIsIPActive, pTaskWin );
	if ( bUIActive || bIsActive )
		pWorkWin->UpdateObjectBars_Impl();

    if ( pBindings )
        pBindings->DLEAVEREGISTRATIONS();

    if ( xLayoutManager.is() )
        xLayoutManager->unlock();

    return;
}

void SfxDispatcher::_Update_Impl( sal_Bool bUIActive, sal_Bool bIsMDIApp, sal_Bool bIsIPOwner, SfxWorkWindow *pTaskWin )
{
	SFX_APP();
    SfxWorkWindow *pWorkWin = pImp->pFrame->GetFrame().GetWorkWindow_Impl();
	sal_Bool bIsActive = sal_False;
	sal_Bool bIsTaskActive = sal_False;
	SfxDispatcher *pActDispat = pWorkWin->GetBindings().GetDispatcher_Impl();
	SfxDispatcher *pDispat = this;
	while ( pActDispat && !bIsActive )
	{
		if ( pDispat == pActDispat )
			bIsActive = sal_True;
		pActDispat = pActDispat->pImp->pParent;
	}

    if ( pImp->pParent && !pImp->bQuiet /* && bUIActive */ )
        pImp->pParent->_Update_Impl( bUIActive, bIsMDIApp, bIsIPOwner, pTaskWin );

	for (sal_uInt16 n=0; n<SFX_OBJECTBAR_MAX; n++)
		pImp->aObjBars[n].nResId = 0;
	pImp->aChildWins.Remove(0, pImp->aChildWins.Count());

    // bQuiet : own shells aren't considered for UI and SlotServer
    // bNoUI: own Shells aren't considered fors UI
    if ( pImp->bQuiet || pImp->bNoUI || (pImp->pFrame && pImp->pFrame->GetObjectShell()->IsPreview()) )
		return;

	sal_uInt32 nStatBarId=0;
	SfxShell *pStatusBarShell = NULL;

    SfxSlotPool* pSlotPool = &SfxSlotPool::GetSlotPool( GetFrame() );
	sal_uInt16 nTotCount = pImp->aStack.Count();
	for ( sal_uInt16 nShell = nTotCount; nShell > 0; --nShell )
	{
		SfxShell *pShell = GetShell( nShell-1 );
		SfxInterface *pIFace = pShell->GetInterface();

        // don't consider shells if "Hidden" oder "Quiet"
		sal_Bool bReadOnlyShell = IsReadOnlyShell_Impl( nShell-1 );
		sal_uInt16 nNo;
		for ( nNo = 0; pIFace && nNo<pIFace->GetObjectBarCount(); ++nNo )
		{
			sal_uInt16 nPos = pIFace->GetObjectBarPos(nNo);
			if ( bReadOnlyShell && !( nPos & SFX_VISIBILITY_READONLYDOC ) )
				continue;

            // check wether toolbar needs activation of a special feature
            sal_uInt32 nFeature = pIFace->GetObjectBarFeature(nNo);
			if ( nFeature && !pShell->HasUIFeature( nFeature ) )
				continue;

			// check for toolboxes that are exclusively for a viewer
			if ( pImp->pFrame)
			{
				sal_Bool bViewerTbx = SFX_VISIBILITY_VIEWER == ( nPos & SFX_VISIBILITY_VIEWER );
				SfxObjectShell* pSh = pImp->pFrame->GetObjectShell();
				SFX_ITEMSET_ARG( pSh->GetMedium()->GetItemSet(), pItem, SfxBoolItem, SID_VIEWONLY, sal_False );
				sal_Bool bIsViewer = pItem && pItem->GetValue();
				if ( bIsViewer != bViewerTbx )
					continue;
			}

            // always register toolbars, allows to switch them on
            sal_Bool bVisible = pIFace->IsObjectBarVisible(nNo);
			if ( !bVisible )
				nPos &= SFX_POSITION_MASK;

			SfxObjectBars_Impl& rBar = pImp->aObjBars[nPos & SFX_POSITION_MASK];
			rBar.nMode = nPos;
			rBar.nResId = pIFace->GetObjectBarResId(nNo).GetId();
			const String *pName = pIFace->GetObjectBarName(nNo);
			if ( pName )
				rBar.aName = *pName;
			else
				rBar.aName.Erase();
			rBar.pIFace = pIFace;

			if ( bUIActive || bIsActive )
			{
				pWorkWin->SetObjectBar_Impl(
					nPos, rBar.nResId, rBar.pIFace, &rBar.aName );
			}

			if ( !bVisible )
				rBar.nResId = 0;
		}

		for ( nNo=0; pIFace && nNo<pIFace->GetChildWindowCount(); nNo++ )
		{
			sal_uInt32 nId = pIFace->GetChildWindowId(nNo);
            const SfxSlot *pSlot = pSlotPool->GetSlot( (sal_uInt16) nId );
            DBG_ASSERT( pSlot, "Childwindow slot missing!");
			if ( bReadOnlyShell )
			{
                // only show ChildWindows if their slot is allowed for readonly documents
                if ( pSlot && !pSlot->IsMode( SFX_SLOT_READONLYDOC ) )
					continue;
			}

			sal_uInt32 nFeature = pIFace->GetChildWindowFeature(nNo);
			if ( nFeature && !pShell->HasUIFeature( nFeature ) )
				continue;

            // slot decides wether a ChildWindow is shown when document is OLE server or OLE client
            sal_uInt16 nMode = SFX_VISIBILITY_STANDARD;
			if( pSlot )
			{
                if ( pSlot->IsMode(SFX_SLOT_CONTAINER) )
				{
                    if ( pWorkWin->IsVisible_Impl( SFX_VISIBILITY_CLIENT ) )
                        nMode |= SFX_VISIBILITY_CLIENT;
				}
				else
				{
                    if ( pWorkWin->IsVisible_Impl( SFX_VISIBILITY_SERVER ) )
                        nMode |= SFX_VISIBILITY_SERVER;
				}
			}

			if ( bUIActive || bIsActive )
				pWorkWin->SetChildWindowVisible_Impl( nId, sal_True, nMode );
			if ( bUIActive || bIsActive || !pWorkWin->IsFloating( (sal_uInt16) ( nId & 0xFFFF ) ) )
				pImp->aChildWins.Insert( nId, pImp->aChildWins.Count());
		}

		if ( bIsMDIApp || bIsIPOwner )
		{
			sal_uInt32 nId = pIFace->GetStatusBarResId().GetId();
			if ( nId )
			{
				nStatBarId = nId;
				pStatusBarShell =  pShell;
			}
		}
	}

	for ( sal_uInt16 nPos=0; nPos<SFX_OBJECTBAR_MAX; nPos++ )
	{
		SfxObjectBars_Impl& rFixed = pImp->aFixedObjBars[nPos];
		if ( rFixed.nResId )
		{
			SfxObjectBars_Impl& rBar = pImp->aObjBars[nPos];
			rBar = rFixed;
			pWorkWin->SetObjectBar_Impl( rFixed.nMode,
				rFixed.nResId, rFixed.pIFace, &rFixed.aName );
		}
	}

	if ( pTaskWin && ( bIsMDIApp || bIsIPOwner ) )
	{
		SfxDispatcher *pActDispatcher = pTaskWin->GetBindings().GetDispatcher_Impl();
		SfxDispatcher *pDispatcher = this;
		while ( pActDispatcher && !bIsTaskActive )
		{
			if ( pDispatcher == pActDispatcher )
				bIsTaskActive = sal_True;
			pActDispatcher = pActDispatcher->pImp->pParent;
		}

        if ( bIsTaskActive && nStatBarId && pImp->pFrame )
		{
            // internal frames also may control statusbar
            SfxBindings& rBindings = pImp->pFrame->GetBindings();
            pImp->pFrame->GetFrame().GetWorkWindow_Impl()->SetStatusBar_Impl( nStatBarId, pStatusBarShell, rBindings );
		}
	}
}

//--------------------------------------------------------------------
void SfxDispatcher::FlushImpl()

/*	[Beschreibung]

	Hilfsmethode zum Ausf"uhren der ausstehenden Push- und Pop-Befehle.
*/

{
	DBG_PROFSTART(SfxDispatcherFlush);
	DBG_MEMTEST();
	SFX_STACK(SfxDispatcher::FlushImpl);

	DBG_TRACE("Flushing dispatcher!");

#ifdef DBG_UTIL
	ByteString aMsg( "SfxDispatcher(" );
	aMsg += ByteString::CreateFromInt64( (sal_uIntPtr) this );
	aMsg += ")::Flush()";
#endif

	pImp->aTimer.Stop();

	if ( pImp->pParent )
		pImp->pParent->Flush();

//	if ( pImp->bQuiet )
//		return;

	pImp->bFlushing = !pImp->bFlushing;
	if ( !pImp->bFlushing )
	{
		pImp->bFlushing = sal_True;
		DBG_PROFSTOP(SfxDispatcherFlush);
//!
#ifdef DBG_UTIL_MESSEHACK_AUSKOMMENT
		DBG_ERROR( "reentering SfxDispatcher::Flush()" );
		aMsg += " reentering, aborted";
		DbgTrace( aMsg.GetBuffer() );
#endif
		return;
	}

	SfxApplication *pSfxApp = SFX_APP();

	// in der 1. Runde den echten Stack 'um'bauen
	SfxToDoStack_Impl aToDoCopy;
	sal_Bool bModify = sal_False;
	short nToDo;
	for ( nToDo = pImp->aToDoStack.Count()-1; nToDo >= 0; --nToDo )
	{
		bModify = sal_True;

		SfxToDo_Impl aToDo( pImp->aToDoStack.Top(nToDo) );
		if ( aToDo.bPush )
		{
			// tats"aechlich pushen
			DBG_ASSERT( !pImp->aStack.Contains( aToDo.pCluster ),
						"pushed SfxShell already on stack" );
			pImp->aStack.Push( aToDo.pCluster );
			aToDo.pCluster->SetDisableFlags( pImp->nDisableFlags );

			// die bewegte Shell merken
			aToDoCopy.Push( aToDo );
		}
		else
		{
			// tats"aechlich poppen
			SfxShell* pPopped = 0;
			bool bFound = sal_False;
			do
			{
				DBG_ASSERT( pImp->aStack.Count(), "popping from empty stack" );
				pPopped = pImp->aStack.Pop();
				pPopped->SetDisableFlags( 0 );
				bFound = pPopped == aToDo.pCluster;

				// die bewegte Shell merken
				aToDoCopy.Push( SfxToDo_Impl( sal_False, aToDo.bDelete, sal_False, *pPopped) );
			}
			while ( aToDo.bUntil && !bFound );
			DBG_ASSERT( bFound, "wrong SfxShell popped" );
		}

		if ( nToDo == 0 )
			pImp->aToDoStack.Clear();
	}

	// ggf. Bindings invalidieren
	if ( !pSfxApp->IsDowning() )
	{
		if ( bModify )
		{
			pImp->pCachedServ1 = 0;
			pImp->pCachedServ2 = 0;
		}

		InvalidateBindings_Impl( bModify );
	}

	pImp->bFlushing = sal_False;
	pImp->bUpdated = sal_False; // nicht nur bei bModify, falls Doc/Template-Config
	bFlushed = sal_True;
	DBG_TRACE("Successfully flushed dispatcher!");

	// in der 2. Runde die Shells aktivieren und ggf. l"oschen
	for ( nToDo = aToDoCopy.Count()-1; nToDo >= 0; --nToDo )
	{
		SfxToDo_Impl aToDo( aToDoCopy.Top(nToDo) );
		if ( aToDo.bPush )
		{
			if ( pImp->bActive )
				aToDo.pCluster->DoActivate_Impl(pImp->pFrame, sal_True);
		}
		else
			if ( pImp->bActive )
				aToDo.pCluster->DoDeactivate_Impl(pImp->pFrame, sal_True);
	}
	for ( nToDo = aToDoCopy.Count()-1; nToDo >= 0; --nToDo )
	{
		SfxToDo_Impl aToDo( aToDoCopy.Top(nToDo) );
		if ( aToDo.bDelete ) delete aToDo.pCluster;
	}
	sal_Bool bAwakeBindings = aToDoCopy.Count() != 0;
	if( bAwakeBindings )
		aToDoCopy.Clear();

	// Wenn bei Activate/Deactivate/Delete weitere Stackbewegungen erfolgt sind :
	if (!bFlushed)
		// falls jemand Push/Pop gerufen hat, wurde auch EnterReg gerufen!
		FlushImpl();

    if( bAwakeBindings && GetBindings() )
		GetBindings()->DLEAVEREGISTRATIONS();
	DBG_PROFSTOP(SfxDispatcherFlush);

	for (sal_uInt16 n=0; n<SFX_OBJECTBAR_MAX; n++)
		pImp->aFixedObjBars[n].nResId = 0;

#ifdef DBG_UTIL
	aMsg += " done";
	DbgTrace( aMsg.GetBuffer() );
#endif
}

//--------------------------------------------------------------------
void SfxDispatcher::SetSlotFilter
(
	HACK(hier muss mal ein enum rein)
	sal_Bool 			bEnable,	/*	sal_True:
									nur angegebene Slots enablen,
									alle anderen disablen

									sal_False:
									die angegebenen Slots disablen,
									alle anderen zun"achst enablen
								*/
	sal_uInt16 			nCount, 	// 	Anzahl der SIDs im folgenden Array
	const sal_uInt16*	pSIDs		// 	sortiertes Array von 'nCount' SIDs
)

/*	[Beschreibung]

	Mit dieser Methode wird ein Filter gesetzt, mit dem gezielt Slots
	enabled bzw. disabled werden k"onnen. Das "ubergebene Array mu\s
	bis zum Dtor bzw. n"achsten <SetSlotFilter()> erhalten bleiben, es
	wird nicht vom Dispatcher gel"oscht, es kann daher static sein.

	In ReadOnly-Dokumenten kann man mit 'bEnable==2' quasi das ReadOnlyDoc
	Flag von Slots "ubersteuern, dieser werden also wieder gefunden. Auf
	andere Slots hat das dann keine Auswirkung.


	[Beispiel]

	gezieltes disablen der Slots 1, 2 und 3:

		static sal_uInt16 __READONLY_DATA pSIDs[] = { 1, 2, 3 };
		pDisp->SetSlotFilter( sal_False, sizeof(pSIDs)/sizeof(sal_uInt16), pSIDs );

	nur die Slots 5, 6 und 7 zulassen:

		static sal_uInt16 __READONLY_DATA pSIDs[] = { 5, 6, 7 };
		pDisp->SetSlotFilter( sal_True, sizeof(pSIDs)/sizeof(sal_uInt16), pSIDs );

	Filter ausschalten:

		pDisp->SetSlotFilter();
*/

{
#ifdef DBG_UTIL
	// Array "uberpr"ufen
	for ( sal_uInt16 n = 1; n < nCount; ++n )
		DBG_ASSERT( pSIDs[n] > pSIDs[n-1], "SetSlotFilter: SIDs not sortet" );
#endif

	if ( pImp->pFilterSIDs )
		pImp->pFilterSIDs = 0;

	pImp->bFilterEnabling = bEnable;
	pImp->nFilterCount = nCount;
	pImp->pFilterSIDs = pSIDs;

	GetBindings()->InvalidateAll(sal_True);
}

//--------------------------------------------------------------------
EXTERN_C
#if defined( PM2 ) && (!defined( CSET ) && !defined ( MTW ) && !defined( WTC ))
int _stdcall
#else
#ifdef WNT
int _cdecl
#else
int
#endif
#endif

SfxCompareSIDs_Impl( const void* pSmaller, const void* pBigger )
{
	DBG_MEMTEST();
	return ( (long) *((sal_uInt16*)pSmaller) ) - ( (long) *((sal_uInt16*)pBigger) );
}

//--------------------------------------------------------------------
sal_Bool SfxDispatcher::IsSlotEnabledByFilter_Impl( sal_uInt16 nSID ) const

/*	[Beschreibung]

	Sucht 'nSID' in dem mit <SetSlotFilter()> gesetzten Filter und
	liefert sal_True, falls die SID erlaubt ist, bzw. sal_False, falls sie
	durch den Filter disabled ist.

	[R"uckgabewert]
	sal_Bool				0	=>	disabled
						1	=> 	enabled
						2	=>	enabled even if ReadOnlyDoc
*/

{
	// kein Filter?
	if ( 0 == pImp->nFilterCount )
		// => alle SIDs erlaubt
		return sal_True;

	// suchen
	sal_Bool bFound = 0 != bsearch( &nSID, pImp->pFilterSIDs, pImp->nFilterCount,
								sizeof(sal_uInt16), SfxCompareSIDs_Impl );

	// even if ReadOnlyDoc
	if ( 2 == pImp->bFilterEnabling )
		return bFound ? 2 : 1;
	// sonst je nach Negativ/Positiv Filter
	return pImp->bFilterEnabling ? bFound : !bFound;
}

//--------------------------------------------------------------------
sal_Bool SfxDispatcher::_TryIntercept_Impl
(
	sal_uInt16				nSlot,		// zu suchende Slot-Id
	SfxSlotServer&	 	rServer,	// zu f"uellende <SfxSlotServer>-Instanz
	sal_Bool				bSelf
)
{
	// Eventuell geh"ort der parent auch zu einer Komponente
	SfxDispatcher *pParent = pImp->pParent;
	sal_uInt16 nLevels = pImp->aStack.Count();
	while ( pParent && pParent->pImp->pFrame )
	{
		if ( pParent->pImp->pFrame->GetFrame().HasComponent() )
		{
			// Components d"urfen intercepten
			if ( pParent->_TryIntercept_Impl( nSlot, rServer, sal_True ) )
			{
				// Die eigenen Shells zum Shelllevel hinzuz"ahlen
				rServer.SetShellLevel( rServer.GetShellLevel() + nLevels );
				return sal_True;
			}
			else
				// Keine weitere Interception
				break;
		}
		else
			nLevels = nLevels + pParent->pImp->aStack.Count();

		pParent = pParent->pImp->pParent;
	}

	if ( bSelf )
	{
		// Die ComponentViewShell befragen
		Flush();
		SfxShell *pObjShell = GetShell(0);
		SfxInterface *pIFace = pObjShell->GetInterface();
		const SfxSlot *pSlot = pIFace->GetSlot(nSlot);

		if ( pSlot )
		{
			rServer.SetSlot(pSlot);
			rServer.SetShellLevel(0);
#ifdef DBG_UTILx
			String aMsg( nSlot );
			aMsg += " intercepted";
			DbgTrace( aMsg.GetBuffer() );
#endif
			return sal_True;
		}
	}

	return sal_False;
}

sal_Bool SfxDispatcher::_FindServer
(
	sal_uInt16				nSlot,		// zu suchende Slot-Id
	SfxSlotServer&	 rServer,	 // zu f"uellnde <SfxSlotServer>-Instanz
	sal_Bool				bModal		// trotz ModalMode
)

/*	[Beschreibung]

	Diese Hilfsmethode sucht den <Slot-Server>, der nSlot zur Zeit bedient.
	Als Ergebnis wird rServer entsprechend gef"ullt.

	Falls bekannt, kann das SfxInterface mitgegeben werden, von welchem
	nSlot momentan bedient wird.

	Vor der Suche nach nSlot wird der SfxDispatcher geflusht.


	[R"uckgabewert]

	sal_Bool				sal_True
						Der Slot wurde gefunden, rServer ist g"ultig.

						sal_False
						Der Slot wird momentan nicht bedient, rServer
						ist ung"ultig.
*/

{
	SFX_STACK(SfxDispatcher::_FindServer);

	// Dispatcher gelockt? (SID_HELP_PI trotzdem durchlassen)
	if ( IsLocked(nSlot) )
	{
		pImp->bInvalidateOnUnlock = sal_True;
		return sal_False;
	}

	// Anzahl der Shells auf den verkettenten Dispatchern z"ahlen
	Flush();
	sal_uInt16 nTotCount = pImp->aStack.Count();
	if ( pImp->pParent )
	{
		SfxDispatcher *pParent = pImp->pParent;
		while ( pParent )
		{
			nTotCount = nTotCount + pParent->pImp->aStack.Count();
			pParent = pParent->pImp->pParent;
		}
	}

	// Verb-Slot?
	if (nSlot >= SID_VERB_START && nSlot <= SID_VERB_END)
	{
		for ( sal_uInt16 nShell = 0;; ++nShell )
		{
            SfxShell *pSh = GetShell(nShell);
            if ( pSh == NULL )
                return false;
			if ( pSh->ISA(SfxViewShell) )
			{
                const SfxSlot* pSlot = pSh->GetVerbSlot_Impl(nSlot);
                if ( pSlot )
                {
                    rServer.SetShellLevel(nShell);
                    rServer.SetSlot( pSlot );
                    return true;
                }
			}
		}
	}

	// SID gegen gesetzten Filter pr"ufen
	sal_uInt16 nSlotEnableMode=0;
	if ( pImp->pFrame )
	{
		nSlotEnableMode = IsSlotEnabledByFilter_Impl( nSlot );
		if ( 0 == nSlotEnableMode )
			return sal_False;
	}

	// im Quiet-Mode nur Parent-Dispatcher
	if ( pImp->bQuiet )
	{
		if ( pImp->pParent )
		{
			sal_Bool bRet = pImp->pParent->_FindServer( nSlot, rServer, bModal );
			rServer.SetShellLevel
				( rServer.GetShellLevel() + pImp->aStack.Count() );
			return bRet;
		}
		else
			return sal_False;
	}

	sal_Bool bReadOnly = ( 2 != nSlotEnableMode && pImp->bReadOnly );
//				( pImp->pFrame && pImp->pFrame->GetObjectShell() );
//				  pImp->pFrame->GetObjectShell()->IsLoading() );

	// durch alle Shells der verketteten Dispatchern von oben nach unten suchen
#ifdef DBG_UTILx
	String aStack( "Stack:" );
#endif
	sal_uInt16 nFirstShell = pImp->bModal && !bModal ? pImp->aStack.Count() : 0;
	for ( sal_uInt16 i = nFirstShell; i < nTotCount; ++i )
	{
		SfxShell *pObjShell = GetShell(i);
		SfxInterface *pIFace = pObjShell->GetInterface();
		const SfxSlot *pSlot = pIFace->GetSlot(nSlot);

		if ( pSlot && pSlot->nDisableFlags && ( pSlot->nDisableFlags & pObjShell->GetDisableFlags() ) != 0 )
			return sal_False;

		if ( pSlot && !( pSlot->nFlags & SFX_SLOT_READONLYDOC ) && bReadOnly )
			return sal_False;

		if ( pSlot )
		{
			// Slot geh"ort zum Container?
			bool bIsContainerSlot = pSlot->IsMode(SFX_SLOT_CONTAINER);
            bool bIsInPlace = pImp->pFrame && pImp->pFrame->GetObjectShell()->IsInPlaceActive();

			// Shell geh"ort zum Server?
			// AppDispatcher oder IPFrame-Dispatcher
			bool bIsServerShell = !pImp->pFrame || bIsInPlace;

			// Nat"urlich sind ServerShell-Slots auch ausf"uhrbar, wenn sie auf
			// einem Container-Dispatcher ohne IPClient ausgef"uhrt werden sollen.
			if ( !bIsServerShell )
			{
				SfxViewShell *pViewSh = pImp->pFrame->GetViewShell();
                bIsServerShell = !pViewSh || !pViewSh->GetUIActiveClient();
			}

			// Shell geh"ort zum Container?
			// AppDispatcher oder kein IPFrameDispatcher
			bool bIsContainerShell = !pImp->pFrame || !bIsInPlace;
			// Shell und Slot passen zusammen
			if ( !( ( bIsContainerSlot && bIsContainerShell ) ||
					( !bIsContainerSlot && bIsServerShell ) ) )
				pSlot = 0;
		}

#ifdef DBG_UTILx
		if ( pSlot )
		{
			String aMsg( nSlot );
			aMsg += " found in ";
			aMsg += pObjShell->GetInterface()->GetClassName();
			DbgTrace( aMsg.GetBuffer() );
		}
		else
		{
			aStack += " ";
			aStack += pObjShell->GetInterface()->GetClassName();
		}
#endif
		if ( pSlot && !IsAllowed( nSlot ) )
		{
			pSlot = NULL;
		}

		if ( pSlot )
		{
			rServer.SetSlot(pSlot);
			rServer.SetShellLevel(i);
			return sal_True;
		}
	}

#ifdef DBG_UTILx
	String aMsg( nSlot );
	aMsg += " not found in ";
	aMsg += aStack;
	DbgTrace( aMsg.GetBuffer() );
#endif
	return sal_False;
}

sal_Bool SfxDispatcher::HasSlot_Impl( sal_uInt16 nSlot )
{
	Flush();
	sal_uInt16 nTotCount = pImp->aStack.Count();

    if ( pImp->pParent && !pImp->pParent->pImp->pFrame )
    {
        // the last frame also uses the AppDispatcher
        nTotCount = nTotCount + pImp->aStack.Count();
    }

	if (nSlot >= SID_VERB_START && nSlot <= SID_VERB_END)
	{
        // Verb-Slot?
		for ( sal_uInt16 nShell = 0;; ++nShell )
		{
            SfxShell *pSh = GetShell(nShell);
            if ( pSh == NULL )
                return false;
			if ( pSh->ISA(SfxViewShell) )
				return true;
		}
	}

	// SID gegen gesetzten Filter pr"ufen
	sal_uInt16 nSlotEnableMode=0;
	if ( pImp->pFrame )
	{
		nSlotEnableMode = IsSlotEnabledByFilter_Impl( nSlot );
		if ( 0 == nSlotEnableMode )
			return sal_False;
	}

	// im Quiet-Mode nur Parent-Dispatcher
	if ( pImp->bQuiet )
		return sal_False;

	sal_Bool bReadOnly = ( 2 != nSlotEnableMode && pImp->bReadOnly );
//				( pImp->pFrame && pImp->pFrame->GetObjectShell());
//				  pImp->pFrame->GetObjectShell()->IsLoading() );

	for ( sal_uInt16 i=0 ; i < nTotCount; ++i )
	{
		SfxShell *pObjShell = GetShell(i);
		SfxInterface *pIFace = pObjShell->GetInterface();
		const SfxSlot *pSlot = pIFace->GetSlot(nSlot);
		if ( pSlot && pSlot->nDisableFlags && ( pSlot->nDisableFlags & pObjShell->GetDisableFlags() ) != 0 )
			return sal_False;

		if ( pSlot && !( pSlot->nFlags & SFX_SLOT_READONLYDOC ) && bReadOnly )
			return sal_False;

		if ( pSlot )
		{
			// Slot geh"ort zum Container?
			bool bIsContainerSlot = pSlot->IsMode(SFX_SLOT_CONTAINER);
            bool bIsInPlace = pImp->pFrame && pImp->pFrame->GetObjectShell()->IsInPlaceActive();

            // Shell geh"ort zum Server?
			// AppDispatcher oder IPFrame-Dispatcher
			bool bIsServerShell = !pImp->pFrame || bIsInPlace;

			// Nat"urlich sind ServerShell-Slots auch ausf"uhrbar, wenn sie auf
			// einem Container-Dispatcher ohne IPClient ausgef"uhrt werden sollen.
			if ( !bIsServerShell )
			{
				SfxViewShell *pViewSh = pImp->pFrame->GetViewShell();
                bIsServerShell = !pViewSh || !pViewSh->GetUIActiveClient();
			}

			// Shell geh"ort zum Container?
			// AppDispatcher oder kein IPFrameDispatcher
			bool bIsContainerShell = !pImp->pFrame || !bIsInPlace;

			// Shell und Slot passen zusammen
			if ( !( ( bIsContainerSlot && bIsContainerShell ) ||
					( !bIsContainerSlot && bIsServerShell ) ) )
				pSlot = 0;
		}

		if ( pSlot && !IsAllowed( nSlot ) )
			pSlot = NULL;

		if ( pSlot )
			return sal_True;
	}

	return sal_False;
}



//--------------------------------------------------------------------
sal_Bool SfxDispatcher::_FillState
(
	const SfxSlotServer& rSvr,		 // abzufragende <Slot-Server>
	SfxItemSet& 			rState, 	// zu f"ullendes <SfxItemSet>
	const SfxSlot*			pRealSlot	// ggf. der tats"achliche Slot
)

/*	[Beschreibung]

	Hilfsmethode zum Abfragen des Status des <Slot-Server>s rSvr.
	In rState m"ussen die gew"unschten Slots-Ids (teilweise in Which-Ids
	des betreffenden Pools umgewandelt) vorhanden sein.

	Der SfxDispatcher wird vor der Abfrage geflusht.
*/

{
	SFX_STACK(SfxDispatcher::_FillState);

	DBG_PROFSTART(SfxDispatcherFillState);

	const SfxSlot *pSlot = rSvr.GetSlot();
	if ( pSlot && IsLocked( pSlot->GetSlotId() ) )
	{
		pImp->bInvalidateOnUnlock = sal_True;
		DBG_PROFSTOP(SfxDispatcherFillState);
		return sal_False;
	}

	if ( pSlot )
	{
		DBG_ASSERT(bFlushed, "Dispatcher not flushed after retrieving slot servers!");
        if ( !bFlushed )
            return sal_False;
		// Flush();

		// Objekt ermitteln und Message an diesem Objekt aufrufen
		SfxShell *pSh = GetShell(rSvr.GetShellLevel());
		DBG_ASSERT(pSh, "ObjektShell nicht gefunden");

		SfxStateFunc pFunc;

		if (pRealSlot)
			pFunc = pRealSlot->GetStateFnc();
		else
			pFunc = pSlot->GetStateFnc();

		pSh->CallState( pFunc, rState );
#ifdef DBG_UTIL
		// pr"ufen, ob IDL (SlotMap) und aktuelle Items "ubereinstimmen
		if ( DbgIsAssertWarning() && rState.Count() )
		{
			SfxInterface *pIF = pSh->GetInterface();
			SfxItemIter aIter( rState );
			for ( const SfxPoolItem *pItem = aIter.FirstItem();
				  pItem;
				  pItem = aIter.NextItem() )
				if ( !IsInvalidItem(pItem) && !pItem->ISA(SfxVoidItem) )
				{
					sal_uInt16 nSlotId = rState.GetPool()->GetSlotId(pItem->Which());
					if ( !pItem->IsA(pIF->GetSlot(nSlotId)->GetType()->Type()) )
					{
						ByteString aMsg( "item-type unequal to IDL (=> no BASIC)" );
						aMsg += "\nwith SID: ";
						aMsg += ByteString::CreateFromInt32( nSlotId );
						aMsg += "\nin ";
						aMsg += pIF->GetClassName();
						DbgOut( aMsg.GetBuffer(), DBG_OUT_ERROR, __FILE__, __LINE__);
					}
				}
		}
#endif

		DBG_PROFSTOP(SfxDispatcherFillState);
		return sal_True;
	}

	DBG_PROFSTOP(SfxDispatcherFillState);
	return sal_False;
}

//--------------------------------------------------------------------
const SfxPoolItem* SfxDispatcher::_Execute( const SfxSlotServer &rSvr )

/*  [Beschreibung]

	Diese Methode f"uhrt einen Request "uber einen gecachten <Slot-Server>
	aus.
*/

{
	const SfxSlot *pSlot = rSvr.GetSlot();
	if ( IsLocked( pSlot->GetSlotId() ) )
		return 0;

	if ( pSlot )
	{
		Flush();

		if ( pSlot->IsMode(SFX_SLOT_ASYNCHRON) )
			//! ignoriert rSvr
		{
			SfxShell *pShell = GetShell( rSvr.GetShellLevel() );
			SfxDispatcher *pDispat = this;
			while ( pDispat )
			{
				sal_uInt16 nShellCount = pDispat->pImp->aStack.Count();
				for ( sal_uInt16 n=0; n<nShellCount; n++ )
					if ( pShell == pDispat->pImp->aStack.Top(n) )
					{
                        pDispat->pImp->xPoster->Post(
                            new SfxRequest( pSlot->GetSlotId(),
                                SFX_CALLMODE_RECORD, pShell->GetPool() ) );
//                        pDispat->pImp->xPoster->Post(new Executer(
//                                new SfxRequest( pSlot->GetSlotId(),
//                                    SFX_CALLMODE_RECORD, pShell->GetPool() ),
//                                pSlot, n ));
						return 0;
					}
			}
		}
		else
		{
			// Objekt ermitteln und Message an diesem Objekt aufrufen
			SfxShell *pSh = GetShell(rSvr.GetShellLevel());
			SfxRequest aReq( pSlot->GetSlotId(), SFX_CALLMODE_RECORD, pSh->GetPool() );
			if ( Call_Impl( *pSh, *pSlot, aReq, sal_True ) ) // von Bindings immer recorden
				return aReq.GetReturnValue();
		}
	}
	return 0;
}

//----------------------------------------------------------------------
void SfxDispatcher::ExecutePopup( sal_uInt16 nConfigId,
								  Window *pWin, const Point *pPos,
								  const SfxPoolItem *, ... )
{
    ExecutePopup( nConfigId, pWin, pPos );
}

SfxPopupMenuManager* SfxDispatcher::Popup( sal_uInt16 nConfigId,Window *pWin, const Point *pPos )
{
	SfxDispatcher &rDisp = *SFX_APP()->GetDispatcher_Impl();
	sal_uInt16 nShLevel = 0;
	SfxShell *pSh;
	nShLevel=0;

	if ( rDisp.pImp->bQuiet )
	{
		nConfigId = 0;
		nShLevel = rDisp.pImp->aStack.Count();
	}

	Window *pWindow = pWin ? pWin : rDisp.pImp->pFrame->GetFrame().GetWorkWindow_Impl()->GetWindow();
    for ( pSh = rDisp.GetShell(nShLevel); pSh; ++nShLevel, pSh = rDisp.GetShell(nShLevel) )
	{
		const ResId& rResId = pSh->GetInterface()->GetPopupMenuResId();
        if ( ( nConfigId == 0 && rResId.GetId() ) || ( nConfigId != 0 && rResId.GetId() == nConfigId ) )
		{
                return SfxPopupMenuManager::Popup( rResId, rDisp.GetFrame(), pPos ? *pPos : pWindow->GetPointerPosPixel(), pWindow );
		}
	}
	return 0;
}


//----------------------------------------------------------------------
void SfxDispatcher::ExecutePopup( sal_uInt16 nConfigId, Window *pWin, const Point *pPos )
{
    SfxDispatcher &rDisp = *SFX_APP()->GetDispatcher_Impl();
	sal_uInt16 nShLevel = 0;
	SfxShell *pSh;
/*
	const SvVerbList *pVerbList = 0;
	sal_uInt16 nMaxShellLevel = rDisp.pImp->aStack.Count();
	for ( pSh = rDisp.GetShell(nShLevel);
		  pSh && nShLevel < nMaxShellLevel ;
		  ++nShLevel, pSh = rDisp.GetShell(nShLevel) )
	{
        if ( pSh->GetVerbs() )
		{
			pVerbList = pSh->GetVerbs();
			break;
		}
    }
*/
	nShLevel=0;
	if ( rDisp.pImp->bQuiet )
	{
		nConfigId = 0;
		nShLevel = rDisp.pImp->aStack.Count();
	}

    Window *pWindow = pWin ? pWin : rDisp.pImp->pFrame->GetFrame().GetWorkWindow_Impl()->GetWindow();
    for ( pSh = rDisp.GetShell(nShLevel); pSh; ++nShLevel, pSh = rDisp.GetShell(nShLevel) )
	{
		const ResId& rResId = pSh->GetInterface()->GetPopupMenuResId();
        if ( ( nConfigId == 0 && rResId.GetId() ) || ( nConfigId != 0 && rResId.GetId() == nConfigId ) )
		{
            //SfxPopupMenuManager aPop( rResId.GetId(), *rDisp.GetBindings() );
            //aPop.SetResMgr(rResId.GetResMgr());
            //aPop.AddClipboardFunctions();
            //aPop.Initialize();
            //if ( pVerbList && pVerbList->Count() )
            //    aPop.InsertVerbs(pVerbList);
            //aPop.RemoveDisabledEntries();
            //aPop.Execute( pPos ? *pPos : pWindow->GetPointerPosPixel(), pWindow );
            SfxPopupMenuManager::ExecutePopup( rResId, rDisp.GetFrame(), pPos ? *pPos : pWindow->GetPointerPosPixel(), pWindow );
			return;
		}
	}
}

//----------------------------------------------------------------------
void SfxDispatcher::ExecutePopup( const ResId &rId, Window *pWin, const Point *pPos )
{
    Window *pWindow = pWin ? pWin : pImp->pFrame->GetFrame().GetWorkWindow_Impl()->GetWindow();
/*
	SfxPopupMenuManager aPop( rId, *GetBindings() );
	aPop.AddClipboardFunctions();
	aPop.Initialize();
	aPop.RemoveDisabledEntries();
    aPop.Execute( pPos ? *pPos : pWindow->GetPointerPosPixel(), pWindow );
*/
    SfxPopupMenuManager::ExecutePopup( rId, GetFrame(), pPos ? *pPos : pWindow->GetPointerPosPixel(), pWindow );
}

//--------------------------------------------------------------------
void SfxDispatcher::Lock( sal_Bool bLock )

/*  [Beschreibung]

	Mit dieser Methode kann der SfxDispatcher gesperrt und freigegeben
	werden. Ein gesperrter SfxDispatcher f"uhrt keine <SfxRequest>s mehr
	aus und liefert keine Status-Informationen mehr. Er verh"alt sich
	so als w"aren alle Slots disabled.
*/

{
    SfxBindings* pBindings = GetBindings();
	if ( !bLock && pImp->bLocked && pImp->bInvalidateOnUnlock )
	{
        if ( pBindings )
            pBindings->InvalidateAll(sal_True);
		pImp->bInvalidateOnUnlock = sal_False;
	}
    else if ( pBindings )
        pBindings->InvalidateAll(sal_False);
	pImp->bLocked = bLock;
    if ( !bLock )
    {
        sal_uInt16 nCount = pImp->aReqArr.Count();
        for ( sal_uInt16 i=0; i<nCount; i++ )
            pImp->xPoster->Post( pImp->aReqArr[i] );
        pImp->aReqArr.Remove( 0, nCount );
    }
}

sal_uInt32 SfxDispatcher::GetObjectBarId( sal_uInt16 nPos ) const
{
	return pImp->aObjBars[nPos].nResId;
}

//--------------------------------------------------------------------
void SfxDispatcher::ResetObjectBars_Impl()

/*  [Beschreibung]

	Mit dieser Methode werden alle Objectbar-Anforderungen, die dieser
	Dispatcher an das AppWindow hat, beseitigt.
*/
{
	for (sal_uInt16 n=0; n<SFX_OBJECTBAR_MAX; n++)
		pImp->aObjBars[n].nResId = 0;
	pImp->aChildWins.Remove(0, pImp->aChildWins.Count());
}


//--------------------------------------------------------------------
void SfxDispatcher::DebugOutput_Impl() const
{
#ifdef DBG_UTIL

	sal_uInt16 nOld = (sal_uInt16) DbgGetData()->nTraceOut;
	DbgGetData()->nTraceOut = DBG_OUT_FILE;

	if (bFlushed)
		DBG_TRACE("Flushed");
	if (pImp->bUpdated)
		DBG_TRACE("Updated");

	for ( sal_uInt16 nShell = pImp->aStack.Count(); nShell > 0; --nShell )
	{
		SfxShell *pShell = GetShell(nShell-1);
		const SfxInterface *pIFace = pShell->GetInterface();
		DBG_TRACE (pIFace->GetClassName());
	}

	DbgGetData()->nTraceOut = nOld;

#endif
}

void SfxDispatcher::LockUI_Impl( sal_Bool bLock )
{
	sal_Bool bWasLocked = pImp->bUILocked;
	pImp->bUILocked = bLock;
	if ( !bLock && bWasLocked )
		Update_Impl( sal_True );
}

//-------------------------------------------------------------------------
void SfxDispatcher::HideUI( sal_Bool bHide )
{
//	if ( !bHide && pImp->bReadOnly )
//		bHide = sal_True;
	sal_Bool bWasHidden = pImp->bNoUI;
	pImp->bNoUI = bHide;
	if ( pImp->pFrame )
	{
        SfxViewFrame* pTop = pImp->pFrame->GetTopViewFrame();
        if ( pTop && pTop->GetBindings().GetDispatcher() == this )
        {
			SfxFrame& rFrame = pTop->GetFrame();
            if ( rFrame.IsMenuBarOn_Impl() )
            {
                com::sun::star::uno::Reference < com::sun::star::beans::XPropertySet > xPropSet( rFrame.GetFrameInterface(), com::sun::star::uno::UNO_QUERY );
                if ( xPropSet.is() )
                {
                    com::sun::star::uno::Reference< ::com::sun::star::frame::XLayoutManager > xLayoutManager;
                    com::sun::star::uno::Any aValue = xPropSet->getPropertyValue( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" )));
                    aValue >>= xLayoutManager;
                    if ( xLayoutManager.is() )
                        xLayoutManager->setVisible( !bHide );
                }
            }
        }
    }

	if ( bHide != bWasHidden )
		Update_Impl( sal_True );
}

void SfxDispatcher::SetReadOnly_Impl( sal_Bool bOn )
{
	pImp->bReadOnly = bOn;
//	pImp->bNoUI = bOn;
}

sal_Bool SfxDispatcher::GetReadOnly_Impl() const
{
	return pImp->bReadOnly;
}

//-------------------------------------------------------------------------
void SfxDispatcher::SetQuietMode_Impl( sal_Bool bOn )

/*	[Beschreibung]

	Bei 'bOn' stellt sich dieser Dispatcher quasi tot und leitet alles
	an den Parent-Dispatcher weiter.
*/

{
	pImp->bQuiet = bOn;
    SfxBindings* pBindings = GetBindings();
    if ( pBindings )
        pBindings->InvalidateAll(sal_True);
}

//-------------------------------------------------------------------------
void SfxDispatcher::SetModalMode_Impl( sal_Bool bOn )

/*	[Beschreibung]

	Bei 'bOn' werden nur noch Slots des Parent-Dispatchers gefunden.
*/

{
	pImp->bModal = bOn;
    SfxBindings* pBindings = GetBindings();
    if ( pBindings )
        pBindings->InvalidateAll(sal_True);
}

void SfxDispatcher::SetExecuteMode( sal_uInt16 nMode )
{
	pImp->nStandardMode = nMode;
}

SfxItemState SfxDispatcher::QueryState( sal_uInt16 nSlot, const SfxPoolItem* &rpState )
{
	SfxShell *pShell = 0;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSlot, &pShell, &pSlot, sal_False, sal_False ) )
	{
		rpState = pShell->GetSlotState(nSlot);
		if ( !rpState )
			return SFX_ITEM_DISABLED;
		else
			return SFX_ITEM_AVAILABLE;
	}

	return SFX_ITEM_DISABLED;
}

SfxItemState SfxDispatcher::QueryState( sal_uInt16 nSID, ::com::sun::star::uno::Any& rAny )
{
	SfxShell *pShell = 0;
	const SfxSlot *pSlot = 0;
	if ( GetShellAndSlot_Impl( nSID, &pShell, &pSlot, sal_False, sal_False ) )
	{
        const SfxPoolItem* pItem( 0 );

        pItem = pShell->GetSlotState( nSID );
		if ( !pItem )
			return SFX_ITEM_DISABLED;
        else
        {
            ::com::sun::star::uno::Any aState;
            if ( !pItem->ISA(SfxVoidItem) )
            {
                sal_uInt16 nSubId( 0 );
                SfxItemPool& rPool = pShell->GetPool();
                sal_uInt16 nWhich = rPool.GetWhich( nSID );
                if ( rPool.GetMetric( nWhich ) == SFX_MAPUNIT_TWIP )
                    nSubId |= CONVERT_TWIPS;
                pItem->QueryValue( aState, (sal_uInt8)nSubId );
            }
            rAny = aState;

            return SFX_ITEM_AVAILABLE;
        }
	}

	return SFX_ITEM_DISABLED;
}

sal_Bool SfxDispatcher::IsReadOnlyShell_Impl( sal_uInt16 nShell ) const
{
	sal_uInt16 nShellCount = pImp->aStack.Count();
	if ( nShell < nShellCount )
	{
        SfxShell* pShell = pImp->aStack.Top( nShell );
        if( pShell->ISA( SfxModule ) || pShell->ISA( SfxApplication ) || pShell->ISA( SfxViewFrame ) )
            return sal_False;
        else
            return pImp->bReadOnly;
	}
	else if ( pImp->pParent )
		return pImp->pParent->IsReadOnlyShell_Impl( nShell - nShellCount );
	return sal_True;
}

// Ein dirty trick, um an die Methoden der private base class von
// SfxShellStack_Impl heranzukommen
class StackAccess_Impl : public SfxShellStack_Implarr_
{};

void SfxDispatcher::InsertShell_Impl( SfxShell& rShell, sal_uInt16 nPos )
{
	Flush();

	// Der cast geht, weil SfxShellStack_Impl keine eigenen member hat
	((StackAccess_Impl*) (&pImp->aStack))->Insert( nPos, &rShell );
	rShell.SetDisableFlags( pImp->nDisableFlags );
	rShell.DoActivate_Impl(pImp->pFrame, sal_True);

	if ( !SFX_APP()->IsDowning() )
	{
		pImp->bUpdated = sal_False;
		pImp->pCachedServ1 = 0;
		pImp->pCachedServ2 = 0;
		InvalidateBindings_Impl(sal_True);
	}
}

void SfxDispatcher::RemoveShell_Impl( SfxShell& rShell )
{
	Flush();

	// Der cast geht, weil SfxShellStack_Impl keine eigenen member hat
	StackAccess_Impl& rStack = *((StackAccess_Impl*) (&pImp->aStack));
	sal_uInt16 nCount = rStack.Count();
	for ( sal_uInt16 n=0; n<nCount; ++n )
	{
		if ( rStack[n] == &rShell )
		{
			rStack.Remove( n );
			rShell.SetDisableFlags( 0 );
			rShell.DoDeactivate_Impl(pImp->pFrame, sal_True);
			break;
		}
	}

	if ( !SFX_APP()->IsDowning() )
	{
		pImp->bUpdated = sal_False;
		pImp->pCachedServ1 = 0;
		pImp->pCachedServ2 = 0;
		InvalidateBindings_Impl(sal_True);
	}
}

sal_Bool SfxDispatcher::IsAllowed
(
	sal_uInt16 nSlot
) const
/*
	[Beschreibung]
	Die Methode prueft, ob der Zugriff auf diese Schnittstelle erlaubt ist.
	*/
{
	if ( !pImp->pDisableList )
	{
		return sal_True;
	}

	// BinSearch in der DisableListe
	SvUShorts& rList = *pImp->pDisableList;
	sal_uInt16 nCount = rList.Count();
	sal_uInt16 nLow = 0, nMid = 0, nHigh;
	sal_Bool bFound = sal_False;
	nHigh = nCount - 1;

	while ( !bFound && nLow <= nHigh )
	{
		nMid = (nLow + nHigh) >> 1;
		DBG_ASSERT( nMid < nCount, "bsearch ist buggy" );

		int nDiff = (int) nSlot - (int) rList[nMid];
		if ( nDiff < 0)
		{
			if ( nMid == 0 )
				break;
			nHigh = nMid - 1;
		}
		else if ( nDiff > 0 )
		{
			nLow = nMid + 1;
			if ( nLow == 0 )
				break;
		}
		else
			bFound = sal_True;
	}

#ifdef _DEBUG
	// Slot in der Liste gefunden ?
	sal_uInt16 nPos = bFound ? nMid : nLow;

	DBG_ASSERT( nPos <= nCount, "" );
	DBG_ASSERT( nPos == nCount || nSlot <= rList[nPos], "" );
	DBG_ASSERT( nPos == 0 || nSlot > rList[nPos-1], "" );
	DBG_ASSERT( ( (nPos+1) >= nCount ) || nSlot < rList[nPos+1], "" );
#endif

	return !bFound;
}

void SfxDispatcher::InvalidateBindings_Impl( sal_Bool bModify )
{
	// App-Dispatcher?
	if ( IsAppDispatcher() )
	{
		for ( SfxViewFrame *pFrame = SfxViewFrame::GetFirst();
				pFrame;
				pFrame = SfxViewFrame::GetNext( *pFrame ) )
			pFrame->GetBindings().InvalidateAll(bModify);
	}
	else
	{
		SfxDispatcher *pDisp = GetBindings()->GetDispatcher_Impl();
		while ( pDisp )
		{
			if ( pDisp == this )
			{
				GetBindings()->InvalidateAll( bModify );
				break;
			}

			pDisp = pDisp->pImp->pParent;
		}
	}
}

sal_Bool SfxDispatcher::IsUpdated_Impl() const
{
	return pImp->bUpdated;
}

void SfxDispatcher::SetDisableFlags( sal_uInt32 nFlags )
{
	pImp->nDisableFlags = nFlags;
	for ( int i = int(pImp->aStack.Count()) - 1; i >= 0; --i )
		pImp->aStack.Top( (sal_uInt16) i )->SetDisableFlags( nFlags );
}

sal_uInt32 SfxDispatcher::GetDisableFlags() const
{
	return pImp->nDisableFlags;
}

SfxModule* SfxDispatcher::GetModule() const
{
	for ( sal_uInt16 nShell = 0;; ++nShell )
	{
        SfxShell *pSh = GetShell(nShell);
        if ( pSh == NULL )
            return 0;
		if ( pSh->ISA(SfxModule) )
			return (SfxModule*) pSh;
	}
}