basctl/source/basicide/basobj2.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 <basidesh.hxx>
  21 #include <iderdll.hxx>
  22 #include "iderdll2.hxx"
  23 #include "macrodlg.hxx"
  24 #include "moduldlg.hxx"
  25 #include <iderid.hxx>
  26 #include <strings.hrc>
  27 #include "baside2.hxx"
  28
  29 #include <com/sun/star/document/XScriptInvocationContext.hpp>
  30
  31 #include <basic/sbmeth.hxx>
  32 #include <comphelper/processfactory.hxx>
  33 #include <comphelper/string.hxx>
  34 #include <comphelper/sequence.hxx>
  35 #include <framework/documentundoguard.hxx>
  36 #include <sal/log.hxx>
  37 #include <tools/diagnose_ex.h>
  38 #include <unotools/moduleoptions.hxx>
  39 #include <vcl/settings.hxx>
  40 #include <vcl/svapp.hxx>
  41 #include <vcl/weld.hxx>
  42
  43 #include <memory>
  44 #include <vector>
  45 #include <algorithm>
  46 #include <basic/basmgr.hxx>
  47 namespace basctl
  48 {
  49
  50 using namespace ::com::sun::star;
  51 using namespace ::com::sun::star::uno;
  52 using namespace ::com::sun::star::container;
  53
  54 extern "C" {
  55     SAL_DLLPUBLIC_EXPORT rtl_uString* basicide_choose_macro(void* pParent, void* pOnlyInDocument_AsXModel, void* pDocFrame_AsXFrame, sal_Bool bChooseOnly )
  56     {
  57         Reference< frame::XModel > aDocument( static_cast< frame::XModel* >( pOnlyInDocument_AsXModel ) );
  58         Reference< frame::XFrame > aDocFrame( static_cast< frame::XFrame* >( pDocFrame_AsXFrame ) );
  59         OUString aScriptURL = basctl::ChooseMacro(static_cast<weld::Window*>(pParent), aDocument, aDocFrame, bChooseOnly);
  60         rtl_uString* pScriptURL = aScriptURL.pData;
  61         rtl_uString_acquire( pScriptURL );
  62
  63         return pScriptURL;
  64     }
  65     SAL_DLLPUBLIC_EXPORT void basicide_macro_organizer(void *pParent, sal_Int16 nTabId)
  66     {
  67         SAL_INFO("basctl.basicide","in basicide_macro_organizer");
  68         basctl::Organize(static_cast<weld::Window*>(pParent), nTabId);
  69     }
  70 }
  71
  72 void Organize(weld::Window* pParent, sal_Int16 tabId)
  73 {
  74     EnsureIde();
  75
  76     auto xDlg(std::make_shared<OrganizeDialog>(pParent, tabId));
  77     weld::DialogController::runAsync(xDlg, [](int) {});
  78 }
  79
  80 bool IsValidSbxName( const OUString& rName )
  81 {
  82     for ( sal_Int32 nChar = 0; nChar < rName.getLength(); nChar++ )
  83     {
  84         sal_Unicode c = rName[nChar];
  85         bool bValid = (
  86             ( c >= 'A' && c <= 'Z' ) ||
  87             ( c >= 'a' && c <= 'z' ) ||
  88             ( c >= '0' && c <= '9' && nChar ) ||
  89             ( c == '_' )
  90         );
  91         if ( !bValid )
  92             return false;
  93     }
  94     return true;
  95 }
  96
  97 Sequence< OUString > GetMergedLibraryNames( const Reference< script::XLibraryContainer >& xModLibContainer, const Reference< script::XLibraryContainer >& xDlgLibContainer )
  98 {
  99     // create a list of module library names
 100     std::vector<OUString> aLibList;
 101     if ( xModLibContainer.is() )
 102     {
 103         Sequence< OUString > aModLibNames = xModLibContainer->getElementNames();
 104         sal_Int32 nModLibCount = aModLibNames.getLength();
 105         const OUString* pModLibNames = aModLibNames.getConstArray();
 106         for ( sal_Int32 i = 0 ; i < nModLibCount ; i++ )
 107             aLibList.push_back( pModLibNames[ i ] );
 108     }
 109
 110     // create a list of dialog library names
 111     if ( xDlgLibContainer.is() )
 112     {
 113         Sequence< OUString > aDlgLibNames = xDlgLibContainer->getElementNames();
 114         sal_Int32 nDlgLibCount = aDlgLibNames.getLength();
 115         const OUString* pDlgLibNames = aDlgLibNames.getConstArray();
 116         for ( sal_Int32 i = 0 ; i < nDlgLibCount ; i++ )
 117             aLibList.push_back( pDlgLibNames[ i ] );
 118     }
 119
 120     // sort list
 121     auto const sort = comphelper::string::NaturalStringSorter(
 122         comphelper::getProcessComponentContext(),
 123         Application::GetSettings().GetUILanguageTag().getLocale());
 124     std::sort(aLibList.begin(), aLibList.end(),
 125               [&sort](const OUString& rLHS, const OUString& rRHS) {
 126                   return sort.compare(rLHS, rRHS) < 0;
 127               });
 128     // remove duplicates
 129     std::vector<OUString>::iterator aIterEnd = std::unique( aLibList.begin(), aLibList.end() );
 130     aLibList.erase( aIterEnd, aLibList.end() );
 131
 132     return comphelper::containerToSequence(aLibList);
 133 }
 134
 135 bool RenameModule (
 136     weld::Widget* pErrorParent,
 137     const ScriptDocument& rDocument,
 138     const OUString& rLibName,
 139     const OUString& rOldName,
 140     const OUString& rNewName
 141 )
 142 {
 143     if ( !rDocument.hasModule( rLibName, rOldName ) )
 144     {
 145         SAL_WARN( "basctl.basicide","basctl::RenameModule: old module name is invalid!" );
 146         return false;
 147     }
 148
 149     if ( rDocument.hasModule( rLibName, rNewName ) )
 150     {
 151         std::unique_ptr<weld::MessageDialog> xError(Application::CreateMessageDialog(pErrorParent,
 152                                                     VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_SBXNAMEALLREADYUSED2)));
 153         xError->run();
 154         return false;
 155     }
 156
 157     // #i74440
 158     if ( rNewName.isEmpty() )
 159     {
 160         std::unique_ptr<weld::MessageDialog> xError(Application::CreateMessageDialog(pErrorParent,
 161                                                     VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_BADSBXNAME)));
 162         xError->run();
 163         return false;
 164     }
 165
 166     if ( !rDocument.renameModule( rLibName, rOldName, rNewName ) )
 167         return false;
 168
 169     if (Shell* pShell = GetShell())
 170     {
 171         if (VclPtr<ModulWindow> pWin = pShell->FindBasWin(rDocument, rLibName, rNewName, false, true))
 172         {
 173             // set new name in window
 174             pWin->SetName( rNewName );
 175
 176             // set new module in module window
 177             pWin->SetSbModule( pWin->GetBasic()->FindModule( rNewName ) );
 178
 179             // update tabwriter
 180             sal_uInt16 nId = pShell->GetWindowId( pWin );
 181             SAL_WARN_IF( nId == 0 , "basctl.basicide", "No entry in Tabbar!");
 182             if ( nId )
 183             {
 184                 TabBar& rTabBar = pShell->GetTabBar();
 185                 rTabBar.SetPageText(nId, rNewName);
 186                 rTabBar.Sort();
 187                 rTabBar.MakeVisible(rTabBar.GetCurPageId());
 188             }
 189         }
 190     }
 191     return true;
 192 }
 193
 194 namespace
 195 {
 196     struct MacroExecutionData
 197     {
 198         ScriptDocument  aDocument;
 199         SbMethodRef     xMethod;
 200
 201         MacroExecutionData()
 202             :aDocument( ScriptDocument::NoDocument )
 203         {
 204         }
 205     };
 206
 207     class MacroExecution
 208     {
 209     public:
 210         DECL_STATIC_LINK( MacroExecution, ExecuteMacroEvent, void*, void );
 211     };
 212
 213     IMPL_STATIC_LINK( MacroExecution, ExecuteMacroEvent, void*, p, void )
 214     {
 215         MacroExecutionData* i_pData = static_cast<MacroExecutionData*>(p);
 216         ENSURE_OR_RETURN_VOID( i_pData, "wrong MacroExecutionData" );
 217         // take ownership of the data
 218         std::unique_ptr< MacroExecutionData > pData( i_pData );
 219
 220         SAL_WARN_IF( (pData->xMethod->GetParent()->GetFlags() & SbxFlagBits::ExtSearch) == SbxFlagBits::NONE, "basctl.basicide","No EXTSEARCH!" );
 221
 222         // in case this is a document-local macro, try to protect the document's Undo Manager from
 223         // flawed scripts
 224         std::unique_ptr< ::framework::DocumentUndoGuard > pUndoGuard;
 225         if ( pData->aDocument.isDocument() )
 226             pUndoGuard.reset( new ::framework::DocumentUndoGuard( pData->aDocument.getDocument() ) );
 227
 228         RunMethod( pData->xMethod.get() );
 229     }
 230 }
 231
 232 OUString ChooseMacro(weld::Window* pParent,
 233                      const uno::Reference< frame::XModel >& rxLimitToDocument,
 234                      const uno::Reference< frame::XFrame >& xDocFrame,
 235                      bool bChooseOnly)
 236 {
 237     EnsureIde();
 238
 239     GetExtraData()->ChoosingMacro() = true;
 240
 241     OUString aScriptURL;
 242     SbMethod* pMethod = nullptr;
 243
 244     MacroChooser aChooser(pParent, xDocFrame);
 245     if ( bChooseOnly || !SvtModuleOptions::IsBasicIDE() )
 246         aChooser.SetMode(MacroChooser::ChooseOnly);
 247
 248     if ( !bChooseOnly && rxLimitToDocument.is() )
 249     {
 250         // Hack!
 251         aChooser.SetMode(MacroChooser::Recording);
 252     }
 253
 254     short nRetValue = aChooser.run();
 255
 256     GetExtraData()->ChoosingMacro() = false;
 257
 258     switch ( nRetValue )
 259     {
 260         case Macro_OkRun:
 261         {
 262             bool bError = false;
 263
 264             pMethod = aChooser.GetMacro();
 265             if ( !pMethod && aChooser.GetMode() == MacroChooser::Recording )
 266                 pMethod = aChooser.CreateMacro();
 267
 268             if ( !pMethod )
 269                 break;
 270
 271             SbModule* pModule = pMethod->GetModule();
 272             if ( !pModule )
 273             {
 274                 SAL_WARN( "basctl.basicide", "basctl::ChooseMacro: No Module found!" );
 275                 break;
 276             }
 277
 278             StarBASIC* pBasic = dynamic_cast<StarBASIC*>(pModule->GetParent());
 279             if ( !pBasic )
 280             {
 281                 SAL_WARN( "basctl.basicide", "basctl::ChooseMacro: No Basic found!" );
 282                 break;
 283             }
 284
 285             BasicManager* pBasMgr = FindBasicManager( pBasic );
 286             if ( !pBasMgr )
 287             {
 288                 SAL_WARN( "basctl.basicide", "basctl::ChooseMacro: No BasicManager found!" );
 289                 break;
 290             }
 291
 292             // name
 293             OUString aName = pBasic->GetName() + "." + pModule->GetName() + "." + pMethod->GetName();
 294
 295             // location
 296             OUString aLocation;
 297             ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) );
 298             if ( aDocument.isDocument() )
 299             {
 300                 // document basic
 301                 aLocation = "document" ;
 302
 303                 if ( rxLimitToDocument.is() )
 304                 {
 305                     uno::Reference< frame::XModel > xLimitToDocument( rxLimitToDocument );
 306
 307                     uno::Reference< document::XEmbeddedScripts > xScripts( rxLimitToDocument, UNO_QUERY );
 308                     if ( !xScripts.is() )
 309                     {   // the document itself does not support embedding scripts
 310                         uno::Reference< document::XScriptInvocationContext > xContext( rxLimitToDocument, UNO_QUERY );
 311                         if ( xContext.is() )
 312                             xScripts = xContext->getScriptContainer();
 313                         if ( xScripts.is() )
 314                         {   // but it is able to refer to a document which actually does support this
 315                             xLimitToDocument.set( xScripts, UNO_QUERY );
 316                             if ( !xLimitToDocument.is() )
 317                             {
 318                                 SAL_WARN_IF(!xLimitToDocument.is(), "basctl.basicide", "basctl::ChooseMacro: a script container which is no document!?" );
 319                                 xLimitToDocument = rxLimitToDocument;
 320                             }
 321                         }
 322                     }
 323
 324                     if ( xLimitToDocument != aDocument.getDocument() )
 325                     {
 326                         // error
 327                         bError = true;
 328                         std::unique_ptr<weld::MessageDialog> xError(Application::CreateMessageDialog(nullptr,
 329                                                                     VclMessageType::Warning, VclButtonsType::Ok, IDEResId(RID_STR_ERRORCHOOSEMACRO)));
 330                         xError->run();
 331                     }
 332                 }
 333             }
 334             else
 335             {
 336                 // application basic
 337                 aLocation = "application" ;
 338             }
 339
 340             // script URL
 341             if ( !bError )
 342             {
 343                 aScriptURL = "vnd.sun.star.script:" + aName + "?language=Basic&location=" + aLocation;
 344             }
 345
 346             if ( !rxLimitToDocument.is() )
 347             {
 348                 MacroExecutionData* pExecData = new MacroExecutionData;
 349                 pExecData->aDocument = aDocument;
 350                 pExecData->xMethod = pMethod;   // keep alive until the event has been processed
 351                 Application::PostUserEvent( LINK( nullptr, MacroExecution, ExecuteMacroEvent ), pExecData );
 352             }
 353         }
 354         break;
 355     }
 356
 357     return aScriptURL;
 358 }
 359
 360 Sequence< OUString > GetMethodNames( const ScriptDocument& rDocument, const OUString& rLibName, const OUString& rModName )
 361 {
 362     Sequence< OUString > aSeqMethods;
 363
 364     // get module
 365     OUString aOUSource;
 366     if ( rDocument.getModule( rLibName, rModName, aOUSource ) )
 367     {
 368         BasicManager* pBasMgr = rDocument.getBasicManager();
 369         StarBASIC* pSb = pBasMgr ? pBasMgr->GetLib( rLibName ) : nullptr;
 370         SbModule* pMod = pSb ? pSb->FindModule( rModName ) : nullptr;
 371
 372         SbModuleRef xModule;
 373         // Only reparse modules if ScriptDocument source is out of sync
 374         // with basic's Module
 375         if ( !pMod || pMod->GetSource32() != aOUSource )
 376         {
 377             xModule = new SbModule( rModName );
 378             xModule->SetSource32( aOUSource );
 379             pMod = xModule.get();
 380         }
 381
 382         sal_uInt32 nCount = pMod->GetMethods()->Count32();
 383         sal_uInt32 nRealCount = nCount;
 384         for ( sal_uInt32 i = 0; i < nCount; i++ )
 385         {
 386             SbMethod* pMethod = static_cast<SbMethod*>(pMod->GetMethods()->Get32( i ));
 387             if( pMethod->IsHidden() )
 388                 --nRealCount;
 389         }
 390         aSeqMethods.realloc( nRealCount );
 391
 392         sal_uInt32 iTarget = 0;
 393         for ( sal_uInt32 i = 0 ; i < nCount; ++i )
 394         {
 395             SbMethod* pMethod = static_cast<SbMethod*>(pMod->GetMethods()->Get32( i ));
 396             if( pMethod->IsHidden() )
 397                 continue;
 398             SAL_WARN_IF( !pMethod, "basctl.basicide","Method not found! (NULL)" );
 399             aSeqMethods.getArray()[ iTarget++ ] = pMethod->GetName();
 400         }
 401     }
 402
 403     return aSeqMethods;
 404 }
 405
 406 bool HasMethod (
 407     ScriptDocument const& rDocument,
 408     OUString const& rLibName,
 409     OUString const& rModName,
 410     OUString const& rMethName
 411 )
 412 {
 413     bool bHasMethod = false;
 414
 415     OUString aOUSource;
 416     if ( rDocument.hasModule( rLibName, rModName ) && rDocument.getModule( rLibName, rModName, aOUSource ) )
 417     {
 418         // Check if we really need to scan the source ( again )
 419         BasicManager* pBasMgr = rDocument.getBasicManager();
 420         StarBASIC* pSb = pBasMgr ? pBasMgr->GetLib( rLibName ) : nullptr;
 421         SbModule* pMod = pSb ? pSb->FindModule( rModName ) : nullptr;
 422         SbModuleRef xModule;
 423         // Only reparse modules if ScriptDocument source is out of sync
 424         // with basic's Module
 425         if ( !pMod || pMod->GetSource32() != aOUSource )
 426         {
 427             xModule = new SbModule( rModName );
 428             xModule->SetSource32( aOUSource );
 429             pMod = xModule.get();
 430         }
 431         SbxArray* pMethods = pMod->GetMethods().get();
 432         if ( pMethods )
 433         {
 434             SbMethod* pMethod = static_cast<SbMethod*>(pMethods->Find( rMethName, SbxClassType::Method ));
 435             if ( pMethod && !pMethod->IsHidden() )
 436                 bHasMethod = true;
 437         }
 438     }
 439
 440     return bHasMethod;
 441 }
 442
 443 } // namespace basctl
 444
 445 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */