xmlscript/source/xmlflat_imexp/xmlbas_import.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 <sal/config.h>
  21
  22 #include "xmlbas_import.hxx"
  23 #include <sal/log.hxx>
  24 #include <xmlscript/xmlns.h>
  25 #include <com/sun/star/beans/XPropertySet.hpp>
  26 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  27 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  28 #include <com/sun/star/xml/sax/SAXException.hpp>
  29 #include <cppuhelper/supportsservice.hxx>
  30 #include <tools/diagnose_ex.h>
  31
  32 using namespace ::com::sun::star;
  33 using namespace ::com::sun::star::lang;
  34 using namespace ::com::sun::star::uno;
  35
  36 namespace xmlscript
  37 {
  38
  39     // BasicElementBase
  40
  41     BasicElementBase::BasicElementBase( const OUString& rLocalName,
  42             const Reference< xml::input::XAttributes >& xAttributes,
  43             BasicElementBase* pParent, BasicImport* pImport )
  44         :m_xImport( pImport )
  45         ,m_xParent( pParent )
  46         ,m_aLocalName( rLocalName )
  47         ,m_xAttributes( xAttributes )
  48     {
  49     }
  50
  51     BasicElementBase::~BasicElementBase()
  52     {
  53     }
  54
  55     bool BasicElementBase::getBoolAttr( bool* pRet, const OUString& rAttrName,
  56         const css::uno::Reference< css::xml::input::XAttributes >& xAttributes,
  57         sal_Int32 nUid )
  58     {
  59         if ( xAttributes.is() )
  60         {
  61             OUString aValue( xAttributes->getValueByUidName( nUid, rAttrName ) );
  62             if ( !aValue.isEmpty() )
  63             {
  64                 if ( aValue == "true" )
  65                 {
  66                     *pRet = true;
  67                     return true;
  68                 }
  69                 else if ( aValue == "false" )
  70                 {
  71                     *pRet = false;
  72                     return true;
  73                 }
  74                 else
  75                 {
  76                     throw xml::sax::SAXException(rAttrName + ": no boolean value (true|false)!", Reference< XInterface >(), Any() );
  77                 }
  78             }
  79         }
  80         return false;
  81     }
  82
  83     // XElement
  84
  85     Reference< xml::input::XElement > BasicElementBase::getParent()
  86     {
  87         return m_xParent.get();
  88     }
  89
  90     OUString BasicElementBase::getLocalName()
  91     {
  92         return m_aLocalName;
  93     }
  94
  95     sal_Int32 BasicElementBase::getUid()
  96     {
  97         sal_Int32 nId = -1;
  98         if ( m_xImport.is() )
  99             nId = m_xImport->XMLNS_UID;
 100         return nId;
 101     }
 102
 103     Reference< xml::input::XAttributes > BasicElementBase::getAttributes()
 104     {
 105         return m_xAttributes;
 106     }
 107
 108     Reference< xml::input::XElement > BasicElementBase::startChildElement(
 109         sal_Int32 /*nUid*/, const OUString& /*rLocalName*/,
 110         const Reference< xml::input::XAttributes >& /*xAttributes*/ )
 111     {
 112         throw xml::sax::SAXException("unexpected element!", Reference< XInterface >(), Any() );
 113     }
 114
 115 void BasicElementBase::characters( const OUString& /*rChars*/ )
 116     {
 117         // not used, all characters ignored
 118     }
 119
 120 void BasicElementBase::ignorableWhitespace( const OUString& /*rWhitespaces*/ )
 121     {
 122     }
 123
 124 void BasicElementBase::processingInstruction( const OUString& /*rTarget*/, const OUString& /*rData*/ )
 125     {
 126     }
 127
 128     void BasicElementBase::endElement()
 129     {
 130     }
 131
 132     // BasicLibrariesElement
 133
 134     BasicLibrariesElement::BasicLibrariesElement( const OUString& rLocalName,
 135             const Reference< xml::input::XAttributes >& xAttributes,
 136             BasicImport* pImport,
 137             const Reference< script::XLibraryContainer2 >& rxLibContainer )
 138         :BasicElementBase( rLocalName, xAttributes, nullptr, pImport )
 139         ,m_xLibContainer( rxLibContainer )
 140     {
 141     }
 142
 143     // XElement
 144
 145     Reference< xml::input::XElement > BasicLibrariesElement::startChildElement(
 146             sal_Int32 nUid, const OUString& rLocalName,
 147             const Reference< xml::input::XAttributes >& xAttributes )
 148     {
 149         Reference< xml::input::XElement > xElement;
 150
 151         if ( nUid != m_xImport->XMLNS_UID )
 152         {
 153             throw xml::sax::SAXException( "illegal namespace!", Reference< XInterface >(), Any() );
 154         }
 155         else if ( rLocalName == "library-linked" )
 156         {
 157             if ( xAttributes.is() )
 158             {
 159                 OUString aName = xAttributes->getValueByUidName( m_xImport->XMLNS_UID, "name" );
 160
 161                 OUString aStorageURL = xAttributes->getValueByUidName(m_xImport->XMLNS_XLINK_UID, "href" );
 162
 163                 bool bReadOnly = false;
 164                 getBoolAttr( &bReadOnly,"readonly", xAttributes, m_xImport->XMLNS_UID );
 165
 166                 if ( m_xLibContainer.is() )
 167                 {
 168                     try
 169                     {
 170                         Reference< container::XNameAccess > xLib(
 171                             m_xLibContainer->createLibraryLink( aName, aStorageURL, bReadOnly ) );
 172                         if ( xLib.is() )
 173                             xElement.set( new BasicElementBase( rLocalName, xAttributes, this, m_xImport.get() ) );
 174                     }
 175                     catch ( const container::ElementExistException& )
 176                     {
 177                         TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicLibrariesElement::startChildElement" );
 178                     }
 179                     catch ( const lang::IllegalArgumentException& )
 180                     {
 181                         TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicLibrariesElement::startChildElement" );
 182                     }
 183                 }
 184             }
 185         }
 186         else if ( rLocalName == "library-embedded" )
 187         {
 188             // TODO: create password protected libraries
 189
 190             if ( xAttributes.is() )
 191             {
 192                 OUString aName = xAttributes->getValueByUidName( m_xImport->XMLNS_UID, "name" );
 193
 194                 bool bReadOnly = false;
 195                 getBoolAttr( &bReadOnly, "readonly", xAttributes, m_xImport->XMLNS_UID );
 196
 197                 if ( m_xLibContainer.is() )
 198                 {
 199                     try
 200                     {
 201                         Reference< container::XNameContainer > xLib;
 202                         if ( m_xLibContainer->hasByName( aName ) )
 203                         {
 204                             // Standard library
 205                             m_xLibContainer->getByName( aName ) >>= xLib;
 206                         }
 207                         else
 208                         {
 209                             xLib.set( m_xLibContainer->createLibrary( aName ) );
 210                         }
 211
 212                         if ( xLib.is() )
 213                             xElement.set( new BasicEmbeddedLibraryElement( rLocalName, xAttributes, this, m_xImport.get(), m_xLibContainer, aName, bReadOnly ) );
 214                     }
 215                     catch ( const lang::IllegalArgumentException& )
 216                     {
 217                         TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicLibrariesElement::startChildElement" );
 218                     }
 219                 }
 220             }
 221         }
 222         else
 223         {
 224             throw xml::sax::SAXException( "expected library-linked or library-embedded element!", Reference< XInterface >(), Any() );
 225         }
 226
 227         return xElement;
 228     }
 229
 230     void BasicLibrariesElement::endElement()
 231     {
 232     }
 233
 234     // BasicEmbeddedLibraryElement
 235
 236     BasicEmbeddedLibraryElement::BasicEmbeddedLibraryElement( const OUString& rLocalName,
 237             const Reference< xml::input::XAttributes >& xAttributes,
 238             BasicElementBase* pParent, BasicImport* pImport,
 239             const Reference< script::XLibraryContainer2 >& rxLibContainer,
 240             const OUString& rLibName, bool bReadOnly )
 241         :BasicElementBase( rLocalName, xAttributes, pParent, pImport )
 242         ,m_xLibContainer( rxLibContainer )
 243         ,m_aLibName( rLibName )
 244         ,m_bReadOnly( bReadOnly )
 245     {
 246         try
 247         {
 248             if ( m_xLibContainer.is() && m_xLibContainer->hasByName( m_aLibName ) )
 249                 m_xLibContainer->getByName( m_aLibName ) >>= m_xLib;
 250         }
 251         catch ( const lang::WrappedTargetException& )
 252         {
 253             TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicEmbeddedLibraryElement::CTOR:" );
 254         }
 255     }
 256
 257     // XElement
 258
 259     Reference< xml::input::XElement > BasicEmbeddedLibraryElement::startChildElement(
 260             sal_Int32 nUid, const OUString& rLocalName,
 261             const Reference< xml::input::XAttributes >& xAttributes )
 262     {
 263         Reference< xml::input::XElement > xElement;
 264
 265         if ( nUid != m_xImport->XMLNS_UID )
 266         {
 267             throw xml::sax::SAXException( "illegal namespace!", Reference< XInterface >(), Any() );
 268         }
 269         else if ( rLocalName == "module" )
 270         {
 271             if ( xAttributes.is() )
 272             {
 273                 OUString aName = xAttributes->getValueByUidName(m_xImport->XMLNS_UID, "name" );
 274
 275                 if ( m_xLib.is() && !aName.isEmpty() )
 276                     xElement.set( new BasicModuleElement( rLocalName, xAttributes, this, m_xImport.get(), m_xLib, aName ) );
 277             }
 278         }
 279         else
 280         {
 281             throw xml::sax::SAXException( "expected module element!", Reference< XInterface >(), Any() );
 282         }
 283
 284         return xElement;
 285     }
 286
 287     void BasicEmbeddedLibraryElement::endElement()
 288     {
 289         if ( m_xLibContainer.is() && m_xLibContainer->hasByName( m_aLibName ) && m_bReadOnly )
 290             m_xLibContainer->setLibraryReadOnly( m_aLibName, m_bReadOnly );
 291     }
 292
 293     // BasicModuleElement
 294
 295     BasicModuleElement::BasicModuleElement( const OUString& rLocalName,
 296             const Reference< xml::input::XAttributes >& xAttributes,
 297             BasicElementBase* pParent, BasicImport* pImport,
 298             const Reference< container::XNameContainer >& rxLib, const OUString& rName )
 299         :BasicElementBase( rLocalName, xAttributes, pParent, pImport )
 300         ,m_xLib( rxLib )
 301         ,m_aName( rName )
 302     {
 303     }
 304
 305     // XElement
 306
 307     Reference< xml::input::XElement > BasicModuleElement::startChildElement(
 308             sal_Int32 nUid, const OUString& rLocalName,
 309             const Reference< xml::input::XAttributes >& xAttributes )
 310     {
 311         // TODO: <byte-code>
 312
 313         Reference< xml::input::XElement > xElement;
 314
 315         if ( nUid != m_xImport->XMLNS_UID )
 316         {
 317             throw xml::sax::SAXException( "illegal namespace!", Reference< XInterface >(), Any() );
 318         }
 319         else if ( rLocalName == "source-code" )
 320         {
 321             // TODO: password protected libraries
 322
 323             if ( xAttributes.is() )
 324             {
 325                 if ( m_xLib.is() && !m_aName.isEmpty() )
 326                     xElement.set( new BasicSourceCodeElement( rLocalName, xAttributes, this, m_xImport.get(), m_xLib, m_aName ) );
 327             }
 328         }
 329         else
 330         {
 331             throw xml::sax::SAXException( "expected source-code element!", Reference< XInterface >(), Any() );
 332         }
 333
 334         return xElement;
 335     }
 336
 337     void BasicModuleElement::endElement()
 338     {
 339     }
 340
 341     // BasicSourceCodeElement
 342
 343     BasicSourceCodeElement::BasicSourceCodeElement( const OUString& rLocalName,
 344             const Reference< xml::input::XAttributes >& xAttributes,
 345             BasicElementBase* pParent, BasicImport* pImport,
 346             const Reference< container::XNameContainer >& rxLib, const OUString& rName )
 347         :BasicElementBase( rLocalName, xAttributes, pParent, pImport )
 348         ,m_xLib( rxLib )
 349         ,m_aName( rName )
 350     {
 351     }
 352
 353     // XElement
 354
 355     void BasicSourceCodeElement::characters( const OUString& rChars )
 356     {
 357         m_aBuffer.append( rChars );
 358     }
 359
 360     void BasicSourceCodeElement::endElement()
 361     {
 362         try
 363         {
 364             if ( m_xLib.is() && !m_aName.isEmpty() )
 365             {
 366                 Any aElement;
 367                 aElement <<= m_aBuffer.makeStringAndClear();
 368                 m_xLib->insertByName( m_aName, aElement );
 369             }
 370         }
 371         catch ( const container::ElementExistException& )
 372         {
 373             TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicSourceCodeElement::endElement" );
 374         }
 375         catch ( const lang::IllegalArgumentException& )
 376         {
 377             TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicSourceCodeElement::endElement" );
 378         }
 379         catch ( const lang::WrappedTargetException& )
 380         {
 381             TOOLS_INFO_EXCEPTION("xmlscript.xmlflat", "BasicSourceCodeElement::endElement" );
 382         }
 383     }
 384
 385     // BasicImport
 386
 387     BasicImport::BasicImport( const Reference< frame::XModel >& rxModel, bool bOasis )
 388         : XMLNS_UID(0)
 389         , XMLNS_XLINK_UID(0)
 390         , m_xModel(rxModel)
 391         , m_bOasis(bOasis)
 392     {
 393     }
 394
 395     BasicImport::~BasicImport()
 396     {
 397     }
 398
 399     // XRoot
 400
 401     void BasicImport::startDocument( const Reference< xml::input::XNamespaceMapping >& xNamespaceMapping )
 402     {
 403         if ( xNamespaceMapping.is() )
 404         {
 405             OUString aURI;
 406             if ( m_bOasis )
 407                 aURI = XMLNS_OOO_URI;
 408             else
 409                 aURI = XMLNS_SCRIPT_URI;
 410             XMLNS_UID = xNamespaceMapping->getUidByUri( aURI );
 411             XMLNS_XLINK_UID = xNamespaceMapping->getUidByUri( XMLNS_XLINK_URI );
 412         }
 413     }
 414
 415     void BasicImport::endDocument()
 416     {
 417     }
 418
 419 void BasicImport::processingInstruction( const OUString& /*rTarget*/, const OUString& /*rData*/ )
 420     {
 421     }
 422
 423 void BasicImport::setDocumentLocator( const Reference< xml::sax::XLocator >& /*xLocator*/ )
 424     {
 425     }
 426
 427     Reference< xml::input::XElement > BasicImport::startRootElement( sal_Int32 nUid, const OUString& rLocalName,
 428             Reference< xml::input::XAttributes > const & xAttributes )
 429     {
 430         Reference< xml::input::XElement > xElement;
 431
 432         if ( nUid != XMLNS_UID )
 433         {
 434             throw xml::sax::SAXException( "illegal namespace!", Reference< XInterface >(), Any() );
 435         }
 436         else if ( rLocalName == "libraries" )
 437         {
 438             Reference< script::XLibraryContainer2 > xLibContainer;
 439
 440             // try the XEmbeddedScripts interface
 441             Reference< document::XEmbeddedScripts > xDocumentScripts( m_xModel, UNO_QUERY );
 442             if ( xDocumentScripts.is() )
 443                 xLibContainer.set( xDocumentScripts->getBasicLibraries().get() );
 444
 445             if ( !xLibContainer.is() )
 446             {
 447                 // try the "BasicLibraries" property (old-style, for compatibility)
 448                 Reference< beans::XPropertySet > xPSet( m_xModel, UNO_QUERY );
 449                 if ( xPSet.is() )
 450                     xPSet->getPropertyValue("BasicLibraries" ) >>= xLibContainer;
 451             }
 452
 453             SAL_WARN_IF( !xLibContainer.is(), "xmlscript.xmlflat", "BasicImport::startRootElement: nowhere to import to!" );
 454
 455             if ( xLibContainer.is() )
 456             {
 457                 xElement.set( new BasicLibrariesElement( rLocalName, xAttributes, this, xLibContainer ) );
 458             }
 459         }
 460         else
 461         {
 462             throw xml::sax::SAXException("illegal root element (expected libraries) given: " + rLocalName, Reference< XInterface >(), Any() );
 463         }
 464
 465         return xElement;
 466     }
 467
 468     // XMLBasicImporterBase
 469
 470     XMLBasicImporterBase::XMLBasicImporterBase( const Reference< XComponentContext >& rxContext, bool bOasis )
 471         :m_xContext( rxContext )
 472         ,m_bOasis( bOasis )
 473     {
 474     }
 475
 476     XMLBasicImporterBase::~XMLBasicImporterBase()
 477     {
 478     }
 479
 480     // XServiceInfo
 481     sal_Bool XMLBasicImporterBase::supportsService( const OUString& rServiceName )
 482     {
 483         return cppu::supportsService(this, rServiceName);
 484     }
 485
 486     // XImporter
 487     void XMLBasicImporterBase::setTargetDocument( const Reference< XComponent >& rxDoc )
 488     {
 489         ::osl::MutexGuard aGuard( m_aMutex );
 490
 491         m_xModel.set( rxDoc, UNO_QUERY );
 492
 493         if ( !m_xModel.is() )
 494         {
 495             throw IllegalArgumentException( "XMLBasicExporter::setTargetDocument: no document model!", Reference< XInterface >(), 1 );
 496         }
 497
 498         if ( m_xContext.is() )
 499         {
 500             Reference< XMultiComponentFactory > xSMgr( m_xContext->getServiceManager() );
 501             if ( xSMgr.is() )
 502             {
 503                 Reference < xml::input::XRoot > xRoot( new BasicImport( m_xModel, m_bOasis ) );
 504                 Sequence < Any > aArgs( 1 );
 505                 aArgs[0] <<= xRoot;
 506                 m_xHandler.set( xSMgr->createInstanceWithArgumentsAndContext("com.sun.star.xml.input.SaxDocumentHandler", aArgs, m_xContext ), UNO_QUERY );
 507             }
 508         }
 509     }
 510
 511     // XDocumentHandler
 512
 513     void XMLBasicImporterBase::startDocument()
 514     {
 515         ::osl::MutexGuard aGuard( m_aMutex );
 516
 517         if ( m_xHandler.is() )
 518             m_xHandler->startDocument();
 519     }
 520
 521     void XMLBasicImporterBase::endDocument()
 522     {
 523         ::osl::MutexGuard aGuard( m_aMutex );
 524
 525         if ( m_xHandler.is() )
 526             m_xHandler->endDocument();
 527     }
 528
 529     void XMLBasicImporterBase::startElement( const OUString& aName,
 530             const Reference< xml::sax::XAttributeList >& xAttribs )
 531     {
 532         ::osl::MutexGuard aGuard( m_aMutex );
 533
 534         if ( m_xHandler.is() )
 535             m_xHandler->startElement( aName, xAttribs );
 536     }
 537
 538     void XMLBasicImporterBase::endElement( const OUString& aName )
 539     {
 540         ::osl::MutexGuard aGuard( m_aMutex );
 541
 542         if ( m_xHandler.is() )
 543             m_xHandler->endElement( aName );
 544     }
 545
 546     void XMLBasicImporterBase::characters( const OUString& aChars )
 547     {
 548         ::osl::MutexGuard aGuard( m_aMutex );
 549
 550         if ( m_xHandler.is() )
 551             m_xHandler->characters( aChars );
 552     }
 553
 554     void XMLBasicImporterBase::ignorableWhitespace( const OUString& aWhitespaces )
 555     {
 556         ::osl::MutexGuard aGuard( m_aMutex );
 557
 558         if ( m_xHandler.is() )
 559             m_xHandler->ignorableWhitespace( aWhitespaces );
 560     }
 561
 562     void XMLBasicImporterBase::processingInstruction( const OUString& aTarget,
 563             const OUString& aData )
 564     {
 565         ::osl::MutexGuard aGuard( m_aMutex );
 566
 567         if ( m_xHandler.is() )
 568             m_xHandler->processingInstruction( aTarget, aData );
 569     }
 570
 571     void XMLBasicImporterBase::setDocumentLocator( const Reference< xml::sax::XLocator >& xLocator )
 572     {
 573         ::osl::MutexGuard aGuard( m_aMutex );
 574
 575         if ( m_xHandler.is() )
 576             m_xHandler->setDocumentLocator( xLocator );
 577     }
 578
 579     // XMLBasicImporter
 580
 581     XMLBasicImporter::XMLBasicImporter( const Reference< XComponentContext >& rxContext )
 582         :XMLBasicImporterBase( rxContext, false )
 583     {
 584     }
 585
 586     XMLBasicImporter::~XMLBasicImporter()
 587     {
 588     }
 589
 590     // XServiceInfo
 591
 592     OUString XMLBasicImporter::getImplementationName(  )
 593     {
 594         return "com.sun.star.comp.xmlscript.XMLBasicImporter";
 595     }
 596
 597     Sequence< OUString > XMLBasicImporter::getSupportedServiceNames(  )
 598     {
 599         Sequence< OUString > aNames { "com.sun.star.document.XMLBasicImporter" };
 600         return aNames;
 601     }
 602
 603     // XMLOasisBasicImporter
 604
 605     XMLOasisBasicImporter::XMLOasisBasicImporter( const Reference< XComponentContext >& rxContext )
 606         :XMLBasicImporterBase( rxContext, true )
 607     {
 608     }
 609
 610     XMLOasisBasicImporter::~XMLOasisBasicImporter()
 611     {
 612     }
 613
 614     // XServiceInfo
 615
 616     OUString XMLOasisBasicImporter::getImplementationName(  )
 617     {
 618         return "com.sun.star.comp.xmlscript.XMLOasisBasicImporter";
 619     }
 620
 621     Sequence< OUString > XMLOasisBasicImporter::getSupportedServiceNames(  )
 622     {
 623         Sequence< OUString > aNames { "com.sun.star.document.XMLOasisBasicImporter" };
 624         return aNames;
 625     }
 626
 627 }   // namespace xmlscript
 628
 629 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 630 com_sun_star_comp_xmlscript_XMLBasicImporter(
 631     css::uno::XComponentContext *context,
 632     css::uno::Sequence<css::uno::Any> const &)
 633 {
 634     return cppu::acquire(new xmlscript::XMLBasicImporter(context));
 635 }
 636
 637 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface *
 638 com_sun_star_comp_xmlscript_XMLOasisBasicImporter(
 639     css::uno::XComponentContext *context,
 640     css::uno::Sequence<css::uno::Any> const &)
 641 {
 642     return cppu::acquire(new xmlscript::XMLOasisBasicImporter(context));
 643 }
 644
 645 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */