basctl/source/basicide/basobj2.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: basobj2.cxx,v $
  10  * $Revision: 1.37 $
  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_basctl.hxx"
  33
  34 #include <ide_pch.hxx>
  35
  36 #include <vector>
  37 #include <algorithm>
  38 #include <basic/sbx.hxx>
  39 #include <svtools/moduleoptions.hxx>
  40 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  41 #include <com/sun/star/document/XScriptInvocationContext.hpp>
  42 #include <basobj.hxx>
  43 #include <iderdll.hxx>
  44 #include <iderdll2.hxx>
  45 #include <iderid.hxx>
  46 #include <macrodlg.hxx>
  47 #include <moduldlg.hxx>
  48 #include <basidesh.hxx>
  49 #include <basidesh.hrc>
  50 #include <baside2.hxx>
  51 #include <basicmod.hxx>
  52 #include <basdoc.hxx>
  53
  54 using namespace ::com::sun::star;
  55 using namespace ::com::sun::star::uno;
  56 using namespace ::com::sun::star::container;
  57
  58
  59 //----------------------------------------------------------------------------
  60
  61 extern "C" {
  62     SAL_DLLPUBLIC_EXPORT rtl_uString* basicide_choose_macro( void* pOnlyInDocument_AsXModel, BOOL bChooseOnly, rtl_uString* pMacroDesc )
  63     {
  64         ::rtl::OUString aMacroDesc( pMacroDesc );
  65         Reference< frame::XModel > aDocument( static_cast< frame::XModel* >( pOnlyInDocument_AsXModel ) );
  66         ::rtl::OUString aScriptURL = BasicIDE::ChooseMacro( aDocument, bChooseOnly, aMacroDesc );
  67         rtl_uString* pScriptURL = aScriptURL.pData;
  68         rtl_uString_acquire( pScriptURL );
  69
  70         return pScriptURL;
  71     }
  72     SAL_DLLPUBLIC_EXPORT void basicide_macro_organizer( INT16 nTabId )
  73     {
  74         OSL_TRACE("in basicide_macro_organizer");
  75         BasicIDE::Organize( nTabId );
  76     }
  77 }
  78
  79 namespace BasicIDE
  80 {
  81 //----------------------------------------------------------------------------
  82
  83 void Organize( INT16 tabId )
  84 {
  85     BasicIDEDLL::Init();
  86
  87     BasicEntryDescriptor aDesc;
  88     BasicIDEShell* pIDEShell = IDE_DLL()->GetShell();
  89     if ( pIDEShell )
  90     {
  91         IDEBaseWindow* pCurWin = pIDEShell->GetCurWindow();
  92         if ( pCurWin )
  93             aDesc = pCurWin->CreateEntryDescriptor();
  94     }
  95
  96     Window* pParent = Application::GetDefDialogParent();
  97     OrganizeDialog* pDlg = new OrganizeDialog( pParent, tabId, aDesc );
  98     pDlg->Execute();
  99     delete pDlg;
 100 }
 101
 102 //----------------------------------------------------------------------------
 103
 104 BOOL IsValidSbxName( const String& rName )
 105 {
 106     for ( USHORT nChar = 0; nChar < rName.Len(); nChar++ )
 107     {
 108         BOOL bValid = ( ( rName.GetChar(nChar) >= 'A' && rName.GetChar(nChar) <= 'Z' ) ||
 109                         ( rName.GetChar(nChar) >= 'a' && rName.GetChar(nChar) <= 'z' ) ||
 110                         ( rName.GetChar(nChar) >= '0' && rName.GetChar(nChar) <= '9' && nChar ) ||
 111                         ( rName.GetChar(nChar) == '_' ) );
 112         if ( !bValid )
 113             return FALSE;
 114     }
 115     return TRUE;
 116 }
 117
 118 static BOOL StringCompareLessThan( const String& rStr1, const String& rStr2 )
 119 {
 120     return (rStr1.CompareIgnoreCaseToAscii( rStr2 ) == COMPARE_LESS);
 121 }
 122
 123 //----------------------------------------------------------------------------
 124
 125 Sequence< ::rtl::OUString > GetMergedLibraryNames( const Reference< script::XLibraryContainer >& xModLibContainer, const Reference< script::XLibraryContainer >& xDlgLibContainer )
 126 {
 127     // create a sorted list of module library names
 128     ::std::vector<String> aModLibList;
 129     if ( xModLibContainer.is() )
 130     {
 131         Sequence< ::rtl::OUString > aModLibNames = xModLibContainer->getElementNames();
 132         sal_Int32 nModLibCount = aModLibNames.getLength();
 133         const ::rtl::OUString* pModLibNames = aModLibNames.getConstArray();
 134         for ( sal_Int32 i = 0 ; i < nModLibCount ; i++ )
 135             aModLibList.push_back( pModLibNames[ i ] );
 136         ::std::sort( aModLibList.begin() , aModLibList.end() , StringCompareLessThan );
 137     }
 138
 139     // create a sorted list of dialog library names
 140     ::std::vector<String> aDlgLibList;
 141     if ( xDlgLibContainer.is() )
 142     {
 143         Sequence< ::rtl::OUString > aDlgLibNames = xDlgLibContainer->getElementNames();
 144         sal_Int32 nDlgLibCount = aDlgLibNames.getLength();
 145         const ::rtl::OUString* pDlgLibNames = aDlgLibNames.getConstArray();
 146         for ( sal_Int32 i = 0 ; i < nDlgLibCount ; i++ )
 147             aDlgLibList.push_back( pDlgLibNames[ i ] );
 148         ::std::sort( aDlgLibList.begin() , aDlgLibList.end() , StringCompareLessThan );
 149     }
 150
 151     // merge both lists
 152     ::std::vector<String> aLibList( aModLibList.size() + aDlgLibList.size() );
 153     ::std::merge( aModLibList.begin(), aModLibList.end(), aDlgLibList.begin(), aDlgLibList.end(), aLibList.begin(), StringCompareLessThan );
 154     ::std::vector<String>::iterator aIterEnd = ::std::unique( aLibList.begin(), aLibList.end() );  // move unique elements to the front
 155     aLibList.erase( aIterEnd, aLibList.end() ); // remove duplicates
 156
 157     // copy to sequence
 158     sal_Int32 nLibCount = aLibList.size();
 159     Sequence< ::rtl::OUString > aSeqLibNames( nLibCount );
 160     for ( sal_Int32 i = 0 ; i < nLibCount ; i++ )
 161         aSeqLibNames.getArray()[ i ] = aLibList[ i ];
 162
 163     return aSeqLibNames;
 164 }
 165
 166 //----------------------------------------------------------------------------
 167
 168 bool RenameModule( Window* pErrorParent, const ScriptDocument& rDocument, const String& rLibName, const String& rOldName, const String& rNewName )
 169 {
 170     if ( !rDocument.hasModule( rLibName, rOldName ) )
 171     {
 172         OSL_ENSURE( false, "BasicIDE::RenameModule: old module name is invalid!" );
 173         return false;
 174     }
 175
 176     if ( rDocument.hasModule( rLibName, rNewName ) )
 177     {
 178         ErrorBox aError( pErrorParent, WB_OK | WB_DEF_OK, String( IDEResId( RID_STR_SBXNAMEALLREADYUSED2 ) ) );
 179         aError.Execute();
 180         return false;
 181     }
 182
 183     // #i74440
 184     if ( rNewName.Len() == 0 )
 185     {
 186         ErrorBox aError( pErrorParent, WB_OK | WB_DEF_OK, String( IDEResId( RID_STR_BADSBXNAME ) ) );
 187         aError.Execute();
 188         return false;
 189     }
 190
 191     if ( !rDocument.renameModule( rLibName, rOldName, rNewName ) )
 192         return false;
 193
 194     BasicIDEShell* pIDEShell = IDE_DLL()->GetShell();
 195     if ( pIDEShell )
 196     {
 197         IDEBaseWindow* pWin = pIDEShell->FindWindow( rDocument, rLibName, rOldName, BASICIDE_TYPE_MODULE, FALSE );
 198         if ( pWin )
 199         {
 200             // set new name in window
 201             pWin->SetName( rNewName );
 202
 203             // set new module in module window
 204             ModulWindow* pModWin = (ModulWindow*)pWin;
 205             pModWin->SetSbModule( (SbModule*)pModWin->GetBasic()->FindModule( rNewName ) );
 206
 207             // update tabwriter
 208             USHORT nId = (USHORT)(pIDEShell->GetIDEWindowTable()).GetKey( pWin );
 209             DBG_ASSERT( nId, "No entry in Tabbar!" );
 210             if ( nId )
 211             {
 212                 BasicIDETabBar* pTabBar = (BasicIDETabBar*)pIDEShell->GetTabBar();
 213                 pTabBar->SetPageText( nId, rNewName );
 214                 pTabBar->Sort();
 215                 pTabBar->MakeVisible( pTabBar->GetCurPageId() );
 216             }
 217         }
 218     }
 219     return true;
 220 }
 221
 222 //----------------------------------------------------------------------------
 223
 224 ::rtl::OUString ChooseMacro( const uno::Reference< frame::XModel >& rxLimitToDocument, BOOL bChooseOnly, const ::rtl::OUString& rMacroDesc )
 225 {
 226     (void)rMacroDesc;
 227
 228     BasicIDEDLL::Init();
 229
 230     IDE_DLL()->GetExtraData()->ChoosingMacro() = TRUE;
 231     SFX_APP()->EnterBasicCall();
 232
 233     String aScriptURL;
 234     BOOL bError = FALSE;
 235     SbMethod* pMethod = NULL;
 236
 237     MacroChooser* pChooser = new MacroChooser( NULL, TRUE );
 238     if ( bChooseOnly || !SvtModuleOptions().IsBasicIDE() )
 239         pChooser->SetMode( MACROCHOOSER_CHOOSEONLY );
 240
 241     if ( !bChooseOnly && rxLimitToDocument.is() )
 242         // Hack!
 243         pChooser->SetMode( MACROCHOOSER_RECORDING );
 244
 245     short nRetValue = pChooser->Execute();
 246
 247     IDE_DLL()->GetExtraData()->ChoosingMacro() = FALSE;
 248
 249     switch ( nRetValue )
 250     {
 251         case MACRO_OK_RUN:
 252         {
 253             pMethod = pChooser->GetMacro();
 254             if ( !pMethod && pChooser->GetMode() == MACROCHOOSER_RECORDING )
 255                 pMethod = pChooser->CreateMacro();
 256
 257             if ( pMethod )
 258             {
 259                 SbModule* pModule = pMethod->GetModule();
 260                 DBG_ASSERT(pModule, "BasicIDE::ChooseMacro: No Module found!");
 261                 if ( pModule )
 262                 {
 263                     StarBASIC* pBasic = (StarBASIC*)pModule->GetParent();
 264                     DBG_ASSERT(pBasic, "BasicIDE::ChooseMacro: No Basic found!");
 265                     if ( pBasic )
 266                     {
 267                         BasicManager* pBasMgr = BasicIDE::FindBasicManager( pBasic );
 268                         DBG_ASSERT(pBasMgr, "BasicIDE::ChooseMacro: No BasicManager found!");
 269                         if ( pBasMgr )
 270                         {
 271                             // name
 272                             String aName;
 273                             aName += pBasic->GetName();
 274                             aName += '.';
 275                             aName += pModule->GetName();
 276                             aName += '.';
 277                             aName += pMethod->GetName();
 278
 279                             // language
 280                             String aLanguage = String::CreateFromAscii("Basic");
 281
 282                             // location
 283                             String aLocation;
 284                             ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) );
 285                             if ( aDocument.isDocument() )
 286                             {
 287                                 // document basic
 288                                 aLocation = String::CreateFromAscii("document");
 289
 290                                 if ( rxLimitToDocument.is() )
 291                                 {
 292                                     uno::Reference< frame::XModel > xLimitToDocument( rxLimitToDocument );
 293
 294                                     uno::Reference< document::XEmbeddedScripts > xScripts( rxLimitToDocument, UNO_QUERY );
 295                                     if ( !xScripts.is() )
 296                                     {   // the document itself does not support embedding scripts
 297                                         uno::Reference< document::XScriptInvocationContext > xContext( rxLimitToDocument, UNO_QUERY );
 298                                         if ( xContext.is() )
 299                                             xScripts = xContext->getScriptContainer();
 300                                         if ( xScripts.is() )
 301                                         {   // but it is able to refer to a document which actually does support this
 302                                             xLimitToDocument.set( xScripts, UNO_QUERY );
 303                                             if ( !xLimitToDocument.is() )
 304                                             {
 305                                                 OSL_ENSURE( false, "BasicIDE::ChooseMacro: a script container which is no document!?" );
 306                                                 xLimitToDocument = rxLimitToDocument;
 307                                             }
 308                                         }
 309                                     }
 310
 311                                     if ( xLimitToDocument != aDocument.getDocument() )
 312                                     {
 313                                         // error
 314                                         bError = TRUE;
 315                                         ErrorBox( NULL, WB_OK | WB_DEF_OK, String( IDEResId( RID_STR_ERRORCHOOSEMACRO ) ) ).Execute();
 316                                     }
 317                                 }
 318                             }
 319                             else
 320                             {
 321                                 // application basic
 322                                 aLocation = String::CreateFromAscii("application");
 323                             }
 324
 325                             // script URL
 326                             if ( !bError )
 327                             {
 328                                 aScriptURL = String::CreateFromAscii("vnd.sun.star.script:");
 329                                 aScriptURL += aName;
 330                                 aScriptURL += String::CreateFromAscii("?language=");
 331                                 aScriptURL += aLanguage;
 332                                 aScriptURL += String::CreateFromAscii("&location=");
 333                                 aScriptURL += aLocation;
 334                             }
 335                         }
 336                     }
 337                 }
 338             }
 339
 340             if ( pMethod && !rxLimitToDocument.is() )
 341             {
 342                 pMethod->AddRef();      // festhalten, bis Event abgearbeitet.
 343                 Application::PostUserEvent( LINK( IDE_DLL()->GetExtraData(), BasicIDEData, ExecuteMacroEvent ), pMethod );
 344             }
 345         }
 346         break;
 347     }
 348
 349     delete pChooser;
 350
 351     SFX_APP()->LeaveBasicCall();
 352
 353     return ::rtl::OUString( aScriptURL );
 354 }
 355
 356 //----------------------------------------------------------------------------
 357
 358 Sequence< ::rtl::OUString > GetMethodNames( const ScriptDocument& rDocument, const String& rLibName, const String& rModName )
 359     throw(NoSuchElementException )
 360 {
 361     Sequence< ::rtl::OUString > aSeqMethods;
 362
 363     // get module
 364     ::rtl::OUString aOUSource;
 365     if ( rDocument.getModule( rLibName, rModName, aOUSource ) )
 366     {
 367         SbModuleRef xModule = new SbModule( rModName );
 368         xModule->SetSource32( aOUSource );
 369         USHORT nCount = xModule->GetMethods()->Count();
 370         aSeqMethods.realloc( nCount );
 371
 372         for ( USHORT i = 0; i < nCount; i++ )
 373         {
 374             SbMethod* pMethod = (SbMethod*)xModule->GetMethods()->Get( i );
 375             DBG_ASSERT( pMethod, "Method not found! (NULL)" );
 376             aSeqMethods.getArray()[ i ] = pMethod->GetName();
 377         }
 378     }
 379
 380     return aSeqMethods;
 381 }
 382
 383 //----------------------------------------------------------------------------
 384
 385 BOOL HasMethod( const ScriptDocument& rDocument, const String& rLibName, const String& rModName, const String& rMethName )
 386 {
 387     BOOL bHasMethod = FALSE;
 388
 389     ::rtl::OUString aOUSource;
 390     if ( rDocument.hasModule( rLibName, rModName ) && rDocument.getModule( rLibName, rModName, aOUSource ) )
 391     {
 392         SbModuleRef xModule = new SbModule( rModName );
 393         xModule->SetSource32( aOUSource );
 394         SbxArray* pMethods = xModule->GetMethods();
 395         if ( pMethods )
 396         {
 397             SbMethod* pMethod = (SbMethod*)pMethods->Find( rMethName, SbxCLASS_METHOD );
 398             if ( pMethod )
 399                 bHasMethod = TRUE;
 400         }
 401     }
 402
 403     return bHasMethod;
 404 }
 405 } //namespace BasicIDE
 406 //----------------------------------------------------------------------------