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