basctl/source/basicide/scriptdocument.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 "scriptdocument.hxx"
  21 #include "basobj.hxx"
  22 #include "basidesh.hrc"
  23 #include "iderid.hxx"
  24 #include "dlgeddef.hxx"
  25 #include "doceventnotifier.hxx"
  26 #include "documentenumeration.hxx"
  27
  28 #include <com/sun/star/uri/UriReferenceFactory.hpp>
  29 #include <com/sun/star/util/theMacroExpander.hpp>
  30 #include <com/sun/star/document/MacroExecMode.hpp>
  31 #include <com/sun/star/frame/XStorable.hpp>
  32 #include <com/sun/star/frame/FrameSearchFlag.hpp>
  33 #include <com/sun/star/frame/XDesktop.hpp>
  34 #include <com/sun/star/frame/XModel2.hpp>
  35 #include <com/sun/star/awt/XWindow2.hpp>
  36 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  37 #include <com/sun/star/script/vba/XVBACompatibility.hpp>
  38 #include <com/sun/star/script/vba/XVBAModuleInfo.hpp>
  39
  40 #include <sfx2/objsh.hxx>
  41 #include <sfx2/bindings.hxx>
  42 #include <sfx2/docfile.hxx>
  43
  44
  45 #include <basic/basicmanagerrepository.hxx>
  46
  47 #include <xmlscript/xmldlg_imexp.hxx>
  48
  49 #include <unotools/syslocale.hxx>
  50
  51 #include <unotools/collatorwrapper.hxx>
  52
  53 #include <tools/diagnose_ex.h>
  54
  55 #include <comphelper/documentinfo.hxx>
  56 #include <comphelper/processfactory.hxx>
  57 #include <comphelper/propertysequence.hxx>
  58
  59 #include <osl/file.hxx>
  60 #include <rtl/uri.hxx>
  61 #include <set>
  62
  63
  64 namespace basctl
  65 {
  66     using ::com::sun::star::uno::Sequence;
  67     using ::com::sun::star::uno::Reference;
  68     using ::com::sun::star::frame::XModel;
  69     using ::com::sun::star::beans::XPropertySet;
  70     using ::com::sun::star::script::XLibraryContainer;
  71     using ::com::sun::star::uno::UNO_QUERY_THROW;
  72     using ::com::sun::star::uno::UNO_SET_THROW;
  73     using ::com::sun::star::beans::XPropertySetInfo;
  74     using ::com::sun::star::uno::Exception;
  75     using ::com::sun::star::container::XNameContainer;
  76     using ::com::sun::star::container::NoSuchElementException;
  77     using ::com::sun::star::uno::UNO_QUERY;
  78     using ::com::sun::star::task::XStatusIndicator;
  79     using ::com::sun::star::uno::makeAny;
  80     using ::com::sun::star::script::XLibraryContainer2;
  81     using ::com::sun::star::lang::XMultiServiceFactory;
  82     using ::com::sun::star::uri::UriReferenceFactory;
  83     using ::com::sun::star::uri::XUriReferenceFactory;
  84     using ::com::sun::star::uri::XUriReference;
  85     using ::com::sun::star::uno::XComponentContext;
  86     using ::com::sun::star::util::XMacroExpander;
  87     using ::com::sun::star::util::theMacroExpander;
  88     using ::com::sun::star::io::XInputStreamProvider;
  89     using ::com::sun::star::uno::Any;
  90     using ::com::sun::star::io::XInputStream;
  91     using ::com::sun::star::frame::XStorable;
  92     using ::com::sun::star::util::XModifiable;
  93     using ::com::sun::star::frame::XController;
  94     using ::com::sun::star::frame::XFrame;
  95     using ::com::sun::star::util::URL;
  96     using ::com::sun::star::frame::XDispatchProvider;
  97     using ::com::sun::star::frame::XDispatch;
  98     using ::com::sun::star::beans::PropertyValue;
  99     using ::com::sun::star::frame::XDesktop;
 100     using ::com::sun::star::container::XEnumerationAccess;
 101     using ::com::sun::star::container::XEnumeration;
 102     using ::com::sun::star::frame::XModel2;
 103     using ::com::sun::star::awt::XWindow2;
 104     using ::com::sun::star::document::XEventListener;
 105     using ::com::sun::star::lang::EventObject;
 106     using ::com::sun::star::uno::RuntimeException;
 107     using ::com::sun::star::document::XEmbeddedScripts;
 108     using ::com::sun::star::script::ModuleInfo;
 109     using ::com::sun::star::script::vba::XVBACompatibility;
 110     using ::com::sun::star::script::vba::XVBAModuleInfo;
 111
 112     namespace MacroExecMode = ::com::sun::star::document::MacroExecMode;
 113     namespace FrameSearchFlag = ::com::sun::star::frame::FrameSearchFlag;
 114
 115
 116     namespace
 117     {
 118         static bool StringCompareLessThan( const OUString& lhs, const OUString& rhs )
 119         {
 120             return lhs.compareToIgnoreAsciiCase( rhs ) < 0;
 121         }
 122
 123         class FilterDocuments : public docs::IDocumentDescriptorFilter
 124         {
 125         public:
 126             explicit FilterDocuments(bool _bFilterInvisible)
 127                 : m_bFilterInvisible(_bFilterInvisible)
 128             {
 129             }
 130
 131             virtual ~FilterDocuments() {}
 132
 133             virtual bool    includeDocument( const docs::DocumentDescriptor& _rDocument ) const SAL_OVERRIDE;
 134
 135         private:
 136             static bool    impl_isDocumentVisible_nothrow( const docs::DocumentDescriptor& _rDocument );
 137
 138         private:
 139             bool    m_bFilterInvisible;
 140         };
 141
 142         bool FilterDocuments::impl_isDocumentVisible_nothrow( const docs::DocumentDescriptor& _rDocument )
 143         {
 144             try
 145             {
 146                 for (   docs::Controllers::const_iterator controller = _rDocument.aControllers.begin();
 147                         controller != _rDocument.aControllers.end();
 148                         ++controller
 149                     )
 150                 {
 151                     Reference< XFrame > xFrame( (*controller)->getFrame(), UNO_SET_THROW );
 152                     Reference< XWindow2 > xContainer( xFrame->getContainerWindow(), UNO_QUERY_THROW );
 153                     if ( xContainer->isVisible() )
 154                         return true;
 155                 }
 156             }
 157             catch( const Exception& )
 158             {
 159                 DBG_UNHANDLED_EXCEPTION();
 160             }
 161             return false;
 162         }
 163
 164         bool FilterDocuments::includeDocument( const docs::DocumentDescriptor& _rDocument ) const
 165         {
 166             Reference< XEmbeddedScripts > xScripts( _rDocument.xModel, UNO_QUERY );
 167             if ( !xScripts.is() )
 168                 return false;
 169             if ( !m_bFilterInvisible || impl_isDocumentVisible_nothrow( _rDocument ) )
 170                 return true;
 171             return false;
 172         }
 173
 174         void lcl_getAllModels_throw( docs::Documents& _out_rModels, bool _bVisibleOnly )
 175         {
 176             _out_rModels.clear();
 177
 178             FilterDocuments aFilter( _bVisibleOnly );
 179             docs::DocumentEnumeration aEnum(
 180                 comphelper::getProcessComponentContext(), &aFilter );
 181
 182             aEnum.getDocuments( _out_rModels );
 183         }
 184     }
 185
 186     class ScriptDocument::Impl : public DocumentEventListener
 187     {
 188     private:
 189         bool                            m_bIsApplication;
 190         bool                            m_bValid;
 191         bool                            m_bDocumentClosed;
 192         Reference< XModel >             m_xDocument;
 193         Reference< XModifiable >        m_xDocModify;
 194         Reference< XEmbeddedScripts >   m_xScriptAccess;
 195         boost::scoped_ptr< DocumentEventNotifier > m_pDocListener;
 196
 197     public:
 198         Impl ();
 199         explicit Impl(Reference<XModel> const& rxDocument);
 200         virtual ~Impl();
 201
 202         /** determines whether the instance refers to a valid "document" with script and
 203             dialog libraries
 204         */
 205         inline  bool    isValid()       const   { return m_bValid; }
 206         /** determines whether the instance refers to a non-closed document
 207         */
 208         inline  bool    isAlive()       const   { return m_bValid && ( m_bIsApplication || !m_bDocumentClosed ); }
 209         /// determines whether the "document" refers to the application in real
 210         inline  bool    isApplication() const   { return m_bValid && m_bIsApplication; }
 211         /// determines whether the document refers to a real document (instead of the application)
 212         inline  bool    isDocument()    const   { return m_bValid && !m_bIsApplication; }
 213
 214         /** invalidates the instance
 215         */
 216         void    invalidate();
 217
 218         const Reference< XModel >&
 219                         getDocumentRef() const { return m_xDocument; }
 220
 221         /// returns a library container belonging to the document
 222         Reference< XLibraryContainer >
 223                     getLibraryContainer( LibraryContainerType _eType ) const;
 224
 225         /// determines whether a given library is part of the shared installation
 226         bool        isLibraryShared( const OUString& _rLibName, LibraryContainerType _eType );
 227
 228         /** returns the current frame of the document
 229
 230             To be called for documents only, not for the application.
 231
 232             If <FALSE/> is returned, an assertion will be raised in non-product builds.
 233         */
 234         bool        getCurrentFrame( Reference< XFrame >& _out_rxFrame ) const;
 235
 236         // versions with the same signature/semantics as in ScriptDocument itself
 237         bool        isReadOnly() const;
 238         bool        isInVBAMode() const;
 239         BasicManager*
 240                     getBasicManager() const;
 241         Reference< XModel >
 242                     getDocument() const;
 243         void        setDocumentModified() const;
 244         bool        isDocumentModified() const;
 245         bool        saveDocument( const Reference< XStatusIndicator >& _rxStatusIndicator ) const;
 246
 247         OUString    getTitle() const;
 248         OUString    getURL() const;
 249
 250         bool        allowMacros() const;
 251
 252         Reference< XNameContainer >
 253                     getLibrary( LibraryContainerType _eType, const OUString& _rLibName, bool _bLoadLibrary ) const;
 254         bool        hasLibrary( LibraryContainerType _eType, const OUString& _rLibName ) const;
 255         Reference< XNameContainer >
 256                     getOrCreateLibrary( LibraryContainerType _eType, const OUString& _rLibName ) const;
 257
 258         void        loadLibraryIfExists( LibraryContainerType _eType, const OUString& _rLibrary );
 259
 260         bool        removeModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName, const OUString& _rModuleName );
 261         bool        hasModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName, const OUString& _rModName ) const;
 262         bool        getModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName, const OUString& _rObjectName, Any& _out_rModuleOrDialog );
 263         bool        renameModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName, const OUString& _rOldName, const OUString& _rNewName, const Reference< XNameContainer >& _rxExistingDialogModel );
 264         bool        createModule( const OUString& _rLibName, const OUString& _rModName, bool _bCreateMain, OUString& _out_rNewModuleCode ) const;
 265         bool        insertModuleOrDialog( LibraryContainerType _eType, const OUString& _rObjectName, const OUString& _rModName, const Any& _rElement ) const;
 266         bool        updateModule( const OUString& _rLibName, const OUString& _rModName, const OUString& _rModuleCode ) const;
 267         bool        createDialog( const OUString& _rLibName, const OUString& _rDialogName, Reference< XInputStreamProvider >& _out_rDialogProvider ) const;
 268
 269     protected:
 270         // DocumentEventListener
 271         virtual void onDocumentCreated( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 272         virtual void onDocumentOpened( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 273         virtual void onDocumentSave( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 274         virtual void onDocumentSaveDone( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 275         virtual void onDocumentSaveAs( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 276         virtual void onDocumentSaveAsDone( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 277         virtual void onDocumentClosed( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 278         virtual void onDocumentTitleChanged( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 279         virtual void onDocumentModeChanged( const ScriptDocument& _rDocument ) SAL_OVERRIDE;
 280
 281     private:
 282         bool        impl_initDocument_nothrow( const Reference< XModel >& _rxModel );
 283     };
 284
 285
 286     ScriptDocument::Impl::Impl()
 287         :m_bIsApplication( true )
 288         ,m_bValid( true )
 289         ,m_bDocumentClosed( false )
 290     {
 291     }
 292
 293     ScriptDocument::Impl::Impl( const Reference< XModel >& _rxDocument )
 294         :m_bIsApplication( false )
 295         ,m_bValid( false )
 296         ,m_bDocumentClosed( false )
 297     {
 298         if ( _rxDocument.is() )
 299         {
 300             if ( impl_initDocument_nothrow( _rxDocument ) )
 301             {
 302             }
 303         }
 304     }
 305
 306     ScriptDocument::Impl::~Impl()
 307     {
 308         invalidate();
 309     }
 310
 311     void ScriptDocument::Impl::invalidate()
 312     {
 313         m_bIsApplication = false;
 314         m_bValid = false;
 315         m_bDocumentClosed = false;
 316
 317         m_xDocument.clear();
 318         m_xDocModify.clear();
 319         m_xScriptAccess.clear();
 320
 321         if ( m_pDocListener.get() )
 322             m_pDocListener->dispose();
 323     }
 324
 325     bool ScriptDocument::Impl::impl_initDocument_nothrow( const Reference< XModel >& _rxModel )
 326     {
 327         try
 328         {
 329             m_xDocument.set     ( _rxModel, UNO_SET_THROW );
 330             m_xDocModify.set    ( _rxModel, UNO_QUERY_THROW );
 331             m_xScriptAccess.set ( _rxModel, UNO_QUERY );
 332
 333             m_bValid = m_xScriptAccess.is();
 334
 335             if ( m_bValid )
 336                 m_pDocListener.reset( new DocumentEventNotifier( *this, _rxModel ) );
 337         }
 338         catch( const Exception& )
 339         {
 340             DBG_UNHANDLED_EXCEPTION();
 341             m_bValid = false;
 342         }
 343
 344         if ( !m_bValid )
 345         {
 346             invalidate();
 347         }
 348
 349         return m_bValid;
 350     }
 351
 352     Reference< XLibraryContainer > ScriptDocument::Impl::getLibraryContainer( LibraryContainerType _eType ) const
 353     {
 354         OSL_ENSURE( isValid(), "ScriptDocument::Impl::getLibraryContainer: invalid!" );
 355
 356         Reference< XLibraryContainer > xContainer;
 357         if ( !isValid() )
 358             return xContainer;
 359
 360         try
 361         {
 362             if ( isApplication() )
 363                 xContainer.set( _eType == E_SCRIPTS ? SfxGetpApp()->GetBasicContainer() : SfxGetpApp()->GetDialogContainer(), UNO_QUERY_THROW );
 364             else
 365             {
 366                 xContainer.set(
 367                     _eType == E_SCRIPTS ? m_xScriptAccess->getBasicLibraries() : m_xScriptAccess->getDialogLibraries(),
 368                     UNO_QUERY_THROW );
 369             }
 370         }
 371         catch( const Exception& )
 372         {
 373             DBG_UNHANDLED_EXCEPTION();
 374         }
 375         return xContainer;
 376     }
 377
 378     bool ScriptDocument::Impl::isReadOnly() const
 379     {
 380         OSL_ENSURE( isValid(), "ScriptDocument::Impl::isReadOnly: invalid state!" );
 381         OSL_ENSURE( !isApplication(), "ScriptDocument::Impl::isReadOnly: not allowed to be called for the application!" );
 382
 383         bool bIsReadOnly = true;
 384         if ( isValid() && !isApplication() )
 385         {
 386             try
 387             {
 388                 // note that XStorable is required by the OfficeDocument service
 389                 Reference< XStorable > xDocStorable( m_xDocument, UNO_QUERY_THROW );
 390                 bIsReadOnly = xDocStorable->isReadonly();
 391             }
 392             catch( const Exception& )
 393             {
 394                 DBG_UNHANDLED_EXCEPTION();
 395             }
 396         }
 397         return bIsReadOnly;
 398     }
 399
 400     bool ScriptDocument::Impl::isInVBAMode() const
 401     {
 402         bool bResult = false;
 403         if ( !isApplication() )
 404         {
 405             Reference< XVBACompatibility > xVBACompat( getLibraryContainer( E_SCRIPTS ), UNO_QUERY );
 406             if ( xVBACompat.is() )
 407                 bResult = xVBACompat->getVBACompatibilityMode();
 408         }
 409         return bResult;
 410     }
 411
 412     BasicManager* ScriptDocument::Impl::getBasicManager() const
 413     {
 414         try
 415         {
 416             OSL_ENSURE( isValid(), "ScriptDocument::Impl::getBasicManager: invalid state!" );
 417             if ( !isValid() )
 418                 return NULL;
 419
 420             if ( isApplication() )
 421                 return SfxApplication::GetBasicManager();
 422
 423             return ::basic::BasicManagerRepository::getDocumentBasicManager( m_xDocument );
 424         }
 425         catch (const css::ucb::ContentCreationException& e)
 426         {
 427             SAL_WARN( "basctl.basicide", "ScriptDocument::getBasicManager: Caught exception: " << e.Message );
 428         }
 429         return NULL;
 430     }
 431
 432     Reference< XModel > ScriptDocument::Impl::getDocument() const
 433     {
 434         OSL_ENSURE( isValid(), "ScriptDocument::Impl::getDocument: invalid state!" );
 435         OSL_ENSURE( isDocument(), "ScriptDocument::Impl::getDocument: for documents only!" );
 436         if ( !isValid() || !isDocument() )
 437             return NULL;
 438
 439         return m_xDocument;
 440     }
 441
 442
 443     Reference< XNameContainer > ScriptDocument::Impl::getLibrary( LibraryContainerType _eType, const OUString& _rLibName, bool _bLoadLibrary ) const
 444     {
 445         OSL_ENSURE( isValid(), "ScriptDocument::Impl::getLibrary: invalid state!" );
 446
 447         Reference< XNameContainer > xContainer;
 448         try
 449         {
 450             Reference< XLibraryContainer > xLibContainer = getLibraryContainer( _eType );
 451             if ( isValid() )
 452             {
 453                 if ( xLibContainer.is() )
 454                     xContainer.set( xLibContainer->getByName( _rLibName ), UNO_QUERY_THROW );
 455             }
 456
 457             if ( !xContainer.is() )
 458                 throw NoSuchElementException();
 459
 460             // load library
 461             if ( _bLoadLibrary && !xLibContainer->isLibraryLoaded( _rLibName ) )
 462                 xLibContainer->loadLibrary( _rLibName );
 463         }
 464         catch( const NoSuchElementException& )
 465         {
 466             throw;  // allowed to leave
 467         }
 468         catch( const Exception& )
 469         {
 470             DBG_UNHANDLED_EXCEPTION();
 471         }
 472
 473         return xContainer;
 474     }
 475
 476
 477     bool ScriptDocument::Impl::hasLibrary( LibraryContainerType _eType, const OUString& _rLibName ) const
 478     {
 479         bool bHas = false;
 480         try
 481         {
 482             Reference< XLibraryContainer > xLibContainer = getLibraryContainer( _eType );
 483             bHas = xLibContainer.is() && xLibContainer->hasByName( _rLibName );
 484         }
 485         catch( const Exception& )
 486         {
 487             DBG_UNHANDLED_EXCEPTION();
 488         }
 489         return bHas;
 490     }
 491
 492
 493     Reference< XNameContainer > ScriptDocument::Impl::getOrCreateLibrary( LibraryContainerType _eType, const OUString& _rLibName ) const
 494     {
 495         Reference< XNameContainer > xLibrary;
 496         try
 497         {
 498             Reference< XLibraryContainer > xLibContainer( getLibraryContainer( _eType ), UNO_QUERY_THROW );
 499             if ( xLibContainer->hasByName( _rLibName ) )
 500                 xLibrary.set( xLibContainer->getByName( _rLibName ), UNO_QUERY_THROW );
 501             else
 502                 xLibrary.set( xLibContainer->createLibrary( _rLibName ), UNO_QUERY_THROW );
 503
 504             if ( !xLibContainer->isLibraryLoaded( _rLibName ) )
 505                 xLibContainer->loadLibrary( _rLibName );
 506         }
 507         catch( const Exception& )
 508         {
 509             DBG_UNHANDLED_EXCEPTION();
 510         }
 511         return xLibrary;
 512     }
 513
 514
 515     void ScriptDocument::Impl::loadLibraryIfExists( LibraryContainerType _eType, const OUString& _rLibrary )
 516     {
 517         try
 518         {
 519             Reference< XLibraryContainer > xLibContainer( getLibraryContainer( _eType ) );
 520             if ( xLibContainer.is() && xLibContainer->hasByName( _rLibrary ) && !xLibContainer->isLibraryLoaded( _rLibrary ) )
 521                 xLibContainer->loadLibrary( _rLibrary );
 522         }
 523         catch( const Exception& )
 524         {
 525             DBG_UNHANDLED_EXCEPTION();
 526         }
 527     }
 528
 529
 530     bool ScriptDocument::Impl::removeModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName, const OUString& _rModuleName )
 531     {
 532         OSL_ENSURE( isValid(), "ScriptDocument::Impl::removeModuleOrDialog: invalid!" );
 533         if ( isValid() )
 534         {
 535             try
 536             {
 537                 Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, true ) );
 538                 if ( xLib.is() )
 539                 {
 540                     xLib->removeByName( _rModuleName );
 541                     return true;
 542                 }
 543             }
 544             catch( const Exception& )
 545             {
 546                 DBG_UNHANDLED_EXCEPTION();
 547             }
 548         }
 549         return false;
 550     }
 551
 552
 553     bool ScriptDocument::Impl::hasModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName, const OUString& _rModName ) const
 554     {
 555         OSL_ENSURE( isValid(), "ScriptDocument::Impl::hasModuleOrDialog: invalid!" );
 556         if ( !isValid() )
 557             return false;
 558
 559         try
 560         {
 561             Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, true ) );
 562             if ( xLib.is() )
 563                 return xLib->hasByName( _rModName );
 564         }
 565         catch( const Exception& )
 566         {
 567             DBG_UNHANDLED_EXCEPTION();
 568         }
 569         return false;
 570     }
 571
 572
 573     bool ScriptDocument::Impl::getModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName, const OUString& _rObjectName, Any& _out_rModuleOrDialog )
 574     {
 575         OSL_ENSURE( isValid(), "ScriptDocument::Impl::getModuleOrDialog: invalid!" );
 576         if ( !isValid() )
 577             return false;
 578
 579         _out_rModuleOrDialog.clear();
 580         try
 581         {
 582             Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, true ), UNO_QUERY_THROW );
 583             if ( xLib->hasByName( _rObjectName ) )
 584             {
 585                 _out_rModuleOrDialog = xLib->getByName( _rObjectName );
 586                 return true;
 587             }
 588         }
 589         catch( const Exception& )
 590         {
 591             DBG_UNHANDLED_EXCEPTION();
 592         }
 593         return false;
 594     }
 595
 596
 597     bool ScriptDocument::Impl::renameModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName,
 598         const OUString& _rOldName, const OUString& _rNewName, const Reference< XNameContainer >& _rxExistingDialogModel )
 599     {
 600         OSL_ENSURE( isValid(), "ScriptDocument::Impl::renameModuleOrDialog: invalid!" );
 601         if ( !isValid() )
 602             return false;
 603
 604         try
 605         {
 606             Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, true ), UNO_QUERY_THROW );
 607
 608             // get element
 609             Any aElement( xLib->getByName( _rOldName ) );
 610
 611             // remove element from container
 612             xLib->removeByName( _rOldName );
 613
 614             // if it's a dialog, import and export, to reflect the new name
 615             if ( _eType == E_DIALOGS )
 616             {
 617                 // create dialog model
 618                 Reference< XComponentContext > aContext(
 619                     comphelper::getProcessComponentContext() );
 620                 Reference< XNameContainer > xDialogModel;
 621                 if ( _rxExistingDialogModel.is() )
 622                     xDialogModel = _rxExistingDialogModel;
 623                 else
 624                     xDialogModel.set(
 625                         ( aContext->getServiceManager()->
 626                           createInstanceWithContext(
 627                               "com.sun.star.awt.UnoControlDialogModel",
 628                               aContext ) ),
 629                         UNO_QUERY_THROW );
 630
 631                 // import dialog model
 632                 Reference< XInputStreamProvider > xISP( aElement, UNO_QUERY_THROW );
 633                 if ( !_rxExistingDialogModel.is() )
 634                 {
 635                     Reference< XInputStream > xInput( xISP->createInputStream(), UNO_QUERY_THROW );
 636                     ::xmlscript::importDialogModel( xInput, xDialogModel, aContext, isDocument() ? getDocument() : Reference< XModel >() );
 637                 }
 638
 639                 // set new name as property
 640                 Reference< XPropertySet > xDlgPSet( xDialogModel, UNO_QUERY_THROW );
 641                 xDlgPSet->setPropertyValue( DLGED_PROP_NAME, makeAny( _rNewName ) );
 642
 643                 // export dialog model
 644                 xISP = ::xmlscript::exportDialogModel( xDialogModel, aContext, isDocument() ? getDocument() : Reference< XModel >() );
 645                 aElement <<= xISP;
 646             }
 647
 648             // insert element by new name in container
 649             if ( _eType == E_SCRIPTS )
 650             {
 651                 Reference< XVBAModuleInfo > xVBAModuleInfo( xLib, UNO_QUERY );
 652                 if ( xVBAModuleInfo->hasModuleInfo( _rOldName ) )
 653                 {
 654                     ModuleInfo sModuleInfo = xVBAModuleInfo->getModuleInfo( _rOldName );
 655                     xVBAModuleInfo->removeModuleInfo( _rOldName );
 656                     xVBAModuleInfo->insertModuleInfo( _rNewName, sModuleInfo );
 657                 }
 658             }
 659             xLib->insertByName( _rNewName, aElement );
 660             return true;
 661         }
 662         catch( const Exception& )
 663         {
 664             DBG_UNHANDLED_EXCEPTION();
 665         }
 666         return false;
 667     }
 668
 669
 670     bool ScriptDocument::Impl::createModule( const OUString& _rLibName, const OUString& _rModName, bool _bCreateMain, OUString& _out_rNewModuleCode ) const
 671     {
 672         _out_rNewModuleCode.clear();
 673         try
 674         {
 675             Reference< XNameContainer > xLib( getLibrary( E_SCRIPTS, _rLibName, true ) );
 676             if ( !xLib.is() || xLib->hasByName( _rModName ) )
 677                 return false;
 678
 679             // create new module
 680             _out_rNewModuleCode = "REM  *****  BASIC  *****\n\n" ;
 681             if ( _bCreateMain )
 682                 _out_rNewModuleCode += "Sub Main\n\nEnd Sub\n" ;
 683
 684             // insert module into library
 685             xLib->insertByName( _rModName, makeAny( _out_rNewModuleCode ) );
 686         }
 687         catch( const Exception& )
 688         {
 689             DBG_UNHANDLED_EXCEPTION();
 690             return false;
 691         }
 692
 693         return true;
 694     }
 695
 696
 697     bool ScriptDocument::Impl::insertModuleOrDialog( LibraryContainerType _eType, const OUString& _rLibName, const OUString& _rObjectName, const Any& _rElement ) const
 698     {
 699         try
 700         {
 701             Reference< XNameContainer > xLib( getOrCreateLibrary( _eType, _rLibName ), UNO_QUERY_THROW );
 702             if ( xLib->hasByName( _rObjectName ) )
 703                 return false;
 704
 705             xLib->insertByName( _rObjectName, _rElement );
 706             return true;
 707         }
 708         catch( const Exception& )
 709         {
 710             DBG_UNHANDLED_EXCEPTION();
 711         }
 712         return false;
 713     }
 714
 715
 716     bool ScriptDocument::Impl::updateModule( const OUString& _rLibName, const OUString& _rModName, const OUString& _rModuleCode ) const
 717     {
 718         try
 719         {
 720             Reference< XNameContainer > xLib( getOrCreateLibrary( E_SCRIPTS, _rLibName ), UNO_QUERY_THROW );
 721             if ( !xLib->hasByName( _rModName ) )
 722                 return false;
 723             xLib->replaceByName( _rModName, makeAny( _rModuleCode ) );
 724             return true;
 725         }
 726         catch( const Exception& )
 727         {
 728             DBG_UNHANDLED_EXCEPTION();
 729         }
 730         return false;
 731     }
 732
 733
 734     bool ScriptDocument::Impl::createDialog( const OUString& _rLibName, const OUString& _rDialogName, Reference< XInputStreamProvider >& _out_rDialogProvider ) const
 735     {
 736         try
 737         {
 738             Reference< XNameContainer > xLib( getLibrary( E_DIALOGS, _rLibName, true ), UNO_QUERY_THROW );
 739
 740             // create dialog
 741             _out_rDialogProvider.clear();
 742             if ( xLib->hasByName( _rDialogName ) )
 743                 return false;
 744
 745             // create new dialog model
 746             Reference< XComponentContext > aContext(
 747                 comphelper::getProcessComponentContext() );
 748             Reference< XNameContainer > xDialogModel(
 749                 aContext->getServiceManager()->createInstanceWithContext(
 750                     "com.sun.star.awt.UnoControlDialogModel", aContext ),
 751                 UNO_QUERY_THROW );
 752
 753             // set name property
 754             Reference< XPropertySet > xDlgPSet( xDialogModel, UNO_QUERY_THROW );
 755             xDlgPSet->setPropertyValue( DLGED_PROP_NAME, makeAny( _rDialogName ) );
 756
 757             // export dialog model
 758             _out_rDialogProvider = ::xmlscript::exportDialogModel( xDialogModel, aContext, isDocument() ? getDocument() : Reference< XModel >() );
 759
 760             // insert dialog into library
 761             xLib->insertByName( _rDialogName, makeAny( _out_rDialogProvider ) );
 762         }
 763         catch( const Exception& )
 764         {
 765             DBG_UNHANDLED_EXCEPTION();
 766         }
 767
 768         return _out_rDialogProvider.is();
 769     }
 770
 771
 772     void ScriptDocument::Impl::setDocumentModified() const
 773     {
 774         OSL_ENSURE( isValid() && isDocument(), "ScriptDocument::Impl::setDocumentModified: only to be called for real documents!" );
 775         if ( isValid() && isDocument() )
 776         {
 777             try
 778             {
 779                 m_xDocModify->setModified( true );
 780             }
 781             catch( const Exception& )
 782             {
 783                 DBG_UNHANDLED_EXCEPTION();
 784             }
 785         }
 786     }
 787
 788
 789     bool ScriptDocument::Impl::isDocumentModified() const
 790     {
 791         OSL_ENSURE( isValid() && isDocument(), "ScriptDocument::Impl::isDocumentModified: only to be called for real documents!" );
 792         bool bIsModified = false;
 793         if ( isValid() && isDocument() )
 794         {
 795             try
 796             {
 797                 bIsModified = m_xDocModify->isModified();
 798             }
 799             catch( const Exception& )
 800             {
 801                 DBG_UNHANDLED_EXCEPTION();
 802             }
 803         }
 804         return bIsModified;
 805     }
 806
 807
 808     bool ScriptDocument::Impl::saveDocument( const Reference< XStatusIndicator >& _rxStatusIndicator ) const
 809     {
 810         Reference< XFrame > xFrame;
 811         if ( !getCurrentFrame( xFrame ) )
 812             return false;
 813
 814         Sequence< PropertyValue > aArgs;
 815         if ( _rxStatusIndicator.is() )
 816         {
 817             aArgs = ::comphelper::InitPropertySequence({
 818                 { "StatusIndicator", makeAny(_rxStatusIndicator) }
 819             });
 820         }
 821
 822         try
 823         {
 824             URL aURL;
 825             aURL.Complete = ".uno:Save" ;
 826             aURL.Main = aURL.Complete;
 827             aURL.Protocol = ".uno:" ;
 828             aURL.Path = "Save" ;
 829
 830             Reference< XDispatchProvider > xDispProv( xFrame, UNO_QUERY_THROW );
 831             Reference< XDispatch > xDispatch(
 832                 xDispProv->queryDispatch( aURL, "_self", FrameSearchFlag::AUTO ),
 833                 UNO_SET_THROW );
 834
 835             xDispatch->dispatch( aURL, aArgs );
 836         }
 837         catch( const Exception& )
 838         {
 839             DBG_UNHANDLED_EXCEPTION();
 840             return false;
 841         }
 842
 843         return true;
 844     }
 845
 846
 847     OUString ScriptDocument::Impl::getTitle() const
 848     {
 849         OSL_PRECOND( isValid() && isDocument(), "ScriptDocument::Impl::getTitle: for documents only!" );
 850
 851         OUString sTitle;
 852         if ( isValid() && isDocument() )
 853         {
 854             sTitle = ::comphelper::DocumentInfo::getDocumentTitle( m_xDocument );
 855         }
 856         return sTitle;
 857     }
 858
 859
 860     OUString ScriptDocument::Impl::getURL() const
 861     {
 862         OSL_PRECOND( isValid() && isDocument(), "ScriptDocument::Impl::getURL: for documents only!" );
 863
 864         OUString sURL;
 865         if ( isValid() && isDocument() )
 866         {
 867             try
 868             {
 869                 sURL = m_xDocument->getURL();
 870             }
 871             catch( const Exception& )
 872             {
 873                 DBG_UNHANDLED_EXCEPTION();
 874             }
 875         }
 876         return sURL;
 877     }
 878
 879
 880     bool ScriptDocument::Impl::allowMacros() const
 881     {
 882         OSL_ENSURE( isValid() && isDocument(), "ScriptDocument::Impl::allowMacros: for documents only!" );
 883         bool bAllow = false;
 884         if ( isValid() && isDocument() )
 885         {
 886             try
 887             {
 888                 bAllow = m_xScriptAccess->getAllowMacroExecution();
 889             }
 890             catch( const Exception& )
 891             {
 892                 DBG_UNHANDLED_EXCEPTION();
 893             }
 894         }
 895         return bAllow;
 896     }
 897
 898
 899     bool ScriptDocument::Impl::getCurrentFrame( Reference< XFrame >& _out_rxFrame ) const
 900     {
 901         _out_rxFrame.clear();
 902         OSL_PRECOND( isValid() && isDocument(), "ScriptDocument::Impl::getCurrentFrame: documents only!" );
 903         if ( !isValid() || !isDocument() )
 904             return false;
 905
 906         try
 907         {
 908             Reference< XModel > xDocument( m_xDocument, UNO_SET_THROW );
 909             Reference< XController > xController( xDocument->getCurrentController(), UNO_SET_THROW );
 910             _out_rxFrame.set( xController->getFrame(), UNO_SET_THROW );
 911         }
 912         catch( const Exception& )
 913         {
 914             DBG_UNHANDLED_EXCEPTION();
 915         }
 916
 917         return _out_rxFrame.is();
 918     }
 919
 920
 921     bool ScriptDocument::Impl::isLibraryShared( const OUString& _rLibName, LibraryContainerType _eType )
 922     {
 923         bool bIsShared = false;
 924         try
 925         {
 926             Reference< XLibraryContainer2 > xLibContainer( getLibraryContainer( _eType ), UNO_QUERY_THROW );
 927
 928             if ( !xLibContainer->hasByName( _rLibName ) || !xLibContainer->isLibraryLink( _rLibName ) )
 929                 return false;
 930             OUString aFileURL;
 931             Reference< XComponentContext > xContext( ::comphelper::getProcessComponentContext() );
 932             Reference< XUriReferenceFactory > xUriFac = UriReferenceFactory::create(xContext);
 933
 934             OUString aLinkURL( xLibContainer->getLibraryLinkURL( _rLibName ) );
 935             Reference< XUriReference > xUriRef( xUriFac->parse( aLinkURL ), UNO_QUERY_THROW );
 936
 937             OUString aScheme = xUriRef->getScheme();
 938             if ( aScheme.equalsIgnoreAsciiCase("file") )
 939             {
 940                 aFileURL = aLinkURL;
 941             }
 942             else if ( aScheme.equalsIgnoreAsciiCase("vnd.sun.star.pkg") )
 943             {
 944                 OUString aAuthority = xUriRef->getAuthority();
 945                 if ( aAuthority.matchIgnoreAsciiCase("vnd.sun.star.expand:") )
 946                 {
 947                     OUString aDecodedURL( aAuthority.copy( sizeof ( "vnd.sun.star.expand:" ) - 1 ) );
 948                     aDecodedURL = ::rtl::Uri::decode( aDecodedURL, rtl_UriDecodeWithCharset, RTL_TEXTENCODING_UTF8 );
 949                     Reference< XMacroExpander > xMacroExpander = theMacroExpander::get(xContext);
 950                     aFileURL = xMacroExpander->expandMacros( aDecodedURL );
 951                 }
 952             }
 953
 954             if ( !aFileURL.isEmpty() )
 955             {
 956                 ::osl::DirectoryItem aFileItem;
 957                 ::osl::FileStatus aFileStatus( osl_FileStatus_Mask_FileURL );
 958                 OSL_VERIFY( ::osl::DirectoryItem::get( aFileURL, aFileItem ) == ::osl::FileBase::E_None );
 959                 OSL_VERIFY( aFileItem.getFileStatus( aFileStatus ) == ::osl::FileBase::E_None );
 960                 OUString aCanonicalFileURL( aFileStatus.getFileURL() );
 961
 962                 OUString aSearchURL1( "share/basic" );
 963                 OUString aSearchURL2( "share/uno_packages" );
 964                 OUString aSearchURL3( "share/extensions" );
 965                 if( aCanonicalFileURL.indexOf( aSearchURL1 ) >= 0 ||
 966                     aCanonicalFileURL.indexOf( aSearchURL2 ) >= 0 ||
 967                     aCanonicalFileURL.indexOf( aSearchURL3 ) >= 0 )
 968                         bIsShared = true;
 969             }
 970         }
 971         catch( const Exception& )
 972         {
 973             DBG_UNHANDLED_EXCEPTION();
 974         }
 975
 976         return bIsShared;
 977     }
 978
 979
 980     void ScriptDocument::Impl::onDocumentCreated( const ScriptDocument& /*_rDocument*/ )
 981     {
 982         // not interested in
 983     }
 984
 985     void ScriptDocument::Impl::onDocumentOpened( const ScriptDocument& /*_rDocument*/ )
 986     {
 987         // not interested in
 988     }
 989
 990     void ScriptDocument::Impl::onDocumentSave( const ScriptDocument& /*_rDocument*/ )
 991     {
 992         // not interested in
 993     }
 994
 995     void ScriptDocument::Impl::onDocumentSaveDone( const ScriptDocument& /*_rDocument*/ )
 996     {
 997         // not interested in
 998     }
 999
1000     void ScriptDocument::Impl::onDocumentSaveAs( const ScriptDocument& /*_rDocument*/ )
1001     {
1002         // not interested in
1003     }
1004
1005     void ScriptDocument::Impl::onDocumentSaveAsDone( const ScriptDocument& /*_rDocument*/ )
1006     {
1007         // not interested in
1008     }
1009
1010     void ScriptDocument::Impl::onDocumentClosed( const ScriptDocument& _rDocument )
1011     {
1012         DBG_TESTSOLARMUTEX();
1013         OSL_PRECOND( isValid(), "ScriptDocument::Impl::onDocumentClosed: should not be listening if I'm not valid!" );
1014
1015         bool bMyDocument = m_xDocument == _rDocument.getDocument();
1016         OSL_PRECOND( bMyDocument, "ScriptDocument::Impl::onDocumentClosed: didn't want to know *this*!" );
1017         if ( bMyDocument )
1018         {
1019             m_bDocumentClosed = true;
1020         }
1021     }
1022
1023
1024     void ScriptDocument::Impl::onDocumentTitleChanged( const ScriptDocument& /*_rDocument*/ )
1025     {
1026         // not interested in
1027     }
1028
1029     void ScriptDocument::Impl::onDocumentModeChanged( const ScriptDocument& /*_rDocument*/ )
1030     {
1031         // not interested in
1032     }
1033
1034
1035     ScriptDocument::ScriptDocument()
1036         :m_pImpl(new Impl)
1037     { }
1038
1039
1040     ScriptDocument::ScriptDocument( ScriptDocument::SpecialDocument _eType )
1041         :m_pImpl( new Impl( Reference< XModel >() ) )
1042     {
1043         OSL_ENSURE( _eType == NoDocument, "ScriptDocument::ScriptDocument: unknown SpecialDocument type!" );
1044         (void)_eType;
1045     }
1046
1047
1048     ScriptDocument::ScriptDocument( const Reference< XModel >& _rxDocument )
1049         :m_pImpl( new Impl( _rxDocument ) )
1050     {
1051         OSL_ENSURE( _rxDocument.is(), "ScriptDocument::ScriptDocument: document must not be NULL!" );
1052             // a NULL document results in an uninitialized instance, and for this
1053             // purpose, there is a dedicated constructor
1054     }
1055
1056
1057     ScriptDocument::ScriptDocument( const ScriptDocument& _rSource )
1058         :m_pImpl( _rSource.m_pImpl )
1059     {
1060     }
1061
1062
1063     ScriptDocument::~ScriptDocument()
1064     {
1065     }
1066
1067
1068     const ScriptDocument& ScriptDocument::getApplicationScriptDocument()
1069     {
1070         static ScriptDocument s_aApplicationScripts;
1071         return s_aApplicationScripts;
1072     }
1073
1074
1075     ScriptDocument ScriptDocument::getDocumentForBasicManager( const BasicManager* _pManager )
1076     {
1077         if ( _pManager == SfxApplication::GetBasicManager() )
1078             return getApplicationScriptDocument();
1079
1080         docs::Documents aDocuments;
1081         lcl_getAllModels_throw( aDocuments, false );
1082
1083         for (   docs::Documents::const_iterator doc = aDocuments.begin();
1084                 doc != aDocuments.end();
1085                 ++doc
1086             )
1087         {
1088             const BasicManager* pDocBasicManager = ::basic::BasicManagerRepository::getDocumentBasicManager( doc->xModel );
1089             if  (   ( pDocBasicManager != SfxApplication::GetBasicManager() )
1090                 &&  ( pDocBasicManager == _pManager )
1091                 )
1092             {
1093                 return ScriptDocument( doc->xModel );
1094             }
1095         }
1096
1097         OSL_FAIL( "ScriptDocument::getDocumentForBasicManager: did not find a document for this manager!" );
1098         return ScriptDocument( NoDocument );
1099     }
1100
1101
1102     ScriptDocument ScriptDocument::getDocumentWithURLOrCaption( const OUString& _rUrlOrCaption )
1103     {
1104         ScriptDocument aDocument( getApplicationScriptDocument() );
1105         if ( _rUrlOrCaption.isEmpty() )
1106             return aDocument;
1107
1108         docs::Documents aDocuments;
1109         lcl_getAllModels_throw( aDocuments, false );
1110
1111         for (   docs::Documents::const_iterator doc = aDocuments.begin();
1112                 doc != aDocuments.end();
1113                 ++doc
1114             )
1115         {
1116             const ScriptDocument aCheck = ScriptDocument( doc->xModel );
1117             if  (   _rUrlOrCaption == aCheck.getTitle()
1118                 ||  _rUrlOrCaption == aCheck.getURL()
1119                 )
1120             {
1121                 aDocument = aCheck;
1122                 break;
1123             }
1124         }
1125
1126         return aDocument;
1127     }
1128
1129
1130     namespace
1131     {
1132         struct DocumentTitleLess : public ::std::binary_function< ScriptDocument, ScriptDocument, bool >
1133         {
1134             explicit DocumentTitleLess( const CollatorWrapper& _rCollator )
1135                 :m_aCollator( _rCollator )
1136             {
1137             }
1138
1139             bool operator()( const ScriptDocument& _lhs, const ScriptDocument& _rhs ) const
1140             {
1141                 return m_aCollator.compareString( _lhs.getTitle(), _rhs.getTitle() ) < 0;
1142             }
1143         private:
1144             const CollatorWrapper   m_aCollator;
1145         };
1146     }
1147
1148
1149     ScriptDocuments ScriptDocument::getAllScriptDocuments( ScriptDocument::ScriptDocumentList _eListType )
1150     {
1151         ScriptDocuments aScriptDocs;
1152
1153         // include application?
1154         if ( _eListType == AllWithApplication )
1155             aScriptDocs.push_back( getApplicationScriptDocument() );
1156
1157         // obtain documents
1158         try
1159         {
1160             docs::Documents aDocuments;
1161             lcl_getAllModels_throw( aDocuments, true /* exclude invisible */ );
1162
1163             for (   docs::Documents::const_iterator doc = aDocuments.begin();
1164                     doc != aDocuments.end();
1165                     ++doc
1166                 )
1167             {
1168                 // exclude documents without script/library containers
1169                 ScriptDocument aDoc( doc->xModel );
1170                 if ( !aDoc.isValid() )
1171                     continue;
1172
1173                 aScriptDocs.push_back( aDoc );
1174             }
1175         }
1176         catch( const Exception& )
1177         {
1178             DBG_UNHANDLED_EXCEPTION();
1179         }
1180
1181         // sort document list by doc title?
1182         if ( _eListType == DocumentsSorted )
1183         {
1184             CollatorWrapper aCollator( ::comphelper::getProcessComponentContext() );
1185             aCollator.loadDefaultCollator( SvtSysLocale().GetLanguageTag().getLocale(), 0 );
1186             ::std::sort( aScriptDocs.begin(), aScriptDocs.end(), DocumentTitleLess( aCollator ) );
1187         }
1188
1189         return aScriptDocs;
1190     }
1191
1192
1193     bool ScriptDocument::operator==( const ScriptDocument& _rhs ) const
1194     {
1195         return m_pImpl->getDocumentRef() == _rhs.m_pImpl->getDocumentRef();
1196     }
1197
1198
1199     sal_Int32 ScriptDocument::hashCode() const
1200     {
1201         return sal::static_int_cast<sal_Int32>(reinterpret_cast< sal_IntPtr >( m_pImpl->getDocumentRef().get() ));
1202     }
1203
1204
1205     bool ScriptDocument::isValid() const
1206     {
1207         return m_pImpl->isValid();
1208     }
1209
1210
1211     bool ScriptDocument::isAlive() const
1212     {
1213         return m_pImpl->isAlive();
1214     }
1215
1216
1217     Reference< XLibraryContainer > ScriptDocument::getLibraryContainer( LibraryContainerType _eType ) const
1218     {
1219         return m_pImpl->getLibraryContainer( _eType );
1220     }
1221
1222
1223     Reference< XNameContainer > ScriptDocument::getLibrary( LibraryContainerType _eType, const OUString& _rLibName, bool _bLoadLibrary ) const
1224     {
1225         return m_pImpl->getLibrary( _eType, _rLibName, _bLoadLibrary );
1226     }
1227
1228
1229     bool ScriptDocument::hasLibrary( LibraryContainerType _eType, const OUString& _rLibName ) const
1230     {
1231         return m_pImpl->hasLibrary( _eType, _rLibName );
1232     }
1233
1234
1235     Reference< XNameContainer > ScriptDocument::getOrCreateLibrary( LibraryContainerType _eType, const OUString& _rLibName ) const
1236     {
1237         return m_pImpl->getOrCreateLibrary( _eType, _rLibName );
1238     }
1239
1240
1241     void ScriptDocument::loadLibraryIfExists( LibraryContainerType _eType, const OUString& _rLibrary )
1242     {
1243         m_pImpl->loadLibraryIfExists( _eType, _rLibrary );
1244     }
1245
1246
1247     Sequence< OUString > ScriptDocument::getObjectNames( LibraryContainerType _eType, const OUString& _rLibName ) const
1248     {
1249         Sequence< OUString > aModuleNames;
1250
1251         try
1252         {
1253             if ( hasLibrary( _eType, _rLibName ) )
1254             {
1255                 Reference< XNameContainer > xLib( getLibrary( _eType, _rLibName, false ) );
1256                 if ( xLib.is() )
1257                     aModuleNames = xLib->getElementNames();
1258             }
1259         }
1260         catch( const Exception& )
1261         {
1262             DBG_UNHANDLED_EXCEPTION();
1263         }
1264
1265         // sort
1266         ::std::sort( aModuleNames.getArray() , aModuleNames.getArray() + aModuleNames.getLength() , StringCompareLessThan );
1267
1268         return aModuleNames;
1269     }
1270
1271
1272     OUString ScriptDocument::createObjectName( LibraryContainerType _eType, const OUString& _rLibName ) const
1273     {
1274         OUString aObjectName;
1275
1276         OUString aBaseName = _eType == E_SCRIPTS ? OUString("Module") : OUString("Dialog");
1277
1278         Sequence< OUString > aUsedNames( getObjectNames( _eType, _rLibName ) );
1279         ::std::set< OUString > aUsedNamesCheck;
1280         ::std::copy( aUsedNames.getConstArray(), aUsedNames.getConstArray() + aUsedNames.getLength(),
1281             ::std::insert_iterator< ::std::set< OUString > >( aUsedNamesCheck, aUsedNamesCheck.begin() ) );
1282
1283         bool bValid = false;
1284         sal_Int32 i = 1;
1285         while ( !bValid )
1286         {
1287             aObjectName = aBaseName;
1288             aObjectName += OUString::number( i );
1289
1290             if ( aUsedNamesCheck.find( aObjectName ) == aUsedNamesCheck.end() )
1291                 bValid = true;
1292
1293             ++i;
1294         }
1295
1296         return aObjectName;
1297     }
1298
1299
1300     Sequence< OUString > ScriptDocument::getLibraryNames() const
1301     {
1302         return GetMergedLibraryNames( getLibraryContainer( E_SCRIPTS ), getLibraryContainer( E_DIALOGS ) );
1303     }
1304
1305
1306     bool ScriptDocument::isReadOnly() const
1307     {
1308         return m_pImpl->isReadOnly();
1309     }
1310
1311
1312     bool ScriptDocument::isApplication() const
1313     {
1314         return m_pImpl->isApplication();
1315     }
1316
1317     bool ScriptDocument::isInVBAMode() const
1318     {
1319         return m_pImpl->isInVBAMode();
1320     }
1321
1322
1323     BasicManager* ScriptDocument::getBasicManager() const
1324     {
1325         return m_pImpl->getBasicManager();
1326     }
1327
1328
1329     Reference< XModel > ScriptDocument::getDocument() const
1330     {
1331         return m_pImpl->getDocument();
1332     }
1333
1334
1335     Reference< XModel > ScriptDocument::getDocumentOrNull() const
1336     {
1337         if ( isDocument() )
1338             return m_pImpl->getDocument();
1339         return NULL;
1340     }
1341
1342
1343     bool ScriptDocument::removeModule( const OUString& _rLibName, const OUString& _rModuleName ) const
1344     {
1345         return m_pImpl->removeModuleOrDialog( E_SCRIPTS, _rLibName, _rModuleName );
1346     }
1347
1348
1349     bool ScriptDocument::hasModule( const OUString& _rLibName, const OUString& _rModuleName ) const
1350     {
1351         return m_pImpl->hasModuleOrDialog( E_SCRIPTS, _rLibName, _rModuleName );
1352     }
1353
1354
1355     bool ScriptDocument::getModule( const OUString& _rLibName, const OUString& _rModName, OUString& _out_rModuleSource ) const
1356     {
1357         Any aCode;
1358         if ( !m_pImpl->getModuleOrDialog( E_SCRIPTS, _rLibName, _rModName, aCode ) )
1359             return false;
1360         OSL_VERIFY( aCode >>= _out_rModuleSource );
1361         return true;
1362     }
1363
1364
1365     bool ScriptDocument::renameModule( const OUString& _rLibName, const OUString& _rOldName, const OUString& _rNewName ) const
1366     {
1367         return m_pImpl->renameModuleOrDialog( E_SCRIPTS, _rLibName, _rOldName, _rNewName, NULL );
1368     }
1369
1370
1371     bool ScriptDocument::createModule( const OUString& _rLibName, const OUString& _rModName, bool _bCreateMain, OUString& _out_rNewModuleCode ) const
1372     {
1373         if ( !m_pImpl->createModule( _rLibName, _rModName, _bCreateMain, _out_rNewModuleCode ) )
1374             return false;
1375
1376         // doc shell modified
1377         MarkDocumentModified( *const_cast< ScriptDocument* >( this ) );    // here?
1378         return true;
1379     }
1380
1381
1382     bool ScriptDocument::insertModule( const OUString& _rLibName, const OUString& _rModName, const OUString& _rModuleCode ) const
1383     {
1384         return m_pImpl->insertModuleOrDialog( E_SCRIPTS, _rLibName, _rModName, makeAny( _rModuleCode ) );
1385     }
1386
1387
1388     bool ScriptDocument::updateModule( const OUString& _rLibName, const OUString& _rModName, const OUString& _rModuleCode ) const
1389     {
1390         return m_pImpl->updateModule( _rLibName, _rModName, _rModuleCode );
1391     }
1392
1393
1394     bool ScriptDocument::removeDialog( const OUString& _rLibName, const OUString& _rDialogName ) const
1395     {
1396         return m_pImpl->removeModuleOrDialog( E_DIALOGS, _rLibName, _rDialogName );
1397     }
1398
1399
1400     bool ScriptDocument::hasDialog( const OUString& _rLibName, const OUString& _rDialogName ) const
1401     {
1402         return m_pImpl->hasModuleOrDialog( E_DIALOGS, _rLibName, _rDialogName );
1403     }
1404
1405
1406     bool ScriptDocument::getDialog( const OUString& _rLibName, const OUString& _rDialogName, Reference< XInputStreamProvider >& _out_rDialogProvider ) const
1407     {
1408         Any aCode;
1409         if ( !m_pImpl->getModuleOrDialog( E_DIALOGS, _rLibName, _rDialogName, aCode ) )
1410             return false;
1411         OSL_VERIFY( aCode >>= _out_rDialogProvider );
1412         return _out_rDialogProvider.is();
1413     }
1414
1415
1416     bool ScriptDocument::renameDialog( const OUString& _rLibName, const OUString& _rOldName, const OUString& _rNewName, const Reference< XNameContainer >& _rxExistingDialogModel ) const
1417     {
1418         return m_pImpl->renameModuleOrDialog( E_DIALOGS, _rLibName, _rOldName, _rNewName, _rxExistingDialogModel );
1419     }
1420
1421
1422     bool ScriptDocument::createDialog( const OUString& _rLibName, const OUString& _rDialogName, Reference< XInputStreamProvider >& _out_rDialogProvider ) const
1423     {
1424         if ( !m_pImpl->createDialog( _rLibName, _rDialogName, _out_rDialogProvider ) )
1425             return false;
1426
1427         MarkDocumentModified( *const_cast< ScriptDocument* >( this ) );    // here?
1428         return true;
1429     }
1430
1431
1432     bool ScriptDocument::insertDialog( const OUString& _rLibName, const OUString& _rDialogName, const Reference< XInputStreamProvider >& _rxDialogProvider ) const
1433     {
1434         return m_pImpl->insertModuleOrDialog( E_DIALOGS, _rLibName, _rDialogName, makeAny( _rxDialogProvider ) );
1435     }
1436
1437
1438     void ScriptDocument::setDocumentModified() const
1439     {
1440         m_pImpl->setDocumentModified();
1441     }
1442
1443
1444     bool ScriptDocument::isDocumentModified() const
1445     {
1446         return m_pImpl->isDocumentModified();
1447     }
1448
1449
1450     bool ScriptDocument::saveDocument( const Reference< XStatusIndicator >& _rxStatusIndicator ) const
1451     {
1452         return m_pImpl->saveDocument( _rxStatusIndicator );
1453     }
1454
1455
1456     LibraryLocation ScriptDocument::getLibraryLocation( const OUString& _rLibName ) const
1457     {
1458         LibraryLocation eLocation = LIBRARY_LOCATION_UNKNOWN;
1459         if ( !_rLibName.isEmpty() )
1460         {
1461             if ( isDocument() )
1462             {
1463                 eLocation = LIBRARY_LOCATION_DOCUMENT;
1464             }
1465             else
1466             {
1467                 if  (  ( hasLibrary( E_SCRIPTS, _rLibName ) && !m_pImpl->isLibraryShared( _rLibName, E_SCRIPTS ) )
1468                     || ( hasLibrary( E_DIALOGS, _rLibName ) && !m_pImpl->isLibraryShared( _rLibName, E_DIALOGS ) )
1469                     )
1470                 {
1471                     eLocation = LIBRARY_LOCATION_USER;
1472                 }
1473                 else
1474                 {
1475                     eLocation = LIBRARY_LOCATION_SHARE;
1476                 }
1477             }
1478         }
1479
1480         return eLocation;
1481     }
1482
1483
1484     OUString ScriptDocument::getTitle( LibraryLocation _eLocation, LibraryType _eType ) const
1485     {
1486         OUString aTitle;
1487
1488         switch ( _eLocation )
1489         {
1490             case LIBRARY_LOCATION_USER:
1491             {
1492                 switch ( _eType )
1493                 {
1494                 case LIBRARY_TYPE_MODULE:   aTitle = IDE_RESSTR(RID_STR_USERMACROS); break;
1495                 case LIBRARY_TYPE_DIALOG:   aTitle = IDE_RESSTR(RID_STR_USERDIALOGS); break;
1496                 case LIBRARY_TYPE_ALL:      aTitle = IDE_RESSTR(RID_STR_USERMACROSDIALOGS); break;
1497                 default:
1498                     break;
1499             }
1500             break;
1501             case LIBRARY_LOCATION_SHARE:
1502             {
1503                 switch ( _eType )
1504                 {
1505                 case LIBRARY_TYPE_MODULE:   aTitle = IDE_RESSTR(RID_STR_SHAREMACROS); break;
1506                 case LIBRARY_TYPE_DIALOG:   aTitle = IDE_RESSTR(RID_STR_SHAREDIALOGS); break;
1507                 case LIBRARY_TYPE_ALL:      aTitle = IDE_RESSTR(RID_STR_SHAREMACROSDIALOGS); break;
1508                 default:
1509                     break;
1510                 }
1511             }
1512             break;
1513             case LIBRARY_LOCATION_DOCUMENT:
1514                 aTitle = getTitle();
1515                 break;
1516             default:
1517                 break;
1518             }
1519         }
1520
1521         return aTitle;
1522     }
1523
1524
1525     OUString ScriptDocument::getTitle() const
1526     {
1527         return m_pImpl->getTitle();
1528     }
1529
1530
1531     OUString ScriptDocument::getURL() const
1532     {
1533         return m_pImpl->getURL();
1534     }
1535
1536
1537     bool ScriptDocument::isActive() const
1538     {
1539         bool bIsActive( false );
1540         try
1541         {
1542             Reference< XFrame > xFrame;
1543             if ( m_pImpl->getCurrentFrame( xFrame ) )
1544                 bIsActive = xFrame->isActive();
1545         }
1546         catch( const Exception& )
1547         {
1548             DBG_UNHANDLED_EXCEPTION();
1549         }
1550         return bIsActive;
1551     }
1552
1553
1554     bool ScriptDocument::allowMacros() const
1555     {
1556         return m_pImpl->allowMacros();
1557     }
1558
1559 } // namespace basctl
1560
1561 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */