sfx2/source/control/shell.cxx

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