xref: /aoo42x/main/sfx2/source/control/shell.cxx (revision 24c56ab9)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sfx2.hxx"
26 #include <com/sun/star/embed/VerbDescriptor.hpp>
27 #include <com/sun/star/embed/VerbAttributes.hpp>
28 #include <basic/sbstar.hxx>
29 #include <svl/itempool.hxx>
30 #include <svl/undo.hxx>
31 #include <svtools/itemdel.hxx>
32 #include <svtools/asynclink.hxx>
33 #include <basic/sbx.hxx>
34 
35 #include <unotools/undoopt.hxx>
36 
37 #ifndef GCC
38 #endif
39 
40 #include <sfx2/app.hxx>
41 #include <sfx2/shell.hxx>
42 #include <sfx2/bindings.hxx>
43 #include <sfx2/dispatch.hxx>
44 #include <sfx2/viewfrm.hxx>
45 #include <sfx2/objface.hxx>
46 #include <sfx2/objsh.hxx>
47 #include <sfx2/viewsh.hxx>
48 #include <sfx2/dispatch.hxx>
49 #include "sfxtypes.hxx"
50 #include <sfx2/request.hxx>
51 #include <sfx2/mnumgr.hxx>
52 #include "statcach.hxx"
53 #include <sfx2/msgpool.hxx>
54 #include <sfx2/sidebar/ContextChangeBroadcaster.hxx>
55 
56 //====================================================================
57 
58 DBG_NAME(SfxShell)
59 
60 //====================================================================
61 
62 TYPEINIT0(SfxShell);
63 
64 //====================================================================
65 typedef SfxSlot* SfxSlotPtr;
66 SV_DECL_PTRARR_DEL( SfxVerbSlotArr_Impl, SfxSlotPtr, 4, 4)
67 SV_IMPL_PTRARR( SfxVerbSlotArr_Impl, SfxSlotPtr);
68 
69 using namespace com::sun::star;
70 
71 //=========================================================================
72 // SfxShell_Impl
73 //=========================================================================
74 struct SfxShell_Impl: public SfxBroadcaster
75 {
76 	String                      aObjectName;// Name des Sbx-Objects
77 	SfxItemArray_Impl           aItems;     // Datenaustausch auf Item-Basis
78     SfxViewShell*               pViewSh;    // SfxViewShell falls Shell ViewFrame/ViewShell/SubShell ist
79 	SfxViewFrame*               pFrame;     // Frame, falls <UI-aktiv>
80 	SfxRepeatTarget*            pRepeatTarget;
81 //    SbxObjectRef                xParent;
82 	sal_Bool						bInAppBASIC;
83 	sal_Bool                        bActive;
84 	sal_uIntPtr						nDisableFlags;
85 	sal_uIntPtr                       nHelpId;
86     svtools::AsynchronLink*     pExecuter;
87     svtools::AsynchronLink*     pUpdater;
88     SfxVerbSlotArr_Impl         aSlotArr;
89     com::sun::star::uno::Sequence < com::sun::star::embed::VerbDescriptor > aVerbList;
90     ::sfx2::sidebar::ContextChangeBroadcaster maContextChangeBroadcaster;
91 
SfxShell_ImplSfxShell_Impl92 	SfxShell_Impl()  : pExecuter( 0 ), pUpdater( 0 ) {}
~SfxShell_ImplSfxShell_Impl93 	~SfxShell_Impl() { delete pExecuter; delete pUpdater;}
94 };
95 
96 //====================================================================
97 #ifdef DBG_UTIL
98 
SfxShellIdent_Impl(const SfxShell * pSh)99 String SfxShellIdent_Impl( const SfxShell *pSh )
100 
101 /*  [Beschreibung]
102 
103 	Interne Hilfesfunktion. Liefert einen die SfxShell 'pSh' beschreibenden
104 	String zur"uck. Z.B.: SfxApplication[StarWriter]
105 */
106 
107 {
108 	String aIdent( pSh->ISA(SfxApplication) ? DEFINE_CONST_UNICODE("SfxApplication") :
109 				   pSh->ISA(SfxViewFrame) ? DEFINE_CONST_UNICODE("SfxViewFrame") :
110 				   pSh->ISA(SfxViewShell) ? DEFINE_CONST_UNICODE("SfxViewShell") :
111 				   pSh->ISA(SfxObjectShell) ? DEFINE_CONST_UNICODE("SfxObjectShell") : DEFINE_CONST_UNICODE("SfxShell") );
112 	aIdent += '[';
113 	aIdent += pSh->GetName();
114 	aIdent += ']';
115 	return aIdent;
116 }
117 
118 #endif
119 //====================================================================
120 
121 //=========================================================================
122 // SfxShell
123 //=========================================================================
124 
EmptyExecStub(SfxShell *,SfxRequest &)125 void __EXPORT SfxShell::EmptyExecStub(SfxShell *, SfxRequest &)
126 {
127 }
128 
EmptyStateStub(SfxShell *,SfxItemSet &)129 void __EXPORT SfxShell::EmptyStateStub(SfxShell *, SfxItemSet &)
130 {
131 }
132 
SfxShell()133 SfxShell::SfxShell()
134 
135 /*  [Beschreibung]
136 
137 	Der Konstruktor der Klasse SfxShell initialisierung nur einfache
138 	Typen, das dazugeh"orige SbxObject wird erst on-demand erzeugt.
139 	Daher ist das Anlegen einer SfxShell Instanz sehr billig.
140 */
141 
142 :	pImp(0),
143     pPool(0),
144 	pUndoMgr(0)
145 {
146 	DBG_CTOR(SfxShell, 0);
147 	pImp = new SfxShell_Impl;
148 	pImp->pViewSh = 0;
149 	pImp->pFrame = 0;
150 	pImp->pRepeatTarget = 0;
151 	pImp->bInAppBASIC = sal_False;
152 	pImp->nHelpId = 0L;
153 	pImp->bActive = sal_False;
154 	pImp->nDisableFlags = 0;
155 }
156 
157 //-------------------------------------------------------------------------
158 
SfxShell(SfxViewShell * pViewSh)159 SfxShell::SfxShell( SfxViewShell *pViewSh )
160 
161 /*  [Beschreibung]
162 
163 	Der Konstruktor der Klasse SfxShell initialisierung nur einfache
164 	Typen, das dazugeh"orige SbxObject wird erst on-demand erzeugt.
165 	Daher ist das Anlegen einer SfxShell Instanz sehr billig.
166 */
167 
168 :	pImp(0),
169     pPool(0),
170 	pUndoMgr(0)
171 {
172 	DBG_CTOR(SfxShell, 0);
173 	pImp = new SfxShell_Impl;
174 	pImp->pViewSh = pViewSh;
175 	pImp->pFrame = 0;
176 	pImp->pRepeatTarget = 0;
177 	pImp->bInAppBASIC = sal_False;
178 	pImp->nHelpId = 0L;
179 	pImp->bActive = sal_False;
180 }
181 
182 //--------------------------------------------------------------------
183 
~SfxShell()184 SfxShell::~SfxShell()
185 
186 /*  [Beschreibung]
187 
188 	Die Verbindungs zu einem ggf. zugeh"origen SbxObject wird gel"ost.
189 	Das SbxObject existiert ggf. weiter, kann aber keine Funktionen
190 	mehr ausf"uhren und keine Properties mehr bereitstellen.
191 */
192 
193 {
194 	DBG_DTOR(SfxShell, 0);
195 
196 
197 	delete pImp;
198 }
199 
200 //--------------------------------------------------------------------
201 
SetName(const String & rName)202 void SfxShell::SetName( const String &rName )
203 
204 /*  [Beschreibung]
205 
206 	Setzt den Namen des Shell-Objekts. Mit diesem Namen kann die
207 	SfxShell-Instanz vom BASIC aus angesprochen werden.
208 */
209 
210 {
211 	pImp->aObjectName = rName;
212 }
213 
214 //--------------------------------------------------------------------
215 
GetName() const216 const String& SfxShell::GetName() const
217 
218 /*  [Beschreibung]
219 
220 	Liefert den Namen des Shell-Objekts. Mit diesem Namen kann die
221 	SfxShell-Instanz vom BASIC aus angesprochen werden.
222 */
223 
224 {
225 	return pImp->aObjectName;
226 }
227 
228 //--------------------------------------------------------------------
229 
GetGlobalName() const230 SvGlobalName SfxShell::GetGlobalName() const
231 
232 /*  [Beschreibung]
233 
234 	Liefert den Global Unique Identifier des Shell-Objekts. Mit diesem
235 	Namen kann die SfxShell-Instanz z.B. via OLE Automation angesprochen
236 	werden, bzw. in der Registration-Database gefunden werden.
237 */
238 
239 {
240 	return SvGlobalName();
241 }
242 
243 //--------------------------------------------------------------------
244 
GetDispatcher() const245 SfxDispatcher* SfxShell::GetDispatcher() const
246 
247 /*  [Beschreibung]
248 
249 	Diese Methode liefert einen Pointer auf den <SfxDispatcher>, in
250 	dem die SfxShell gerade <UI-aktiv> ist bzw. einen 0-Pointer, wenn
251 	sie gerade nicht UI-aktiv ist.
252 
253 	Der zur"uckgegebene Pointer ist nur im unmittelbaren Kontext des
254 	Methodenaufrufs g"ultig.
255 */
256 
257 {
258 	return pImp->pFrame ? pImp->pFrame->GetDispatcher() : 0;
259 }
260 
261 //--------------------------------------------------------------------
262 
GetViewShell() const263 SfxViewShell* SfxShell::GetViewShell() const
264 
265 /*  [Beschreibung]
266 
267 	Liefert bei SubShells die SfxViewShell, in der sie liegen. Sonst und
268 	falls nicht vom App-Entwickler angegeben liefert diese Methode 0.
269 */
270 
271 {
272 	return pImp->pViewSh;
273 }
274 
275 //--------------------------------------------------------------------
276 
GetFrame() const277 SfxViewFrame* SfxShell::GetFrame() const
278 
279 /*  [Beschreibung]
280 
281 	Diese Methode liefert einen Pointer auf den <SfxViewFrame>, dem diese
282 	SfxShell-Instanz zugeordnet ist oder in dem sie zur Zeit <UI-aktiv> ist.
283 	Ein 0-Pointer wird geliefert, wenn diese SfxShell-OInstanz gerade nicht
284 	UI-aktiv ist und auch keinem SfxViewFrame fest zugeordnet ist.
285 
286 	Der zur"uckgegebene Pointer ist nur im unmittelbaren Kontext des
287 	Methodenaufrufs g"ultig.
288 
289 
290 	[Anmerkung]
291 
292 	Nur Instanzen von Subklasse von SfxApplication und SfxObjectShell sollten
293 	hier einen 0-Pointer liefern. Ansonsten liegt ein Fehler im Anwendungs-
294 	programm vor (falscher Ctor von SfxShell gerufen).
295 
296 
297 	[Querverweise]
298 
299 	<SfxViewShell::GetViewFrame()const>
300 */
301 
302 {
303 	if ( pImp->pFrame )
304 		return pImp->pFrame;
305 	if ( pImp->pViewSh )
306 		return pImp->pViewSh->GetViewFrame();
307 	return 0;
308 }
309 
310 //--------------------------------------------------------------------
311 
GetItem(sal_uInt16 nSlotId) const312 const SfxPoolItem* SfxShell::GetItem
313 (
314 	sal_uInt16  nSlotId         // Slot-Id des zu erfragenden <SfxPoolItem>s
315 )   const
316 
317 /*  [Beschreibung]
318 
319 	Mit dieser Methode kann auf beliebige Objekte von Subklassen von
320 	<SfxPoolItem> zugegriffen werden. Diese Austauschtechnik wird ben"otigt,
321 	wenn z.B. spezielle <SfxToolBoxControl> Subklassen Zugriff auf
322 	bestimmte Daten z.B. der <SfxObjectShell> ben"otigen.
323 
324 	Die zur"uckgelieferte Instanz geh"ort der jeweilige SfxShell und
325 	darf nur im unmittelbaren Kontext des Methodenaufrufs verwendet werden.
326 
327 
328 	[Querverweise]
329 
330 	<SfxShell::PutItem(const SfxPoolItem&)>
331 	<SfxShell::RemoveItem(sal_uInt16)>
332 */
333 
334 {
335 	for ( sal_uInt16 nPos = 0; nPos < pImp->aItems.Count(); ++nPos )
336 		if ( pImp->aItems.GetObject(nPos)->Which() == nSlotId )
337 			return pImp->aItems.GetObject(nPos);
338 	return 0;
339 }
340 
341 //--------------------------------------------------------------------
342 
RemoveItem(sal_uInt16 nSlotId)343 void SfxShell::RemoveItem
344 (
345 	sal_uInt16  nSlotId         // Slot-Id des zu l"oschenden <SfxPoolItem>s
346 )
347 
348 /*  [Beschreibung]
349 
350 	Mit dieser Methode k"onnen die allgemein zur Verf"ugung gestellten
351 	Instanzen von Subklassen von <SfxPoolItem> aus der SfxShell entfernt
352 	werden.
353 
354 	Die gespeicherte Instanz wird gel"oscht.
355 
356 
357 	[Querverweise]
358 
359 	<SfxShell::PutItem(const SfxPoolItem&)>
360 	<SfxShell::GetItem(sal_uInt16)>
361 */
362 
363 {
364 	for ( sal_uInt16 nPos = 0; nPos < pImp->aItems.Count(); ++nPos )
365 		if ( pImp->aItems.GetObject(nPos)->Which() == nSlotId )
366 		{
367 			// Item entfernen und l"oschen
368 			SfxPoolItem *pItem = pImp->aItems.GetObject(nPos);
369 			delete pItem;
370 			pImp->aItems.Remove(nPos);
371 
372 			// falls aktiv Bindings benachrichtigen
373 			SfxDispatcher *pDispat = GetDispatcher();
374 			if ( pDispat )
375 			{
376 				SfxVoidItem aVoid( nSlotId );
377 				pDispat->GetBindings()->Broadcast( SfxPoolItemHint( &aVoid ) );
378 			}
379 		}
380 }
381 
382 //--------------------------------------------------------------------
383 
PutItem(const SfxPoolItem & rItem)384 void SfxShell::PutItem
385 (
386 	const SfxPoolItem&  rItem   /*  Instanz, von der eine Kopie erstellt wird,
387 									die in der SfxShell in einer Liste
388 									gespeichert wird. */
389 )
390 
391 /*  [Beschreibung]
392 
393 	Mit dieser Methode k"onnen beliebige Objekte von Subklassen von
394 	<SfxPoolItem> zur Verf"ugung gestellt werden. Diese Austauschtechnik
395 	wird ben"otigt, wenn z.B. spezielle <SfxToolBoxControl> Subklassen
396 	Zugriff auf bestimmte Daten z.B. der <SfxObjectShell> ben"otigen.
397 
398 	Falls ein SfxPoolItem mit derselben Slot-Id exisitert, wird dieses
399 	automatisch gel"oscht.
400 
401 
402 	[Querverweise]
403 
404 	<SfxShell::RemoveItem(sal_uInt16)>
405 	<SfxShell::GetItem(sal_uInt16)>
406 */
407 
408 {
409 	DBG_ASSERT( !rItem.ISA(SfxSetItem), "SetItems aren't allowed here" );
410 	DBG_ASSERT( SfxItemPool::IsSlot( rItem.Which() ),
411 				"items with Which-Ids aren't allowed here" );
412 
413 	// MSC auf WNT/W95 machte hier Mist, Vorsicht bei Umstellungen
414 	const SfxPoolItem *pItem = rItem.Clone();
415 	SfxPoolItemHint aItemHint( (SfxPoolItem*) pItem );
416 	const sal_uInt16 nWhich = rItem.Which();
417 	SfxPoolItem **ppLoopItem = (SfxPoolItem**) pImp->aItems.GetData();
418 	sal_uInt16 nPos;
419 	for ( nPos = 0; nPos < pImp->aItems.Count(); ++nPos, ++ppLoopItem )
420 	{
421 		if ( (*ppLoopItem)->Which() == nWhich )
422 		{
423 			// Item austauschen
424 			delete *ppLoopItem;
425 			pImp->aItems.Remove(nPos);
426 			pImp->aItems.Insert( (SfxPoolItemPtr) pItem, nPos );
427 
428 			// falls aktiv Bindings benachrichtigen
429 			SfxDispatcher *pDispat = GetDispatcher();
430 			if ( pDispat )
431             {
432                 SfxBindings* pBindings = pDispat->GetBindings();
433                 pBindings->Broadcast( aItemHint );
434                 sal_uInt16 nSlotId = nWhich; //pItem->GetSlotId();
435                 SfxStateCache* pCache = pBindings->GetStateCache( nSlotId );
436                 if ( pCache )
437                 {
438                     pCache->SetState( SFX_ITEM_AVAILABLE, pItem->Clone(), sal_True );
439                     pCache->SetCachedState( sal_True );
440                 }
441             }
442             return;
443 		}
444 	}
445 
446 	Broadcast( aItemHint );
447 	pImp->aItems.Insert((SfxPoolItemPtr)pItem, nPos );
448 }
449 
450 //--------------------------------------------------------------------
451 
GetInterface() const452 SfxInterface* SfxShell::GetInterface() const
453 
454 /*  [Beschreibung]
455 
456 	Mit dieser virtuellen Methode, die durch das Makro <SFX_DECL_INTERFACE>
457 	von jeder Subclass mit eigenen Slots automatisch "uberladen wird, kann
458 	auf die zu der Subklasse geh"orende <SfxInterface>-Instanz zugegriffen
459 	werden.
460 
461 	Die Klasse SfxShell selbst hat noch kein eigenes SfxInterface
462 	(keine Slots), daher wird ein 0-Pointer zur"uckgeliefert.
463 */
464 
465 {
466     return GetStaticInterface();
467 }
468 
469 //--------------------------------------------------------------------
470 
GetBroadcaster()471 SfxBroadcaster* SfxShell::GetBroadcaster()
472 
473 /*	[Beschreibung]
474 
475 	Liefert einen SfxBroadcaster f"ur diese SfxShell-Instanz bis die
476 	Klasse SfxShell von SfxBroadcaster abgeleitet ist.
477 */
478 
479 {
480 	return pImp;
481 }
482 
483 //--------------------------------------------------------------------
484 
GetUndoManager()485 ::svl::IUndoManager* SfxShell::GetUndoManager()
486 
487 /*  [Beschreibung]
488 
489 	Jede Subclass von SfxShell kann "uber einen <SfxUndoManager> verf"ugen.
490 	Dieser kann in den abgeleiteten Klasse mit <SfxShell:SetUndoManager()>
491 	gesetzt werden.
492 
493 	Die Klasse SfxShell selbst hat noch keinen SfxUndoManager, es wird
494 	daher ein 0-Pointer zur"uckgeliefert.
495 */
496 
497 {
498 	return pUndoMgr;
499 }
500 
501 //--------------------------------------------------------------------
502 
SetUndoManager(::svl::IUndoManager * pNewUndoMgr)503 void SfxShell::SetUndoManager( ::svl::IUndoManager *pNewUndoMgr )
504 
505 /*  [Beschreibung]
506 
507 	Setzt einen <SfxUndoManager> f"ur diese <SfxShell> Instanz. F"ur das
508 	Undo wird immer nur der Undo-Manager an der jeweils oben auf dem
509 	Stack des <SfxDispatcher> liegenden SfxShell verwendet.
510 
511 	Am "ubergebenen <SfxUndoManager> wird automatisch die aktuelle
512 	Max-Undo-Action-Count Einstellung aus den Optionen gesetzt.
513 
514 	'pNewUndoMgr' mu\s bis zum Dtor dieser SfxShell-Instanz oder bis
515 	zum n"achsten 'SetUndoManager()' existieren.
516 */
517 
518 {
519     OSL_ENSURE( ( pUndoMgr == NULL ) || ( pNewUndoMgr == NULL ) || ( pUndoMgr == pNewUndoMgr ),
520         "SfxShell::SetUndoManager: exchanging one non-NULL manager with another non-NULL manager? Suspicious!" );
521     // there's at least one client of our UndoManager - the DocumentUndoManager at the SfxBaseModel - which
522     // caches the UndoManager, and registers itself as listener. If exchanging non-NULL UndoManagers is really
523     // a supported scenario (/me thinks it is not), then we would need to notify all such clients instances.
524 
525 	pUndoMgr = pNewUndoMgr;
526 	if ( pUndoMgr )
527         pUndoMgr->SetMaxUndoActionCount( (sal_uInt16) SvtUndoOptions().GetUndoCount() );
528 }
529 
530 //--------------------------------------------------------------------
531 
GetRepeatTarget() const532 SfxRepeatTarget* SfxShell::GetRepeatTarget() const
533 
534 /*  [Beschreibung]
535 
536 	Liefert einen Pointer auf die <SfxRepeatTarget>-Instanz, die
537 	als RepeatTarget bei SID_REPEAT verwendet wird, wenn der
538 	von dieser SfxShell gelieferte <SfxUndoManager> angesprochen wird.
539 	Der R"uckgabewert kann 0 sein.
540 
541 
542 	[Anmerkung]
543 
544 	Eine Ableitung von <SfxShell> oder einer ihrer Subklassen von
545 	<SfxRepeatTarget> ist nicht zu empfehlen, da Compiler-Fehler
546 	provoziert werden (wegen Call-to-Pointer-to-Member-Function to
547 	subclass).
548 */
549 
550 {
551 	return pImp->pRepeatTarget;
552 }
553 
554 //--------------------------------------------------------------------
555 
SetRepeatTarget(SfxRepeatTarget * pTarget)556 void SfxShell::SetRepeatTarget( SfxRepeatTarget *pTarget )
557 
558 /*  [Beschreibung]
559 
560 	Setzt den die <SfxRepeatTarget>-Instanz, die bei SID_REPEAT als
561 	RepeatTarget verwendet wird, wenn der von dieser SfxShell gelieferte
562 	<SfxUndoManager> angesprochen wird. Durch 'pTarget==0' wird SID_REPEAT
563 	f"ur diese SfxShell disabled. Die Instanz '*pTarget' mu\s so lange
564 	leben, wie sie angemeldet ist.
565 
566 
567 	[Anmerkung]
568 
569 	Eine Ableitung von <SfxShell> oder einer ihrer Subklassen von
570 	<SfxRepeatTarget> ist nicht zu empfehlen, da Compiler-Fehler
571 	provoziert werden (wegen Call-to-Pointer-to-Member-Function to
572 	subclass).
573 */
574 
575 {
576 	pImp->pRepeatTarget = pTarget;
577 }
578 
579 //--------------------------------------------------------------------
580 
Invalidate(sal_uInt16 nId)581 void SfxShell::Invalidate
582 (
583 	sal_uInt16          nId     /* Zu invalidierende Slot-Id oder Which-Id.
584 							   Falls diese 0 ist (default), werden
585 							   alle z.Zt. von dieser Shell bedienten
586 							   Slot-Ids invalidiert. */
587 )
588 
589 /*  [Beschreibung]
590 
591 	Mit dieser Methode k"onnen Slots der Subclasses "uber die Slot-Id
592 	oder alternativ "uber die Which-Id invalidiert werden. Slot-Ids,
593 	die von der Subclass ererbt sind, werden ebenfalls invalidert.
594 
595 	[Querverweise]
596 	<SfxBindings::Invalidate(sal_uInt16)>
597 	<SfxBindings::InvalidateAll(sal_Bool)>
598 */
599 
600 {
601     if ( !GetViewShell() )
602     {
603         DBG_ERROR( "wrong Invalidate method called!" );
604         return;
605     }
606 
607     Invalidate_Impl( GetViewShell()->GetViewFrame()->GetBindings(), nId );
608 }
609 
Invalidate_Impl(SfxBindings & rBindings,sal_uInt16 nId)610 void SfxShell::Invalidate_Impl( SfxBindings& rBindings, sal_uInt16 nId )
611 {
612 	if ( nId == 0 )
613     {
614         rBindings.InvalidateShell( *this, sal_False );
615     }
616 	else
617 	{
618 		const SfxInterface *pIF = GetInterface();
619 		do
620 		{
621 			const SfxSlot *pSlot = pIF->GetSlot(nId);
622 			if ( pSlot )
623 			{
624 				// bei Enum-Slots ist der Master-Slot zu invalidieren
625 				if ( SFX_KIND_ENUM == pSlot->GetKind() )
626 					pSlot = pSlot->GetLinkedSlot();
627 
628 				// den Slot selbst und ggf. auch alle Slave-Slots invalidieren
629 				rBindings.Invalidate( pSlot->GetSlotId() );
630 				for ( const SfxSlot *pSlave = pSlot->GetLinkedSlot();
631 					  pSlave && pIF->ContainsSlot_Impl( pSlave ) &&
632 						pSlave->GetLinkedSlot() == pSlot;
633 					  ++pSlave )
634 					rBindings.Invalidate( pSlave->GetSlotId() );
635 
636 				return;
637 			}
638 
639 			pIF = pIF->GetGenoType();
640 		}
641 
642 		while ( pIF );
643 
644 		DBG_WARNING( "W3: invalidating slot-id unknown in shell" );
645 	}
646 }
647 
648 //--------------------------------------------------------------------
649 
DoActivate_Impl(SfxViewFrame * pFrame,sal_Bool bMDI)650 void SfxShell::DoActivate_Impl( SfxViewFrame *pFrame, sal_Bool bMDI )
651 
652 /*  [Beschreibung]
653 
654 	Diese Methode steuert die Aktivierung der SfxShell-Instanz. Zun"achst
655 	wird durch Aufruf der virtuellen Methode <SfxShell::Activate(sal_Bool)>
656 	der Subclass die M"oglichkeit gegeben, auf das Event zu reagieren.
657 
658 	Bei bMDI == TRUE wird das zugeh"orige SbxObject 'scharfgeschaltet',
659 	so da\s Methoden des Objekts unqualifiziert (ohne den Namen des Objekts)
660 	vom BASIC gefunden werden.
661 */
662 
663 {
664 #ifdef DBG_UTIL
665 	const SfxInterface *p_IF = GetInterface();
666 	if ( !p_IF )
667 		return;
668 #endif
669 #ifdef DBG_UTIL_VB
670 		String aMsg("SfxShell::DoActivate() ");
671 		aMsg += (long)this;
672 		aMsg += "  ";
673 		aMsg += GetInterface()->GetName();
674 		aMsg += " bMDI ";
675 		if ( bMDI ) aMsg += "MDI";
676 		DbgTrace( aMsg.GetBuffer() );
677 #endif
678 
679 	if ( bMDI )
680 	{
681 		// Frame merken, in dem aktiviert wird
682 		pImp->pFrame = pFrame;
683 		pImp->bActive = sal_True;
684 	}
685 
686 	// Subklasse benachrichtigen
687 	Activate(bMDI);
688 }
689 
690 //--------------------------------------------------------------------
691 
DoDeactivate_Impl(SfxViewFrame * pFrame,sal_Bool bMDI)692 void SfxShell::DoDeactivate_Impl( SfxViewFrame *pFrame, sal_Bool bMDI )
693 
694 /*  [Beschreibung]
695 
696 	Diese Methode steuert die Deaktivierung der SfxShell-Instanz. Bei
697 	bMDI == TRUE wird zun"achst das SbxObject in einen Status versetzt,
698 	so da\s Methoden vom BASIC aus nur noch qualifiziert gerufen werden
699 	k"onnen.
700 
701 	Dann erh"alt in jedem Fall die Subclass durch Aufruf der virtuellen
702 	Methode <SfxShell::Deactivate(sal_Bool)> die M"oglichkeit auf das Event
703 	zu reagieren.
704 */
705 
706 {
707 #ifdef DBG_UTIL
708 	const SfxInterface *p_IF = GetInterface();
709 	if ( !p_IF )
710 		return;
711 #endif
712 #ifdef DBG_UTIL_VB
713 		String aMsg("SfxShell::DoDeactivate()");
714 		aMsg += (long)this;
715 		aMsg += "  ";
716 		aMsg += GetInterface()->GetName();
717 		aMsg += " bMDI ";
718 		if ( bMDI ) aMsg += "MDI";
719 		DbgTrace( aMsg.GetBuffer() );
720 #endif
721 
722 	// nur wenn er vom Frame kommt (nicht z.B. pop der BASIC-IDE vom AppDisp)
723 	if ( bMDI && pImp->pFrame == pFrame )
724 	{
725 		// austragen
726 		pImp->pFrame = 0;
727 		pImp->bActive = sal_False;
728 	}
729 
730 	// Subklasse benachrichtigen
731 	Deactivate(bMDI);
732 }
733 
734 //--------------------------------------------------------------------
735 
IsActive() const736 sal_Bool SfxShell::IsActive() const
737 {
738 	return pImp->bActive;
739 }
740 
741 //--------------------------------------------------------------------
742 
Activate(sal_Bool)743 void SfxShell::Activate
744 (
745 	sal_Bool    /*bMDI*/        /*  TRUE
746 							der <SfxDispatcher>, auf dem die SfxShell sich
747 							befindet, ist aktiv geworden oder die SfxShell
748 							Instanz wurde auf einen aktiven SfxDispatcher
749 							gepusht. (vergl. SystemWindow::IsMDIActivate())
750 
751 							FALSE
752 							das zum <SfxViewFrame>, auf dessen SfxDispatcher
753 							sich die SfxShell Instanz befindet, wurde
754 							aktiviert.
755 							(z.B. durch einen geschlossenen Dialog) */
756 )
757 
758 /*  [Beschreibung]
759 
760 	Virtuelle Methode, die beim Aktivieren der SfxShell Instanz gerufen
761 	wird, um den Subclasses die Gelegenheit zu geben, auf das Aktivieren
762 	zu reagieren.
763 
764 	[Querverweise]
765 	StarView SystemWindow::Activate(sal_Bool)
766 */
767 
768 {
769     BroadcastContextForActivation(true);
770 }
771 
772 //--------------------------------------------------------------------
773 
Deactivate(sal_Bool)774 void SfxShell::Deactivate
775 (
776 	sal_Bool    /*bMDI*/        /*  TRUE
777 							der <SfxDispatcher>, auf dem die SfxShell sich
778 							befindet, ist inaktiv geworden oder die SfxShell
779 							Instanz wurde auf einen aktiven SfxDispatcher
780 							gepoppt. (vergl. SystemWindow::IsMDIActivate())
781 
782 							FALSE
783 							das zum <SfxViewFrame>, auf dessen SfxDispatcher
784 							sich die SfxShell Instanz befindet, wurde
785 							deaktiviert. (z.B. durch einen Dialog) */
786 
787 )
788 
789 /*  [Beschreibung]
790 
791 	Virtuelle Methode, die beim Deaktivieren der SfxShell Instanz gerufen
792 	wird, um den Subclasses die Gelegenheit zu geben, auf das Deaktivieren
793 	zu reagieren.
794 
795 	[Querverweise]
796 	StarView SystemWindow::Dectivate(sal_Bool)
797 */
798 
799 {
800     BroadcastContextForActivation(false);
801 }
802 
803 
ParentActivate()804 void SfxShell::ParentActivate
805 (
806 )
807 
808 /*  [Beschreibung]
809 
810 	Ein Parent des <SfxDispatcher>, auf dem die SfxShell sich befindet,
811 	ist aktiv geworden, oder die SfxShell Instanz wurde auf einen
812 	<SfxDispatcher> gepusht, dessen parent aktiv ist.
813 
814 	Die Basisimplementation ist leer und braucht nicht gerufen zu werden.
815 
816 	[Querverweise]
817 	SfxShell::Activate()
818 */
819 {
820 }
821 
822 //--------------------------------------------------------------------
823 
ParentDeactivate()824 void SfxShell::ParentDeactivate
825 (
826 )
827 
828 /*  [Beschreibung]
829 
830 	Der aktive Parent des <SfxDispatcher>, auf dem die SfxShell sich befindet,
831 	ist deaktiviert worden.
832 
833 	Die Basisimplementation ist leer und braucht nicht gerufen zu werden.
834 
835 	[Querverweise]
836 	SfxShell::Deactivate()
837 */
838 {
839 }
840 
841 //--------------------------------------------------------------------
842 
GetResMgr() const843 ResMgr* SfxShell::GetResMgr() const
844 
845 /*  [Beschreibung]
846 
847 	Diese Methode liefert den ResMgr der <Resource-DLL>, die von der
848 	SfxShell-Instanz verwendet wird. Ist dies ein 0-Pointer, so
849 	ist der aktuelle Resource-Manager zu verwenden.
850 */
851 
852 {
853 	return GetInterface()->GetResMgr();
854 }
855 
856 //--------------------------------------------------------------------
857 
CanExecuteSlot_Impl(const SfxSlot & rSlot)858 bool SfxShell::CanExecuteSlot_Impl( const SfxSlot &rSlot )
859 
860 /*  [Beschreibung]
861 
862 	Diese Methode stellt durch Aufruf der Statusfunktion fest,
863 	ob 'rSlot' aktuell ausgef"uhrt werden kann.
864 */
865 {
866 	// Slot-Status holen
867 	SfxItemPool &rPool = GetPool();
868 	const sal_uInt16 nId = rSlot.GetWhich( rPool );
869 	SfxItemSet aSet(rPool, nId, nId);
870 	SfxStateFunc pFunc = rSlot.GetStateFnc();
871 	CallState( pFunc, aSet );
872 	return aSet.GetItemState(nId) != SFX_ITEM_DISABLED;
873 }
874 
875 //--------------------------------------------------------------------
876 
ShellCall_Impl(void * pObj,void * pArg)877 long ShellCall_Impl( void* pObj, void* pArg )
878 {
879 	((SfxShell* )pObj)->ExecuteSlot( *(SfxRequest*)pArg, (SfxInterface*)0L );
880 	return 0;
881 }
882 
883 /*  [Beschreibung]
884 	Asynchrones ExecuteSlot fuer das RELOAD
885  */
886 
887 //--------------------------------------------------------------------
ExecuteSlot(SfxRequest & rReq,sal_Bool bAsync)888 const SfxPoolItem* SfxShell::ExecuteSlot( SfxRequest& rReq, sal_Bool bAsync )
889 {
890 	if( !bAsync )
891 		return ExecuteSlot( rReq, (SfxInterface*)0L );
892 	else
893 	{
894 		if( !pImp->pExecuter )
895             pImp->pExecuter = new svtools::AsynchronLink(
896 				Link( this, ShellCall_Impl ) );
897 		pImp->pExecuter->Call( new SfxRequest( rReq ) );
898 		return 0;
899 	}
900 }
901 
ExecuteSlot(SfxRequest & rReq,const SfxInterface * pIF)902 const SfxPoolItem* SfxShell::ExecuteSlot
903 (
904 	SfxRequest &rReq,			// der weiterzuleitende <SfxRequest>
905 	const SfxInterface* pIF     // default = 0 bedeutet virtuell besorgen
906 )
907 
908 /*  [Beschreibung]
909 
910 	Diese Methode erm"oglicht das Weiterleiten eines <SfxRequest> an
911 	die angegebene Basis-<SfxShell>.
912 
913 
914 	[Beispiel]
915 
916 	In einer von SfxViewShell abgeleiteten Klasse soll SID_PRINTDOCDIRECT
917 	abgefangen werden. Unter bestimmten Umst"anden soll vor dem Drucken
918 	eine Abfrage erscheinen, und der Request soll ggf. abgebrochen werden.
919 
920 	Dazu ist in der IDL dieser Subklasse der o.g. Slot einzutragen. Die
921 	Execute-Methode enth"alt dann skizziert:
922 
923 	void SubViewShell::Exec( SfxRequest &rReq )
924 	{
925 		if ( rReq.GetSlot() == SID_PRINTDOCDIRECT )
926 		{
927 			'dialog'
928 			if ( 'condition' )
929 				ExecuteSlot( rReq, SfxViewShell::GetInterface() );
930 		}
931 	}
932 
933 	Es braucht i.d.R. kein rReq.Done() gerufen zu werden, da das bereits
934 	die Implementierung der SfxViewShell erledigt bzw. abgebrochen wurde.
935 
936 
937 	[Querverweise]
938 
939 	<SfxShell::GetSlotState(sal_uInt16,const SfxInterface*,SfxItemSet*)>
940 */
941 
942 {
943 	if ( !pIF )
944 		pIF = GetInterface();
945 
946     sal_uInt16 nSlot = rReq.GetSlot();
947     const SfxSlot* pSlot = NULL;
948     if ( nSlot >= SID_VERB_START && nSlot <= SID_VERB_END )
949         pSlot = GetVerbSlot_Impl(nSlot);
950     if ( !pSlot )
951         pSlot = pIF->GetSlot(nSlot);
952 	DBG_ASSERT( pSlot, "slot not supported" );
953 
954 	SfxExecFunc pFunc = pSlot->GetExecFnc();
955     if ( pFunc )
956         CallExec( pFunc, rReq );
957 
958 	return rReq.GetReturnValue();
959 }
960 
961 //--------------------------------------------------------------------
962 
GetSlotState(sal_uInt16 nSlotId,const SfxInterface * pIF,SfxItemSet * pStateSet)963 const SfxPoolItem* SfxShell::GetSlotState
964 (
965 	sal_uInt16              nSlotId,    // Slot-Id des zu befragenden Slots
966 	const SfxInterface* pIF,        // default = 0 bedeutet virtuell besorgen
967 	SfxItemSet*         pStateSet   // SfxItemSet der Slot-State-Methode
968 )
969 
970 /*  [Beschreibung]
971 
972 	Diese Methode liefert den Status des Slots mit der angegebenen Slot-Id
973 	"uber das angegebene Interface.
974 
975 	Ist der Slot disabled oder in dieser SfxShell (und deren Parent-Shells)
976 	nicht bekannt, wird ein 0-Pointer zur"uckgeliefert.
977 
978 	Hat der Slot keinen Status, wird ein SfxVoidItem zur"uckgeliefert.
979 
980 	Der Status wird bei pStateSet != 0 gleich in diesem Set gesetzt, so
981 	da\s <SfxShell>-Subklassen Slots-"uberladen und auch bei der
982 	Status-Methode die Basis-Implementierung rufen k"onnen.
983 
984 
985 	[Beispiel]
986 
987 	In einer von SfxViewShell abgeleiteten Klasse soll SID_PRINTDOCDIRECT
988 	abgefangen werden. Unter bestimmten Umst"anden soll vor dem Drucken
989 	eine Abfrage erscheinen, und der Request soll ggf. abgebrochen werden.
990 
991 	Dazu ist in der IDL dieser Subklasse der o.g. Slot einzutragen. Die
992 	Status-Methode enth"alt dann skizziert:
993 
994 	void SubViewShell::PrintState( SfxItemSet &rState )
995 	{
996 		if ( rState.GetItemState( SID_PRINTDOCDIRECT ) != SFX_ITEM_UNKNOWN )
997 			GetSlotState( SID_PRINTDOCDIRECT, SfxViewShell::GetInterface(),
998 					&rState );
999 		...
1000 	}
1001 
1002 
1003 	[Querverweise]
1004 
1005 	<SfxShell::ExecuteSlot(SfxRequest&)>
1006 */
1007 
1008 {
1009 	// Slot am angegebenen Interface besorgen
1010 	if ( !pIF )
1011 		pIF = GetInterface();
1012 	SfxItemState eState;
1013 	SfxItemPool &rPool = GetPool();
1014 
1015     const SfxSlot* pSlot = NULL;
1016     if ( nSlotId >= SID_VERB_START && nSlotId <= SID_VERB_END )
1017         pSlot = GetVerbSlot_Impl(nSlotId);
1018     if ( !pSlot )
1019         pSlot = pIF->GetSlot(nSlotId);
1020 	if ( pSlot )
1021 		// ggf. auf Which-Id mappen
1022 		nSlotId = pSlot->GetWhich( rPool );
1023 
1024 	// Item und Item-Status besorgen
1025 	const SfxPoolItem *pItem = NULL;
1026 	SfxItemSet aSet( rPool, nSlotId, nSlotId ); // pItem stirbt sonst zu fr"uh
1027 	if ( pSlot )
1028 	{
1029 		// Status-Methode rufen
1030 		SfxStateFunc pFunc = pSlot->GetStateFnc();
1031         if ( pFunc )
1032             CallState( pFunc, aSet );
1033 		eState = aSet.GetItemState( nSlotId, sal_True, &pItem );
1034 
1035 		// ggf. Default-Item besorgen
1036 		if ( eState == SFX_ITEM_DEFAULT )
1037 		{
1038 			if ( SfxItemPool::IsWhich(nSlotId) )
1039 				pItem = &rPool.GetDefaultItem(nSlotId);
1040 			else
1041 				eState = SFX_ITEM_DONTCARE;
1042 		}
1043 	}
1044 	else
1045 		eState = SFX_ITEM_UNKNOWN;
1046 
1047 	// Item und Item-Status auswerten und ggf. in pStateSet mitpflegen
1048 	SfxPoolItem *pRetItem = 0;
1049 	if ( eState <= SFX_ITEM_DISABLED )
1050 	{
1051 		if ( pStateSet )
1052 			pStateSet->DisableItem(nSlotId);
1053 		return 0;
1054 	}
1055 	else if ( eState == SFX_ITEM_DONTCARE )
1056 	{
1057 		if ( pStateSet )
1058 			pStateSet->ClearItem(nSlotId);
1059 		pRetItem = new SfxVoidItem(0);
1060 	}
1061 	else
1062 	{
1063 		if ( pStateSet && pStateSet->Put( *pItem ) )
1064 			return &pStateSet->Get( pItem->Which() );
1065 		pRetItem = pItem->Clone();
1066 	}
1067 	DeleteItemOnIdle(pRetItem);
1068 
1069 	return pRetItem;
1070 }
1071 
1072 //--------------------------------------------------------------------
1073 
SFX_EXEC_STUB(SfxShell,VerbExec)1074 SFX_EXEC_STUB(SfxShell, VerbExec)
1075 SFX_STATE_STUB(SfxShell, VerbState)
1076 
1077 void SfxShell::SetVerbs(const com::sun::star::uno::Sequence < com::sun::star::embed::VerbDescriptor >& aVerbs)
1078 {
1079 	SfxViewShell *pViewSh = PTR_CAST ( SfxViewShell, this);
1080 
1081 	DBG_ASSERT(pViewSh, "SetVerbs nur an der ViewShell aufrufen!");
1082     if ( !pViewSh )
1083         return;
1084 
1085     // Zun"achst alle Statecaches dirty machen, damit keiner mehr versucht,
1086     // die Slots zu benutzen
1087     {
1088         SfxBindings *pBindings =
1089             pViewSh->GetViewFrame()->GetDispatcher()->GetBindings();
1090         sal_uInt16 nCount = pImp->aSlotArr.Count();
1091         for (sal_uInt16 n1=0; n1<nCount ; n1++)
1092         {
1093             sal_uInt16 nId = SID_VERB_START + n1;
1094             pBindings->Invalidate(nId, sal_False, sal_True);
1095         }
1096     }
1097 
1098     sal_uInt16 nr=0;
1099     for (sal_Int32 n=0; n<aVerbs.getLength(); n++)
1100     {
1101         sal_uInt16 nSlotId = SID_VERB_START + nr++;
1102         DBG_ASSERT(nSlotId <= SID_VERB_END, "Zuviele Verben!");
1103         if (nSlotId > SID_VERB_END)
1104             break;
1105 
1106         SfxSlot *pNewSlot = new SfxSlot;
1107         pNewSlot->nSlotId = nSlotId;
1108         pNewSlot->nGroupId = 0;
1109 
1110         // Verb-Slots m"ussen asynchron ausgef"uhrt werden, da sie w"ahrend
1111         // des Ausf"uhrens zerst"ort werden k"onnten
1112         pNewSlot->nFlags = SFX_SLOT_ASYNCHRON | SFX_SLOT_CONTAINER;
1113         pNewSlot->nMasterSlotId = 0;
1114         pNewSlot->nValue = 0;
1115         pNewSlot->fnExec = SFX_STUB_PTR(SfxShell,VerbExec);
1116         pNewSlot->fnState = SFX_STUB_PTR(SfxShell,VerbState);
1117         pNewSlot->pType = 0; HACK(SFX_TYPE(SfxVoidItem))
1118         pNewSlot->pName = OUStringToOString( aVerbs[n].VerbName, RTL_TEXTENCODING_UTF8).getStr(); // TODO: life time of temp is suspicious!!!
1119         pNewSlot->pLinkedSlot = 0;
1120         pNewSlot->nArgDefCount = 0;
1121         pNewSlot->pFirstArgDef = 0;
1122         pNewSlot->pUnoName = 0;
1123 
1124         if (pImp->aSlotArr.Count())
1125         {
1126             SfxSlot *pSlot = (pImp->aSlotArr)[0];
1127             pNewSlot->pNextSlot = pSlot->pNextSlot;
1128             pSlot->pNextSlot = pNewSlot;
1129         }
1130         else
1131             pNewSlot->pNextSlot = pNewSlot;
1132 
1133         pImp->aSlotArr.Insert(pNewSlot, (sal_uInt16) n);
1134 	}
1135 
1136     pImp->aVerbList = aVerbs;
1137 
1138     if (pViewSh)
1139 	{
1140 		// Der Status von SID_OBJECT wird im Controller direkt an der Shell
1141 		// abgeholt, es reicht also, ein neues StatusUpdate anzuregen
1142 		SfxBindings *pBindings = pViewSh->GetViewFrame()->GetDispatcher()->
1143 				GetBindings();
1144 		pBindings->Invalidate( SID_OBJECT, sal_True, sal_True );
1145 	}
1146 }
1147 
1148 //--------------------------------------------------------------------
1149 
GetVerbs() const1150 const com::sun::star::uno::Sequence < com::sun::star::embed::VerbDescriptor >& SfxShell::GetVerbs() const
1151 {
1152     return pImp->aVerbList;
1153 }
1154 
1155 //--------------------------------------------------------------------
1156 
VerbExec(SfxRequest & rReq)1157 void SfxShell::VerbExec(SfxRequest& rReq)
1158 {
1159 	sal_uInt16 nId = rReq.GetSlot();
1160 	SfxViewShell *pViewShell = GetViewShell();
1161 	if ( pViewShell )
1162 	{
1163         sal_Bool bReadOnly = pViewShell->GetObjectShell()->IsReadOnly();
1164         com::sun::star::uno::Sequence < com::sun::star::embed::VerbDescriptor > aList = pViewShell->GetVerbs();
1165         for (sal_Int32 n=0, nVerb=0; n<aList.getLength(); n++)
1166 		{
1167             // check for ReadOnly verbs
1168             if ( bReadOnly && !(aList[n].VerbAttributes & embed::VerbAttributes::MS_VERBATTR_NEVERDIRTIES) )
1169                 continue;
1170 
1171             // check for verbs that shouldn't appear in the menu
1172             if ( !(aList[n].VerbAttributes & embed::VerbAttributes::MS_VERBATTR_ONCONTAINERMENU) )
1173                 continue;
1174 
1175             if (nId == SID_VERB_START + nVerb++)
1176 			{
1177                 pViewShell->DoVerb(aList[n].VerbID);
1178 				rReq.Done();
1179 				return;
1180 			}
1181 		}
1182 	}
1183 }
1184 
1185 //--------------------------------------------------------------------
1186 
VerbState(SfxItemSet &)1187 void SfxShell::VerbState(SfxItemSet& )
1188 {
1189 }
1190 
1191 //--------------------------------------------------------------------
1192 
GetVerbSlot_Impl(sal_uInt16 nId) const1193 const SfxSlot* SfxShell::GetVerbSlot_Impl(sal_uInt16 nId) const
1194 {
1195     com::sun::star::uno::Sequence < com::sun::star::embed::VerbDescriptor > rList = pImp->aVerbList;
1196 
1197 	DBG_ASSERT(nId >= SID_VERB_START && nId <= SID_VERB_END,"Falsche VerbId!");
1198 	sal_uInt16 nIndex = nId - SID_VERB_START;
1199     DBG_ASSERT(nIndex < rList.getLength(),"Falsche VerbId!");
1200 
1201     if (nIndex < rList.getLength())
1202         return pImp->aSlotArr[nIndex];
1203 	else
1204 		return 0;
1205 }
1206 
1207 //--------------------------------------------------------------------
1208 
SetHelpId(sal_uIntPtr nId)1209 void SfxShell::SetHelpId(sal_uIntPtr nId)
1210 {
1211 	pImp->nHelpId = nId;
1212 }
1213 
1214 //--------------------------------------------------------------------
1215 
GetHelpId() const1216 sal_uIntPtr SfxShell::GetHelpId() const
1217 {
1218 	return pImp->nHelpId;
1219 }
1220 
1221 //--------------------------------------------------------------------
1222 
GetObjectShell()1223 SfxObjectShell* SfxShell::GetObjectShell()
1224 {
1225 	if ( GetViewShell() )
1226 		return GetViewShell()->GetViewFrame()->GetObjectShell();
1227 	else
1228 		return NULL;
1229 }
1230 
1231 //--------------------------------------------------------------------
1232 
HasUIFeature(sal_uInt32)1233 sal_Bool SfxShell::HasUIFeature( sal_uInt32 )
1234 {
1235 	return sal_False;
1236 }
1237 
DispatcherUpdate_Impl(void *,void * pArg)1238 long DispatcherUpdate_Impl( void*, void* pArg )
1239 {
1240 	((SfxDispatcher*) pArg)->Update_Impl( sal_True );
1241     ((SfxDispatcher*) pArg)->GetBindings()->InvalidateAll(sal_False);
1242 	return 0;
1243 }
1244 
UIFeatureChanged()1245 void SfxShell::UIFeatureChanged()
1246 {
1247 	SfxViewFrame *pFrame = GetFrame();
1248     if ( pFrame && pFrame->IsVisible() )
1249 	{
1250 		// Auch dann Update erzwingen, wenn Dispatcher schon geupdated ist,
1251 		// sonst bleibt evtl. irgendwas in den gebunkerten Tools stecken.
1252 		// Asynchron aufrufen, um Rekursionen zu vermeiden
1253 		if ( !pImp->pUpdater )
1254             pImp->pUpdater = new svtools::AsynchronLink( Link( this, DispatcherUpdate_Impl ) );
1255 
1256 		// Mehrfachaufrufe gestattet
1257 		pImp->pUpdater->Call( pFrame->GetDispatcher(), sal_True );
1258 	}
1259 }
1260 
SetDisableFlags(sal_uIntPtr nFlags)1261 void SfxShell::SetDisableFlags( sal_uIntPtr nFlags )
1262 {
1263 	pImp->nDisableFlags = nFlags;
1264 }
1265 
GetDisableFlags() const1266 sal_uIntPtr SfxShell::GetDisableFlags() const
1267 {
1268 	return pImp->nDisableFlags;
1269 }
1270 
CreateItemSet(sal_uInt16)1271 SfxItemSet*	SfxShell::CreateItemSet( sal_uInt16 )
1272 {
1273 	return NULL;
1274 }
1275 
ApplyItemSet(sal_uInt16,const SfxItemSet &)1276 void SfxShell::ApplyItemSet( sal_uInt16, const SfxItemSet& )
1277 {
1278 }
1279 
SetContextName(const::rtl::OUString & rsContextName)1280 void SfxShell::SetContextName (const ::rtl::OUString& rsContextName)
1281 {
1282     pImp->maContextChangeBroadcaster.Initialize(rsContextName);
1283 }
1284 
SetViewShell_Impl(SfxViewShell * pView)1285 void SfxShell::SetViewShell_Impl( SfxViewShell* pView )
1286 {
1287     pImp->pViewSh = pView;
1288 }
1289 
1290 
1291 
1292 
BroadcastContextForActivation(const bool bIsActivated)1293 void SfxShell::BroadcastContextForActivation (const bool bIsActivated)
1294 {
1295     SfxViewFrame* pViewFrame = GetFrame();
1296     if (pViewFrame != NULL)
1297         if (bIsActivated)
1298             pImp->maContextChangeBroadcaster.Activate(pViewFrame->GetFrame().GetFrameInterface());
1299         else
1300             pImp->maContextChangeBroadcaster.Deactivate(pViewFrame->GetFrame().GetFrameInterface());
1301 }
1302 
1303 
1304 
1305 
SetContextBroadcasterEnabled(const bool bIsEnabled)1306 bool SfxShell::SetContextBroadcasterEnabled (const bool bIsEnabled)
1307 {
1308     return pImp->maContextChangeBroadcaster.SetBroadcasterEnabled(bIsEnabled);
1309 }
1310