basic/source/classes/eventatt.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 <comphelper/processfactory.hxx>
  22 #include <comphelper/string.hxx>
  23
  24 #include <com/sun/star/awt/XControlContainer.hpp>
  25 #include <com/sun/star/awt/XControl.hpp>
  26 #include <com/sun/star/awt/DialogProvider.hpp>
  27 #include <com/sun/star/beans/XPropertySet.hpp>
  28 #include <com/sun/star/container/XEnumerationAccess.hpp>
  29 #include <com/sun/star/container/XNameContainer.hpp>
  30 #include <com/sun/star/frame/XModel.hpp>
  31 #include <com/sun/star/frame/Desktop.hpp>
  32 #include <com/sun/star/script/XLibraryContainer.hpp>
  33 #include <com/sun/star/script/provider/theMasterScriptProviderFactory.hpp>
  34 #include <com/sun/star/script/provider/XScriptProviderSupplier.hpp>
  35 #include <com/sun/star/script/provider/XScriptProvider.hpp>
  36 #include <com/sun/star/io/XInputStreamProvider.hpp>
  37
  38 #include <basic/basicmanagerrepository.hxx>
  39 #include <basic/basmgr.hxx>
  40
  41 #include <sal/log.hxx>
  42 #include <comphelper/diagnose_ex.hxx>
  43 #include <vcl/svapp.hxx>
  44 #include <sbunoobj.hxx>
  45 #include <basic/sberrors.hxx>
  46 #include <basic/sbstar.hxx>
  47 #include <basic/sbmeth.hxx>
  48 #include <basic/sbuno.hxx>
  49 #include <runtime.hxx>
  50 #include <sbintern.hxx>
  51 #include <eventatt.hxx>
  52
  53 #include <cppuhelper/implbase.hxx>
  54
  55 using namespace ::com::sun::star;
  56 using namespace ::com::sun::star::uno;
  57 using namespace ::com::sun::star::script;
  58 using namespace ::com::sun::star::lang;
  59 using namespace ::com::sun::star::beans;
  60 using namespace ::com::sun::star::container;
  61 using namespace ::com::sun::star::awt;
  62 using namespace ::com::sun::star::io;
  63 using namespace ::cppu;
  64
  65 namespace {
  66
  67 void SFURL_firing_impl( const ScriptEvent& aScriptEvent, Any* pRet, const Reference< frame::XModel >& xModel )
  68 {
  69         SAL_INFO("basic", "Processing script url " << aScriptEvent.ScriptCode);
  70         try
  71         {
  72             Reference< provider::XScriptProvider > xScriptProvider;
  73             if ( xModel.is() )
  74             {
  75                 Reference< provider::XScriptProviderSupplier > xSupplier( xModel, UNO_QUERY );
  76                 OSL_ENSURE( xSupplier.is(), "SFURL_firing_impl: failed to get script provider supplier" );
  77                 if ( xSupplier.is() )
  78                     xScriptProvider.set( xSupplier->getScriptProvider() );
  79             }
  80             else
  81             {
  82                 const Reference< XComponentContext >& xContext(
  83                     comphelper::getProcessComponentContext() );
  84                 Reference< provider::XScriptProviderFactory > xFactory =
  85                     provider::theMasterScriptProviderFactory::get( xContext );
  86
  87                 Any aCtx;
  88                 aCtx <<= u"user"_ustr;
  89                 xScriptProvider = xFactory->createScriptProvider( aCtx );
  90             }
  91
  92             if ( !xScriptProvider.is() )
  93             {
  94                 SAL_INFO("basic", "Failed to create msp");
  95                 return;
  96             }
  97             Sequence< Any > inArgs( 0 );
  98             Sequence< Any > outArgs( 0 );
  99             Sequence< sal_Int16 > outIndex;
 100
 101             // get Arguments for script
 102             inArgs = aScriptEvent.Arguments;
 103
 104             Reference< provider::XScript > xScript = xScriptProvider->getScript( aScriptEvent.ScriptCode );
 105
 106             if ( !xScript.is() )
 107             {
 108                 SAL_INFO("basic", "Failed to Failed to obtain XScript");
 109                 return;
 110             }
 111
 112             Any result = xScript->invoke( inArgs, outIndex, outArgs );
 113             if ( pRet )
 114             {
 115                 *pRet = std::move(result);
 116             }
 117         }
 118         catch ( const RuntimeException& )
 119         {
 120             TOOLS_INFO_EXCEPTION("basic", "" );
 121         }
 122         catch ( const Exception& )
 123         {
 124             TOOLS_INFO_EXCEPTION("basic", "" );
 125         }
 126
 127 }
 128
 129
 130 class BasicScriptListener_Impl : public WeakImplHelper< XScriptListener >
 131 {
 132     StarBASICRef maBasicRef;
 133         Reference< frame::XModel > m_xModel;
 134
 135     void firing_impl(const ScriptEvent& aScriptEvent, Any* pRet);
 136
 137 public:
 138     BasicScriptListener_Impl( StarBASIC* pBasic, const Reference< frame::XModel >& xModel )
 139         : maBasicRef( pBasic ), m_xModel( xModel ) {}
 140
 141     // Methods of XAllListener
 142     virtual void SAL_CALL firing(const ScriptEvent& aScriptEvent) override;
 143     virtual Any SAL_CALL approveFiring(const ScriptEvent& aScriptEvent) override;
 144
 145     // Methods of XEventListener
 146     virtual void SAL_CALL disposing(const EventObject& Source) override;
 147 };
 148
 149 // Methods XAllListener
 150 void BasicScriptListener_Impl::firing( const ScriptEvent& aScriptEvent )
 151 {
 152     SolarMutexGuard g;
 153
 154     firing_impl( aScriptEvent, nullptr );
 155 }
 156
 157 Any BasicScriptListener_Impl::approveFiring( const ScriptEvent& aScriptEvent )
 158 {
 159     SolarMutexGuard g;
 160
 161     Any aRetAny;
 162     firing_impl( aScriptEvent, &aRetAny );
 163     return aRetAny;
 164 }
 165
 166 // Methods XEventListener
 167 void BasicScriptListener_Impl::disposing(const EventObject& )
 168 {
 169     // TODO: ???
 170     //SolarMutexGuard aGuard;
 171     //xSbxObj.Clear();
 172 }
 173
 174
 175 void BasicScriptListener_Impl::firing_impl( const ScriptEvent& aScriptEvent, Any* pRet )
 176 {
 177     if( aScriptEvent.ScriptType == "StarBasic" )
 178     {
 179         // Full qualified name?
 180         OUString aMacro( aScriptEvent.ScriptCode );
 181         OUString aLibName;
 182         OUString aLocation;
 183         if( comphelper::string::getTokenCount(aMacro, '.') == 3 )
 184         {
 185             sal_Int32 nLast = 0;
 186             std::u16string_view aFullLibName = o3tl::getToken(aMacro, 0, '.', nLast );
 187
 188             size_t nIndex = aFullLibName.find( ':' );
 189             if (nIndex != std::u16string_view::npos)
 190             {
 191                 aLocation = aFullLibName.substr( 0, nIndex );
 192                 aLibName = aFullLibName.substr( nIndex + 1 );
 193             }
 194
 195             aMacro = aMacro.copy( nLast );
 196         }
 197
 198         SbxObject* p = maBasicRef.get();
 199         SbxObject* pParent = p->GetParent();
 200         SbxObject* pParentParent = pParent ? pParent->GetParent() : nullptr;
 201
 202         StarBASICRef xAppStandardBasic;
 203         StarBASICRef xDocStandardBasic;
 204         if( pParentParent )
 205         {
 206             // Own basic must be document library
 207             xAppStandardBasic = static_cast<StarBASIC*>(pParentParent);
 208             xDocStandardBasic = static_cast<StarBASIC*>(pParent);
 209         }
 210         else if( pParent )
 211         {
 212             OUString aName = p->GetName();
 213             if( aName == "Standard" )
 214             {
 215                 // Own basic is doc standard lib
 216                 xDocStandardBasic = static_cast<StarBASIC*>(p);
 217             }
 218             xAppStandardBasic = static_cast<StarBASIC*>(pParent);
 219         }
 220         else
 221         {
 222             xAppStandardBasic = static_cast<StarBASIC*>(p);
 223         }
 224
 225         bool bSearchLib = true;
 226         StarBASICRef xLibSearchBasic;
 227         if( aLocation == "application" )
 228         {
 229             xLibSearchBasic = std::move(xAppStandardBasic);
 230         }
 231         else if( aLocation == "document" )
 232         {
 233             xLibSearchBasic = std::move(xDocStandardBasic);
 234         }
 235         else
 236         {
 237             bSearchLib = false;
 238         }
 239         SbxVariable* pMethVar = nullptr;
 240         // Be still tolerant and make default search if no search basic exists
 241         if( bSearchLib && xLibSearchBasic.is() )
 242         {
 243             sal_Int32 nCount = xLibSearchBasic->GetObjects()->Count();
 244             for( sal_Int32 nObj = -1; nObj < nCount ; nObj++ )
 245             {
 246                 StarBASIC* pBasic;
 247                 if( nObj == -1 )
 248                 {
 249                     pBasic = xLibSearchBasic.get();
 250                 }
 251                 else
 252                 {
 253                     SbxVariable* pVar = xLibSearchBasic->GetObjects()->Get(nObj);
 254                     pBasic = dynamic_cast<StarBASIC*>( pVar );
 255                 }
 256                 if( pBasic )
 257                 {
 258                     OUString aName = pBasic->GetName();
 259                     if( aName == aLibName )
 260                     {
 261                         // Search only in the lib, not automatically in application basic
 262                         SbxFlagBits nFlags = pBasic->GetFlags();
 263                         pBasic->ResetFlag( SbxFlagBits::GlobalSearch );
 264                         pMethVar = pBasic->Find( aMacro, SbxClassType::DontCare );
 265                         pBasic->SetFlags( nFlags );
 266                         break;
 267                     }
 268                 }
 269             }
 270         }
 271
 272         // Default: Be tolerant and search everywhere
 273         if( (!pMethVar || dynamic_cast<const SbMethod*>( pMethVar) == nullptr) && maBasicRef.is() )
 274         {
 275             pMethVar = maBasicRef->FindQualified( aMacro, SbxClassType::DontCare );
 276         }
 277         SbMethod* pMeth = dynamic_cast<SbMethod*>( pMethVar );
 278         if( !pMeth )
 279         {
 280             return;
 281         }
 282         // Setup parameters
 283         SbxArrayRef xArray;
 284         sal_Int32 nCnt = aScriptEvent.Arguments.getLength();
 285         if( nCnt )
 286         {
 287             xArray = new SbxArray;
 288             const Any *pArgs = aScriptEvent.Arguments.getConstArray();
 289             for( sal_Int32 i = 0; i < nCnt; i++ )
 290             {
 291                 SbxVariableRef xVar = new SbxVariable( SbxVARIANT );
 292                 unoToSbxValue( xVar.get(), pArgs[i] );
 293                 xArray->Put(xVar.get(), sal::static_int_cast<sal_uInt32>(i + 1));
 294             }
 295         }
 296
 297         // Call method
 298         SbxVariableRef xValue = pRet ? new SbxVariable : nullptr;
 299         if( xArray.is() )
 300         {
 301             pMeth->SetParameters( xArray.get() );
 302         }
 303         pMeth->Call( xValue.get() );
 304         if( pRet )
 305         {
 306             *pRet = sbxToUnoValue( xValue.get() );
 307         }
 308         pMeth->SetParameters( nullptr );
 309     }
 310     else // scripting framework script
 311     {
 312         //callBasic via scripting framework
 313         SFURL_firing_impl( aScriptEvent, pRet, m_xModel );
 314     }
 315 }
 316
 317 css::uno::Reference< css::container::XNameContainer > implFindDialogLibForDialog( const Any& rDlgAny, SbxObject* pBasic )
 318 {
 319     css::uno::Reference< css::container::XNameContainer > aRetDlgLib;
 320
 321     SbxVariable* pDlgLibContVar = pBasic->Find(u"DialogLibraries"_ustr, SbxClassType::Object);
 322     if( auto pDlgLibContUnoObj = dynamic_cast<SbUnoObject*>( pDlgLibContVar) )
 323     {
 324         Any aDlgLibContAny = pDlgLibContUnoObj->getUnoAny();
 325
 326         Reference< XLibraryContainer > xDlgLibContNameAccess( aDlgLibContAny, UNO_QUERY );
 327         OSL_ENSURE( xDlgLibContNameAccess.is(), "implFindDialogLibForDialog: no lib container for the given dialog!" );
 328         if( xDlgLibContNameAccess.is() )
 329         {
 330             Sequence< OUString > aLibNames = xDlgLibContNameAccess->getElementNames();
 331             const OUString* pLibNames = aLibNames.getConstArray();
 332             sal_Int32 nLibNameCount = aLibNames.getLength();
 333
 334             for( sal_Int32 iLib = 0 ; iLib < nLibNameCount ; iLib++ )
 335             {
 336                 if ( !xDlgLibContNameAccess->isLibraryLoaded( pLibNames[ iLib ] ) )
 337                     // if the library isn't loaded, then the dialog cannot originate from this lib
 338                     continue;
 339
 340                 Any aDlgLibAny = xDlgLibContNameAccess->getByName( pLibNames[ iLib ] );
 341
 342                 Reference< XNameContainer > xDlgLibNameCont( aDlgLibAny, UNO_QUERY );
 343                 OSL_ENSURE( xDlgLibNameCont.is(), "implFindDialogLibForDialog: invalid dialog lib!" );
 344                 if( xDlgLibNameCont.is() )
 345                 {
 346                     Sequence< OUString > aDlgNames = xDlgLibNameCont->getElementNames();
 347                     const OUString* pDlgNames = aDlgNames.getConstArray();
 348                     sal_Int32 nDlgNameCount = aDlgNames.getLength();
 349
 350                     for( sal_Int32 iDlg = 0 ; iDlg < nDlgNameCount ; iDlg++ )
 351                     {
 352                         Any aDlgAny = xDlgLibNameCont->getByName( pDlgNames[ iDlg ] );
 353                         if( aDlgAny == rDlgAny )
 354                         {
 355                             aRetDlgLib = xDlgLibNameCont;
 356                             break;
 357                         }
 358                     }
 359                 }
 360             }
 361         }
 362     }
 363
 364     return aRetDlgLib;
 365 }
 366
 367 css::uno::Reference< css::container::XNameContainer > implFindDialogLibForDialogBasic( const Any& aAnyISP, SbxObject* pBasic, StarBASIC*& pFoundBasic )
 368 {
 369     css::uno::Reference< css::container::XNameContainer > aDlgLib;
 370     // Find dialog library for dialog, direct access is not possible here
 371     StarBASIC* pStartedBasic = static_cast<StarBASIC*>(pBasic);
 372     SbxObject* pParentBasic = pStartedBasic ? pStartedBasic->GetParent() : nullptr;
 373     SbxObject* pParentParentBasic = pParentBasic ? pParentBasic->GetParent() : nullptr;
 374
 375     SbxObject* pSearchBasic1 = nullptr;
 376     SbxObject* pSearchBasic2 = nullptr;
 377     if( pParentParentBasic )
 378     {
 379         pSearchBasic1 = pParentBasic;
 380         pSearchBasic2 = pParentParentBasic;
 381     }
 382     else
 383     {
 384         pSearchBasic1 = pStartedBasic;
 385         pSearchBasic2 = pParentBasic;
 386     }
 387     if( pSearchBasic1 )
 388     {
 389         aDlgLib = implFindDialogLibForDialog( aAnyISP, pSearchBasic1 );
 390
 391         if ( aDlgLib.is() )
 392             pFoundBasic = static_cast<StarBASIC*>(pSearchBasic1);
 393
 394         else if( pSearchBasic2 )
 395         {
 396             aDlgLib = implFindDialogLibForDialog( aAnyISP, pSearchBasic2 );
 397             if ( aDlgLib.is() )
 398                 pFoundBasic = static_cast<StarBASIC*>(pSearchBasic2);
 399         }
 400     }
 401     return aDlgLib;
 402 }
 403
 404 }
 405
 406 void RTL_Impl_CreateUnoDialog( SbxArray& rPar )
 407 {
 408     const Reference< XComponentContext >& xContext( comphelper::getProcessComponentContext() );
 409
 410     // We need at least 1 parameter
 411     if (rPar.Count() < 2)
 412     {
 413         StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
 414         return;
 415     }
 416
 417     // Get dialog
 418     SbxBaseRef pObj = rPar.Get(1)->GetObject();
 419     SbUnoObject* pUnoObj = dynamic_cast<SbUnoObject*>(pObj.get());
 420     if( !pUnoObj )
 421     {
 422         StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
 423         return;
 424     }
 425     Any aAnyISP = pUnoObj->getUnoAny();
 426     TypeClass eType = aAnyISP.getValueTypeClass();
 427
 428     if( eType != TypeClass_INTERFACE )
 429     {
 430         StarBASIC::Error( ERRCODE_BASIC_BAD_ARGUMENT );
 431         return;
 432     }
 433
 434     // Create new uno dialog
 435     Reference< XNameContainer > xDialogModel( xContext->getServiceManager()->createInstanceWithContext(
 436                       u"com.sun.star.awt.UnoControlDialogModel"_ustr, xContext), UNO_QUERY );
 437     if( !xDialogModel.is() )
 438     {
 439         return;
 440     }
 441     Reference< XInputStreamProvider > xISP;
 442     aAnyISP >>= xISP;
 443     if( !xISP.is() )
 444     {
 445         return;
 446     }
 447
 448     // Import the DialogModel
 449     Reference< XInputStream > xInput( xISP->createInputStream() );
 450
 451     // i83963 Force decoration
 452     uno::Reference< beans::XPropertySet > xDlgModPropSet( xDialogModel, uno::UNO_QUERY );
 453     if( xDlgModPropSet.is() )
 454     {
 455         try
 456         {
 457             bool bDecoration = true;
 458             OUString aDecorationPropName(u"Decoration"_ustr);
 459             Any aDecorationAny = xDlgModPropSet->getPropertyValue( aDecorationPropName );
 460             aDecorationAny >>= bDecoration;
 461             if( !bDecoration )
 462             {
 463                 xDlgModPropSet->setPropertyValue( aDecorationPropName, Any( true ) );
 464                 xDlgModPropSet->setPropertyValue( u"Title"_ustr, Any( OUString() ) );
 465             }
 466         }
 467         catch(const UnknownPropertyException& )
 468         {}
 469     }
 470
 471     css::uno::Reference< css::container::XNameContainer > aDlgLib;
 472     bool bDocDialog = false;
 473     StarBASIC* pFoundBasic = nullptr;
 474     SAL_INFO("basic", "About to try get a hold of ThisComponent");
 475     Reference< frame::XModel > xModel = StarBASIC::GetModelFromBasic( GetSbData()->pInst->GetBasic() ) ;
 476     aDlgLib = implFindDialogLibForDialogBasic( aAnyISP, GetSbData()->pInst->GetBasic(), pFoundBasic );
 477     // If we found the dialog then it belongs to the Search basic
 478     if ( !pFoundBasic )
 479     {
 480         Reference< frame::XDesktop2 > xDesktop = frame::Desktop::create( xContext );
 481         Reference< container::XEnumeration > xModels;
 482         Reference< container::XEnumerationAccess > xComponents = xDesktop->getComponents();
 483         if ( xComponents.is() )
 484         {
 485             xModels = xComponents->createEnumeration();
 486         }
 487         if ( xModels.is() )
 488         {
 489             while ( xModels->hasMoreElements() )
 490             {
 491                 Reference< frame::XModel > xNextModel( xModels->nextElement(), UNO_QUERY );
 492                 if ( xNextModel.is() )
 493                 {
 494                     BasicManager* pMgr = basic::BasicManagerRepository::getDocumentBasicManager( xNextModel );
 495                     if ( pMgr )
 496                     {
 497                         aDlgLib = implFindDialogLibForDialogBasic( aAnyISP, pMgr->GetLib(0), pFoundBasic );
 498                     }
 499                     if ( aDlgLib.is() )
 500                     {
 501                         bDocDialog = true;
 502                         xModel = std::move(xNextModel);
 503                         break;
 504                     }
 505                 }
 506             }
 507         }
 508     }
 509     if ( pFoundBasic )
 510     {
 511         bDocDialog = pFoundBasic->IsDocBasic();
 512     }
 513     Reference< XScriptListener > xScriptListener = new BasicScriptListener_Impl( GetSbData()->pInst->GetBasic(), xModel );
 514
 515     // Create a "living" Dialog
 516     Reference< XControl > xCntrl;
 517     try
 518     {
 519        Reference< XDialogProvider >  xDlgProv;
 520        if( bDocDialog )
 521            xDlgProv = css::awt::DialogProvider::createWithModelAndScripting( xContext, xModel, xInput, aDlgLib, xScriptListener );
 522        else
 523            xDlgProv = css::awt::DialogProvider::createWithModelAndScripting( xContext, uno::Reference< frame::XModel >(), xInput, aDlgLib, xScriptListener );
 524
 525        xCntrl.set( xDlgProv->createDialog(OUString() ), UNO_QUERY_THROW );
 526        // Add dialog model to dispose vector
 527        Reference< XComponent > xDlgComponent( xCntrl->getModel(), UNO_QUERY );
 528        GetSbData()->pInst->getComponentVector().push_back( xDlgComponent );
 529        // need ThisComponent from calling script
 530     }
 531     // preserve existing bad behaviour, it's possible... but probably
 532     // illegal to open 2 dialogs ( they ARE modal ) when this happens, sometimes
 533     // create dialog fails.  So, in this case let's not throw, just leave basic
 534     // detect the unset object.
 535     catch(const uno::Exception& )
 536     {
 537     }
 538
 539     // Return dialog
 540     Any aRetVal;
 541     aRetVal <<= xCntrl;
 542     SbxVariableRef refVar = rPar.Get(0);
 543     unoToSbxValue( refVar.get(), aRetVal );
 544 }
 545
 546
 547 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */