scripting/source/dlgprov/dlgprov.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 "dlgprov.hxx"
  22 #include "dlgevtatt.hxx"
  23 #include <com/sun/star/awt/UnoControlDialog.hpp>
  24 #include <com/sun/star/awt/Toolkit.hpp>
  25 #include <com/sun/star/awt/XControlContainer.hpp>
  26 #include <com/sun/star/awt/XWindowPeer.hpp>
  27 #include <com/sun/star/beans/theIntrospection.hpp>
  28 #include <com/sun/star/beans/XPropertySet.hpp>
  29 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  30 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  31 #include <com/sun/star/lang/WrappedTargetRuntimeException.hpp>
  32 #include <com/sun/star/io/XInputStreamProvider.hpp>
  33 #include <com/sun/star/resource/XStringResourceSupplier.hpp>
  34 #include <com/sun/star/resource/XStringResourceManager.hpp>
  35 #include <com/sun/star/script/XLibraryContainer.hpp>
  36 #include <com/sun/star/ucb/SimpleFileAccess.hpp>
  37 #include <com/sun/star/uri/XUriReference.hpp>
  38 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  39 #include <com/sun/star/uri/XVndSunStarScriptUrl.hpp>
  40 #include <com/sun/star/uri/XVndSunStarExpandUrl.hpp>
  41 #include <com/sun/star/util/theMacroExpander.hpp>
  42
  43 #include <cppuhelper/exc_hlp.hxx>
  44 #include <cppuhelper/supportsservice.hxx>
  45 #include <sfx2/app.hxx>
  46 #include <xmlscript/xmldlg_imexp.hxx>
  47 #include <tools/urlobj.hxx>
  48 #include <comphelper/namedvaluecollection.hxx>
  49 #include <util/MiscUtils.hxx>
  50 #include <vcl/settings.hxx>
  51 #include <vcl/svapp.hxx>
  52 #include <i18nlangtag/languagetag.hxx>
  53
  54 using namespace ::com::sun::star;
  55 using namespace awt;
  56 using namespace lang;
  57 using namespace uno;
  58 using namespace script;
  59 using namespace beans;
  60 using namespace document;
  61 using namespace ::sf_misc;
  62
  63 namespace dlgprov
  64 {
  65
  66     Reference< resource::XStringResourceManager > lcl_getStringResourceManager(const Reference< XComponentContext >& i_xContext, std::u16string_view i_sURL)
  67     {
  68         INetURLObject aInetObj( i_sURL );
  69         OUString aDlgName = aInetObj.GetBase();
  70         aInetObj.removeSegment();
  71         OUString aDlgLocation = aInetObj.GetMainURL( INetURLObject::DecodeMechanism::NONE );
  72         css::lang::Locale aLocale = Application::GetSettings().GetUILanguageTag().getLocale();
  73
  74         Reference< task::XInteractionHandler > xDummyHandler;
  75
  76         Sequence<Any> aArgs{ Any(aDlgLocation),
  77                              Any(true), // bReadOnly
  78                              Any(aLocale),
  79                              Any(aDlgName),
  80                              Any(OUString()),
  81                              Any(xDummyHandler) };
  82
  83         Reference< XMultiComponentFactory > xSMgr_( i_xContext->getServiceManager(), UNO_SET_THROW );
  84         // TODO: Ctor
  85         Reference< resource::XStringResourceManager > xStringResourceManager( xSMgr_->createInstanceWithContext
  86             ( u"com.sun.star.resource.StringResourceWithLocation"_ustr,
  87                 i_xContext ), UNO_QUERY );
  88         if( xStringResourceManager.is() )
  89         {
  90             Reference< XInitialization > xInit( xStringResourceManager, UNO_QUERY );
  91             if( xInit.is() )
  92                 xInit->initialize( aArgs );
  93         }
  94         return xStringResourceManager;
  95     }
  96     Reference< container::XNameContainer > lcl_createControlModel(const Reference< XComponentContext >& i_xContext)
  97     {
  98         Reference< XMultiComponentFactory > xSMgr_( i_xContext->getServiceManager(), UNO_SET_THROW );
  99         Reference< container::XNameContainer > xControlModel( xSMgr_->createInstanceWithContext(u"com.sun.star.awt.UnoControlDialogModel"_ustr, i_xContext ), UNO_QUERY_THROW );
 100         return xControlModel;
 101     }
 102     Reference< container::XNameContainer > lcl_createDialogModel( const Reference< XComponentContext >& i_xContext,
 103         const Reference< io::XInputStream >& xInput,
 104         const Reference< frame::XModel >& xModel,
 105         const Reference< resource::XStringResourceManager >& xStringResourceManager,
 106         const Any &aDialogSourceURL)
 107     {
 108         Reference< container::XNameContainer > xDialogModel(  lcl_createControlModel(i_xContext) );
 109
 110         Reference< beans::XPropertySet > xDlgPropSet( xDialogModel, UNO_QUERY );
 111         xDlgPropSet->setPropertyValue( u"DialogSourceURL"_ustr, aDialogSourceURL );
 112
 113         // #TODO we really need to detect the source of the Dialog, is it
 114         // the dialog. E.g. if the dialog was created from basic ( then we just
 115         // can't tell  where its from )
 116         // If we are happy to always substitute the form model for the awt
 117         // one then maybe the presence of a document model is enough to trigger
 118         // swapping out the models ( or perhaps we only want to do this
 119         // for vba mode ) there are a number of feasible and valid possibilities
 120         ::xmlscript::importDialogModel( xInput, xDialogModel, i_xContext, xModel );
 121
 122         // Set resource property
 123         if( xStringResourceManager.is() )
 124         {
 125             Reference< beans::XPropertySet > xDlgPSet( xDialogModel, UNO_QUERY );
 126             Any aStringResourceManagerAny;
 127             aStringResourceManagerAny <<= xStringResourceManager;
 128             xDlgPSet->setPropertyValue( u"ResourceResolver"_ustr, aStringResourceManagerAny );
 129         }
 130
 131         return xDialogModel;
 132     }
 133
 134     // mutex
 135
 136
 137     ::osl::Mutex& getMutex()
 138     {
 139         static ::osl::Mutex s_aMutex;
 140
 141         return s_aMutex;
 142     }
 143
 144
 145     // DialogProviderImpl
 146
 147
 148     DialogProviderImpl::DialogProviderImpl( const Reference< XComponentContext >& rxContext )
 149         :m_xContext( rxContext )
 150     {
 151     }
 152
 153
 154     DialogProviderImpl::~DialogProviderImpl()
 155     {
 156     }
 157
 158
 159     static Reference< resource::XStringResourceManager > getStringResourceFromDialogLibrary
 160         ( const Reference< container::XNameContainer >& xDialogLib )
 161     {
 162         Reference< resource::XStringResourceManager > xStringResourceManager;
 163         if( xDialogLib.is() )
 164         {
 165             Reference< resource::XStringResourceSupplier > xStringResourceSupplier( xDialogLib, UNO_QUERY );
 166             if( xStringResourceSupplier.is() )
 167             {
 168                 Reference< resource::XStringResourceResolver >
 169                     xStringResourceResolver = xStringResourceSupplier->getStringResource();
 170
 171                 xStringResourceManager =
 172                     Reference< resource::XStringResourceManager >( xStringResourceResolver, UNO_QUERY );
 173             }
 174         }
 175         return xStringResourceManager;
 176     }
 177
 178     Reference< container::XNameContainer > DialogProviderImpl::createDialogModel(
 179         const Reference< io::XInputStream >& xInput,
 180         const Reference< resource::XStringResourceManager >& xStringResourceManager,
 181         const Any &aDialogSourceURL)
 182     {
 183         return lcl_createDialogModel(m_xContext,xInput,m_xModel,xStringResourceManager,aDialogSourceURL);
 184     }
 185
 186     Reference< XControlModel > DialogProviderImpl::createDialogModelForBasic()
 187     {
 188         if (!m_BasicInfo)
 189             // shouldn't get here
 190             throw RuntimeException(u"No information to create dialog"_ustr );
 191         Reference< resource::XStringResourceManager > xStringResourceManager = getStringResourceFromDialogLibrary( m_BasicInfo->mxDlgLib );
 192
 193         Any aDialogSourceURL((OUString()));
 194         Reference< XControlModel > xCtrlModel( createDialogModel( m_BasicInfo->mxInput, xStringResourceManager, aDialogSourceURL ), UNO_QUERY_THROW );
 195         return xCtrlModel;
 196     }
 197
 198     Reference< XControlModel > DialogProviderImpl::createDialogModel( const OUString& sURL )
 199     {
 200
 201         OUString aURL( sURL );
 202
 203         // parse URL
 204         // TODO: use URL parsing class
 205         // TODO: decoding of location
 206
 207         Reference< uri::XUriReferenceFactory > xFac ( uri::UriReferenceFactory::create( m_xContext )  );
 208
 209         // i75778: Support non-script URLs
 210         Reference< io::XInputStream > xInput;
 211         Reference< container::XNameContainer > xDialogLib;
 212
 213         // Accept file URL to single dialog
 214         bool bSingleDialog = false;
 215
 216         Reference< util::XMacroExpander > xMacroExpander =
 217             util::theMacroExpander::get(m_xContext);
 218
 219         Reference< uri::XUriReference > uriRef;
 220         for (;;)
 221         {
 222             uriRef = xFac->parse( aURL );
 223             if ( !uriRef.is() )
 224             {
 225                 OUString errorMsg = "DialogProviderImpl::getDialogModel: failed to parse URI: " + aURL;
 226                 throw IllegalArgumentException( errorMsg, Reference< XInterface >(), 1 );
 227             }
 228             Reference < uri::XVndSunStarExpandUrl > sxUri( uriRef, UNO_QUERY );
 229             if( !sxUri.is() )
 230                 break;
 231
 232             aURL = sxUri->expand( xMacroExpander );
 233         }
 234
 235         Reference < uri::XVndSunStarScriptUrl > sfUri( uriRef, UNO_QUERY );
 236         if( !sfUri.is() )
 237         {
 238             bSingleDialog = true;
 239
 240             // Try any other URL with SimpleFileAccess
 241             Reference< ucb::XSimpleFileAccess3 > xSFI = ucb::SimpleFileAccess::create(m_xContext);
 242
 243             try
 244             {
 245                 xInput = xSFI->openFileRead( aURL );
 246             }
 247             catch( Exception& )
 248             {}
 249         }
 250         else
 251         {
 252             OUString sDescription = sfUri->getName();
 253
 254             sal_Int32 nIndex = 0;
 255
 256             OUString sLibName = sDescription.getToken( 0, '.', nIndex );
 257             OUString sDlgName;
 258             if ( nIndex != -1 )
 259                 sDlgName = sDescription.getToken( 0, '.', nIndex );
 260
 261             OUString sLocation = sfUri->getParameter( u"location"_ustr );
 262
 263
 264             // get dialog library container
 265             // TODO: dialogs in packages
 266             Reference< XLibraryContainer > xLibContainer;
 267
 268             if ( sLocation == "application" )
 269             {
 270                 xLibContainer = SfxGetpApp()->GetDialogContainer();
 271             }
 272             else if ( sLocation == "document" )
 273             {
 274                 Reference< XEmbeddedScripts > xDocumentScripts( m_xModel, UNO_QUERY );
 275                 if ( xDocumentScripts.is() )
 276                 {
 277                     xLibContainer = xDocumentScripts->getDialogLibraries();
 278                     OSL_ENSURE( xLibContainer.is(),
 279                         "DialogProviderImpl::createDialogModel: invalid dialog container!" );
 280                 }
 281             }
 282             else
 283             {
 284                 const Sequence< OUString > aOpenDocsTdocURLs( MiscUtils::allOpenTDocUrls( m_xContext ) );
 285                 for ( auto const & tdocURL : aOpenDocsTdocURLs )
 286                 {
 287                     Reference< frame::XModel > xModel( MiscUtils::tDocUrlToModel( tdocURL ) );
 288                     OSL_ENSURE( xModel.is(), "DialogProviderImpl::createDialogModel: invalid document model!" );
 289                     if ( !xModel.is() )
 290                         continue;
 291
 292                     OUString sDocURL = xModel->getURL();
 293                     if ( sDocURL.isEmpty() )
 294                     {
 295                         sDocURL = ::comphelper::NamedValueCollection::getOrDefault( xModel->getArgs(), u"Title", sDocURL );
 296                     }
 297
 298                     if ( sLocation != sDocURL )
 299                         continue;
 300
 301                     Reference< XEmbeddedScripts > xDocumentScripts( m_xModel, UNO_QUERY );
 302                     if ( !xDocumentScripts.is() )
 303                         continue;
 304
 305                     xLibContainer = xDocumentScripts->getDialogLibraries();
 306                     OSL_ENSURE( xLibContainer.is(),
 307                         "DialogProviderImpl::createDialogModel: invalid dialog container!" );
 308                 }
 309             }
 310
 311             // get input stream provider
 312             Reference< io::XInputStreamProvider > xISP;
 313             if ( !xLibContainer.is() )
 314             {
 315                 throw IllegalArgumentException(
 316                     u"DialogProviderImpl::getDialog: library container not found!"_ustr,
 317                     Reference< XInterface >(), 1 );
 318             }
 319
 320             // load dialog library
 321             if ( !xLibContainer->isLibraryLoaded( sLibName ) )
 322                 xLibContainer->loadLibrary( sLibName );
 323
 324             // get dialog library
 325             if ( xLibContainer->hasByName( sLibName ) )
 326             {
 327                 Any aElement = xLibContainer->getByName( sLibName );
 328                 aElement >>= xDialogLib;
 329             }
 330
 331             if ( !xDialogLib.is() )
 332             {
 333                 throw IllegalArgumentException(
 334                     u"DialogProviderImpl::getDialogModel: library not found!"_ustr,
 335                     Reference< XInterface >(), 1 );
 336             }
 337
 338             // get input stream provider
 339             if ( xDialogLib->hasByName( sDlgName ) )
 340             {
 341                 Any aElement = xDialogLib->getByName( sDlgName );
 342                 aElement >>= xISP;
 343             }
 344
 345             if ( !xISP.is() )
 346             {
 347                 throw IllegalArgumentException(
 348                     u"DialogProviderImpl::getDialogModel: dialog not found!"_ustr,
 349                     Reference< XInterface >(), 1 );
 350             }
 351
 352
 353
 354             if ( xISP.is() )
 355                 xInput = xISP->createInputStream();
 356             msDialogLibName = sLibName;
 357         }
 358
 359         // import dialog model
 360         Reference< XControlModel > xCtrlModel;
 361         if ( xInput.is() && m_xContext.is() )
 362         {
 363             Reference< resource::XStringResourceManager > xStringResourceManager;
 364             if( bSingleDialog )
 365             {
 366                 xStringResourceManager = lcl_getStringResourceManager(m_xContext,aURL);
 367             }
 368             else if( xDialogLib.is() )
 369             {
 370                 xStringResourceManager = getStringResourceFromDialogLibrary( xDialogLib );
 371             }
 372
 373             Any aDialogSourceURLAny;
 374             aDialogSourceURLAny <<= aURL;
 375
 376             Reference< container::XNameContainer > xDialogModel( createDialogModel( xInput , xStringResourceManager, aDialogSourceURLAny  ), UNO_SET_THROW);
 377
 378             xCtrlModel.set( xDialogModel, UNO_QUERY );
 379         }
 380         return xCtrlModel;
 381     }
 382
 383
 384     Reference< XUnoControlDialog > DialogProviderImpl::createDialogControl
 385         ( const Reference< XControlModel >& rxDialogModel, const Reference< XWindowPeer >& xParent )
 386     {
 387         OSL_ENSURE( rxDialogModel.is(), "DialogProviderImpl::getDialogControl: no dialog model" );
 388
 389         Reference< XUnoControlDialog > xDialogControl;
 390
 391         if ( m_xContext.is() )
 392         {
 393             xDialogControl = UnoControlDialog::create( m_xContext );
 394
 395             // set the model
 396             if ( rxDialogModel.is() )
 397                 xDialogControl->setModel( rxDialogModel );
 398
 399             // set visible
 400             xDialogControl->setVisible( false );
 401
 402             // get the parent of the dialog control
 403             Reference< XWindowPeer > xPeer;
 404             if( xParent.is() )
 405             {
 406                 xPeer = xParent;
 407             }
 408             else if ( m_xModel.is() )
 409             {
 410                 Reference< frame::XController > xController = m_xModel->getCurrentController();
 411                 if ( xController.is() )
 412                 {
 413                     Reference< frame::XFrame > xFrame = xController->getFrame();
 414                     if ( xFrame.is() )
 415                         xPeer.set( xFrame->getContainerWindow(), UNO_QUERY );
 416                 }
 417             }
 418
 419             // create a peer
 420             Reference< XToolkit> xToolkit( Toolkit::create( m_xContext ), UNO_QUERY_THROW );
 421             xDialogControl->createPeer( xToolkit, xPeer );
 422         }
 423
 424         return xDialogControl;
 425     }
 426
 427
 428     void DialogProviderImpl::attachControlEvents(
 429         const Reference< XControl >& rxControl,
 430         const Reference< XInterface >& rxHandler,
 431         const Reference< XIntrospectionAccess >& rxIntrospectionAccess,
 432         bool bDialogProviderMode )
 433     {
 434         if ( !rxControl.is() )
 435             return;
 436
 437         Reference< XControlContainer > xControlContainer( rxControl, UNO_QUERY );
 438
 439         if ( !xControlContainer.is() )
 440             return;
 441
 442         Sequence< Reference< XControl > > aControls = xControlContainer->getControls();
 443         sal_Int32 nControlCount = aControls.getLength();
 444
 445         Sequence< Reference< XInterface > > aObjects( nControlCount + 1 );
 446         Reference< XInterface >* pObjects = aObjects.getArray();
 447         std::transform(aControls.begin(), aControls.end(), pObjects,
 448                        [](auto& xControl) { return xControl.template query<XInterface>(); });
 449
 450         // also add the dialog control itself to the sequence
 451         pObjects[nControlCount].set( rxControl, UNO_QUERY );
 452
 453         Reference<XScriptEventsAttacher> xScriptEventsAttacher
 454             = new DialogEventsAttacherImpl(
 455                 m_xContext, m_xModel, rxControl, rxHandler, rxIntrospectionAccess,
 456                 bDialogProviderMode,
 457                 (m_BasicInfo ? m_BasicInfo->mxBasicRTLListener : nullptr), msDialogLibName);
 458
 459         Any aHelper;
 460         xScriptEventsAttacher->attachEvents( aObjects, Reference< XScriptListener >(), aHelper );
 461     }
 462
 463     Reference< XIntrospectionAccess > DialogProviderImpl::inspectHandler( const Reference< XInterface >& rxHandler )
 464     {
 465         Reference< XIntrospectionAccess > xIntrospectionAccess;
 466         static Reference< XIntrospection > xIntrospection;
 467
 468         if( !rxHandler.is() )
 469             return xIntrospectionAccess;
 470
 471         if( !xIntrospection.is() )
 472         {
 473             // Get introspection service
 474             xIntrospection = theIntrospection::get( m_xContext );
 475         }
 476
 477         // Do introspection
 478         try
 479         {
 480             Any aHandlerAny;
 481             aHandlerAny <<= rxHandler;
 482             xIntrospectionAccess = xIntrospection->inspect( aHandlerAny );
 483         }
 484         catch( RuntimeException& )
 485         {
 486             xIntrospectionAccess.clear();
 487         }
 488         return xIntrospectionAccess;
 489     }
 490
 491
 492     // XServiceInfo
 493
 494
 495     OUString DialogProviderImpl::getImplementationName(  )
 496     {
 497         return u"com.sun.star.comp.scripting.DialogProvider"_ustr;
 498     }
 499
 500     sal_Bool DialogProviderImpl::supportsService( const OUString& rServiceName )
 501     {
 502         return cppu::supportsService(this, rServiceName);
 503     }
 504
 505     Sequence< OUString > DialogProviderImpl::getSupportedServiceNames(  )
 506     {
 507         return { u"com.sun.star.awt.DialogProvider"_ustr,
 508                  u"com.sun.star.awt.DialogProvider2"_ustr,
 509                  u"com.sun.star.awt.ContainerWindowProvider"_ustr };
 510     }
 511
 512
 513     // XInitialization
 514
 515
 516     void DialogProviderImpl::initialize( const Sequence< Any >& aArguments )
 517     {
 518         ::osl::MutexGuard aGuard( getMutex() );
 519
 520         if ( aArguments.getLength() == 1 )
 521         {
 522             aArguments[0] >>= m_xModel;
 523
 524             if ( !m_xModel.is() )
 525             {
 526                 throw RuntimeException( u"DialogProviderImpl::initialize: invalid argument format!"_ustr );
 527             }
 528         }
 529         else if ( aArguments.getLength() == 4 )
 530         {
 531             // call from RTL_Impl_CreateUnoDialog
 532             aArguments[0] >>= m_xModel;
 533             m_BasicInfo.reset( new BasicRTLParams );
 534             m_BasicInfo->mxInput.set( aArguments[ 1 ], UNO_QUERY_THROW );
 535             // allow null mxDlgLib, a document dialog instantiated from
 536             // from application basic is unable to provide ( or find ) it's
 537             // Library
 538             aArguments[ 2 ] >>= m_BasicInfo->mxDlgLib;
 539             // leave the possibility to optionally allow the old dialog creation
 540             // to use the new XScriptListener ( which converts the old style macro
 541             // to a SF url )
 542             m_BasicInfo->mxBasicRTLListener.set( aArguments[ 3 ], UNO_QUERY);
 543         }
 544         else if ( aArguments.getLength() > 4 )
 545         {
 546             throw RuntimeException( u"DialogProviderImpl::initialize: invalid number of arguments!"_ustr );
 547         }
 548     }
 549
 550
 551     // XDialogProvider
 552
 553
 554     constexpr OUString aDecorationPropName = u"Decoration"_ustr;
 555
 556     Reference < XControl > DialogProviderImpl::createDialogImpl(
 557         const OUString& URL, const Reference< XInterface >& xHandler,
 558         const Reference< XWindowPeer >& xParent, bool bDialogProviderMode )
 559     {
 560         // if the dialog is located in a document, the document must already be open!
 561
 562         ::osl::MutexGuard aGuard( getMutex() );
 563
 564
 565         // m_xHandler = xHandler;
 566
 567         //Reference< XDialog > xDialog;
 568         Reference< XControl > xCtrl;
 569         Reference< XControlModel > xCtrlMod;
 570         try
 571         {
 572             // add support for basic RTL_FUNCTION
 573             if (m_BasicInfo)
 574                 xCtrlMod = createDialogModelForBasic();
 575             else
 576             {
 577                 OSL_ENSURE( !URL.isEmpty(), "DialogProviderImpl::getDialog: no URL!" );
 578                 xCtrlMod = createDialogModel( URL );
 579             }
 580         }
 581         catch ( const RuntimeException& ) { throw; }
 582         catch ( const Exception& )
 583         {
 584             const Any aError( ::cppu::getCaughtException() );
 585             throw WrappedTargetRuntimeException( OUString(), *this, aError );
 586         }
 587         if ( xCtrlMod.is() )
 588         {
 589             // i83963 Force decoration
 590             if( bDialogProviderMode )
 591             {
 592                 uno::Reference< beans::XPropertySet > xDlgModPropSet( xCtrlMod, uno::UNO_QUERY );
 593                 if( xDlgModPropSet.is() )
 594                 {
 595                     try
 596                     {
 597                         bool bDecoration = true;
 598                         Any aDecorationAny = xDlgModPropSet->getPropertyValue( aDecorationPropName );
 599                         aDecorationAny >>= bDecoration;
 600                         if( !bDecoration )
 601                         {
 602                             xDlgModPropSet->setPropertyValue( aDecorationPropName, Any( true ) );
 603                             xDlgModPropSet->setPropertyValue( u"Title"_ustr, Any( OUString() ) );
 604                         }
 605                     }
 606                     catch( UnknownPropertyException& )
 607                     {}
 608                 }
 609             }
 610
 611             xCtrl.set( createDialogControl( xCtrlMod, xParent ) );
 612             if ( xCtrl.is() )
 613             {
 614                 Reference< XIntrospectionAccess > xIntrospectionAccess = inspectHandler( xHandler );
 615                 attachControlEvents( xCtrl, xHandler, xIntrospectionAccess, bDialogProviderMode );
 616             }
 617         }
 618
 619         return xCtrl;
 620     }
 621
 622     Reference < XDialog > DialogProviderImpl::createDialog( const OUString& URL )
 623     {
 624         Reference< XInterface > xDummyHandler;
 625         Reference< XWindowPeer > xDummyPeer;
 626         Reference < XControl > xControl = DialogProviderImpl::createDialogImpl( URL, xDummyHandler, xDummyPeer, true );
 627         Reference< XDialog > xDialog( xControl, UNO_QUERY );
 628         return xDialog;
 629     }
 630
 631     Reference < XDialog > DialogProviderImpl::createDialogWithHandler(
 632         const OUString& URL, const Reference< XInterface >& xHandler )
 633     {
 634         if( !xHandler.is() )
 635         {
 636             throw IllegalArgumentException(
 637                 u"DialogProviderImpl::createDialogWithHandler: Invalid xHandler!"_ustr,
 638                 Reference< XInterface >(), 1 );
 639         }
 640         Reference< XWindowPeer > xDummyPeer;
 641         Reference < XControl > xControl = DialogProviderImpl::createDialogImpl( URL, xHandler, xDummyPeer, true );
 642         Reference< XDialog > xDialog( xControl, UNO_QUERY );
 643         return xDialog;
 644     }
 645
 646     Reference < XDialog > DialogProviderImpl::createDialogWithArguments(
 647         const OUString& URL, const Sequence< NamedValue >& Arguments )
 648     {
 649         ::comphelper::NamedValueCollection aArguments( Arguments );
 650
 651         Reference< XWindowPeer > xParentPeer;
 652         if ( aArguments.has( u"ParentWindow"_ustr ) )
 653         {
 654             const Any& aParentWindow( aArguments.get( u"ParentWindow"_ustr ) );
 655             if ( !( aParentWindow >>= xParentPeer ) )
 656             {
 657                 const Reference< XControl > xParentControl( aParentWindow, UNO_QUERY );
 658                 if ( xParentControl.is() )
 659                     xParentPeer = xParentControl->getPeer();
 660             }
 661         }
 662
 663         const Reference< XInterface > xHandler( aArguments.get( u"EventHandler"_ustr ), UNO_QUERY );
 664
 665         Reference < XControl > xControl = DialogProviderImpl::createDialogImpl( URL, xHandler, xParentPeer, true );
 666         Reference< XDialog > xDialog( xControl, UNO_QUERY );
 667         return xDialog;
 668     }
 669
 670     Reference< XWindow > DialogProviderImpl::createContainerWindow(
 671         const OUString& URL, const OUString&,
 672         const Reference< XWindowPeer >& xParent, const Reference< XInterface >& xHandler )
 673     {
 674         if( !xParent.is() )
 675         {
 676             throw IllegalArgumentException(
 677                 u"DialogProviderImpl::createContainerWindow: Invalid xParent!"_ustr,
 678                 Reference< XInterface >(), 1 );
 679         }
 680         Reference < XControl > xControl = DialogProviderImpl::createDialogImpl( URL, xHandler, xParent, false );
 681         Reference< XWindow> xWindow( xControl, UNO_QUERY );
 682         return xWindow;
 683     }
 684
 685
 686     // component operations
 687
 688
 689     extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 690     scripting_DialogProviderImpl_get_implementation(
 691         css::uno::XComponentContext* context, css::uno::Sequence<css::uno::Any> const&)
 692     {
 693         return cppu::acquire(new DialogProviderImpl(context));
 694     }
 695
 696 }   // namespace dlgprov
 697
 698
 699 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */