Line data    Source code

       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 <vcl/layout.hxx>
      21             : #include <algorithm>
      22             : #include <basic/basmgr.hxx>
      23             : #include <basic/sbmeth.hxx>
      24             : #include <basic/sbx.hxx>
      25             : #include <unotools/moduleoptions.hxx>
      26             : 
      27             : #include <iderdll.hxx>
      28             : #include <iderdll2.hxx>
      29             : #include <basobj.hxx>
      30             : #include <basidesh.hxx>
      31             : #include <objdlg.hxx>
      32             : #include <bastypes.hxx>
      33             : #include <basdoc.hxx>
      34             : #include <basidesh.hrc>
      35             : 
      36             : #include <baside2.hxx>
      37             : #include <baside3.hxx>
      38             : #include <basicmod.hxx>
      39             : #include <localizationmgr.hxx>
      40             : #include "dlged.hxx"
      41             : #include <dlgeddef.hxx>
      42             : #include <comphelper/processfactory.hxx>
      43             : #include <com/sun/star/script/XLibraryContainer.hpp>
      44             : #include <com/sun/star/script/XLibraryContainerPassword.hpp>
      45             : #include <com/sun/star/container/XNameContainer.hpp>
      46             : #include <xmlscript/xmldlg_imexp.hxx>
      47             : #include <sfx2/app.hxx>
      48             : #include <sfx2/dispatch.hxx>
      49             : #include <sfx2/request.hxx>
      50             : #include <rtl/uri.hxx>
      51             : #include <osl/process.h>
      52             : #include <osl/file.hxx>
      53             : 
      54             : namespace basctl
      55             : {
      56             : 
      57             : using namespace comphelper;
      58             : using namespace ::com::sun::star;
      59             : using namespace ::com::sun::star::uno;
      60             : using namespace ::com::sun::star::container;
      61             : 
      62             : extern "C" {
      63           0 :     SAL_DLLPUBLIC_EXPORT long basicide_handle_basic_error( void* pPtr )
      64             :     {
      65           0 :         return HandleBasicError( (StarBASIC*)pPtr );
      66             :     }
      67             : }
      68             : 
      69           0 : SbMethod* CreateMacro( SbModule* pModule, const OUString& rMacroName )
      70             : {
      71           0 :     SfxDispatcher* pDispatcher = GetDispatcher();
      72           0 :     if( pDispatcher )
      73             :     {
      74           0 :         pDispatcher->Execute( SID_BASICIDE_STOREALLMODULESOURCES );
      75             :     }
      76             : 
      77           0 :     if ( pModule->GetMethods()->Find( rMacroName, SbxCLASS_METHOD ) )
      78           0 :         return 0;
      79             : 
      80           0 :     OUString aMacroName( rMacroName );
      81           0 :     if ( aMacroName.isEmpty() )
      82             :     {
      83           0 :         if ( !pModule->GetMethods()->Count() )
      84           0 :             aMacroName = "Main" ;
      85             :         else
      86             :         {
      87           0 :             bool bValid = false;
      88           0 :             OUString aStdMacroText( "Macro" );
      89           0 :             sal_Int32 nMacro = 1;
      90           0 :             while ( !bValid )
      91             :             {
      92           0 :                 aMacroName = aStdMacroText;
      93           0 :                 aMacroName += OUString::number( nMacro );
      94             :                 // test whether existing...
      95           0 :                 bValid = pModule->GetMethods()->Find( aMacroName, SbxCLASS_METHOD ) ? false : true;
      96           0 :                 nMacro++;
      97           0 :             }
      98             :         }
      99             :     }
     100             : 
     101           0 :     OUString aOUSource( pModule->GetSource32() );
     102             : 
     103             :     // don't produce too many empty lines...
     104           0 :     sal_Int32 nSourceLen = aOUSource.getLength();
     105           0 :     if ( nSourceLen > 2 )
     106             :     {
     107           0 :         const sal_Unicode* pStr = aOUSource.getStr();
     108           0 :         if ( pStr[ nSourceLen - 1 ]  != LINE_SEP )
     109           0 :             aOUSource += "\n\n" ;
     110           0 :         else if ( pStr[ nSourceLen - 2 ] != LINE_SEP )
     111           0 :             aOUSource += "\n" ;
     112           0 :         else if ( pStr[ nSourceLen - 3 ] == LINE_SEP )
     113           0 :             aOUSource = aOUSource.copy( 0, nSourceLen-1 );
     114             :     }
     115             : 
     116           0 :     OUString aSubStr;
     117           0 :     aSubStr = "Sub " ;
     118           0 :     aSubStr += aMacroName;
     119           0 :     aSubStr += "\n\nEnd Sub" ;
     120             : 
     121           0 :     aOUSource += aSubStr;
     122             : 
     123             :     // update module in library
     124           0 :     ScriptDocument aDocument( ScriptDocument::NoDocument );
     125           0 :     StarBASIC* pBasic = dynamic_cast<StarBASIC*>(pModule->GetParent());
     126             :     DBG_ASSERT(pBasic, "basctl::CreateMacro: No Basic found!");
     127           0 :     if ( pBasic )
     128             :     {
     129           0 :         BasicManager* pBasMgr = FindBasicManager( pBasic );
     130             :         DBG_ASSERT(pBasMgr, "basctl::CreateMacro: No BasicManager found!");
     131           0 :         if ( pBasMgr )
     132             :         {
     133           0 :             aDocument = ScriptDocument::getDocumentForBasicManager( pBasMgr );
     134             :             OSL_ENSURE( aDocument.isValid(), "basctl::CreateMacro: no document for the given BasicManager!" );
     135           0 :             if ( aDocument.isValid() )
     136             :             {
     137           0 :                 OUString aLibName = pBasic->GetName();
     138           0 :                 OUString aModName = pModule->GetName();
     139           0 :                 OSL_VERIFY( aDocument.updateModule( aLibName, aModName, aOUSource ) );
     140             :             }
     141             :         }
     142             :     }
     143             : 
     144           0 :     SbMethod* pMethod = static_cast<SbMethod*>(pModule->GetMethods()->Find( aMacroName, SbxCLASS_METHOD ));
     145             : 
     146           0 :     if( pDispatcher )
     147             :     {
     148           0 :         pDispatcher->Execute( SID_BASICIDE_UPDATEALLMODULESOURCES );
     149             :     }
     150             : 
     151           0 :     if ( aDocument.isAlive() )
     152           0 :         MarkDocumentModified( aDocument );
     153             : 
     154           0 :     return pMethod;
     155             : }
     156             : 
     157           0 : bool RenameDialog (
     158             :     vcl::Window* pErrorParent,
     159             :     ScriptDocument const& rDocument,
     160             :     OUString const& rLibName,
     161             :     OUString const& rOldName,
     162             :     OUString const& rNewName
     163             : )
     164             :     throw (ElementExistException, NoSuchElementException, RuntimeException, std::exception)
     165             : {
     166           0 :     if ( !rDocument.hasDialog( rLibName, rOldName ) )
     167             :     {
     168             :         OSL_FAIL( "basctl::RenameDialog: old module name is invalid!" );
     169           0 :         return false;
     170             :     }
     171             : 
     172           0 :     if ( rDocument.hasDialog( rLibName, rNewName ) )
     173             :     {
     174           0 :         MessageDialog aError(pErrorParent, IDE_RESSTR(RID_STR_SBXNAMEALLREADYUSED2));
     175           0 :         aError.Execute();
     176           0 :         return false;
     177             :     }
     178             : 
     179             :     // #i74440
     180           0 :     if ( rNewName.isEmpty() )
     181             :     {
     182           0 :         MessageDialog aError(pErrorParent, IDE_RESSTR(RID_STR_BADSBXNAME));
     183           0 :         aError.Execute();
     184           0 :         return false;
     185             :     }
     186             : 
     187           0 :     Shell* pShell = GetShell();
     188           0 :     DialogWindow* pWin = pShell ? pShell->FindDlgWin(rDocument, rLibName, rOldName) : 0;
     189           0 :     Reference< XNameContainer > xExistingDialog;
     190           0 :     if ( pWin )
     191           0 :         xExistingDialog = pWin->GetEditor().GetDialog();
     192             : 
     193           0 :     if ( xExistingDialog.is() )
     194           0 :         LocalizationMgr::renameStringResourceIDs( rDocument, rLibName, rNewName, xExistingDialog );
     195             : 
     196           0 :     if ( !rDocument.renameDialog( rLibName, rOldName, rNewName, xExistingDialog ) )
     197           0 :         return false;
     198             : 
     199           0 :     if ( pWin )
     200             :     {
     201             :         // set new name in window
     202           0 :         pWin->SetName( rNewName );
     203             : 
     204             :         // update property browser
     205           0 :         pWin->UpdateBrowser();
     206             : 
     207             :         // update tabwriter
     208           0 :         sal_uInt16 nId = pShell->GetWindowId( pWin );
     209             :         DBG_ASSERT( nId, "No entry in Tabbar!" );
     210           0 :         if ( nId )
     211             :         {
     212           0 :             TabBar& rTabBar = pShell->GetTabBar();
     213           0 :             rTabBar.SetPageText( nId, rNewName );
     214           0 :             rTabBar.Sort();
     215           0 :             rTabBar.MakeVisible( rTabBar.GetCurPageId() );
     216             :         }
     217             :     }
     218           0 :     return true;
     219             : }
     220             : 
     221           0 : bool RemoveDialog( const ScriptDocument& rDocument, const OUString& rLibName, const OUString& rDlgName )
     222             : {
     223           0 :     if (Shell* pShell = GetShell())
     224             :     {
     225           0 :         if (DialogWindow* pDlgWin = pShell->FindDlgWin(rDocument, rLibName, rDlgName))
     226             :         {
     227           0 :             Reference< container::XNameContainer > xDialogModel = pDlgWin->GetDialog();
     228           0 :             LocalizationMgr::removeResourceForDialog( rDocument, rLibName, rDlgName, xDialogModel );
     229             :         }
     230             :     }
     231             : 
     232           0 :     return rDocument.removeDialog( rLibName, rDlgName );
     233             : }
     234             : 
     235           0 : StarBASIC* FindBasic( const SbxVariable* pVar )
     236             : {
     237           0 :     SbxVariable const* pSbx = pVar;
     238           0 :     while (pSbx && !dynamic_cast<StarBASIC const*>(pSbx))
     239           0 :         pSbx = pSbx->GetParent();
     240           0 :     return const_cast<StarBASIC*>(static_cast<const StarBASIC*>(pSbx));
     241             : }
     242             : 
     243           0 : BasicManager* FindBasicManager( StarBASIC* pLib )
     244             : {
     245           0 :     ScriptDocuments aDocuments( ScriptDocument::getAllScriptDocuments( ScriptDocument::AllWithApplication ) );
     246           0 :     for (   ScriptDocuments::const_iterator doc = aDocuments.begin();
     247           0 :             doc != aDocuments.end();
     248             :             ++doc
     249             :         )
     250             :     {
     251           0 :         BasicManager* pBasicMgr = doc->getBasicManager();
     252             :         OSL_ENSURE( pBasicMgr, "basctl::FindBasicManager: no basic manager for the document!" );
     253           0 :         if ( !pBasicMgr )
     254           0 :             continue;
     255             : 
     256           0 :         Sequence< OUString > aLibNames( doc->getLibraryNames() );
     257           0 :         sal_Int32 nLibCount = aLibNames.getLength();
     258           0 :         const OUString* pLibNames = aLibNames.getConstArray();
     259             : 
     260           0 :         for ( sal_Int32 i = 0 ; i < nLibCount ; i++ )
     261             :         {
     262           0 :             StarBASIC* pL = pBasicMgr->GetLib( pLibNames[ i ] );
     263           0 :             if ( pL == pLib )
     264           0 :                 return pBasicMgr;
     265             :         }
     266           0 :     }
     267           0 :     return NULL;
     268             : }
     269             : 
     270           0 : void MarkDocumentModified( const ScriptDocument& rDocument )
     271             : {
     272             :     // does not have to come from a document...
     273           0 :     if ( rDocument.isApplication() )
     274             :     {
     275           0 :         if (Shell* pShell = GetShell())
     276             :         {
     277           0 :             pShell->SetAppBasicModified();
     278           0 :             pShell->UpdateObjectCatalog();
     279             :         }
     280             :     }
     281             :     else
     282             :     {
     283           0 :         rDocument.setDocumentModified();
     284             :     }
     285             : 
     286           0 :     if (SfxBindings* pBindings = GetBindingsPtr())
     287             :     {
     288           0 :         pBindings->Invalidate( SID_SIGNATURE );
     289           0 :         pBindings->Invalidate( SID_SAVEDOC );
     290           0 :         pBindings->Update( SID_SAVEDOC );
     291             :     }
     292           0 : }
     293             : 
     294           0 : void RunMethod( SbMethod* pMethod )
     295             : {
     296           0 :     SbxValues aRes;
     297           0 :     aRes.eType = SbxVOID;
     298           0 :     pMethod->Get( aRes );
     299           0 : }
     300             : 
     301           0 : void StopBasic()
     302             : {
     303           0 :     StarBASIC::Stop();
     304           0 :     if (Shell* pShell = GetShell())
     305             :     {
     306           0 :         Shell::WindowTable& rWindows = pShell->GetWindowTable();
     307           0 :         for (Shell::WindowTableIt it = rWindows.begin(); it != rWindows.end(); ++it )
     308             :         {
     309           0 :             BaseWindow* pWin = it->second;
     310             :             // call BasicStopped manually because the Stop-Notify
     311             :             // might not get through otherwise
     312           0 :             pWin->BasicStopped();
     313             :         }
     314             :     }
     315           0 :     BasicStopped();
     316           0 : }
     317             : 
     318           0 : void BasicStopped(
     319             :     bool* pbAppWindowDisabled,
     320             :     bool* pbDispatcherLocked,
     321             :     sal_uInt16* pnWaitCount,
     322             :     SfxUInt16Item** ppSWActionCount, SfxUInt16Item** ppSWLockViewCount
     323             : )
     324             : {
     325             :     // maybe there are some locks to be removed after an error
     326             :     // or an explicit cancelling of the basic...
     327           0 :     if ( pbAppWindowDisabled )
     328           0 :         *pbAppWindowDisabled = false;
     329           0 :     if ( pbDispatcherLocked )
     330           0 :         *pbDispatcherLocked = false;
     331           0 :     if ( pnWaitCount )
     332           0 :         *pnWaitCount = 0;
     333           0 :     if ( ppSWActionCount )
     334           0 :         *ppSWActionCount = 0;
     335           0 :     if ( ppSWLockViewCount )
     336           0 :         *ppSWLockViewCount = 0;
     337             : 
     338             :     // AppWait?
     339           0 :     if (Shell* pShell = GetShell())
     340             :     {
     341           0 :         sal_uInt16 nWait = 0;
     342           0 :         while ( pShell->GetViewFrame()->GetWindow().IsWait() )
     343             :         {
     344           0 :             pShell->GetViewFrame()->GetWindow().LeaveWait();
     345           0 :             nWait++;
     346             :         }
     347           0 :         if ( pnWaitCount )
     348           0 :             *pnWaitCount = nWait;
     349             :     }
     350             : 
     351           0 :     vcl::Window* pDefParent = Application::GetDefDialogParent();
     352           0 :     if ( pDefParent && !pDefParent->IsEnabled() )
     353             :     {
     354           0 :         pDefParent->Enable(true);
     355           0 :         if ( pbAppWindowDisabled )
     356           0 :             *pbAppWindowDisabled = true;
     357             :     }
     358             : 
     359           0 : }
     360             : 
     361           0 : void InvalidateDebuggerSlots()
     362             : {
     363           0 :     if (SfxBindings* pBindings = GetBindingsPtr())
     364             :     {
     365           0 :         pBindings->Invalidate( SID_BASICSTOP );
     366           0 :         pBindings->Update( SID_BASICSTOP );
     367           0 :         pBindings->Invalidate( SID_BASICRUN );
     368           0 :         pBindings->Update( SID_BASICRUN );
     369           0 :         pBindings->Invalidate( SID_BASICCOMPILE );
     370           0 :         pBindings->Update( SID_BASICCOMPILE );
     371           0 :         pBindings->Invalidate( SID_BASICSTEPOVER );
     372           0 :         pBindings->Update( SID_BASICSTEPOVER );
     373           0 :         pBindings->Invalidate( SID_BASICSTEPINTO );
     374           0 :         pBindings->Update( SID_BASICSTEPINTO );
     375           0 :         pBindings->Invalidate( SID_BASICSTEPOUT );
     376           0 :         pBindings->Update( SID_BASICSTEPOUT );
     377           0 :         pBindings->Invalidate( SID_BASICIDE_TOGGLEBRKPNT );
     378           0 :         pBindings->Update( SID_BASICIDE_TOGGLEBRKPNT );
     379           0 :         pBindings->Invalidate( SID_BASICIDE_STAT_POS );
     380           0 :         pBindings->Update( SID_BASICIDE_STAT_POS );
     381             :     }
     382           0 : }
     383             : 
     384           0 : long HandleBasicError( StarBASIC* pBasic )
     385             : {
     386           0 :     EnsureIde();
     387           0 :     BasicStopped();
     388             : 
     389             :     // no error output during macro choosing
     390           0 :     if (GetExtraData()->ChoosingMacro())
     391           0 :         return 1;
     392           0 :     if (GetExtraData()->ShellInCriticalSection())
     393           0 :         return 2;
     394             : 
     395           0 :     long nRet = 0;
     396           0 :     Shell* pShell = 0;
     397           0 :     if ( SvtModuleOptions().IsBasicIDE() )
     398             :     {
     399           0 :         BasicManager* pBasMgr = FindBasicManager( pBasic );
     400           0 :         if ( pBasMgr )
     401             :         {
     402           0 :             bool bProtected = false;
     403           0 :             ScriptDocument aDocument( ScriptDocument::getDocumentForBasicManager( pBasMgr ) );
     404             :             OSL_ENSURE( aDocument.isValid(), "basctl::HandleBasicError: no document for the given BasicManager!" );
     405           0 :             if ( aDocument.isValid() )
     406             :             {
     407           0 :                 OUString aOULibName( pBasic->GetName() );
     408           0 :                 Reference< script::XLibraryContainer > xModLibContainer( aDocument.getLibraryContainer( E_SCRIPTS ) );
     409           0 :                 if ( xModLibContainer.is() && xModLibContainer->hasByName( aOULibName ) )
     410             :                 {
     411           0 :                     Reference< script::XLibraryContainerPassword > xPasswd( xModLibContainer, UNO_QUERY );
     412           0 :                     if ( xPasswd.is() && xPasswd->isLibraryPasswordProtected( aOULibName ) && !xPasswd->isLibraryPasswordVerified( aOULibName ) )
     413             :                     {
     414           0 :                         bProtected = true;
     415           0 :                     }
     416           0 :                 }
     417             :             }
     418             : 
     419           0 :             if ( !bProtected )
     420             :             {
     421           0 :                 pShell = GetShell();
     422           0 :                 if ( !pShell )
     423             :                 {
     424           0 :                     SfxAllItemSet aArgs( SfxGetpApp()->GetPool() );
     425           0 :                     SfxRequest aRequest( SID_BASICIDE_APPEAR, SfxCallMode::SYNCHRON, aArgs );
     426           0 :                     SfxGetpApp()->ExecuteSlot( aRequest );
     427           0 :                     pShell = GetShell();
     428             :                 }
     429           0 :             }
     430             :         }
     431             :     }
     432             : 
     433           0 :     if ( pShell )
     434           0 :         nRet = long(pShell->CallBasicErrorHdl( pBasic ));
     435             :     else
     436           0 :         ErrorHandler::HandleError( StarBASIC::GetErrorCode() );
     437             : 
     438           0 :     return nRet;
     439             : }
     440             : 
     441           0 : SfxBindings* GetBindingsPtr()
     442             : {
     443           0 :     SfxBindings* pBindings = NULL;
     444             : 
     445           0 :     SfxViewFrame* pFrame = NULL;
     446           0 :     if (Shell* pShell = GetShell())
     447             :     {
     448           0 :         pFrame = pShell->GetViewFrame();
     449             :     }
     450             :     else
     451             :     {
     452           0 :         SfxViewFrame* pView = SfxViewFrame::GetFirst();
     453           0 :         while ( pView )
     454             :         {
     455           0 :             if (dynamic_cast<DocShell*>(pView->GetObjectShell()))
     456             :             {
     457           0 :                 pFrame = pView;
     458           0 :                 break;
     459             :             }
     460           0 :             pView = SfxViewFrame::GetNext( *pView );
     461             :         }
     462             :     }
     463           0 :     if ( pFrame != NULL )
     464           0 :         pBindings = &pFrame->GetBindings();
     465             : 
     466           0 :     return pBindings;
     467             : }
     468             : 
     469           0 : SfxDispatcher* GetDispatcher ()
     470             : {
     471           0 :     if (Shell* pShell = GetShell())
     472           0 :         if (SfxViewFrame* pViewFrame = pShell->GetViewFrame())
     473           0 :             if (SfxDispatcher* pDispatcher = pViewFrame->GetDispatcher())
     474           0 :                 return pDispatcher;
     475           0 :     return 0;
     476             : }
     477           0 : } // namespace basctl
     478             : 
     479             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */