sfx2/source/control/request.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: request.cxx,v $
  10  * $Revision: 1.21 $
  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
  32 // MARKER(update_precomp.py): autogen include statement, do not remove
  33 #include "precompiled_sfx2.hxx"
  34
  35 #include <com/sun/star/frame/DispatchStatement.hpp>
  36 #include <com/sun/star/container/XIndexReplace.hpp>
  37 #include <com/sun/star/beans/PropertyValue.hpp>
  38 #include <com/sun/star/uno/Sequence.hxx>
  39 #include <com/sun/star/beans/XPropertySet.hpp>
  40 #include <com/sun/star/util/XURLTransformer.hpp>
  41 #include <com/sun/star/frame/XDispatchRecorderSupplier.hpp>
  42 #include <svtools/itemiter.hxx>
  43
  44 #ifndef _ARGS_HXX //autogen
  45 #include <svtools/itempool.hxx>
  46 #endif
  47 #include <svtools/itemdel.hxx>
  48
  49 #include <comphelper/processfactory.hxx>
  50
  51 #ifndef GCC
  52 #endif
  53
  54 #include <svtools/smplhint.hxx>
  55
  56 #include <sfx2/request.hxx>
  57 #include <sfx2/dispatch.hxx>
  58 #include <sfx2/msg.hxx>
  59 #include <sfx2/viewfrm.hxx>
  60 #include "macro.hxx"
  61 #include <sfx2/objface.hxx>
  62 #include <sfx2/appuno.hxx>
  63
  64 //===================================================================
  65
  66 using namespace ::com::sun::star;
  67
  68 struct SfxRequest_Impl: public SfxListener
  69
  70 /*      [Beschreibung]
  71
  72     Implementations-Struktur der Klasse <SfxRequest>.
  73 */
  74
  75 {
  76     SfxRequest*                 pAnti;           // Owner wegen sterbendem Pool
  77     String                              aTarget;         // ggf. von App gesetztes Zielobjekt
  78     SfxItemPool*        pPool;           // ItemSet mit diesem Pool bauen
  79     SfxPoolItem*                pRetVal;         // R"uckgabewert geh"ort sich selbst
  80     SfxShell*           pShell;      // ausgef"uhrt an dieser Shell
  81     const SfxSlot*              pSlot;           // ausgef"uhrter Slot
  82     USHORT              nModifier;   // welche Modifier waren gedrueckt?
  83     BOOL                                bDone;           // "uberhaupt ausgef"uhrt
  84     BOOL                                bIgnored;        // vom User abgebrochen
  85     BOOL                                bCancelled;      // nicht mehr zustellen
  86     BOOL                                bUseTarget;      // aTarget wurde von Applikation gesetzt
  87     USHORT                      nCallMode;   // Synch/Asynch/API/Record
  88     BOOL                bAllowRecording;
  89     SfxAllItemSet*      pInternalArgs;
  90     SfxViewFrame*       pViewFrame;
  91
  92     com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder;
  93
  94                         SfxRequest_Impl( SfxRequest *pOwner )
  95                         : pAnti( pOwner)
  96                         , pPool(0)
  97                         , nModifier(0)
  98                         , bCancelled(FALSE)
  99                         , nCallMode( SFX_CALLMODE_SYNCHRON )
 100                         , bAllowRecording( FALSE )
 101                         , pInternalArgs( 0 )
 102                         , pViewFrame(0)
 103                         {}
 104     ~SfxRequest_Impl() { delete pInternalArgs; }
 105
 106
 107     void                                SetPool( SfxItemPool *pNewPool );
 108     virtual void                Notify( SfxBroadcaster &rBC, const SfxHint &rHint );
 109     void                Record( const uno::Sequence < beans::PropertyValue >& rArgs );
 110 };
 111
 112
 113 //====================================================================
 114
 115 void SfxRequest_Impl::Notify( SfxBroadcaster&, const SfxHint &rHint )
 116 {
 117     SfxSimpleHint *pSimpleHint = PTR_CAST(SfxSimpleHint, &rHint);
 118     if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
 119         pAnti->Cancel();
 120 }
 121
 122 //====================================================================
 123
 124 void SfxRequest_Impl::SetPool( SfxItemPool *pNewPool )
 125 {
 126     if ( pNewPool != pPool )
 127     {
 128         if ( pPool )
 129             EndListening( pPool->BC() );
 130         pPool = pNewPool;
 131         if ( pNewPool )
 132             StartListening( pNewPool->BC() );
 133     }
 134 }
 135
 136 //====================================================================
 137
 138
 139 SfxRequest::~SfxRequest()
 140 {
 141     DBG_MEMTEST();
 142
 143     // nicht mit Done() marktierte Requests mit 'rem' rausschreiben
 144     if ( pImp->xRecorder.is() && !pImp->bDone && !pImp->bIgnored )
 145         pImp->Record( uno::Sequence < beans::PropertyValue >() );
 146
 147     // Objekt abr"aumen
 148     delete pArgs;
 149     if ( pImp->pRetVal )
 150         DeleteItemOnIdle(pImp->pRetVal);
 151     delete pImp;
 152 }
 153 //--------------------------------------------------------------------
 154
 155
 156 SfxRequest::SfxRequest
 157 (
 158     const SfxRequest& rOrig
 159 )
 160 :       SfxHint( rOrig ),
 161     nSlot(rOrig.nSlot),
 162     pArgs(rOrig.pArgs? new SfxAllItemSet(*rOrig.pArgs): 0),
 163     pImp( new SfxRequest_Impl(this) )
 164 {
 165     DBG_MEMTEST();
 166
 167     pImp->bAllowRecording = rOrig.pImp->bAllowRecording;
 168     pImp->bDone = FALSE;
 169     pImp->bIgnored = FALSE;
 170     pImp->pRetVal = 0;
 171     pImp->pShell = 0;
 172     pImp->pSlot = 0;
 173     pImp->nCallMode = rOrig.pImp->nCallMode;
 174     pImp->bUseTarget = rOrig.pImp->bUseTarget;
 175     pImp->aTarget = rOrig.pImp->aTarget;
 176     pImp->nModifier = rOrig.pImp->nModifier;
 177
 178     // deep copy needed !
 179     pImp->pInternalArgs = (rOrig.pImp->pInternalArgs ? new SfxAllItemSet(*rOrig.pImp->pInternalArgs) : 0);
 180
 181     if ( pArgs )
 182         pImp->SetPool( pArgs->GetPool() );
 183     else
 184         pImp->SetPool( rOrig.pImp->pPool );
 185 }
 186 //--------------------------------------------------------------------
 187
 188
 189 SfxRequest::SfxRequest
 190 (
 191     SfxViewFrame*   pViewFrame,
 192     USHORT          nSlotId
 193
 194 )
 195
 196 /*      [Beschreibung]
 197
 198     Mit diesem Konstruktor k"onnen Events, die nicht "uber den SfxDispatcher
 199     gelaufen sind (z.B aus KeyInput() oder Mouse-Events) nachtr"aglich
 200     recorded werden. Dazu wird eine SfxRequest-Instanz mit diesem Konstruktor
 201     erzeugt und dann genauso verfahren, wie mit einem SfxRequest, der in
 202     eine <Slot-Execute-Methode> als Parameter gegeben wird.
 203 */
 204
 205 :       nSlot(nSlotId),
 206     pArgs(0),
 207     pImp( new SfxRequest_Impl(this) )
 208 {
 209     DBG_MEMTEST();
 210
 211     pImp->bDone = FALSE;
 212     pImp->bIgnored = FALSE;
 213     pImp->SetPool( &pViewFrame->GetPool() );
 214     pImp->pRetVal = 0;
 215     pImp->pShell = 0;
 216     pImp->pSlot = 0;
 217     pImp->nCallMode = SFX_CALLMODE_SYNCHRON;
 218     pImp->bUseTarget = FALSE;
 219     pImp->pViewFrame = pViewFrame;
 220     if( pImp->pViewFrame->GetDispatcher()->GetShellAndSlot_Impl( nSlotId, &pImp->pShell, &pImp->pSlot, TRUE, TRUE ) )
 221     {
 222         pImp->SetPool( &pImp->pShell->GetPool() );
 223         pImp->xRecorder = SfxRequest::GetMacroRecorder( pViewFrame );
 224         pImp->aTarget = pImp->pShell->GetName();
 225     }
 226 #ifdef DBG_UTIL
 227     else
 228     {
 229         ByteString aStr( "Recording unsupported slot: ");
 230         aStr += ByteString::CreateFromInt32( pImp->pPool->GetSlotId(nSlotId) );
 231         DBG_ERROR( aStr.GetBuffer() );
 232     }
 233 #endif
 234 }
 235
 236 //--------------------------------------------------------------------
 237
 238
 239 SfxRequest::SfxRequest
 240 (
 241     USHORT                      nSlotId,        // auszuf"uhrende <Slot-Id>
 242     SfxCallMode         nMode,          // Synch/API/...
 243     SfxItemPool&        rPool           // ggf. f"ur das SfxItemSet f"ur Parameter
 244 )
 245
 246 // creates a SfxRequest without arguments
 247
 248 :       nSlot(nSlotId),
 249     pArgs(0),
 250     pImp( new SfxRequest_Impl(this) )
 251 {
 252     DBG_MEMTEST();
 253
 254     pImp->bDone = FALSE;
 255     pImp->bIgnored = FALSE;
 256     pImp->SetPool( &rPool );
 257     pImp->pRetVal = 0;
 258     pImp->pShell = 0;
 259     pImp->pSlot = 0;
 260     pImp->nCallMode = nMode;
 261     pImp->bUseTarget = FALSE;
 262 }
 263
 264 SfxRequest::SfxRequest
 265 (
 266     const SfxSlot* pSlot,       // auszuf"uhrende <Slot-Id>
 267     const com::sun::star::uno::Sequence < com::sun::star::beans::PropertyValue >& rArgs,
 268     SfxCallMode         nMode,          // Synch/API/...
 269     SfxItemPool&        rPool           // ggf. f"ur das SfxItemSet f"ur Parameter
 270 )
 271 :       nSlot(pSlot->GetSlotId()),
 272     pArgs(new SfxAllItemSet(rPool)),
 273     pImp( new SfxRequest_Impl(this) )
 274 {
 275     DBG_MEMTEST();
 276
 277     pImp->bDone = FALSE;
 278     pImp->bIgnored = FALSE;
 279     pImp->SetPool( &rPool );
 280     pImp->pRetVal = 0;
 281     pImp->pShell = 0;
 282     pImp->pSlot = 0;
 283     pImp->nCallMode = nMode;
 284     pImp->bUseTarget = FALSE;
 285     TransformParameters( nSlot, rArgs, *pArgs, pSlot );
 286 }
 287
 288 //-----------------------------------------------------------------------
 289
 290 SfxRequest::SfxRequest
 291 (
 292     USHORT                                      nSlotId,
 293     USHORT                                      nMode,
 294     const SfxAllItemSet&        rSfxArgs
 295 )
 296
 297 // creates a SfxRequest with arguments
 298
 299 :       nSlot(nSlotId),
 300     pArgs(new SfxAllItemSet(rSfxArgs)),
 301     pImp( new SfxRequest_Impl(this) )
 302 {
 303     DBG_MEMTEST();
 304
 305     pImp->bDone = FALSE;
 306     pImp->bIgnored = FALSE;
 307     pImp->SetPool( rSfxArgs.GetPool() );
 308     pImp->pRetVal = 0;
 309     pImp->pShell = 0;
 310     pImp->pSlot = 0;
 311     pImp->nCallMode = nMode;
 312     pImp->bUseTarget = FALSE;
 313 }
 314 //--------------------------------------------------------------------
 315
 316 USHORT SfxRequest::GetCallMode() const
 317 {
 318     return pImp->nCallMode;
 319 }
 320
 321 //--------------------------------------------------------------------
 322
 323 BOOL SfxRequest::IsSynchronCall() const
 324 {
 325     return SFX_CALLMODE_SYNCHRON == ( SFX_CALLMODE_SYNCHRON & pImp->nCallMode );
 326 }
 327
 328 //--------------------------------------------------------------------
 329
 330 void SfxRequest::SetSynchronCall( BOOL bSynchron )
 331 {
 332     if ( bSynchron )
 333         pImp->nCallMode |= SFX_CALLMODE_SYNCHRON;
 334     else
 335         pImp->nCallMode &= ~(USHORT) SFX_CALLMODE_SYNCHRON;
 336 }
 337
 338 void SfxRequest::SetInternalArgs_Impl( const SfxAllItemSet& rArgs )
 339 {
 340     delete pImp->pInternalArgs;
 341     pImp->pInternalArgs = new SfxAllItemSet( rArgs );
 342 }
 343
 344 const SfxItemSet* SfxRequest::GetInternalArgs_Impl() const
 345 {
 346     return pImp->pInternalArgs;
 347 }
 348
 349 //--------------------------------------------------------------------
 350
 351
 352 void SfxRequest_Impl::Record
 353 (
 354     const uno::Sequence < beans::PropertyValue >& rArgs    // aktuelle Parameter
 355 )
 356
 357 /*      [Beschreibung]
 358
 359     Interne Hilfsmethode zum erzeugen einer <SfxMacroStatement>-Instanz,
 360     welche den bereits ausgef"uhrten SfxRequest wiederholbar beschreibt.
 361
 362     Die erzeugte Instanz, auf die ein Pointer zur"uckgeliefert wird
 363     geht in das Eigentum des Aufrufers "uber.
 364 */
 365
 366 {
 367     String aCommand = String::CreateFromAscii(".uno:");
 368     aCommand.AppendAscii( pSlot->GetUnoName() );
 369     ::rtl::OUString aCmd( aCommand );
 370     if(xRecorder.is())
 371     {
 372         uno::Reference< container::XIndexReplace > xReplace( xRecorder, uno::UNO_QUERY );
 373         if ( xReplace.is() && aCmd.compareToAscii(".uno:InsertText") == COMPARE_EQUAL )
 374         {
 375             sal_Int32 nCount = xReplace->getCount();
 376             if ( nCount )
 377             {
 378                 frame::DispatchStatement aStatement;
 379                 uno::Any aElement = xReplace->getByIndex(nCount-1);
 380                 if ( (aElement >>= aStatement) && aStatement.aCommand == aCmd )
 381                 {
 382                     ::rtl::OUString aStr;
 383                     ::rtl::OUString aNew;
 384                     aStatement.aArgs[0].Value >>= aStr;
 385                     rArgs[0].Value >>= aNew;
 386                     aStr += aNew;
 387                     aStatement.aArgs[0].Value <<= aStr;
 388                     aElement <<= aStatement;
 389                     xReplace->replaceByIndex( nCount-1, aElement );
 390                     return;
 391                 }
 392             }
 393         }
 394
 395         com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > xFactory(
 396                 ::comphelper::getProcessServiceFactory(),
 397                 com::sun::star::uno::UNO_QUERY);
 398
 399         com::sun::star::uno::Reference< com::sun::star::util::XURLTransformer > xTransform(
 400                 xFactory->createInstance(rtl::OUString::createFromAscii("com.sun.star.util.URLTransformer")),
 401                 com::sun::star::uno::UNO_QUERY);
 402
 403         com::sun::star::util::URL aURL;
 404         aURL.Complete = aCmd;
 405         xTransform->parseStrict(aURL);
 406
 407         if (bDone)
 408             xRecorder->recordDispatch(aURL,rArgs);
 409         else
 410             xRecorder->recordDispatchAsComment(aURL,rArgs);
 411     }
 412 }
 413
 414 //--------------------------------------------------------------------
 415
 416 void SfxRequest::Record_Impl
 417 (
 418     SfxShell& rSh,    // die <SfxShell>, die den Request ausgef"uhrt hat
 419     const SfxSlot&      rSlot,  // der <SfxSlot>, der den Request ausgef"uhrt hat
 420     com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder,  // der Recorder, mit dem aufgezeichnet wird
 421     SfxViewFrame* pViewFrame
 422 )
 423
 424 /*      [Beschreibung]
 425
 426     Diese interne Methode markiert den SfxRequest als in dem angegebenen
 427     SfxMakro aufzuzeichnen.
 428
 429     Pointer auf die Parameter werden in Done() wieder verwendet, m"usseb
 430     dann also noch leben.
 431 */
 432
 433 {
 434     DBG_MEMTEST();
 435     pImp->pShell = &rSh;
 436     pImp->pSlot = &rSlot;
 437     pImp->xRecorder = xRecorder;
 438     pImp->aTarget = rSh.GetName();
 439     pImp->pViewFrame = pViewFrame;
 440 }
 441
 442 //--------------------------------------------------------------------
 443
 444 void SfxRequest::SetArgs( const SfxAllItemSet& rArgs )
 445 {
 446     delete pArgs;
 447     pArgs = new SfxAllItemSet(rArgs);
 448     pImp->SetPool( pArgs->GetPool() );
 449 }
 450
 451 //--------------------------------------------------------------------
 452
 453 void SfxRequest::AppendItem(const SfxPoolItem &rItem)
 454 {
 455     if(!pArgs)
 456         pArgs = new SfxAllItemSet(*pImp->pPool);
 457     pArgs->Put(rItem, rItem.Which());
 458 }
 459
 460 //--------------------------------------------------------------------
 461
 462 void SfxRequest::RemoveItem( USHORT nID )
 463 {
 464     if (pArgs)
 465     {
 466         pArgs->ClearItem(nID);
 467         if ( !pArgs->Count() )
 468             DELETEZ(pArgs);
 469     }
 470 }
 471
 472 //--------------------------------------------------------------------
 473
 474 const SfxPoolItem* SfxRequest::GetArg
 475 (
 476     USHORT                      nSlotId,        // Slot-Id oder Which-Id des Parameters
 477     FASTBOOL            bDeep,          // FALSE: nicht in Parent-ItemSets suchen
 478     TypeId                      aType           // != 0:  RTTI Pruefung mit Assertion
 479 )       const
 480 {
 481     return GetItem( pArgs, nSlotId, bDeep, aType );
 482 }
 483
 484
 485 //--------------------------------------------------------------------
 486 const SfxPoolItem* SfxRequest::GetItem
 487 (
 488     const SfxItemSet* pArgs,
 489     USHORT                      nSlotId,        // Slot-Id oder Which-Id des Parameters
 490     bool                bDeep,          // false: nicht in Parent-ItemSets suchen
 491     TypeId                      aType           // != 0:  RTTI Pruefung mit Assertion
 492 )
 493
 494 /*      [Beschreibung]
 495
 496     Mit dieser Methode wird der Zugriff auf einzelne Parameter im
 497     SfxRequest wesentlich vereinfacht. Insbesondere wird die Typpr"ufung
 498     (per Assertion) durchgef"uhrt, wodurch die Applikations-Sourcen
 499     wesentlich "ubersichtlicher werden. In der PRODUCT-Version wird
 500     eine 0 zur"uckgegeben, wenn das gefundene Item nicht von der
 501     angegebenen Klasse ist.
 502
 503
 504     [Beispiel]
 505
 506     void MyShell::Execute( SfxRequest &rReq )
 507     {
 508         switch ( rReq.GetSlot() )
 509         {
 510             case SID_MY:
 511             {
 512                 ...
 513                 // ein Beispiel ohne Verwendung des Makros
 514                 const SfxInt32Item *pPosItem = (const SfxUInt32Item*)
 515                     rReq.GetArg( SID_POS, FALSE, TYPE(SfxInt32Item) );
 516                 USHORT nPos = pPosItem ? pPosItem->GetValue() : 0;
 517
 518                 // ein Beispiel mit Verwendung des Makros
 519                 SFX_REQUEST_ARG(rReq, pSizeItem, SfxInt32Item, SID_SIZE, FALSE);
 520                 USHORT nSize = pSizeItem ? pPosItem->GetValue() : 0;
 521
 522                 ...
 523             }
 524
 525             ...
 526         }
 527     }
 528 */
 529
 530 {
 531     if ( pArgs )
 532     {
 533         // ggf. in Which-Id umrechnen
 534         USHORT nWhich = pArgs->GetPool()->GetWhich(nSlotId);
 535
 536         // ist das Item gesetzt oder bei bDeep==TRUE verf"ugbar?
 537         const SfxPoolItem *pItem = 0;
 538         if ( ( bDeep ? SFX_ITEM_AVAILABLE : SFX_ITEM_SET )
 539              <= pArgs->GetItemState( nWhich, bDeep, &pItem ) )
 540         {
 541             // stimmt der Typ "uberein?
 542             if ( !pItem || pItem->IsA(aType) )
 543                 return pItem;
 544
 545             // Item da aber falsch => Programmierfehler
 546             DBG_ERROR(  "invalid argument type" );
 547         }
 548     }
 549
 550     // keine Parameter, nicht gefunden oder falschen Typ gefunden
 551     return 0;
 552 }
 553
 554 //--------------------------------------------------------------------
 555
 556 void SfxRequest::SetReturnValue(const SfxPoolItem &rItem)
 557 {
 558     DBG_ASSERT(!pImp->pRetVal, "Returnwert mehrfach setzen?");
 559     if(pImp->pRetVal)
 560         delete pImp->pRetVal;
 561     pImp->pRetVal = rItem.Clone();
 562 }
 563
 564 //--------------------------------------------------------------------
 565
 566 const SfxPoolItem* SfxRequest::GetReturnValue() const
 567 {
 568     return pImp->pRetVal;
 569 }
 570
 571 //--------------------------------------------------------------------
 572
 573 void SfxRequest::Done
 574 (
 575     const SfxItemSet&   rSet,   /*      von der Applikation mitgeteilte Parameter,
 576                                     die z.B. in einem Dialog vom Benuter
 577                                     erfragt wurden, ggf. 0 falls keine
 578                                     Parameter gesetzt wurden */
 579
 580     FASTBOOL                    bKeep   /*  TRUE (default)
 581                                     'rSet' wird gepeichert und ist "uber
 582                                     GetArgs() abfragbar
 583
 584                                     FALSE
 585                                     'rSet' wird nicht kopiert (schneller) */
 586 )
 587
 588 /*      [Beschreibung]
 589
 590     Diese Methode mu\s in der <Execute-Methode> des <SfxSlot>s gerufen
 591     werden, der den SfxRequest ausgef"uhrt hat, wenn die Ausf"uhrung
 592     tats"achlich stattgefunden hat. Wird 'Done()' nicht gerufen, gilt
 593     der SfxRequest als abgebrochen.
 594
 595     Etwaige Returnwerte werden nur durchgereicht, wenn 'Done()' gerufen
 596     wurde. Ebenso werden beim Aufzeichnen von Makros nur echte
 597     Statements erzeugt, wenn 'Done()' gerufen wurde; f"ur SfxRequests,
 598     die nicht derart gekennzeichnet wurden, wird anstelle dessen eine
 599     auf die abgebrochene Funktion hinweisende Bemerkung ('rem') eingf"ugt.
 600
 601
 602     [Anmerkung]
 603
 604     'Done()' wird z.B. nicht gerufen, wenn ein durch die Funktion gestarteter
 605     Dialog vom Benutzer abgebrochen wurde oder das Ausf"uhren aufgrund
 606     eines falschen Kontextes (ohne Verwendung separater <SfxShell>s)
 607     nicht durchgef"uhrt werden konnte. 'Done()' mu\s sehr wohl gerufen
 608     werden, wenn das Ausf"uhren der Funktion zu einem regul"aren Fehler
 609     f"uhrte (z.B. Datei konnte nicht ge"offnet werden).
 610 */
 611
 612 {
 613     Done_Impl( &rSet );
 614
 615     // ggf. Items merken, damit StarDraw sie abfragen kann
 616     if ( bKeep )
 617     {
 618         if ( !pArgs )
 619         {
 620             pArgs = new SfxAllItemSet( rSet );
 621             pImp->SetPool( pArgs->GetPool() );
 622         }
 623         else
 624         {
 625             SfxItemIter aIter(rSet);
 626             const SfxPoolItem* pItem = aIter.FirstItem();
 627             while(pItem)
 628             {
 629                 if(!IsInvalidItem(pItem))
 630                     pArgs->Put(*pItem,pItem->Which());
 631                 pItem = aIter.NextItem();
 632             }
 633         }
 634     }
 635 }
 636
 637 //--------------------------------------------------------------------
 638
 639
 640 void SfxRequest::Done( BOOL bRelease )
 641 //      [<SfxRequest::Done(SfxItemSet&)>]
 642 {
 643     Done_Impl( pArgs );
 644     if( bRelease )
 645         DELETEZ( pArgs );
 646 }
 647
 648 //--------------------------------------------------------------------
 649
 650 void SfxRequest::ForgetAllArgs()
 651 {
 652     DELETEZ( pArgs );
 653     DELETEZ( pImp->pInternalArgs );
 654 }
 655
 656 //--------------------------------------------------------------------
 657
 658 BOOL SfxRequest::IsCancelled() const
 659 {
 660     return pImp->bCancelled;
 661 }
 662
 663 //--------------------------------------------------------------------
 664
 665 void SfxRequest::Cancel()
 666
 667 /*      [Beschreibung]
 668
 669     Markiert diesen Request als nicht mehr auszufuehren. Wird z.B. gerufen,
 670     wenn das Ziel (genauer dessen Pool) stirbt.
 671 */
 672
 673 {
 674     pImp->bCancelled = TRUE;
 675     pImp->SetPool( 0 );
 676     DELETEZ( pArgs );
 677 }
 678
 679 //--------------------------------------------------------------------
 680
 681
 682 void SfxRequest::Ignore()
 683
 684 /*      [Beschreibung]
 685
 686     Wird diese Methode anstelle von <SfxRequest::Done()> gerufen, dann
 687     wird dieser Request nicht recorded.
 688
 689
 690     [Bespiel]
 691
 692     Das Selektieren von Tools im StarDraw soll nicht aufgezeichnet werden,
 693     dieselben Slots sollen aber zum erzeugen der von den Tools zu
 694     erzeugenden Objekte verwendet werde. Also kann nicht NoRecord
 695     angegeben werden, dennoch soll u.U. nicht aufgezeichnet werden.
 696 */
 697
 698 {
 699     // als tats"achlich ausgef"uhrt markieren
 700     pImp->bIgnored = TRUE;
 701 }
 702
 703 //--------------------------------------------------------------------
 704
 705 void SfxRequest::Done_Impl
 706 (
 707     const SfxItemSet*   pSet    /*      von der Applikation mitgeteilte Parameter,
 708                                     die z.B. in einem Dialog vom Benuter
 709                                     erfragt wurden, ggf. 0 falls keine
 710                                     Parameter gesetzt wurden */
 711 )
 712
 713 /*      [Beschreibung]
 714
 715     Interne Methode zum als 'done' markieren des SfxRequest und zum Auswerten
 716     der Parameter in 'pSet' falls aufgezeichnet wird.
 717 */
 718
 719 {
 720     // als tats"achlich ausgef"uhrt markieren
 721     pImp->bDone = TRUE;
 722
 723     // nicht Recorden
 724     if ( !pImp->xRecorder.is() )
 725         return;
 726
 727     // wurde ein anderer Slot ausgef"uhrt als angefordert (Delegation)
 728     if ( nSlot != pImp->pSlot->GetSlotId() )
 729     {
 730         // Slot neu suchen
 731         pImp->pSlot = pImp->pShell->GetInterface()->GetSlot(nSlot);
 732         DBG_ASSERT( pImp->pSlot, "delegated SlotId not found" );
 733         if ( !pImp->pSlot ) // Hosentr"ger und G"urtel
 734             return;
 735     }
 736
 737     // record-f"ahig?
 738     // neues Recorden verwendet UnoName!
 739     if ( !pImp->pSlot->pUnoName )
 740     {
 741         ByteString aStr( "Recording not exported slot: ");
 742         aStr += ByteString::CreateFromInt32( pImp->pSlot->GetSlotId() );
 743         DBG_ERROR( aStr.GetBuffer() );
 744     }
 745
 746     if ( !pImp->pSlot->pUnoName ) // Hosentr"ger und G"urtel
 747         return;
 748
 749     // "ofters ben"otigte Werte
 750     SfxItemPool &rPool = pImp->pShell->GetPool();
 751
 752     // Property-Slot?
 753     if ( !pImp->pSlot->IsMode(SFX_SLOT_METHOD) )
 754     {
 755         // des Property als SfxPoolItem besorgen
 756         const SfxPoolItem *pItem;
 757         USHORT nWhich = rPool.GetWhich(pImp->pSlot->GetSlotId());
 758         SfxItemState eState = pSet ? pSet->GetItemState( nWhich, FALSE, &pItem ) : SFX_ITEM_UNKNOWN;
 759 #ifdef DBG_UTIL
 760         if ( SFX_ITEM_SET != eState )
 761         {
 762             ByteString aStr( "Recording property not available: ");
 763             aStr += ByteString::CreateFromInt32( pImp->pSlot->GetSlotId() );
 764             DBG_ERROR( aStr.GetBuffer() );
 765         }
 766 #endif
 767         uno::Sequence < beans::PropertyValue > aSeq;
 768         if ( eState == SFX_ITEM_SET )
 769             TransformItems( pImp->pSlot->GetSlotId(), *pSet, aSeq, pImp->pSlot );
 770         pImp->Record( aSeq );
 771     }
 772
 773     // alles in ein einziges Statement aufzeichnen?
 774     else if ( pImp->pSlot->IsMode(SFX_SLOT_RECORDPERSET) )
 775     {
 776         uno::Sequence < beans::PropertyValue > aSeq;
 777         if ( pSet )
 778             TransformItems( pImp->pSlot->GetSlotId(), *pSet, aSeq, pImp->pSlot );
 779         pImp->Record( aSeq );
 780     }
 781
 782     // jedes Item als einzelnes Statement recorden
 783     else if ( pImp->pSlot->IsMode(SFX_SLOT_RECORDPERITEM) )
 784     {
 785         if ( pSet )
 786         {
 787             // "uber die Items iterieren
 788             SfxItemIter aIter(*pSet);
 789             for ( const SfxPoolItem* pItem = aIter.FirstItem(); pItem; pItem = aIter.NextItem() )
 790             {
 791                 // die Slot-Id f"ur das einzelne Item ermitteln
 792                 USHORT nSlotId = rPool.GetSlotId( pItem->Which() );
 793                 if ( nSlotId == nSlot )
 794                 {
 795                     // mit Hosentr"ager und G"urtel reparieren des falschen Flags
 796                     DBG_ERROR( "recursion RecordPerItem - use RecordPerSet!" );
 797                     SfxSlot *pSlot = (SfxSlot*) pImp->pSlot;
 798                     pSlot->nFlags &= ~((ULONG)SFX_SLOT_RECORDPERITEM);
 799                     pSlot->nFlags &=  SFX_SLOT_RECORDPERSET;
 800                 }
 801
 802                 // einen Sub-Request recorden
 803                 SfxRequest aReq( pImp->pViewFrame, nSlotId );
 804                 if ( aReq.pImp->pSlot )
 805                     aReq.AppendItem( *pItem );
 806                 aReq.Done();
 807             }
 808         }
 809         else
 810         {
 811             HACK(hierueber nochmal nachdenken)
 812             pImp->Record( uno::Sequence < beans::PropertyValue >() );
 813         }
 814     }
 815 }
 816
 817 //--------------------------------------------------------------------
 818
 819 BOOL SfxRequest::IsDone() const
 820
 821 /*      [Beschreibung]
 822
 823     Mit dieser Methode kann abgefragt werden, ob der SfxRequest tats"achlich
 824     ausgef"uhrt wurde oder nicht. Wurde ein SfxRequest nicht ausgef"uhrt,
 825     liegt dies z.B. daran, da\s der Benutzer abgebrochen hat oder
 826     der Kontext f"ur diesen Request falsch war, dieses aber nicht "uber
 827     eine separate <SfxShell> realisiert wurde.
 828
 829     SfxRequest-Instanzen, die hier FALSE liefern, werden nicht recorded.
 830
 831
 832     [Querverweise]
 833
 834     <SfxRequest::Done(const SfxItemSet&)>
 835     <SfxRequest::Done()>
 836 */
 837
 838 {
 839     return pImp->bDone;
 840 }
 841
 842 //--------------------------------------------------------------------
 843
 844 SfxMacro* SfxRequest::GetRecordingMacro()
 845
 846 /*      [Beschreibung]
 847
 848     Mit dieser Methode kann abgefragt werden, ob und in welchem <SfxMacro>
 849     die SfxRequests gerade aufgezeichnet werden.
 850 */
 851
 852 {
 853     return NULL;
 854 }
 855
 856 //--------------------------------------------------------------------
 857
 858 com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > SfxRequest::GetMacroRecorder( SfxViewFrame* pView )
 859
 860 /*  [Beschreibung]
 861
 862     Hier wird versucht einen Recorder fuer dispatch() Aufrufe vom Frame zu bekommen.
 863     Dieser ist dort per Property an einem Supplier verfuegbar - aber nur dann, wenn
 864     recording angeschaltet wurde.
 865     (Siehe auch SfxViewFrame::MiscExec_Impl() und SID_RECORDING)
 866 */
 867
 868 {
 869     com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder;
 870
 871     com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xSet(
 872         (pView ? pView : SfxViewFrame::Current())->GetFrame()->GetFrameInterface(),
 873         com::sun::star::uno::UNO_QUERY);
 874
 875     if(xSet.is())
 876     {
 877         com::sun::star::uno::Any aProp = xSet->getPropertyValue(rtl::OUString::createFromAscii("DispatchRecorderSupplier"));
 878         com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorderSupplier > xSupplier;
 879         aProp >>= xSupplier;
 880         if(xSupplier.is())
 881             xRecorder = xSupplier->getDispatchRecorder();
 882     }
 883
 884     return xRecorder;
 885 }
 886
 887 BOOL SfxRequest::HasMacroRecorder( SfxViewFrame* pView )
 888 {
 889     return GetMacroRecorder( pView ).is();
 890 }
 891
 892
 893 //--------------------------------------------------------------------
 894
 895 BOOL SfxRequest::IsAPI() const
 896
 897 /*      [Beschreibung]
 898
 899     Liefert TRUE, wenn dieser SfxRequest von einer API (z.B. BASIC)
 900     erzeugt wurde, sonst FALSE.
 901 */
 902
 903 {
 904     return SFX_CALLMODE_API == ( SFX_CALLMODE_API & pImp->nCallMode );
 905 }
 906
 907 //--------------------------------------------------------------------
 908
 909
 910 FASTBOOL SfxRequest::IsRecording() const
 911
 912 /*      [Beschreibung]
 913
 914     Liefert TRUE, wenn dieser SfxRequest recorded werden soll, d.h.
 915     1. zu Zeit ein Makro aufgezeichnet wird
 916     2. dieser Request "uberhaupt aufgezeichnet wird
 917     3. der Request nicht von reiner API (z.B. BASIC) ausgeht,
 918     sonst FALSE.
 919 */
 920
 921 {
 922     return ( AllowsRecording() && GetMacroRecorder().is() );
 923 }
 924
 925 //--------------------------------------------------------------------
 926 void SfxRequest::SetModifier( USHORT nModi )
 927 {
 928     pImp->nModifier = nModi;
 929 }
 930
 931 //--------------------------------------------------------------------
 932 USHORT SfxRequest::GetModifier() const
 933 {
 934     return pImp->nModifier;
 935 }
 936
 937 //--------------------------------------------------------------------
 938
 939 void SfxRequest::SetTarget( const String &rTarget )
 940
 941 /*      [Beschreibung]
 942
 943     Mit dieser Methode kann das zu recordende Zielobjekt umgesetzt werden.
 944
 945
 946     [Beispiel]
 947
 948     Die BASIC-Methode 'Open' wird zwar von der Shell 'Application' ausgef"uhrt,
 949     aber am Objekt 'Documents' (global) recorded:
 950
 951         rReq.SetTarget( "Documents" );
 952
 953     Dies f"uhrt dann zu:
 954
 955         Documents.Open( ... )
 956 */
 957
 958 {
 959     pImp->aTarget = rTarget;
 960     pImp->bUseTarget = TRUE;
 961 }
 962
 963 void SfxRequest::AllowRecording( BOOL bSet )
 964 {
 965     pImp->bAllowRecording = bSet;
 966 }
 967
 968 BOOL SfxRequest::AllowsRecording() const
 969 {
 970     BOOL bAllow = pImp->bAllowRecording;
 971     if( !bAllow )
 972         bAllow = ( SFX_CALLMODE_API != ( SFX_CALLMODE_API & pImp->nCallMode ) ) &&
 973                  ( SFX_CALLMODE_RECORD == ( SFX_CALLMODE_RECORD & pImp->nCallMode ) );
 974     return bAllow;
 975 }
 976
 977 void SfxRequest::ReleaseArgs()
 978 {
 979     DELETEZ( pArgs );
 980     DELETEZ( pImp->pInternalArgs );
 981 }