/************************************************************** * * 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 #include #include #include #include #include #include #ifndef _SFXEITEM_HXX //autogen #include #endif #include #ifndef _WRKWIN_HXX //autogen #include #endif #include #include #include #include // wg. bsearch #define _SVSTDARR_ULONGS #include #include #include #include #ifndef GCC #endif // wg. nAutoPageID #include "appdata.hxx" #include "sfx2/sfxhelp.hxx" #include #include #include #include #include #include #include #include #include "slotserv.hxx" #include #include "sfxtypes.hxx" #include #include #include #include #include #include #include #include #include #include #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 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 () 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; naObjBars[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 -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 -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 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 () und die 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 oder Bewegungen auf dem Stack ( und 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 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 , 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 Instanz zur"uck, an die der SfxDispatcher gerade gebunden ist. Ein SfxDispatcher ist nur dann an SfxBindings gebunden, wenn er ist. Ist er nicht UI-aktiv, wird ein 0-Pointer zur"uckgegeben. Der zur"uckgegebene Pointer ist nur im des Methodenaufrufs g"ultig. */ { if ( pImp->pFrame ) return &pImp->pFrame->GetBindings(); else return NULL; } //-------------------------------------------------------------------- SfxViewFrame* SfxDispatcher::GetFrame() const /* [Beschreibung] Liefert einen Pointer auf die 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 -Dispatchers oder selbst, wird er nie als ganzes Aktiviert, sondern nur seine einzelnen s bei . Beim Aktivieren eines SfxDispatchers wird an allen auf seinem Stack befindlichen SfxShells, beginnend mit der untersten, der Handler 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 -Dispatchers oder selbst, wird er nie als ganzes Deaktiviert, sondern nur seine einzelnen s bei . Beim Deaktivieren eines SfxDispatchers wird an allen auf seinem Stack befindlichen SfxShells, beginnend mit der obersten, der Handler 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; naChildWins.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 , 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 const SfxSlot& rSlot, // zu rufender 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 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; npImp->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 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 // mit Parametern ) /* [Beschreibung] Methode zum Ausf"uhren eines 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 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 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 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; naObjBars[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 && nNoGetObjectBarCount(); ++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 && nNoGetChildWindowCount(); 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; nPosaFixedObjBars[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; naFixedObjBars[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 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 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 -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 -Instanz sal_Bool bModal // trotz ModalMode ) /* [Beschreibung] Diese Hilfsmethode sucht den , 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 SfxItemSet& rState, // zu f"ullendes const SfxSlot* pRealSlot // ggf. der tats"achliche Slot ) /* [Beschreibung] Hilfsmethode zum Abfragen des Status des 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 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; npImp->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 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; ixPoster->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; naObjBars[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; npFrame, 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; } }