sfx2/source/control/request.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <com/sun/star/frame/DispatchStatement.hpp>
  21 #include <com/sun/star/container/XIndexReplace.hpp>
  22 #include <com/sun/star/beans/PropertyValue.hpp>
  23 #include <com/sun/star/uno/Sequence.hxx>
  24 #include <com/sun/star/beans/XPropertySet.hpp>
  25 #include <com/sun/star/util/URLTransformer.hpp>
  26 #include <com/sun/star/util/XURLTransformer.hpp>
  27 #include <com/sun/star/frame/XDispatchRecorderSupplier.hpp>
  28 #include <svl/itemiter.hxx>
  29
  30 #include <svl/itempool.hxx>
  31 #include <svtools/itemdel.hxx>
  32
  33 #include <comphelper/processfactory.hxx>
  34
  35 #include <svl/smplhint.hxx>
  36
  37 #include <sfx2/request.hxx>
  38 #include <sfx2/dispatch.hxx>
  39 #include <sfx2/msg.hxx>
  40 #include <sfx2/viewfrm.hxx>
  41 #include <sfx2/objface.hxx>
  42 #include <sfx2/appuno.hxx>
  43 #include <rtl/strbuf.hxx>
  44
  45 //===================================================================
  46
  47 using namespace ::com::sun::star;
  48
  49 struct SfxRequest_Impl: public SfxListener
  50
  51 /*  [Description]
  52
  53     Implementation structur of the <SfxRequest> class.
  54 */
  55
  56 {
  57     SfxRequest*     pAnti;       // Owner because of dying pool
  58     String          aTarget;     // if possible from target object set by App
  59     SfxItemPool*    pPool;       // ItemSet build with this pool
  60     SfxPoolItem*    pRetVal;     // Return value belongs to itself
  61     SfxShell*       pShell;      // run from this shell
  62     const SfxSlot*  pSlot;       // executed Slot
  63     sal_uInt16          nModifier;   // which Modifier was pressed?
  64     sal_Bool            bDone;       // at all executed
  65     sal_Bool            bIgnored;    // Cancelled by the User
  66     sal_Bool            bCancelled;  // no longer notify
  67     sal_Bool            bUseTarget;  // aTarget was set by Application
  68     sal_uInt16              nCallMode;   // Synch/Asynch/API/Record
  69     sal_Bool                bAllowRecording;
  70     SfxAllItemSet*      pInternalArgs;
  71     SfxViewFrame*       pViewFrame;
  72
  73     com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder;
  74
  75                         SfxRequest_Impl( SfxRequest *pOwner )
  76                         : pAnti( pOwner)
  77                         , pPool(0)
  78                         , nModifier(0)
  79                         , bCancelled(sal_False)
  80                         , nCallMode( SFX_CALLMODE_SYNCHRON )
  81                         , bAllowRecording( sal_False )
  82                         , pInternalArgs( 0 )
  83                         , pViewFrame(0)
  84                         {}
  85     ~SfxRequest_Impl() { delete pInternalArgs; }
  86
  87
  88     void                SetPool( SfxItemPool *pNewPool );
  89     virtual void        Notify( SfxBroadcaster &rBC, const SfxHint &rHint );
  90     void                Record( const uno::Sequence < beans::PropertyValue >& rArgs );
  91 };
  92
  93
  94 //====================================================================
  95
  96 void SfxRequest_Impl::Notify( SfxBroadcaster&, const SfxHint &rHint )
  97 {
  98     SfxSimpleHint *pSimpleHint = PTR_CAST(SfxSimpleHint, &rHint);
  99     if ( pSimpleHint && pSimpleHint->GetId() == SFX_HINT_DYING )
 100         pAnti->Cancel();
 101 }
 102
 103 //====================================================================
 104
 105 void SfxRequest_Impl::SetPool( SfxItemPool *pNewPool )
 106 {
 107     if ( pNewPool != pPool )
 108     {
 109         if ( pPool )
 110             EndListening( pPool->BC() );
 111         pPool = pNewPool;
 112         if ( pNewPool )
 113             StartListening( pNewPool->BC() );
 114     }
 115 }
 116
 117 //====================================================================
 118
 119
 120 SfxRequest::~SfxRequest()
 121 {
 122     // Leave out Done() marked requests with 'rem'
 123     if ( pImp->xRecorder.is() && !pImp->bDone && !pImp->bIgnored )
 124         pImp->Record( uno::Sequence < beans::PropertyValue >() );
 125
 126     // Clear object
 127     delete pArgs;
 128     if ( pImp->pRetVal )
 129         DeleteItemOnIdle(pImp->pRetVal);
 130     delete pImp;
 131 }
 132 //--------------------------------------------------------------------
 133
 134
 135 SfxRequest::SfxRequest
 136 (
 137     const SfxRequest& rOrig
 138 )
 139 :   SfxHint( rOrig ),
 140     nSlot(rOrig.nSlot),
 141     pArgs(rOrig.pArgs? new SfxAllItemSet(*rOrig.pArgs): 0),
 142     pImp( new SfxRequest_Impl(this) )
 143 {
 144     pImp->bAllowRecording = rOrig.pImp->bAllowRecording;
 145     pImp->bDone = sal_False;
 146     pImp->bIgnored = sal_False;
 147     pImp->pRetVal = 0;
 148     pImp->pShell = 0;
 149     pImp->pSlot = 0;
 150     pImp->nCallMode = rOrig.pImp->nCallMode;
 151     pImp->bUseTarget = rOrig.pImp->bUseTarget;
 152     pImp->aTarget = rOrig.pImp->aTarget;
 153     pImp->nModifier = rOrig.pImp->nModifier;
 154
 155     // deep copy needed !
 156     pImp->pInternalArgs = (rOrig.pImp->pInternalArgs ? new SfxAllItemSet(*rOrig.pImp->pInternalArgs) : 0);
 157
 158     if ( pArgs )
 159         pImp->SetPool( pArgs->GetPool() );
 160     else
 161         pImp->SetPool( rOrig.pImp->pPool );
 162 }
 163 //--------------------------------------------------------------------
 164
 165
 166 SfxRequest::SfxRequest
 167 (
 168     SfxViewFrame*   pViewFrame,
 169     sal_uInt16          nSlotId
 170
 171 )
 172
 173 /*  [Description]
 174
 175     With this constructor events can subsequently be recorded that are not run
 176     across SfxDispatcher (eg from KeyInput() or mouse events). For this, a
 177     SfxRequest instance is created by this constructor and then proceed
 178     exactly as with a SfxRequest that in a <Slot-Execute-Method> is given as a
 179     parameter.
 180 */
 181
 182 :   nSlot(nSlotId),
 183     pArgs(0),
 184     pImp( new SfxRequest_Impl(this) )
 185 {
 186     pImp->bDone = sal_False;
 187     pImp->bIgnored = sal_False;
 188     pImp->SetPool( &pViewFrame->GetPool() );
 189     pImp->pRetVal = 0;
 190     pImp->pShell = 0;
 191     pImp->pSlot = 0;
 192     pImp->nCallMode = SFX_CALLMODE_SYNCHRON;
 193     pImp->bUseTarget = sal_False;
 194     pImp->pViewFrame = pViewFrame;
 195     if( pImp->pViewFrame->GetDispatcher()->GetShellAndSlot_Impl( nSlotId, &pImp->pShell, &pImp->pSlot, sal_True, sal_True ) )
 196     {
 197         pImp->SetPool( &pImp->pShell->GetPool() );
 198         pImp->xRecorder = SfxRequest::GetMacroRecorder( pViewFrame );
 199         pImp->aTarget = pImp->pShell->GetName();
 200     }
 201 #ifdef DBG_UTIL
 202     else
 203     {
 204         OStringBuffer aStr(RTL_CONSTASCII_STRINGPARAM(
 205             "Recording unsupported slot: "));
 206         aStr.append(static_cast<sal_Int32>(pImp->pPool->GetSlotId(nSlotId)));
 207         OSL_FAIL(aStr.getStr());
 208     }
 209 #endif
 210 }
 211
 212 //--------------------------------------------------------------------
 213
 214
 215 SfxRequest::SfxRequest
 216 (
 217     sal_uInt16        nSlotId,  // executed <Slot-Id>
 218     SfxCallMode     nMode,      // Synch/API/...
 219     SfxItemPool&  rPool     // necessary for the SfxItemSet for parameters
 220 )
 221
 222 // creates a SfxRequest without arguments
 223
 224 :   nSlot(nSlotId),
 225     pArgs(0),
 226     pImp( new SfxRequest_Impl(this) )
 227 {
 228     pImp->bDone = sal_False;
 229     pImp->bIgnored = sal_False;
 230     pImp->SetPool( &rPool );
 231     pImp->pRetVal = 0;
 232     pImp->pShell = 0;
 233     pImp->pSlot = 0;
 234     pImp->nCallMode = nMode;
 235     pImp->bUseTarget = sal_False;
 236 }
 237
 238 SfxRequest::SfxRequest
 239 (
 240     const SfxSlot* pSlot,       // executed <Slot-Id>
 241     const com::sun::star::uno::Sequence < com::sun::star::beans::PropertyValue >& rArgs,
 242     SfxCallMode     nMode,      // Synch/API/...
 243     SfxItemPool&   rPool        // necessary for the SfxItemSet for parameters
 244 )
 245 :   nSlot(pSlot->GetSlotId()),
 246     pArgs(new SfxAllItemSet(rPool)),
 247     pImp( new SfxRequest_Impl(this) )
 248 {
 249     pImp->bDone = sal_False;
 250     pImp->bIgnored = sal_False;
 251     pImp->SetPool( &rPool );
 252     pImp->pRetVal = 0;
 253     pImp->pShell = 0;
 254     pImp->pSlot = 0;
 255     pImp->nCallMode = nMode;
 256     pImp->bUseTarget = sal_False;
 257     TransformParameters( nSlot, rArgs, *pArgs, pSlot );
 258 }
 259
 260 //-----------------------------------------------------------------------
 261
 262 SfxRequest::SfxRequest
 263 (
 264     sal_uInt16                  nSlotId,
 265     sal_uInt16                  nMode,
 266     const SfxAllItemSet&    rSfxArgs
 267 )
 268
 269 // creates a SfxRequest with arguments
 270
 271 :   nSlot(nSlotId),
 272     pArgs(new SfxAllItemSet(rSfxArgs)),
 273     pImp( new SfxRequest_Impl(this) )
 274 {
 275     pImp->bDone = sal_False;
 276     pImp->bIgnored = sal_False;
 277     pImp->SetPool( rSfxArgs.GetPool() );
 278     pImp->pRetVal = 0;
 279     pImp->pShell = 0;
 280     pImp->pSlot = 0;
 281     pImp->nCallMode = nMode;
 282     pImp->bUseTarget = sal_False;
 283 }
 284 //--------------------------------------------------------------------
 285
 286 sal_uInt16 SfxRequest::GetCallMode() const
 287 {
 288     return pImp->nCallMode;
 289 }
 290
 291 //--------------------------------------------------------------------
 292
 293 sal_Bool SfxRequest::IsSynchronCall() const
 294 {
 295     return SFX_CALLMODE_SYNCHRON == ( SFX_CALLMODE_SYNCHRON & pImp->nCallMode );
 296 }
 297
 298 //--------------------------------------------------------------------
 299
 300 void SfxRequest::SetSynchronCall( sal_Bool bSynchron )
 301 {
 302     if ( bSynchron )
 303         pImp->nCallMode |= SFX_CALLMODE_SYNCHRON;
 304     else
 305         pImp->nCallMode &= ~(sal_uInt16) SFX_CALLMODE_SYNCHRON;
 306 }
 307
 308 void SfxRequest::SetInternalArgs_Impl( const SfxAllItemSet& rArgs )
 309 {
 310     delete pImp->pInternalArgs;
 311     pImp->pInternalArgs = new SfxAllItemSet( rArgs );
 312 }
 313
 314 const SfxItemSet* SfxRequest::GetInternalArgs_Impl() const
 315 {
 316     return pImp->pInternalArgs;
 317 }
 318
 319 //--------------------------------------------------------------------
 320
 321
 322 void SfxRequest_Impl::Record
 323 (
 324     const uno::Sequence < beans::PropertyValue >& rArgs  // current Parameter
 325 )
 326
 327 /*  [Description]
 328
 329     Internal helper method to create a repeatable description of the just
 330     executed SfxRequest.
 331 */
 332
 333 {
 334     String aCommand = OUString(".uno:");
 335     aCommand.AppendAscii( pSlot->GetUnoName() );
 336     OUString aCmd( aCommand );
 337     if(xRecorder.is())
 338     {
 339         uno::Reference< container::XIndexReplace > xReplace( xRecorder, uno::UNO_QUERY );
 340         if ( xReplace.is() && aCmd.compareToAscii(".uno:InsertText") == COMPARE_EQUAL )
 341         {
 342             sal_Int32 nCount = xReplace->getCount();
 343             if ( nCount )
 344             {
 345                 frame::DispatchStatement aStatement;
 346                 uno::Any aElement = xReplace->getByIndex(nCount-1);
 347                 if ( (aElement >>= aStatement) && aStatement.aCommand == aCmd )
 348                 {
 349                     OUString aStr;
 350                     OUString aNew;
 351                     aStatement.aArgs[0].Value >>= aStr;
 352                     rArgs[0].Value >>= aNew;
 353                     aStr += aNew;
 354                     aStatement.aArgs[0].Value <<= aStr;
 355                     aElement <<= aStatement;
 356                     xReplace->replaceByIndex( nCount-1, aElement );
 357                     return;
 358                 }
 359             }
 360         }
 361
 362         uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
 363
 364         uno::Reference< util::XURLTransformer > xTransform = util::URLTransformer::create( xContext );
 365
 366         com::sun::star::util::URL aURL;
 367         aURL.Complete = aCmd;
 368         xTransform->parseStrict(aURL);
 369
 370         if (bDone)
 371             xRecorder->recordDispatch(aURL,rArgs);
 372         else
 373             xRecorder->recordDispatchAsComment(aURL,rArgs);
 374     }
 375 }
 376
 377 //--------------------------------------------------------------------
 378
 379 void SfxRequest::Record_Impl
 380 (
 381     SfxShell&       rSh,    // the <SfxShell>, which has excecuted the Request
 382     const SfxSlot&  rSlot,  // the <SfxSlot>, which has executed the Request
 383     com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder,
 384     SfxViewFrame* pViewFrame
 385 )
 386
 387 /*  [Description]
 388
 389     This internal method marks the specified SfxMakro SfxRequest as recorded in
 390     SfxMakro. Pointer to the parameters in Done() is used again, thus has to
 391     still be alive.
 392 */
 393
 394 {
 395     pImp->pShell = &rSh;
 396     pImp->pSlot = &rSlot;
 397     pImp->xRecorder = xRecorder;
 398     pImp->aTarget = rSh.GetName();
 399     pImp->pViewFrame = pViewFrame;
 400 }
 401
 402 //--------------------------------------------------------------------
 403
 404 void SfxRequest::SetArgs( const SfxAllItemSet& rArgs )
 405 {
 406     delete pArgs;
 407     pArgs = new SfxAllItemSet(rArgs);
 408     pImp->SetPool( pArgs->GetPool() );
 409 }
 410
 411 //--------------------------------------------------------------------
 412
 413 void SfxRequest::AppendItem(const SfxPoolItem &rItem)
 414 {
 415     if(!pArgs)
 416         pArgs = new SfxAllItemSet(*pImp->pPool);
 417     pArgs->Put(rItem, rItem.Which());
 418 }
 419
 420 //--------------------------------------------------------------------
 421
 422 void SfxRequest::RemoveItem( sal_uInt16 nID )
 423 {
 424     if (pArgs)
 425     {
 426         pArgs->ClearItem(nID);
 427         if ( !pArgs->Count() )
 428             DELETEZ(pArgs);
 429     }
 430 }
 431
 432 //--------------------------------------------------------------------
 433
 434 const SfxPoolItem* SfxRequest::GetArg
 435 (
 436     sal_uInt16  nSlotId,  // Slot-Id or Which-Id of the parameters
 437     bool    bDeep,    // sal_False: do not seach in the Parent-ItemSets
 438     TypeId  aType     // != 0:  RTTI check with Assertion
 439 )   const
 440 {
 441     return GetItem( pArgs, nSlotId, bDeep, aType );
 442 }
 443
 444
 445 //--------------------------------------------------------------------
 446 const SfxPoolItem* SfxRequest::GetItem
 447 (
 448     const SfxItemSet* pArgs,
 449     sal_uInt16            nSlotId,  // Slot-Id or Which-Id of the parameters
 450     bool              bDeep,    // sal_False: do not seach in the Parent-ItemSets
 451     TypeId            aType     // != 0:  RTTI check with Assertion
 452 )
 453
 454 /*  [Description]
 455
 456     With this method the access to individual parameters in the SfxRequest is
 457     simplified. In particular the type-examination (by Assertion) is performed,
 458     whereby the application source code will be much clearer. In the product-
 459     version is a 0 returned, if the found item is not of the specified class.
 460
 461     [Example]
 462
 463     void MyShell::Execute( SfxRequest &rReq )
 464     {
 465         switch ( rReq.GetSlot() )
 466         {
 467             case SID_MY:
 468             {
 469                 ...
 470                 // An Example on not using the macros
 471                 const SfxInt32Item *pPosItem = (const SfxUInt32Item*)
 472                     rReq.GetArg( SID_POS, sal_False, TYPE(SfxInt32Item) );
 473                 sal_uInt16 nPos = pPosItem ? pPosItem->GetValue() : 0;
 474
 475                 // An Example on using the macros
 476                 SFX_REQUEST_ARG(rReq, pSizeItem, SfxInt32Item, SID_SIZE, sal_False);
 477                 sal_uInt16 nSize = pSizeItem ? pPosItem->GetValue() : 0;
 478
 479                 ...
 480             }
 481
 482             ...
 483         }
 484     }
 485 */
 486
 487 {
 488     if ( pArgs )
 489     {
 490         // Which may be converted to ID
 491         sal_uInt16 nWhich = pArgs->GetPool()->GetWhich(nSlotId);
 492
 493         // Is the item set or available at bDeep == sal_True?
 494         const SfxPoolItem *pItem = 0;
 495         if ( ( bDeep ? SFX_ITEM_AVAILABLE : SFX_ITEM_SET )
 496              <= pArgs->GetItemState( nWhich, bDeep, &pItem ) )
 497         {
 498             // Compare type
 499             if ( !pItem || pItem->IsA(aType) )
 500                 return pItem;
 501
 502             // Item of wrong type => Programming error
 503             OSL_FAIL(  "invalid argument type" );
 504         }
 505     }
 506
 507     // No Parameter, not found or wrong type
 508     return 0;
 509 }
 510
 511 //--------------------------------------------------------------------
 512
 513 void SfxRequest::SetReturnValue(const SfxPoolItem &rItem)
 514 {
 515     DBG_ASSERT(!pImp->pRetVal, "Set Return value multiple times?");
 516     if(pImp->pRetVal)
 517         delete pImp->pRetVal;
 518     pImp->pRetVal = rItem.Clone();
 519 }
 520
 521 //--------------------------------------------------------------------
 522
 523 const SfxPoolItem* SfxRequest::GetReturnValue() const
 524 {
 525     return pImp->pRetVal;
 526 }
 527
 528 //--------------------------------------------------------------------
 529
 530 void SfxRequest::Done
 531 (
 532     const SfxItemSet&   rSet,   /* parameters passed on by the application,
 533                                    that for example were asked for by the user
 534                                    in a dialogue, 0 if no parameters have been
 535                                    set */
 536
 537     bool                bKeep   /*  true (default)
 538                                    'rSet' is saved and GetArgs() queriable.
 539
 540                                     false
 541                                    'rSet' is not copied (faster) */
 542 )
 543
 544 /*  [Description]
 545
 546     This method must be called in the <Execute-Method> of the <SfxSlot>s, which
 547     has performed the SfxRequest when the execution actually took place. If
 548     'Done()' is not called, then the SfxRequest is considered canceled.
 549
 550     Any return values are passed only when 'Done()' was called. Similar, when
 551     recording a macro only true statements are generated if 'Done()' was
 552     called; for SfxRequests that were not identified as such will instead
 553     be commented out by inserting ('rem').
 554
 555     [Note]
 556
 557     'Done ()' is not called, for example when a dialoge started by the function
 558     was canceled by the user or if the execution could not be performed due to
 559     a wrong context (without use of separate <SfxShell>s). 'Done ()' will be
 560     launched, when executing the function led to a regular error
 561     (for example, file could not be opened).
 562 */
 563
 564 {
 565     Done_Impl( &rSet );
 566
 567     // Keep items if possible, so they can be queried by StarDraw.
 568     if ( bKeep )
 569     {
 570         if ( !pArgs )
 571         {
 572             pArgs = new SfxAllItemSet( rSet );
 573             pImp->SetPool( pArgs->GetPool() );
 574         }
 575         else
 576         {
 577             SfxItemIter aIter(rSet);
 578             const SfxPoolItem* pItem = aIter.FirstItem();
 579             while(pItem)
 580             {
 581                 if(!IsInvalidItem(pItem))
 582                     pArgs->Put(*pItem,pItem->Which());
 583                 pItem = aIter.NextItem();
 584             }
 585         }
 586     }
 587 }
 588
 589 //--------------------------------------------------------------------
 590
 591
 592 void SfxRequest::Done( sal_Bool bRelease )
 593 //  [<SfxRequest::Done(SfxItemSet&)>]
 594 {
 595     Done_Impl( pArgs );
 596     if( bRelease )
 597         DELETEZ( pArgs );
 598 }
 599
 600 //--------------------------------------------------------------------
 601
 602 void SfxRequest::ForgetAllArgs()
 603 {
 604     DELETEZ( pArgs );
 605     DELETEZ( pImp->pInternalArgs );
 606 }
 607
 608 //--------------------------------------------------------------------
 609
 610 sal_Bool SfxRequest::IsCancelled() const
 611 {
 612     return pImp->bCancelled;
 613 }
 614
 615 //--------------------------------------------------------------------
 616
 617 void SfxRequest::Cancel()
 618
 619 /*  [Description]
 620
 621     Marks this request as no longer executable. For example, if called when
 622     the target (more precisely, its pool) dies.
 623 */
 624
 625 {
 626     pImp->bCancelled = sal_True;
 627     pImp->SetPool( 0 );
 628     DELETEZ( pArgs );
 629 }
 630
 631 //--------------------------------------------------------------------
 632
 633
 634 void SfxRequest::Ignore()
 635
 636 /*  [Description]
 637
 638     If this method is called instead of <SfxRequest::Done()>, then this
 639     request is not recorded.
 640
 641     [Example]
 642
 643     The selecting of tools in StarDraw should not be recorded, but the same
 644     slots are to be used from the generation of the tools to the generated
 645     objects. Thus can NoRecords not be specified, i.e. should not be recorded.
 646 */
 647
 648 {
 649     // Mark as actually executed
 650     pImp->bIgnored = sal_True;
 651 }
 652
 653 //--------------------------------------------------------------------
 654
 655 void SfxRequest::Done_Impl
 656 (
 657     const SfxItemSet*   pSet    /* parameters passed on by the application,
 658                                    that for example were asked for by the user
 659                                    in a dialogue, 0 if no parameters have been
 660                                    set */
 661
 662 )
 663
 664 /*  [Description]
 665
 666     Internal method to mark SfxRequest with 'done' and to evaluate the
 667     parameters in 'pSet' in case it is recorded.
 668 */
 669
 670 {
 671     // Mark as actually executed
 672     pImp->bDone = sal_True;
 673
 674     // not Recording
 675     if ( !pImp->xRecorder.is() )
 676         return;
 677
 678     // was running a different slot than requested (Delegation)
 679     if ( nSlot != pImp->pSlot->GetSlotId() )
 680     {
 681         // Search Slot again
 682         pImp->pSlot = pImp->pShell->GetInterface()->GetSlot(nSlot);
 683         DBG_ASSERT( pImp->pSlot, "delegated SlotId not found" );
 684         if ( !pImp->pSlot ) // playing it safe
 685             return;
 686     }
 687
 688     // recordable?
 689     // new Recording uses UnoName!
 690     if ( !pImp->pSlot->pUnoName )
 691     {
 692         OStringBuffer aStr(RTL_CONSTASCII_STRINGPARAM(
 693             "Recording not exported slot: "));
 694         aStr.append(static_cast<sal_Int32>(pImp->pSlot->GetSlotId()));
 695         OSL_FAIL(aStr.getStr());
 696     }
 697
 698     if ( !pImp->pSlot->pUnoName ) // playing it safe
 699         return;
 700
 701     // often required values
 702     SfxItemPool &rPool = pImp->pShell->GetPool();
 703
 704     // Property-Slot?
 705     if ( !pImp->pSlot->IsMode(SFX_SLOT_METHOD) )
 706     {
 707         // get the property as SfxPoolItem
 708         const SfxPoolItem *pItem;
 709         sal_uInt16 nWhich = rPool.GetWhich(pImp->pSlot->GetSlotId());
 710         SfxItemState eState = pSet ? pSet->GetItemState( nWhich, sal_False, &pItem ) : SFX_ITEM_UNKNOWN;
 711 #ifdef DBG_UTIL
 712         if ( SFX_ITEM_SET != eState )
 713         {
 714             OStringBuffer aStr(RTL_CONSTASCII_STRINGPARAM(
 715                 "Recording property not available: "));
 716             aStr.append(static_cast<sal_Int32>(pImp->pSlot->GetSlotId()));
 717             OSL_FAIL(aStr.getStr());
 718         }
 719 #endif
 720         uno::Sequence < beans::PropertyValue > aSeq;
 721         if ( eState == SFX_ITEM_SET )
 722             TransformItems( pImp->pSlot->GetSlotId(), *pSet, aSeq, pImp->pSlot );
 723         pImp->Record( aSeq );
 724     }
 725
 726     // record everything in a single statement?
 727     else if ( pImp->pSlot->IsMode(SFX_SLOT_RECORDPERSET) )
 728     {
 729         uno::Sequence < beans::PropertyValue > aSeq;
 730         if ( pSet )
 731             TransformItems( pImp->pSlot->GetSlotId(), *pSet, aSeq, pImp->pSlot );
 732         pImp->Record( aSeq );
 733     }
 734
 735     // record each item as a single statement
 736     else if ( pImp->pSlot->IsMode(SFX_SLOT_RECORDPERITEM) )
 737     {
 738         if ( pSet )
 739         {
 740             // iterate over Items
 741             SfxItemIter aIter(*pSet);
 742             for ( const SfxPoolItem* pItem = aIter.FirstItem(); pItem; pItem = aIter.NextItem() )
 743             {
 744                 // to determine the slot ID for the individual item
 745                 sal_uInt16 nSlotId = rPool.GetSlotId( pItem->Which() );
 746                 if ( nSlotId == nSlot )
 747                 {
 748                     // play it safe; repair the wrong flags
 749                     OSL_FAIL( "recursion RecordPerItem - use RecordPerSet!" );
 750                     SfxSlot *pSlot = (SfxSlot*) pImp->pSlot;
 751                     pSlot->nFlags &= ~((sal_uIntPtr)SFX_SLOT_RECORDPERITEM);
 752                     pSlot->nFlags &=  SFX_SLOT_RECORDPERSET;
 753                 }
 754
 755                 // Record a Sub-Request
 756                 SfxRequest aReq( pImp->pViewFrame, nSlotId );
 757                 if ( aReq.pImp->pSlot )
 758                     aReq.AppendItem( *pItem );
 759                 aReq.Done();
 760             }
 761         }
 762         else
 763         {
 764           //HACK(think about this again)
 765             pImp->Record( uno::Sequence < beans::PropertyValue >() );
 766         }
 767     }
 768 }
 769
 770 //--------------------------------------------------------------------
 771
 772 sal_Bool SfxRequest::IsDone() const
 773
 774 /*  [Description]
 775
 776     With this method it can be queried whether the SfxRequest was actually
 777     executed or not. If a SfxRequest was not executed, then this is for example
 778     because it was canceled by the user or the context for this request was
 779     wrong, this was not implemented on a separate <SfxShell>.
 780
 781     SfxRequest instances that return sal_False will not be recorded.
 782
 783     [Cross-reference]
 784
 785     <SfxRequest::Done(const SfxItemSet&)>
 786     <SfxRequest::Done()>
 787 */
 788
 789 {
 790     return pImp->bDone;
 791 }
 792
 793 //--------------------------------------------------------------------
 794
 795 com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > SfxRequest::GetMacroRecorder( SfxViewFrame* pView )
 796
 797 /*  [Description]
 798
 799     This recorder is an attempt for dispatch () to get calls from the Frame.
 800     This is then available through a property by a supplier but only when
 801     recording was turned on.
 802
 803     (See also SfxViewFrame::MiscExec_Impl() and SID_RECORDING)
 804 */
 805
 806 {
 807     com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorder > xRecorder;
 808
 809     com::sun::star::uno::Reference< com::sun::star::beans::XPropertySet > xSet(
 810         (pView ? pView : SfxViewFrame::Current())->GetFrame().GetFrameInterface(),
 811         com::sun::star::uno::UNO_QUERY);
 812
 813     if(xSet.is())
 814     {
 815         com::sun::star::uno::Any aProp = xSet->getPropertyValue(OUString("DispatchRecorderSupplier"));
 816         com::sun::star::uno::Reference< com::sun::star::frame::XDispatchRecorderSupplier > xSupplier;
 817         aProp >>= xSupplier;
 818         if(xSupplier.is())
 819             xRecorder = xSupplier->getDispatchRecorder();
 820     }
 821
 822     return xRecorder;
 823 }
 824
 825 sal_Bool SfxRequest::HasMacroRecorder( SfxViewFrame* pView )
 826 {
 827     return GetMacroRecorder( pView ).is();
 828 }
 829
 830
 831 //--------------------------------------------------------------------
 832
 833 sal_Bool SfxRequest::IsAPI() const
 834
 835 /*  [Description]
 836
 837     Returns sal_True if this SfxRequest was generated by an API (for example BASIC),
 838     otherwise sal_False.
 839 */
 840
 841 {
 842     return SFX_CALLMODE_API == ( SFX_CALLMODE_API & pImp->nCallMode );
 843 }
 844
 845 //--------------------------------------------------------------------
 846 void SfxRequest::SetModifier( sal_uInt16 nModi )
 847 {
 848     pImp->nModifier = nModi;
 849 }
 850
 851 //--------------------------------------------------------------------
 852 sal_uInt16 SfxRequest::GetModifier() const
 853 {
 854     return pImp->nModifier;
 855 }
 856
 857 //--------------------------------------------------------------------
 858
 859 void SfxRequest::AllowRecording( sal_Bool bSet )
 860 {
 861     pImp->bAllowRecording = bSet;
 862 }
 863
 864 sal_Bool SfxRequest::AllowsRecording() const
 865 {
 866     sal_Bool bAllow = pImp->bAllowRecording;
 867     if( !bAllow )
 868         bAllow = ( SFX_CALLMODE_API != ( SFX_CALLMODE_API & pImp->nCallMode ) ) &&
 869                  ( SFX_CALLMODE_RECORD == ( SFX_CALLMODE_RECORD & pImp->nCallMode ) );
 870     return bAllow;
 871 }
 872
 873 void SfxRequest::ReleaseArgs()
 874 {
 875     DELETEZ( pArgs );
 876     DELETEZ( pImp->pInternalArgs );
 877 }
 878
 879 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */