| /************************************************************** |
| * |
| * 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; |
| } |
| } |
