sfx2/source/control/macro.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: macro.cxx,v $
  10  * $Revision: 1.13 $
  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
  34 #if OSL_DEBUG_LEVEL > 1
  35 #include <tools/stream.hxx>
  36 #endif
  37
  38 #include "macro.hxx"
  39 #include <sfx2/request.hxx>
  40 #include <sfx2/msg.hxx>
  41
  42 //====================================================================
  43
  44 SV_DECL_PTRARR_DEL( SfxStatements_Impl, SfxMacroStatement*, 16, 8 )
  45 SV_IMPL_PTRARR( SfxStatements_Impl, SfxMacroStatement* );
  46
  47 //--------------------------------------------------------------------
  48
  49 struct SfxMacro_Impl
  50
  51 /*      [Beschreibung]
  52
  53     Implementations-Struktur der Klasse <SfxMacro>.
  54 */
  55
  56 {
  57     SfxMacroMode                eMode;  /*      Zweck der <SfxMacro>-Instanz,
  58                                     Bedeutung siehe enum <SfxMacroMode> */
  59     SfxStatements_Impl  aList;  /*      Liste von aufgezeichneten Statements */
  60 };
  61
  62 //====================================================================
  63
  64 SfxMacroStatement::SfxMacroStatement
  65 (
  66     const SfxShell& /*rShell*/,         // <SfxShell>, die den Request ausf"uhrte
  67     const String&       /*rTarget*/,    // Name des Zielobjektes vor der Ausf"urhung
  68     BOOL                        /*bAbsolute*/,  // obsolet
  69     const SfxSlot&      rSlot,                  // der <SfxSlot>, der das Statement abspielen kann
  70     BOOL                        bRequestDone,   // wurde der Request tats"achlich ausgef"uhrt
  71     ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rArgs
  72 )
  73
  74 /*      [Beschreibung]
  75
  76     Dieser Konstruktor der Klasse SfxMacroStatement erzeugt ein Statement,
  77     bei dem ein Objekt angesprochen wird, welches durch 'rShell' angegeben
  78     ist. Dabei erfolgt die Addressierung je nach 'bAbsolute' absolut,
  79     also z.B. als '[mydoc.sdc]' oder relativ, also z.B. 'ActiveDocument'.
  80
  81     Je nach Art der Subklasse von 'rShell' ergeben sich folgende
  82     Ausdr"ucke:
  83
  84                           | absolut                  relativ
  85     -----------------------------------------------------------------------
  86     SfxApplication'       | 'StarCalc'                          'Application'
  87     SfxViewFrame'         | '[mydoc.sdc:1]'         'ActiveWindow'
  88     SfxViewShell'         | '[mydoc.sdc:1]'         'AvtiveWindow'
  89     SfxObjectShell'       | '[mydoc.sdc]'           'ActiveDocument'
  90     sonstige (Sub-Shells) | '[mydoc.sdc:1]'                     'ActiveWindow'
  91
  92     Dabei sind 'StarCalc' stellvertretend fuer den Namen der Applikation
  93     (Application::GetAppName()const). In der absoluten Fassung k"onnte
  94     die Selektion auch deskriptiv z.B. als 'CellSelection("A5-D8")')
  95     angesprochen werden, dazu mu\ jedoch vom Anwendungsprogrammierer der
  96     Konstruktor <SfxMacroStatement::SfxMacroStatement(const String&,
  97     const SfxSlot&,BOOL,SfxArguments*)> verwendet werden.
  98
  99     F"ur das so bezeichnete Objekt wird dann je nach Typ des Slots
 100     eine Zuweisung an eines seiner Properties oder der Aufruf einer seiner
 101     Methoden ausgedr"uckt.
 102
 103
 104     [Beispiele]
 105
 106     absolut:
 107     SCalc3.OpenDocument( "\docs\mydoc.sdd", "StarDraw Presentation", 0, 0 )
 108     [mydoc.sdd].Activate()
 109     [mydoc.sdd:1].SwitchToView( 2 )
 110     [mydoc.sdc:1:1].CellSelection( "A5-D8" ).LineColor = 192357
 111
 112     relativ:
 113     ActiveWindow.LineColor = 192357
 114
 115
 116     [Querverweise]
 117
 118     <SfxMacroStatement::SfxMacroStatement(const String&,const SfxSlot&,BOOL,SfxArguments*)>
 119     <SfxMacroStatement::SfxMacroStatement(const String&)>
 120 */
 121
 122 :       nSlotId( rSlot.GetSlotId() ),
 123     aArgs( rArgs ),
 124     bDone( bRequestDone ),
 125     pDummy( 0 )
 126 {
 127     // Workaround Recording nicht exportierter Slots (#25386#)
 128     if ( !rSlot.pName )
 129         return;
 130 /*
 131     // Objekt-Typ bestimmen
 132     FASTBOOL bIsApp = rShell.ISA(SfxApplication);
 133     FASTBOOL bIsDoc = rShell.ISA(SfxObjectShell);
 134     FASTBOOL bIsWin = !bIsApp && !bIsDoc &&
 135                       ( rShell.ISA(SfxViewShell) || rShell.ISA(SfxViewFrame) );
 136     FASTBOOL bIsSel = !bIsApp && !bIsDoc && !bIsWin;
 137
 138     // Objekt nicht schon im Slot-Namen enthalten?
 139     if ( bIsSel || rSlot.pName[0] == '.' )
 140     {
 141         // absolutes Aufzeichnen?
 142         if ( rSlot.IsMode( SFX_SLOT_RECORDABSOLUTE ) )
 143         {
 144             // an der Applikation oder am Modul
 145             if ( rShell.ISA(SfxApplication) || rShell.ISA(SfxModule) )
 146                 aStatement = rTarget;
 147
 148             // am Dokument?
 149             // '[' = 5Bh
 150             // ']' = 5Dh
 151             else if ( rShell.ISA(SfxObjectShell) )
 152             {
 153                 aStatement = 0x005B;
 154                 aStatement += rTarget;
 155                 aStatement += 0x005D;
 156             }
 157
 158             else if ( rShell.ISA(SfxViewFrame) )
 159             {
 160                 aStatement = 0x005B;
 161                 aStatement += String::CreateFromAscii("ViewFrame");//rShell.GetSbxObject()->GetName();
 162                 aStatement += 0x005D;
 163             }
 164
 165             else
 166             {
 167                 // an der View oder Sub-Shell
 168                 SfxViewShell *pViewShell = rShell.GetViewShell();
 169                 aStatement = 0x005B;
 170                 aStatement += String::CreateFromAscii("ViewShell");//pViewShell->GetViewFrame()->GetSbxObject()->GetName();
 171                 aStatement += 0x005D;
 172                 if ( !rShell.ISA(SfxViewFrame) )
 173                     // an einer Sub-Shell zus"atlich ".Selection" anh"angen
 174                     aStatement += DEFINE_CONST_UNICODE(".Selection");
 175             }
 176         }
 177         else // relatives Aufzeichnen
 178         {
 179             // an der Application?
 180             if ( rShell.ISA(SfxApplication) )
 181                 aStatement = DEFINE_CONST_UNICODE("Application");
 182
 183             // am Modul?
 184             else if ( rShell.ISA(SfxModule) )
 185                 aStatement = DEFINE_CONST_UNICODE("ActiveModule");
 186
 187             // am Dokument
 188             else if ( rShell.ISA(SfxObjectShell) )
 189                 aStatement = DEFINE_CONST_UNICODE("ActiveDocument");
 190
 191             // am Window
 192             else if ( rShell.ISA(SfxViewShell) || rShell.ISA(SfxViewFrame) )
 193                 aStatement = DEFINE_CONST_UNICODE("ActiveWindow");
 194
 195             else
 196                 // an einer Sub-Shell
 197                 aStatement = DEFINE_CONST_UNICODE("Selection");
 198         }
 199     }
 200
 201     if ( bIsSel )
 202     {
 203         // bei Selection ggf. noch den Namen der SubShell anh"angen
 204         const SfxShellObject *pShObj =
 205                     (const SfxShellObject*) rShell.GetSbxObject();
 206         if ( pShObj )
 207         {
 208             const SfxShellObject *pParentObj =
 209                         (const SfxShellObject*) pShObj->GetParent();
 210             SfxShell *pParentSh = pParentObj->GetShell();
 211             DBG_ASSERT( pParentSh->ISA(SfxViewFrame),
 212                         "parent of SubShell must be a Frame" );
 213             if ( rSlot.pName[0] == '.' )
 214             {
 215                 aStatement += '.';
 216                 aStatement += rShell.GetSbxObject()->GetName();
 217             }
 218         }
 219         else
 220             DBG_ASSERT( rSlot.pName[0] != '0', "recording unnamed object" );
 221     }
 222 */
 223     aStatement = DEFINE_CONST_UNICODE("Selection");
 224
 225     // an diesen Objekt-Ausdruck den Methoden-/Property-Namen und Parameter
 226     GenerateNameAndArgs_Impl( SfxRequest::GetRecordingMacro(), rSlot, bRequestDone, aArgs);
 227 }
 228
 229 //--------------------------------------------------------------------
 230
 231 SfxMacroStatement::SfxMacroStatement
 232 (
 233     const String&   rTarget,            // Objekt, was beim Playing angesprochen wird
 234     const SfxSlot&      rSlot,                  // der <SfxSlot>, der das Statement abspielen kann
 235     BOOL                        bRequestDone,   // wurde der Request tats"achlich ausgef"uhrt
 236     ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& rArgs
 237 )
 238
 239 /*      [Beschreibung]
 240
 241
 242     [Querverweise]
 243
 244     <SfxMacroStatement::SfxMacroStatement(const String&)>
 245     <SfxMacroStatement::SfxMacroStatement(const SfxShell&,BOOL,const SfxSlot&,BOOL,SfxArguments*)>
 246 */
 247
 248 :       nSlotId( rSlot.GetSlotId() ),
 249     aArgs( rArgs ),
 250     bDone( bRequestDone ),
 251     pDummy( 0 )
 252 {
 253     aStatement = rTarget;
 254     aStatement += '.';
 255     GenerateNameAndArgs_Impl( SfxRequest::GetRecordingMacro(), rSlot, bRequestDone, aArgs);
 256 }
 257
 258 //--------------------------------------------------------------------
 259
 260 SfxMacroStatement::SfxMacroStatement
 261 (
 262     const String&   rStatement          // manuell erzeugte(s) Statement(s)
 263 )
 264
 265 /*      [Beschreibung]
 266
 267     Dieser Konstruktor erzeugt eine SfxMacroStatement-Instanz, deren
 268     Aufbau vollst"andig vom Applikationsentwickler bestimmt wird. Da der
 269     angegebene String auch mehrere mit CR/LF getrennte Statements
 270     enthalten darf, ist damit ein weitgehender Eingriff in das Aufzeichnen
 271     von BASIC-Makros m"oglich, um Spezialf"alle zu behandeln.
 272
 273
 274     [Querverweise]
 275
 276     <SfxMacroStatement::SfxMacroStatement(const String&,const SfxSlot&,BOOL,SfxArguments*)>
 277     <SfxMacroStatement::SfxMacroStatement(const SfxShell&,BOOL,const SfxSlot&,BOOL,SfxArguments*)>
 278 */
 279
 280 :       nSlotId( 0 ),
 281        aStatement( rStatement ),
 282     bDone( TRUE ),
 283     pDummy( 0 )
 284 {
 285 }
 286
 287 //--------------------------------------------------------------------
 288
 289 SfxMacroStatement::SfxMacroStatement
 290 (
 291     const SfxMacroStatement&    rOrig // Original, von dem kopiert wird
 292 )
 293
 294 /*      [Beschreibung]
 295
 296     Copy-Konstruktor der SfxMacroStatement-Klasse.
 297 */
 298
 299 :       nSlotId( rOrig.nSlotId ),
 300     aStatement( rOrig.aStatement ),
 301        bDone( rOrig.bDone ),
 302     pDummy( 0 )
 303 {
 304     aArgs = rOrig.aArgs;
 305 }
 306
 307 //--------------------------------------------------------------------
 308
 309 SfxMacroStatement::~SfxMacroStatement()
 310
 311 /*      [Beschreibung]
 312
 313     Destruktor der Klasse SfxMacroStatement. Gibt die Liste der
 314     aktuellen Parameter frei.
 315 */
 316
 317 {
 318 }
 319
 320 //--------------------------------------------------------------------
 321
 322 void SfxMacroStatement::GenerateNameAndArgs_Impl
 323 (
 324     SfxMacro*           /*pMacro*/,                     // darin wird aufgezeichnet
 325     const SfxSlot&      rSlot,                  // der Slot, der das Statement abspielen kann
 326     BOOL                        bRequestDone,   // TRUE=wurde ausgef"uhrt, FALSE=abgebrochen
 327     ::com::sun::star::uno::Sequence < ::com::sun::star::beans::PropertyValue >& /*rArgs*/
 328 )
 329
 330 /*      [Beschreibung]
 331
 332     Interne Hilfsmethode zum generieren des Funktions-/Property-Names
 333     sowie der Parameter. Diese Methode wird nur verwendet, wenn der
 334     Anwendungsprogrammierer keinen eigenen Source an den <SfxRequest>
 335     geh"angt hat.
 336 */
 337
 338 {
 339     if ( aStatement.Len() && aStatement.GetChar( aStatement.Len() - 1 ) != '.'
 340          && rSlot.pName[0] != '.' )
 341         aStatement += '.';
 342
 343     // der Name des Slots ist der Name der Methode / des Properties
 344     aStatement += String::CreateFromAscii(rSlot.pName);
 345     if ( rSlot.IsMode(SFX_SLOT_METHOD) )
 346         aStatement += DEFINE_CONST_UNICODE("( ");
 347     else
 348         aStatement += DEFINE_CONST_UNICODE(" = ");
 349
 350     // alle zusammengesuchten Parameter rausschreiben
 351     if ( aArgs.getLength() )
 352         for ( USHORT nArg = 0; nArg < aArgs.getLength(); ++nArg )
 353         {
 354             // den Parameter textuell darstellen
 355             String aArg;
 356             ::com::sun::star::uno::Any& rValue = aArgs[nArg].Value;
 357             ::com::sun::star::uno::Type pType = rValue.getValueType();
 358             if ( pType == ::getBooleanCppuType() )
 359             {
 360                 sal_Bool bTemp = false;
 361                 rValue >>= bTemp;
 362                 aArg = bTemp ? DEFINE_CONST_UNICODE("TRUE") : DEFINE_CONST_UNICODE("FALSE");
 363             }
 364             else if ( pType == ::getCppuType((const sal_Int16*)0) )
 365             {
 366                 sal_uInt16 nTemp = 0;
 367                 rValue >>= nTemp;
 368                 aArg = String::CreateFromInt32( (sal_Int32) nTemp );
 369             }
 370             else if ( pType == ::getCppuType((const sal_Int32*)0) )
 371             {
 372                 sal_uInt32 nTemp = 0;
 373                 rValue >>= nTemp;
 374                 aArg = String::CreateFromInt32( nTemp );
 375             }
 376             else if ( pType == ::getCppuType((const ::rtl::OUString*)0) )
 377             {
 378                 ::rtl::OUString sTemp;
 379                 rValue >>= sTemp;
 380
 381                 // Anf"uhrungszeichen werden verdoppelt
 382                 XubString aRecordable( sTemp );
 383                 USHORT nPos = 0;
 384                 while ( TRUE )
 385                 {
 386                     nPos = aRecordable.SearchAndReplace( DEFINE_CONST_UNICODE('"'), DEFINE_CONST_UNICODE("\"\""), nPos );
 387                     if ( STRING_NOTFOUND == nPos )
 388                         break;
 389                     nPos += 2;
 390                 }
 391
 392                 // nicht druckbare Zeichen werden als chr$(...) geschrieben
 393                 FASTBOOL bPrevReplaced = FALSE;
 394                 for ( USHORT n = 0; n < aRecordable.Len(); ++n )
 395                 {
 396                     sal_Unicode cChar = aRecordable.GetChar(n);
 397                     if ( !( cChar>=32 && cChar!=127 ) ) // ALS ERSATZ FUER String::IsPrintable()!
 398                     {
 399                         XubString aReplacement( DEFINE_CONST_UNICODE("+chr$(") );
 400                         aReplacement += cChar;
 401
 402                         if ( bPrevReplaced )
 403                         {
 404                             aRecordable.Insert( aReplacement, n - 2 );
 405                             n = n + aReplacement.Len();
 406                             aRecordable.SetChar((unsigned short) (n-2), 0x0029);// ')' = 29h
 407                             aRecordable.Replace( n-1, 2, DEFINE_CONST_UNICODE("+\"") );
 408                             // ++n;
 409                         }
 410                         else
 411                         {
 412                             aReplacement += DEFINE_CONST_UNICODE(")+\"");
 413                             aRecordable.SetChar(n, 0x0022 );// '"' = 22h
 414                             aRecordable.Insert( aReplacement, n + 1 );
 415                             n = n + aReplacement.Len();
 416                         }
 417                         bPrevReplaced = TRUE;
 418                     }
 419                     else
 420                         bPrevReplaced = FALSE;
 421
 422                     // Argument in Anf"uhrungszeichen
 423                     aArg = '"';
 424                     aArg += aRecordable;
 425                     aArg += '"';
 426                 }
 427 /*
 428                 case SbxBYTE:
 429                 {
 430                     // als Zahl darstellen
 431                     aArg = (USHORT) rVar.GetByte();
 432                     break;
 433                 }
 434 */
 435             }
 436             else
 437             {
 438                 OSL_ENSURE(
 439                     pType == ::getVoidCppuType(), "Unknown Type in recorder!" );
 440             }
 441
 442             // den Parameter anh"angen
 443             aStatement += aArg;
 444             aStatement += DEFINE_CONST_UNICODE(", ");
 445         }
 446
 447     // Statement beeden
 448     if ( aArgs.getLength() )
 449         aStatement.Erase( aStatement.Len() - 2, 1 );
 450     else
 451         aStatement.Erase( aStatement.Len() - 1, 1 );
 452     if ( rSlot.IsMode(SFX_SLOT_METHOD) )
 453         aStatement += ')';
 454
 455     if ( !bRequestDone )
 456         // nicht als "Done()" gekennzeichnete Statements auskommentieren
 457         aStatement.InsertAscii( "rem ", 0 );
 458 }
 459
 460 //--------------------------------------------------------------------
 461
 462 SfxMacro::SfxMacro
 463 (
 464     SfxMacroMode        eMode           // Zweck der Instanz, siehe <SfxMacroMode>
 465 )
 466
 467 /*      [Beschreibung]
 468
 469     Konstruktor der Klasse SfxMacro. Instanzen dieser Klasse werden im
 470     SFx zu zwei Zwecken ben"otigt:
 471
 472     1. zum Aufzeichnen von Makros
 473     In diesem Fall wird der Konstruktor mit SFX_MACRO_RECORDINGABSOLUTE
 474     oder SFX_MACRO_RECORDINGRELATIVE aufgerufen. Es sollte sich um eine
 475     Instanz einer abgeleiteten Klasse handeln, um in der Ableitung
 476     die Information dar"uber unterzubringen, wo das Makro gespeichert
 477     werden soll. Ein solches Makro solle sich dann in seinem Destruktor
 478     an der vom Benutzer gew"ahlten Stelle speichern.
 479
 480     2. zum Zuordnen von exisitierenden Makros
 481     In diesem Fall wird der Konstruktor mit SFX_MACRO_EXISTING aufgerufen.
 482     Eine solche Instanz wird z.B. ben"otigt, wenn Makros auf Events
 483     oder <SfxControllerItem>s konfiguriert werden sollen.
 484 */
 485
 486 :       pImp( new SfxMacro_Impl )
 487
 488 {
 489     pImp->eMode = eMode;
 490 }
 491
 492 //--------------------------------------------------------------------
 493
 494 SfxMacro::~SfxMacro()
 495
 496 /*      [Beschreibung]
 497
 498     Virtueller Destruktor der Klasse SfxMacro. Dieser sollte in den
 499     abgeleiteten Klassen "uberladen werden, um in den Modi
 500     SFX_MACRO_RECORDINGABSOLUTE und SFX_MACRO_RECORDINGRELATIVE den
 501     aufgezeichneten Source abzuspeichern.
 502
 503
 504     [Querverweise]
 505
 506     <SfxMacro::GenerateSource()const>
 507 */
 508
 509 {
 510 #if OSL_DEBUG_LEVEL > 1
 511     SvFileStream aStream( String::CreateFromAscii("file:///f:/testmacro.bas" ), STREAM_STD_READWRITE | STREAM_TRUNC );
 512     aStream << ByteString( GenerateSource(), RTL_TEXTENCODING_UTF8 ).GetBuffer();
 513 #endif
 514     delete pImp;
 515 }
 516
 517 //--------------------------------------------------------------------
 518
 519 SfxMacroMode SfxMacro::GetMode() const
 520
 521 /*      [Beschreibung]
 522
 523     Liefert den Modus, der besagt zu welchem Zweck das SfxMacro konstruiert
 524     wurde.
 525
 526
 527     [Querverweise]
 528
 529     enum <SfxMacroMode>
 530 */
 531
 532 {
 533     return pImp->eMode;
 534 }
 535
 536 //--------------------------------------------------------------------
 537
 538 void SfxMacro::Record
 539 (
 540     SfxMacroStatement*  pStatement      // aufzuzeichnendes <SfxMacroStatement>
 541 )
 542
 543 /*      [Beschreibung]
 544
 545     Diese Methode zeichnet das als Parameter "ubergeben Statement auf.
 546     Die Instanz auf die der "ubergebe Pointer zeigt, geht in das Eigentum
 547     des SfxMacro "uber.
 548
 549     Der Aufruf ist nur g"ultig, wenn es sich um ein SfxMacro handelt,
 550     welches mit SFX_MACRO_RECORDINGABSOLUTE oder SFX_MACRO_RECORDINGRELATIVE
 551     konstruiert wirde.
 552
 553
 554     [Querverweise]
 555
 556     <SfxMacro::Replace(SfxMacroStatement*)>
 557     <SfxMacro::Remove()>
 558     <SfxMacro::GetLastStatement()const>
 559 */
 560
 561 {
 562     DBG_ASSERT( pImp->eMode != SFX_MACRO_EXISTING, "invalid call to non-recording SfxMacro" );
 563     pImp->aList.C40_INSERT( SfxMacroStatement, pStatement, pImp->aList.Count() );
 564 }
 565
 566 //--------------------------------------------------------------------
 567
 568 void SfxMacro::Replace
 569 (
 570     SfxMacroStatement*  pStatement      // aufzuzeichnendes <SfxMacroStatement>
 571 )
 572
 573 /*      [Beschreibung]
 574
 575     Diese Methode zeichnet das als Parameter "ubergeben Statement auf.
 576     Dabei wird das jeweils zuletzt aufgezeichnete Statement "uberschrieben.
 577     Die Instanz auf die der "ubergebe Pointer zeigt, geht in das Eigentum
 578     des SfxMacro "uber.
 579
 580     Mit dieser Methode ist es m"oglich, Statements zusammenzufassen. Z.B.
 581     anstelle f"unfmal hintereinander 'CursorLeft()' aufzurufen, k"onnte
 582     das zu 'CursorLeft(5)' zusammengefa\st werden. Oder anstelle ein Wort
 583     Buchstabe f"ur Buchstabe aufzubauen, k"onnte dies durch ein einziges
 584     Statement 'InsertString("Hallo")' ersetzt werden.
 585
 586     Der Aufruf ist nur g"ultig, wenn es sich um ein SfxMacro handelt,
 587     welches mit SFX_MACRO_RECORDINGABSOLUTE oder SFX_MACRO_RECORDINGRELATIVE
 588     konstruiert wurde und bereits ein aufgezeichnetes Statement vorhanden
 589     ist.
 590
 591
 592     [Anmerkung]
 593
 594     Diese Methode wird typischerweise aus den Execute-Methoden der
 595     <SfxSlot>s von den Applikationsentwicklern gerufen.
 596
 597
 598     [Querverweise]
 599
 600     <SfxMacro::Record(SfxMacroStatement*)>
 601     <SfxMacro::Remove()>
 602     <SfxMacro::GetLastStatement()const>
 603 */
 604
 605 {
 606     DBG_ASSERT( pImp->eMode != SFX_MACRO_EXISTING, "invalid call to non-recording SfxMacro" );
 607     DBG_ASSERT( pImp->aList.Count(), "no replaceable statement available" );
 608     pImp->aList.Remove( pImp->aList.Count() - 1 );
 609     pImp->aList.C40_INSERT( SfxMacroStatement,pStatement, pImp->aList.Count() );
 610 }
 611
 612 //--------------------------------------------------------------------
 613
 614 void SfxMacro::Remove()
 615
 616 /*      [Beschreibung]
 617
 618     Diese Methode l"oscht das zuletzt aufgezeichnete <SfxMacroStatement>
 619     und entfernt es aus dem Macro.
 620
 621     Mit dieser Methode ist es m"oglich, Statements zusammenzufassen. Z.B.
 622     anstelle f"unfmal hintereinander 'CursorLeft()' aufzurufen, k"onnte
 623     das zu 'CursorLeft(5)' zusammengefa\st werden. Oder anstelle ein Wort
 624     Buchstabe f"ur Buchstabe aufzubauen, k"onnte dies durch ein einziges
 625     Statement 'InsertString("Hallo")' ersetzt werden.
 626
 627     Der Aufruf ist nur g"ultig, wenn es sich um ein SfxMacro handelt,
 628     welches mit SFX_MACRO_RECORDINGABSOLUTE oder SFX_MACRO_RECORDINGRELATIVE
 629     konstruiert wurde und bereits ein aufgezeichnetes Statement vorhanden
 630     ist.
 631
 632
 633     [Anmerkung]
 634
 635     Diese Methode wird typischerweise aus den Execute-Methoden der
 636     <SfxSlot>s von den Applikationsentwicklern gerufen.
 637
 638
 639     [Querverweise]
 640
 641     <SfxMacro::Replace(SfxMacroStatement*)>
 642     <SfxMacro::Record(SfxMacroStatement*)>
 643     <SfxMacro::GetLastStatement()const>
 644 */
 645
 646 {
 647     DBG_ASSERT( pImp->eMode != SFX_MACRO_EXISTING, "invalid call to non-recording SfxMacro" );
 648     DBG_ASSERT( pImp->aList.Count(), "no replaceable statement available" );
 649     pImp->aList.Remove( pImp->aList.Count() - 1 );
 650 }
 651
 652 //--------------------------------------------------------------------
 653
 654 const SfxMacroStatement* SfxMacro::GetLastStatement() const
 655
 656 /*  [Beschreibung]
 657
 658     Mit dieser Methode kann auf das jeweils zuletzt aufgezeichnete Statement
 659     lesend zugegriffen werden. Zusammen mit der Methode
 660     <SfxMacro::Replace(SfxMacroStatement*)> ergibt sich dadurch die
 661     M"oglichkeit, Statements zusammenzufassen.
 662
 663     Der Aufruf ist nur g"ultig, wenn es sich um ein SfxMacro handelt,
 664     welches mit SFX_MACRO_RECORDINGABSOLUTE oder SFX_MACRO_RECORDINGRELATIVE
 665     konstruiert wurde.
 666
 667
 668     [Querverweise]
 669
 670     <SfxMacro::Record(SfxMacroStatement*)>
 671     <SfxMacro::Replace(SfxMacroStatement*)>
 672 */
 673
 674 {
 675     DBG_ASSERT( pImp->eMode != SFX_MACRO_EXISTING, "invalid call to non-recording SfxMacro" );
 676     if ( pImp->aList.Count() )
 677         return pImp->aList.GetObject( pImp->aList.Count() - 1 );
 678     return 0;
 679 }
 680
 681 //--------------------------------------------------------------------
 682
 683 String SfxMacro::GenerateSource() const
 684
 685 /*  [Beschreibung]
 686
 687     Diese Funktion generiert aus den, seit dem Konstruieren der Instanz
 688     bis zum Zeitpunkt des Aufrufs dieser Methode aufgezeichneten
 689     <SfxMacroStatement>s einen BASIC-Sourcecode, der die Statements,
 690     jedoch nicht den Header ('Sub X') und den Footer ('End Sub') enth"alt.
 691
 692
 693     [Querverweise]
 694
 695     <SfxMacro::Record(SfxMacroStatement*)>
 696     <SfxMacro::Repeat(SfxMacroStatement*)>
 697 */
 698
 699 {
 700     DBG_ASSERT( pImp->eMode != SFX_MACRO_EXISTING, "invalid call to non-recording SfxMacro" );
 701     String aSource;
 702     for ( USHORT n = 0; n < pImp->aList.Count(); ++n )
 703     {
 704         aSource += pImp->aList.GetObject(n)->GetStatement();
 705         if ( (n+1) < pImp->aList.Count() )
 706             aSource += DEFINE_CONST_UNICODE("\n");
 707     }
 708
 709     return aSource;
 710 }
 711