basctl/source/basicide/macrodlg.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
  21 #include <macrodlg.hxx>
  22 #include <macrodlg.hrc>
  23 #include <basidesh.hxx>
  24 #include <baside2.hrc>
  25
  26 #include <iderdll.hxx>
  27 #include <iderdll2.hxx>
  28
  29 #include <moduldlg.hxx>
  30 #include <basic/basmgr.hxx>
  31 #include <basic/sbmeth.hxx>
  32 #include <basic/sbmod.hxx>
  33
  34 #include <sfx2/dispatch.hxx>
  35 #include <sfx2/minfitem.hxx>
  36 #include <sfx2/request.hxx>
  37
  38
  39 #include <map>
  40
  41 namespace basctl
  42 {
  43
  44 using ::std::map;
  45 using ::std::pair;
  46
  47 using namespace ::com::sun::star;
  48 using namespace ::com::sun::star::uno;
  49
  50 MacroChooser::MacroChooser( vcl::Window* pParnt, bool bCreateEntries )
  51     : SfxModalDialog(pParnt, "BasicMacroDialog", "modules/BasicIDE/ui/basicmacrodialog.ui")
  52     , bNewDelIsDel(true)
  53     // the Sfx doesn't aske the BasicManger whether modified or not
  54     // => start saving in case of a change without a into the BasicIDE.
  55     , bForceStoreBasic(false)
  56     , nMode(All)
  57 {
  58     get(m_pMacroNameEdit, "macronameedit");
  59     get(m_pMacroFromTxT, "macrofromft");
  60     get(m_pMacrosSaveInTxt, "macrotoft");
  61     get(m_pBasicBox, "libraries");
  62     get(m_pMacrosInTxt, "existingmacrosft");
  63     m_aMacrosInTxtBaseStr = m_pMacrosInTxt->GetText();
  64     get(m_pMacroBox, "macros");
  65     get(m_pRunButton, "run");
  66     get(m_pCloseButton, "close");
  67     get(m_pAssignButton, "assign");
  68     get(m_pEditButton, "edit");
  69     get(m_pDelButton, "delete");
  70     get(m_pOrganizeButton, "organize");
  71     get(m_pNewLibButton, "newlibrary");
  72     get(m_pNewModButton, "newmodule");
  73
  74     m_pMacroBox->SetSelectionMode( SINGLE_SELECTION );
  75     m_pMacroBox->SetHighlightRange(); // select over the whole width
  76
  77     m_pRunButton->SetClickHdl( LINK( this, MacroChooser, ButtonHdl ) );
  78     m_pCloseButton->SetClickHdl( LINK( this, MacroChooser, ButtonHdl ) );
  79     m_pAssignButton->SetClickHdl( LINK( this, MacroChooser, ButtonHdl ) );
  80     m_pEditButton->SetClickHdl( LINK( this, MacroChooser, ButtonHdl ) );
  81     m_pDelButton->SetClickHdl( LINK( this, MacroChooser, ButtonHdl ) );
  82     m_pOrganizeButton->SetClickHdl( LINK( this, MacroChooser, ButtonHdl ) );
  83
  84     // Buttons only for MacroChooser::Recording
  85     m_pNewLibButton->SetClickHdl( LINK( this, MacroChooser, ButtonHdl ) );
  86     m_pNewModButton->SetClickHdl( LINK( this, MacroChooser, ButtonHdl ) );
  87     m_pNewLibButton->Hide();       // default
  88     m_pNewModButton->Hide();       // default
  89     m_pMacrosSaveInTxt->Hide();    // default
  90
  91     m_pMacrosInTxt->SetStyle( WB_NOMULTILINE | WB_PATHELLIPSIS );
  92
  93     m_pMacroNameEdit->SetModifyHdl( LINK( this, MacroChooser, EditModifyHdl ) );
  94
  95     m_pBasicBox->SetSelectHdl( LINK( this, MacroChooser, BasicSelectHdl ) );
  96
  97     m_pMacroBox->SetDoubleClickHdl( LINK( this, MacroChooser, MacroDoubleClickHdl ) );
  98     m_pMacroBox->SetSelectHdl( LINK( this, MacroChooser, MacroSelectHdl ) );
  99
 100     m_pBasicBox->SetMode( BROWSEMODE_MODULES );
 101     m_pBasicBox->SetStyle( WB_TABSTOP | WB_BORDER |
 102                         WB_HASLINES | WB_HASLINESATROOT |
 103                         WB_HASBUTTONS | WB_HASBUTTONSATROOT |
 104                         WB_HSCROLL );
 105
 106     if (SfxDispatcher* pDispatcher = GetDispatcher())
 107         pDispatcher->Execute( SID_BASICIDE_STOREALLMODULESOURCES );
 108
 109     if ( bCreateEntries )
 110         m_pBasicBox->ScanAllEntries();
 111 }
 112
 113 MacroChooser::~MacroChooser()
 114 {
 115     disposeOnce();
 116 }
 117
 118 void MacroChooser::dispose()
 119 {
 120     if ( bForceStoreBasic )
 121     {
 122         SfxGetpApp()->SaveBasicAndDialogContainer();
 123         bForceStoreBasic = false;
 124     }
 125     m_pMacroNameEdit.clear();
 126     m_pMacroFromTxT.clear();
 127     m_pMacrosSaveInTxt.clear();
 128     m_pBasicBox.clear();
 129     m_pMacrosInTxt.clear();
 130     m_pMacroBox.clear();
 131     m_pRunButton.clear();
 132     m_pCloseButton.clear();
 133     m_pAssignButton.clear();
 134     m_pEditButton.clear();
 135     m_pDelButton.clear();
 136     m_pOrganizeButton.clear();
 137     m_pNewLibButton.clear();
 138     m_pNewModButton.clear();
 139     SfxModalDialog::dispose();
 140 }
 141
 142 void MacroChooser::StoreMacroDescription()
 143 {
 144     EntryDescriptor aDesc = m_pBasicBox->GetEntryDescriptor(m_pBasicBox->FirstSelected());
 145     OUString aMethodName;
 146     SvTreeListEntry* pEntry = m_pMacroBox->FirstSelected();
 147     if ( pEntry )
 148         aMethodName = m_pMacroBox->GetEntryText( pEntry );
 149     else
 150         aMethodName = m_pMacroNameEdit->GetText();
 151     if ( !aMethodName.isEmpty() )
 152     {
 153         aDesc.SetMethodName( aMethodName );
 154         aDesc.SetType( OBJ_TYPE_METHOD );
 155     }
 156
 157     if (ExtraData* pData = basctl::GetExtraData())
 158         pData->SetLastEntryDescriptor( aDesc );
 159 }
 160
 161 void MacroChooser::RestoreMacroDescription()
 162 {
 163     EntryDescriptor aDesc;
 164     if (Shell* pShell = GetShell())
 165     {
 166         if (BaseWindow* pCurWin = pShell->GetCurWindow())
 167             aDesc = pCurWin->CreateEntryDescriptor();
 168     }
 169     else
 170     {
 171         if (ExtraData* pData = basctl::GetExtraData())
 172             aDesc = pData->GetLastEntryDescriptor();
 173     }
 174
 175     m_pBasicBox->SetCurrentEntry( aDesc );
 176
 177     OUString aLastMacro( aDesc.GetMethodName() );
 178     if ( !aLastMacro.isEmpty() )
 179     {
 180         // find entry in macro box
 181         SvTreeListEntry* pEntry = 0;
 182         sal_uLong nPos = 0;
 183         SvTreeListEntry* pE = m_pMacroBox->GetEntry( nPos );
 184         while ( pE )
 185         {
 186             if ( m_pMacroBox->GetEntryText( pE ) == aLastMacro )
 187             {
 188                 pEntry = pE;
 189                 break;
 190             }
 191             pE = m_pMacroBox->GetEntry( ++nPos );
 192         }
 193
 194         if ( pEntry )
 195             m_pMacroBox->SetCurEntry( pEntry );
 196         else
 197         {
 198             m_pMacroNameEdit->SetText( aLastMacro );
 199             m_pMacroNameEdit->SetSelection( Selection( 0, 0 ) );
 200         }
 201     }
 202 }
 203
 204 short MacroChooser::Execute()
 205 {
 206     RestoreMacroDescription();
 207     m_pRunButton->GrabFocus();
 208
 209     // #104198 Check if "wrong" document is active
 210     SvTreeListEntry* pSelectedEntry = m_pBasicBox->GetCurEntry();
 211     EntryDescriptor aDesc( m_pBasicBox->GetEntryDescriptor( pSelectedEntry ) );
 212     const ScriptDocument& rSelectedDoc( aDesc.GetDocument() );
 213
 214     // App Basic is always ok, so only check if shell was found
 215     if( rSelectedDoc.isDocument() && !rSelectedDoc.isActive() )
 216     {
 217         // Search for the right entry
 218         sal_uLong nRootPos = 0;
 219         SvTreeListEntry* pRootEntry = m_pBasicBox->GetEntry( nRootPos );
 220         while( pRootEntry )
 221         {
 222             EntryDescriptor aCmpDesc( m_pBasicBox->GetEntryDescriptor( pRootEntry ) );
 223             const ScriptDocument& rCmpDoc( aCmpDesc.GetDocument() );
 224             if ( rCmpDoc.isDocument() && rCmpDoc.isActive() )
 225             {
 226                 SvTreeListEntry* pEntry = pRootEntry;
 227                 SvTreeListEntry* pLastValid = pEntry;
 228                 while ( pEntry )
 229                 {
 230                     pLastValid = pEntry;
 231                     pEntry = m_pBasicBox->FirstChild( pEntry );
 232                 }
 233                 if( pLastValid )
 234                     m_pBasicBox->SetCurEntry( pLastValid );
 235             }
 236             pRootEntry = m_pBasicBox->GetEntry( ++nRootPos );
 237         }
 238     }
 239
 240     CheckButtons();
 241     UpdateFields();
 242
 243     if ( StarBASIC::IsRunning() )
 244         m_pCloseButton->GrabFocus();
 245
 246     vcl::Window* pPrevDlgParent = Application::GetDefDialogParent();
 247     Application::SetDefDialogParent( this );
 248     short nRet = ModalDialog::Execute();
 249     // #57314# If the BasicIDE has been activated, don't reset the DefModalDialogParent to the inactive document.
 250     if ( Application::GetDefDialogParent() == this )
 251         Application::SetDefDialogParent( pPrevDlgParent );
 252     return nRet;
 253 }
 254
 255
 256 void MacroChooser::EnableButton( Button& rButton, bool bEnable )
 257 {
 258     if ( bEnable )
 259     {
 260         if (nMode == ChooseOnly || nMode == Recording)
 261             rButton.Enable(&rButton == m_pRunButton);
 262         else
 263             rButton.Enable();
 264     }
 265     else
 266         rButton.Disable();
 267 }
 268
 269
 270
 271
 272 SbMethod* MacroChooser::GetMacro()
 273 {
 274     SbMethod* pMethod = 0;
 275     SbModule* pModule = m_pBasicBox->FindModule( m_pBasicBox->GetCurEntry() );
 276     if ( pModule )
 277     {
 278         SvTreeListEntry* pEntry = m_pMacroBox->FirstSelected();
 279         if ( pEntry )
 280         {
 281             OUString aMacroName( m_pMacroBox->GetEntryText( pEntry ) );
 282             pMethod = static_cast<SbMethod*>(pModule->GetMethods()->Find( aMacroName, SbxCLASS_METHOD ));
 283         }
 284     }
 285     return pMethod;
 286 }
 287
 288
 289
 290 void MacroChooser::DeleteMacro()
 291 {
 292     SbMethod* pMethod = GetMacro();
 293     DBG_ASSERT( pMethod, "DeleteMacro: Kein Macro !" );
 294     if ( pMethod && QueryDelMacro( pMethod->GetName(), this ) )
 295     {
 296         if (SfxDispatcher* pDispatcher = GetDispatcher())
 297             pDispatcher->Execute( SID_BASICIDE_STOREALLMODULESOURCES );
 298
 299         // mark current doc as modified:
 300         StarBASIC* pBasic = FindBasic(pMethod);
 301         assert(pBasic && "Basic?!");
 302         BasicManager* pBasMgr = FindBasicManager( pBasic );
 303         DBG_ASSERT( pBasMgr, "BasMgr?" );
 304         ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) );
 305         if ( aDocument.isDocument() )
 306         {
 307             aDocument.setDocumentModified();
 308             if (SfxBindings* pBindings = GetBindingsPtr())
 309                 pBindings->Invalidate( SID_SAVEDOC );
 310         }
 311
 312         SbModule* pModule = pMethod->GetModule();
 313         DBG_ASSERT( pModule, "DeleteMacro: Kein Modul?!" );
 314         OUString aSource( pModule->GetSource32() );
 315         sal_uInt16 nStart, nEnd;
 316         pMethod->GetLineRange( nStart, nEnd );
 317         pModule->GetMethods()->Remove( pMethod );
 318         CutLines( aSource, nStart-1, nEnd-nStart+1, true );
 319         pModule->SetSource32( aSource );
 320
 321         // update module in library
 322         OUString aLibName = pBasic->GetName();
 323         OUString aModName = pModule->GetName();
 324         OSL_VERIFY( aDocument.updateModule( aLibName, aModName, aSource ) );
 325
 326         SvTreeListEntry* pEntry = m_pMacroBox->FirstSelected();
 327         DBG_ASSERT( pEntry, "DeleteMacro: Entry ?!" );
 328         m_pMacroBox->GetModel()->Remove( pEntry );
 329         bForceStoreBasic = true;
 330     }
 331 }
 332
 333 SbMethod* MacroChooser::CreateMacro()
 334 {
 335     SbMethod* pMethod = 0;
 336     SvTreeListEntry* pCurEntry = m_pBasicBox->GetCurEntry();
 337     EntryDescriptor aDesc = m_pBasicBox->GetEntryDescriptor(pCurEntry);
 338     ScriptDocument aDocument( aDesc.GetDocument() );
 339     OSL_ENSURE( aDocument.isAlive(), "MacroChooser::CreateMacro: no document!" );
 340     if ( !aDocument.isAlive() )
 341         return NULL;
 342
 343     OUString aLibName( aDesc.GetLibName() );
 344
 345     if ( aLibName.isEmpty() )
 346         aLibName = "Standard" ;
 347
 348     aDocument.getOrCreateLibrary( E_SCRIPTS, aLibName );
 349
 350     OUString aOULibName( aLibName );
 351     Reference< script::XLibraryContainer > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ) );
 352     if ( xModLibContainer.is() && xModLibContainer->hasByName( aOULibName ) && !xModLibContainer->isLibraryLoaded( aOULibName ) )
 353         xModLibContainer->loadLibrary( aOULibName );
 354     Reference< script::XLibraryContainer > xDlgLibContainer( aDocument.getLibraryContainer( E_DIALOGS ) );
 355     if ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOULibName ) && !xDlgLibContainer->isLibraryLoaded( aOULibName ) )
 356         xDlgLibContainer->loadLibrary( aOULibName );
 357
 358     BasicManager* pBasMgr = aDocument.getBasicManager();
 359     StarBASIC* pBasic = pBasMgr ? pBasMgr->GetLib( aLibName ) : 0;
 360     if ( pBasic )
 361     {
 362         SbModule* pModule = 0;
 363         OUString aModName( aDesc.GetName() );
 364         if ( !aModName.isEmpty() )
 365         {
 366             // extract the module name from the string like "Sheet1 (Example1)"
 367             if( aDesc.GetLibSubName() == IDE_RESSTR(RID_STR_DOCUMENT_OBJECTS) )
 368             {
 369                 sal_Int32 nIndex = 0;
 370                 aModName = aModName.getToken( 0, ' ', nIndex );
 371             }
 372             pModule = pBasic->FindModule( aModName );
 373         }
 374         else if ( pBasic->GetModules()->Count() )
 375             pModule = static_cast<SbModule*>(pBasic->GetModules()->Get( 0 ));
 376
 377         if ( !pModule )
 378         {
 379             pModule = createModImpl( static_cast<vcl::Window*>( this ),
 380                 aDocument, *m_pBasicBox, aLibName, aModName );
 381         }
 382
 383         OUString aSubName = m_pMacroNameEdit->GetText();
 384         DBG_ASSERT( !pModule || !pModule->GetMethods()->Find( aSubName, SbxCLASS_METHOD ), "Macro existiert schon!" );
 385         pMethod = pModule ? basctl::CreateMacro( pModule, aSubName ) : NULL;
 386     }
 387
 388     return pMethod;
 389 }
 390
 391 void MacroChooser::SaveSetCurEntry( SvTreeListBox& rBox, SvTreeListEntry* pEntry )
 392 {
 393     // the edit would be killed by the highlight otherwise:
 394
 395     OUString aSaveText( m_pMacroNameEdit->GetText() );
 396     Selection aCurSel( m_pMacroNameEdit->GetSelection() );
 397
 398     rBox.SetCurEntry( pEntry );
 399     m_pMacroNameEdit->SetText( aSaveText );
 400     m_pMacroNameEdit->SetSelection( aCurSel );
 401 }
 402
 403 void MacroChooser::CheckButtons()
 404 {
 405     SvTreeListEntry* pCurEntry = m_pBasicBox->GetCurEntry();
 406     EntryDescriptor aDesc = m_pBasicBox->GetEntryDescriptor(pCurEntry);
 407     SvTreeListEntry* pMacroEntry = m_pMacroBox->FirstSelected();
 408     SbMethod* pMethod = GetMacro();
 409
 410     // check, if corresponding libraries are readonly
 411     bool bReadOnly = false;
 412     sal_uInt16 nDepth = pCurEntry ? m_pBasicBox->GetModel()->GetDepth( pCurEntry ) : 0;
 413     if ( nDepth == 1 || nDepth == 2 )
 414     {
 415         ScriptDocument aDocument( aDesc.GetDocument() );
 416         OUString aOULibName( aDesc.GetLibName() );
 417         Reference< script::XLibraryContainer2 > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
 418         Reference< script::XLibraryContainer2 > xDlgLibContainer( aDocument.getLibraryContainer( E_DIALOGS ), UNO_QUERY );
 419         if ( ( xModLibContainer.is() && xModLibContainer->hasByName( aOULibName ) && xModLibContainer->isLibraryReadOnly( aOULibName ) ) ||
 420                 ( xDlgLibContainer.is() && xDlgLibContainer->hasByName( aOULibName ) && xDlgLibContainer->isLibraryReadOnly( aOULibName ) ) )
 421         {
 422             bReadOnly = true;
 423         }
 424     }
 425
 426     if (nMode != Recording)
 427     {
 428         // Run...
 429         bool bEnable = pMethod != nullptr;
 430         if (nMode != ChooseOnly && StarBASIC::IsRunning())
 431             bEnable = false;
 432         EnableButton(*m_pRunButton, bEnable);
 433     }
 434
 435     // organising still possible?
 436
 437     // Assign...
 438     EnableButton(*m_pAssignButton, pMethod != nullptr);
 439
 440     // Edit...
 441     EnableButton(*m_pEditButton, pMacroEntry != nullptr);
 442
 443     // Organizer...
 444     EnableButton(*m_pOrganizeButton, !StarBASIC::IsRunning() && nMode == All);
 445
 446     // m_pDelButton->...
 447     bool bProtected = m_pBasicBox->IsEntryProtected( pCurEntry );
 448     bool bShare = ( aDesc.GetLocation() == LIBRARY_LOCATION_SHARE );
 449     EnableButton(*m_pDelButton, !StarBASIC::IsRunning() && nMode == All && !bProtected && !bReadOnly && !bShare);
 450     bool bPrev = bNewDelIsDel;
 451     bNewDelIsDel = pMethod != nullptr;
 452     if (bPrev != bNewDelIsDel && nMode == All)
 453     {
 454         OUString aBtnText( bNewDelIsDel ? IDEResId(RID_STR_BTNDEL).toString() : IDEResId(RID_STR_BTNNEW).toString() );
 455         m_pDelButton->SetText( aBtnText );
 456     }
 457
 458     if (nMode == Recording)
 459     {
 460         // save button
 461         m_pRunButton->Enable(!bProtected && !bReadOnly && !bShare);
 462         // new library button
 463         m_pNewLibButton->Enable(!bShare);
 464         // new module button
 465         m_pNewModButton->Enable(!bProtected && !bReadOnly && !bShare);
 466     }
 467 }
 468
 469
 470
 471 IMPL_LINK_NOARG(MacroChooser, MacroDoubleClickHdl)
 472 {
 473     StoreMacroDescription();
 474     if (nMode == Recording)
 475     {
 476         SbMethod* pMethod = GetMacro();
 477         if ( pMethod && !QueryReplaceMacro( pMethod->GetName(), this ) )
 478             return 0;
 479     }
 480
 481     EndDialog(Macro_OkRun);
 482     return 0;
 483 }
 484
 485 IMPL_LINK( MacroChooser, MacroSelectHdl, SvTreeListBox *, pBox )
 486 {
 487     // Is also called if deselected!
 488     // Two function calls in every SelectHdl because
 489     // there's no separate DeselectHDL.
 490     // So find out if select or deselect:
 491     if ( pBox->IsSelected( pBox->GetHdlEntry() ) )
 492     {
 493         UpdateFields();
 494         CheckButtons();
 495     }
 496     return 0;
 497 }
 498
 499 IMPL_LINK( MacroChooser, BasicSelectHdl, SvTreeListBox *, pBox )
 500 {
 501     // Is also called if deselected!
 502     // Two function calls in every SelectHdl because
 503     // there's no separate DeselectHDL.
 504     // So find out if select or deselect:
 505     if ( !pBox->IsSelected( pBox->GetHdlEntry() ) )
 506         return 0;
 507
 508     SbModule* pModule = m_pBasicBox->FindModule( m_pBasicBox->GetCurEntry() );
 509
 510     m_pMacroBox->Clear();
 511     if ( pModule )
 512     {
 513         OUString aStr = m_aMacrosInTxtBaseStr;
 514         aStr += " " ;
 515         aStr += pModule->GetName();
 516
 517         m_pMacrosInTxt->SetText( aStr );
 518
 519         // The macros should be called in the same order that they
 520         // are written down in the module.
 521
 522         map< sal_uInt16, SbMethod* > aMacros;
 523         size_t nMacroCount = pModule->GetMethods()->Count();
 524         for ( size_t iMeth = 0; iMeth  < nMacroCount; iMeth++ )
 525         {
 526             SbMethod* pMethod = static_cast<SbMethod*>(pModule->GetMethods()->Get( iMeth ));
 527             if( pMethod->IsHidden() )
 528                 continue;
 529             DBG_ASSERT( pMethod, "Methode nicht gefunden! (NULL)" );
 530             sal_uInt16 nStart, nEnd;
 531             pMethod->GetLineRange( nStart, nEnd );
 532             aMacros.insert( map< sal_uInt16, SbMethod*>::value_type( nStart, pMethod ) );
 533         }
 534
 535         m_pMacroBox->SetUpdateMode(false);
 536         for ( map< sal_uInt16, SbMethod* >::iterator it = aMacros.begin(); it != aMacros.end(); ++it )
 537             m_pMacroBox->InsertEntry( (*it).second->GetName() );
 538         m_pMacroBox->SetUpdateMode(true);
 539
 540         if ( m_pMacroBox->GetEntryCount() )
 541         {
 542             SvTreeListEntry* pEntry = m_pMacroBox->GetEntry( 0 );
 543             DBG_ASSERT( pEntry, "Entry ?!" );
 544             m_pMacroBox->SetCurEntry( pEntry );
 545         }
 546     }
 547
 548     UpdateFields();
 549     CheckButtons();
 550     return 0;
 551 }
 552
 553
 554
 555 IMPL_LINK( MacroChooser, EditModifyHdl, Edit *, pEdit )
 556 {
 557     (void)pEdit;
 558
 559     // select the module in which the macro is put at Neu (new),
 560     // if BasicManager or Lib is selecting
 561     SvTreeListEntry* pCurEntry = m_pBasicBox->GetCurEntry();
 562     if ( pCurEntry )
 563     {
 564         sal_uInt16 nDepth = m_pBasicBox->GetModel()->GetDepth( pCurEntry );
 565         if ( ( nDepth == 1 ) && ( m_pBasicBox->IsEntryProtected( pCurEntry ) ) )
 566         {
 567             // then put to the respective Std-Lib...
 568             SvTreeListEntry* pManagerEntry = m_pBasicBox->GetModel()->GetParent( pCurEntry );
 569             pCurEntry = m_pBasicBox->GetModel()->FirstChild( pManagerEntry );
 570         }
 571         if ( nDepth < 2 )
 572         {
 573             SvTreeListEntry* pNewEntry = pCurEntry;
 574             while ( pCurEntry && ( nDepth < 2 ) )
 575             {
 576                 pCurEntry = m_pBasicBox->FirstChild( pCurEntry );
 577                 if ( pCurEntry )
 578                 {
 579                     pNewEntry = pCurEntry;
 580                     nDepth = m_pBasicBox->GetModel()->GetDepth( pCurEntry );
 581                 }
 582             }
 583             SaveSetCurEntry( *m_pBasicBox, pNewEntry );
 584         }
 585         if ( m_pMacroBox->GetEntryCount() )
 586         {
 587             OUString aEdtText( m_pMacroNameEdit->GetText() );
 588             bool bFound = false;
 589             for ( sal_uInt16 n = 0; n < m_pMacroBox->GetEntryCount(); n++ )
 590             {
 591                 SvTreeListEntry* pEntry = m_pMacroBox->GetEntry( n );
 592                 DBG_ASSERT( pEntry, "Entry ?!" );
 593                 if ( m_pMacroBox->GetEntryText( pEntry ).equalsIgnoreAsciiCase( aEdtText ) )
 594                 {
 595                     SaveSetCurEntry(*m_pMacroBox, pEntry);
 596                     bFound = true;
 597                     break;
 598                 }
 599             }
 600             if ( !bFound )
 601             {
 602                 SvTreeListEntry* pEntry = m_pMacroBox->FirstSelected();
 603                 // if the entry exists ->Select ->Desription...
 604                 if ( pEntry )
 605                     m_pMacroBox->Select( pEntry, false );
 606             }
 607         }
 608     }
 609
 610     CheckButtons();
 611     return 0;
 612 }
 613
 614
 615
 616 IMPL_LINK( MacroChooser, ButtonHdl, Button *, pButton )
 617 {
 618     // apart from New/Record the Description is done by LoseFocus
 619     if (pButton == m_pRunButton)
 620     {
 621         StoreMacroDescription();
 622
 623         // #116444# check security settings before macro execution
 624         if (nMode == All)
 625         {
 626             SbMethod* pMethod = GetMacro();
 627             SbModule* pModule = pMethod ? pMethod->GetModule() : NULL;
 628             StarBASIC* pBasic = pModule ? static_cast<StarBASIC*>(pModule->GetParent()) : NULL;
 629             BasicManager* pBasMgr = pBasic ? FindBasicManager(pBasic) : NULL;
 630             if ( pBasMgr )
 631             {
 632                 ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) );
 633                 if ( aDocument.isDocument() && !aDocument.allowMacros() )
 634                 {
 635                     ScopedVclPtrInstance<MessageDialog>::Create(this, IDEResId(RID_STR_CANNOTRUNMACRO), VCL_MESSAGE_WARNING)->Execute();
 636                     return 0;
 637                 }
 638             }
 639         }
 640         else if (nMode == Recording )
 641         {
 642             if ( !IsValidSbxName(m_pMacroNameEdit->GetText()) )
 643             {
 644                 ScopedVclPtrInstance<MessageDialog>::Create(this, IDEResId(RID_STR_BADSBXNAME))->Execute();
 645                 m_pMacroNameEdit->SetSelection( Selection( 0, m_pMacroNameEdit->GetText().getLength() ) );
 646                 m_pMacroNameEdit->GrabFocus();
 647                 return 0;
 648             }
 649
 650             SbMethod* pMethod = GetMacro();
 651             if ( pMethod && !QueryReplaceMacro( pMethod->GetName(), this ) )
 652                 return 0;
 653         }
 654
 655         EndDialog(Macro_OkRun);
 656     }
 657     else if (pButton == m_pCloseButton)
 658     {
 659         StoreMacroDescription();
 660         EndDialog(Macro_Close);
 661     }
 662     else if ((pButton == m_pEditButton) || (pButton == m_pDelButton))
 663     {
 664         SvTreeListEntry* pCurEntry = m_pBasicBox->GetCurEntry();
 665         EntryDescriptor aDesc = m_pBasicBox->GetEntryDescriptor(pCurEntry);
 666         ScriptDocument aDocument( aDesc.GetDocument() );
 667         DBG_ASSERT( aDocument.isAlive(), "MacroChooser::ButtonHdl: no document, or document is dead!" );
 668         if ( !aDocument.isAlive() )
 669             return 0;
 670         BasicManager* pBasMgr = aDocument.getBasicManager();
 671         OUString aLib( aDesc.GetLibName() );
 672         OUString aMod( aDesc.GetName() );
 673         // extract the module name from the string like "Sheet1 (Example1)"
 674         if( aDesc.GetLibSubName() == IDE_RESSTR(RID_STR_DOCUMENT_OBJECTS) )
 675         {
 676             sal_Int32 nIndex = 0;
 677             aMod = aMod.getToken( 0, ' ', nIndex );
 678         }
 679         OUString aSub( aDesc.GetMethodName() );
 680         SfxMacroInfoItem aInfoItem( SID_BASICIDE_ARG_MACROINFO, pBasMgr, aLib, aMod, aSub, OUString() );
 681         if (pButton == m_pEditButton)
 682         {
 683             SvTreeListEntry* pEntry = m_pMacroBox->FirstSelected();
 684             if ( pEntry )
 685                 aInfoItem.SetMethod( m_pMacroBox->GetEntryText( pEntry ) );
 686             StoreMacroDescription();
 687             SfxAllItemSet aArgs( SfxGetpApp()->GetPool() );
 688             SfxRequest aRequest( SID_BASICIDE_APPEAR, SfxCallMode::SYNCHRON, aArgs );
 689             SfxGetpApp()->ExecuteSlot( aRequest );
 690
 691             if (SfxDispatcher* pDispatcher = GetDispatcher())
 692                 pDispatcher->Execute( SID_BASICIDE_EDITMACRO, SfxCallMode::ASYNCHRON, &aInfoItem, 0L );
 693             EndDialog(Macro_Edit);
 694         }
 695         else
 696         {
 697             if ( bNewDelIsDel )
 698             {
 699                 DeleteMacro();
 700                 if (SfxDispatcher* pDispatcher = GetDispatcher())
 701                     pDispatcher->Execute( SID_BASICIDE_UPDATEMODULESOURCE,
 702                                           SfxCallMode::SYNCHRON, &aInfoItem, 0L );
 703                 CheckButtons();
 704                 UpdateFields();
 705                 //if ( m_pMacroBox->GetCurEntry() )    // OV-Bug ?
 706                 //  m_pMacroBox->Select( m_pMacroBox->GetCurEntry() );
 707             }
 708             else
 709             {
 710                 if ( !IsValidSbxName(m_pMacroNameEdit->GetText()) )
 711                 {
 712                     ScopedVclPtrInstance<MessageDialog>::Create(this, IDEResId(RID_STR_BADSBXNAME))->Execute();
 713                     m_pMacroNameEdit->SetSelection( Selection( 0, m_pMacroNameEdit->GetText().getLength() ) );
 714                     m_pMacroNameEdit->GrabFocus();
 715                     return 1;
 716                 }
 717                 SbMethod* pMethod = CreateMacro();
 718                 if ( pMethod )
 719                 {
 720                     aInfoItem.SetMethod( pMethod->GetName() );
 721                     aInfoItem.SetModule( pMethod->GetModule()->GetName() );
 722                     aInfoItem.SetLib( pMethod->GetModule()->GetParent()->GetName() );
 723                     SfxAllItemSet aArgs( SfxGetpApp()->GetPool() );
 724                     SfxRequest aRequest( SID_BASICIDE_APPEAR, SfxCallMode::SYNCHRON, aArgs );
 725                     SfxGetpApp()->ExecuteSlot( aRequest );
 726
 727                     if (SfxDispatcher* pDispatcher = GetDispatcher())
 728                         pDispatcher->Execute( SID_BASICIDE_EDITMACRO, SfxCallMode::ASYNCHRON, &aInfoItem, 0L );
 729                     StoreMacroDescription();
 730                     EndDialog(Macro_New);
 731                 }
 732             }
 733         }
 734     }
 735     else if (pButton == m_pAssignButton)
 736     {
 737         SvTreeListEntry* pCurEntry = m_pBasicBox->GetCurEntry();
 738         EntryDescriptor aDesc = m_pBasicBox->GetEntryDescriptor(pCurEntry);
 739         ScriptDocument aDocument( aDesc.GetDocument() );
 740         DBG_ASSERT( aDocument.isAlive(), "MacroChooser::ButtonHdl: no document, or document is dead!" );
 741         if ( !aDocument.isAlive() )
 742             return 0;
 743         BasicManager* pBasMgr = aDocument.getBasicManager();
 744         OUString aLib( aDesc.GetLibName() );
 745         OUString aMod( aDesc.GetName() );
 746         OUString aSub( m_pMacroNameEdit->GetText() );
 747         SbMethod* pMethod = GetMacro();
 748         DBG_ASSERT( pBasMgr, "BasMgr?" );
 749         DBG_ASSERT( pMethod, "Method?" );
 750         OUString aComment( GetInfo( pMethod ) );
 751         SfxMacroInfoItem aItem( SID_MACROINFO, pBasMgr, aLib, aMod, aSub, aComment );
 752         SfxAllItemSet Args( SfxGetpApp()->GetPool() );
 753         SfxRequest aRequest( SID_CONFIG, SfxCallMode::SYNCHRON, Args );
 754         aRequest.AppendItem( aItem );
 755         SfxGetpApp()->ExecuteSlot( aRequest );
 756     }
 757     else if (pButton == m_pNewLibButton)
 758     {
 759         SvTreeListEntry* pCurEntry = m_pBasicBox->GetCurEntry();
 760         EntryDescriptor aDesc = m_pBasicBox->GetEntryDescriptor(pCurEntry);
 761         ScriptDocument aDocument( aDesc.GetDocument() );
 762         createLibImpl( static_cast<vcl::Window*>( this ), aDocument, NULL, m_pBasicBox );
 763     }
 764     else if (pButton == m_pNewModButton)
 765     {
 766         SvTreeListEntry* pCurEntry = m_pBasicBox->GetCurEntry();
 767         EntryDescriptor aDesc = m_pBasicBox->GetEntryDescriptor(pCurEntry);
 768         ScriptDocument aDocument( aDesc.GetDocument() );
 769         OUString aLibName( aDesc.GetLibName() );
 770         OUString aModName;
 771         createModImpl( static_cast<vcl::Window*>( this ), aDocument,
 772             *m_pBasicBox, aLibName, aModName, true );
 773     }
 774     else if (pButton == m_pOrganizeButton)
 775     {
 776         StoreMacroDescription();
 777
 778         EntryDescriptor aDesc = m_pBasicBox->GetEntryDescriptor(m_pBasicBox->FirstSelected());
 779         VclPtrInstance< OrganizeDialog > pDlg( this, 0, aDesc );
 780         sal_uInt16 nRet = pDlg->Execute();
 781         pDlg.reset();
 782
 783         if ( nRet ) // not only closed
 784         {
 785             EndDialog(Macro_Edit);
 786             return 0;
 787         }
 788
 789         Shell* pShell = GetShell();
 790         if ( pShell && pShell->IsAppBasicModified() )
 791             bForceStoreBasic = true;
 792
 793         m_pBasicBox->UpdateEntries();
 794     }
 795     return 0;
 796 }
 797
 798
 799
 800 void MacroChooser::UpdateFields()
 801 {
 802     SvTreeListEntry*    pMacroEntry = m_pMacroBox->GetCurEntry();
 803     OUString            aEmptyStr;
 804
 805     m_pMacroNameEdit->SetText( aEmptyStr );
 806     if ( pMacroEntry )
 807         m_pMacroNameEdit->SetText( m_pMacroBox->GetEntryText( pMacroEntry ) );
 808 }
 809
 810 void MacroChooser::SetMode (Mode nM)
 811 {
 812     nMode = nM;
 813     switch (nMode)
 814     {
 815         case All:
 816         {
 817             m_pRunButton->SetText(IDEResId(RID_STR_RUN).toString());
 818             EnableButton(*m_pDelButton, true);
 819             EnableButton(*m_pOrganizeButton, true);
 820             break;
 821         }
 822
 823         case ChooseOnly:
 824         {
 825             m_pRunButton->SetText(IDEResId(RID_STR_CHOOSE).toString());
 826             EnableButton(*m_pDelButton, false);
 827             EnableButton(*m_pOrganizeButton, false);
 828             break;
 829         }
 830
 831         case Recording:
 832         {
 833             m_pRunButton->SetText(IDEResId(RID_STR_RECORD).toString());
 834             EnableButton(*m_pDelButton, false);
 835             EnableButton(*m_pOrganizeButton, false);
 836
 837             m_pAssignButton->Hide();
 838             m_pEditButton->Hide();
 839             m_pDelButton->Hide();
 840             m_pOrganizeButton->Hide();
 841             m_pMacroFromTxT->Hide();
 842
 843             m_pNewLibButton->Show();
 844             m_pNewModButton->Show();
 845             m_pMacrosSaveInTxt->Show();
 846
 847             break;
 848         }
 849     }
 850     CheckButtons();
 851 }
 852
 853 OUString MacroChooser::GetInfo( SbxVariable* pVar )
 854 {
 855     OUString aComment;
 856     SbxInfoRef xInfo = pVar->GetInfo();
 857     if ( xInfo.Is() )
 858         aComment = xInfo->GetComment();
 859     return aComment;
 860 }
 861
 862
 863 } // namespace basctl
 864
 865 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */