xmlscript/source/xmlflat_imexp/xmlbas_import.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: xmlbas_import.cxx,v $
  10  * $Revision: 1.6.10.1 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_xmlscript.hxx"
  33 #include "xmlbas_import.hxx"
  34 #include "xmlscript/xmlns.h"
  35 #include "xmlscript/xml_helper.hxx"
  36 #include <com/sun/star/beans/XPropertySet.hpp>
  37 #include <com/sun/star/lang/XMultiComponentFactory.hpp>
  38 #include <com/sun/star/script/XLibraryContainerPassword.hpp>
  39 #include <com/sun/star/document/XEmbeddedScripts.hpp>
  40 #include <cppuhelper/implementationentry.hxx>
  41
  42 using namespace ::com::sun::star;
  43 using namespace ::com::sun::star::lang;
  44 using namespace ::com::sun::star::uno;
  45
  46
  47 //.........................................................................
  48 namespace xmlscript
  49 {
  50 //.........................................................................
  51
  52     // =============================================================================
  53     // BasicElementBase
  54     // =============================================================================
  55
  56     BasicElementBase::BasicElementBase( const ::rtl::OUString& rLocalName,
  57             const Reference< xml::input::XAttributes >& xAttributes,
  58             BasicElementBase* pParent, BasicImport* pImport )
  59         :m_pImport( pImport )
  60         ,m_pParent( pParent )
  61         ,m_aLocalName( rLocalName )
  62         ,m_xAttributes( xAttributes )
  63     {
  64         if ( m_pImport )
  65             m_pImport->acquire();
  66         if ( m_pParent )
  67             m_pParent->acquire();
  68     }
  69
  70     // -----------------------------------------------------------------------------
  71
  72     BasicElementBase::~BasicElementBase()
  73     {
  74         if ( m_pImport )
  75             m_pImport->release();
  76         if ( m_pParent )
  77             m_pParent->release();
  78     }
  79
  80     // -----------------------------------------------------------------------------
  81
  82     bool BasicElementBase::getBoolAttr( sal_Bool* pRet, const ::rtl::OUString& rAttrName,
  83         const ::com::sun::star::uno::Reference< ::com::sun::star::xml::input::XAttributes >& xAttributes,
  84         sal_Int32 nUid )
  85     {
  86         if ( xAttributes.is() )
  87         {
  88             ::rtl::OUString aValue( xAttributes->getValueByUidName( nUid, rAttrName ) );
  89             if ( aValue.getLength() )
  90             {
  91                 if ( aValue.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "true" ) ) )
  92                 {
  93                     *pRet = sal_True;
  94                     return true;
  95                 }
  96                 else if ( aValue.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "false" ) ) )
  97                 {
  98                     *pRet = sal_False;
  99                     return true;
 100                 }
 101                 else
 102                 {
 103                     throw xml::sax::SAXException(
 104                         rAttrName + ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ": no boolean value (true|false)!" ) ),
 105                         Reference< XInterface >(), Any() );
 106                 }
 107             }
 108         }
 109         return false;
 110     }
 111
 112     // -----------------------------------------------------------------------------
 113     // XElement
 114     // -----------------------------------------------------------------------------
 115
 116     Reference< xml::input::XElement > BasicElementBase::getParent()
 117         throw (RuntimeException)
 118     {
 119         return static_cast< xml::input::XElement* >( m_pParent );
 120     }
 121
 122     // -----------------------------------------------------------------------------
 123
 124     ::rtl::OUString BasicElementBase::getLocalName()
 125         throw (RuntimeException)
 126     {
 127         return m_aLocalName;
 128     }
 129
 130     // -----------------------------------------------------------------------------
 131
 132     sal_Int32 BasicElementBase::getUid()
 133         throw (RuntimeException)
 134     {
 135         sal_Int32 nId = -1;
 136         if ( m_pImport )
 137             nId = m_pImport->XMLNS_UID;
 138         return nId;
 139     }
 140
 141     // -----------------------------------------------------------------------------
 142
 143     Reference< xml::input::XAttributes > BasicElementBase::getAttributes()
 144         throw (RuntimeException)
 145     {
 146         return m_xAttributes;
 147     }
 148
 149     // -----------------------------------------------------------------------------
 150
 151     Reference< xml::input::XElement > BasicElementBase::startChildElement(
 152         sal_Int32 /*nUid*/, const ::rtl::OUString& /*rLocalName*/,
 153         const Reference< xml::input::XAttributes >& /*xAttributes*/ )
 154         throw (xml::sax::SAXException, RuntimeException)
 155     {
 156         throw xml::sax::SAXException(
 157             ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "unexpected element!" ) ),
 158             Reference< XInterface >(), Any() );
 159     }
 160
 161     // -----------------------------------------------------------------------------
 162
 163 void BasicElementBase::characters( const ::rtl::OUString& /*rChars*/ )
 164         throw (xml::sax::SAXException, RuntimeException)
 165     {
 166         // not used, all characters ignored
 167     }
 168
 169     // -----------------------------------------------------------------------------
 170
 171 void BasicElementBase::ignorableWhitespace( const ::rtl::OUString& /*rWhitespaces*/ )
 172         throw (xml::sax::SAXException, RuntimeException)
 173     {
 174     }
 175
 176     // -----------------------------------------------------------------------------
 177
 178 void BasicElementBase::processingInstruction( const ::rtl::OUString& /*rTarget*/, const ::rtl::OUString& /*rData*/ )
 179         throw (xml::sax::SAXException, RuntimeException)
 180     {
 181     }
 182
 183     // -----------------------------------------------------------------------------
 184
 185     void BasicElementBase::endElement()
 186         throw (xml::sax::SAXException, RuntimeException)
 187     {
 188     }
 189
 190
 191     // =============================================================================
 192     // BasicLibrariesElement
 193     // =============================================================================
 194
 195     BasicLibrariesElement::BasicLibrariesElement( const ::rtl::OUString& rLocalName,
 196             const Reference< xml::input::XAttributes >& xAttributes,
 197             BasicElementBase* pParent, BasicImport* pImport,
 198             const Reference< script::XLibraryContainer2 >& rxLibContainer )
 199         :BasicElementBase( rLocalName, xAttributes, pParent, pImport )
 200         ,m_xLibContainer( rxLibContainer )
 201     {
 202     }
 203
 204     // -----------------------------------------------------------------------------
 205     // XElement
 206     // -----------------------------------------------------------------------------
 207
 208     Reference< xml::input::XElement > BasicLibrariesElement::startChildElement(
 209             sal_Int32 nUid, const ::rtl::OUString& rLocalName,
 210             const Reference< xml::input::XAttributes >& xAttributes )
 211         throw (xml::sax::SAXException, RuntimeException)
 212     {
 213         Reference< xml::input::XElement > xElement;
 214
 215         if ( nUid != m_pImport->XMLNS_UID )
 216         {
 217             throw xml::sax::SAXException(
 218                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "illegal namespace!" ) ),
 219                 Reference< XInterface >(), Any() );
 220         }
 221         else if ( rLocalName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "library-linked" ) ) )
 222         {
 223             if ( xAttributes.is() )
 224             {
 225                 ::rtl::OUString aName = xAttributes->getValueByUidName(
 226                     m_pImport->XMLNS_UID,
 227                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "name" ) ) );
 228
 229                 ::rtl::OUString aStorageURL = xAttributes->getValueByUidName(
 230                     m_pImport->XMLNS_XLINK_UID,
 231                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "href" ) ) );
 232
 233                 sal_Bool bReadOnly = sal_False;
 234                 getBoolAttr( &bReadOnly,
 235                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "readonly" ) ),
 236                     xAttributes, m_pImport->XMLNS_UID );
 237
 238                 if ( m_xLibContainer.is() )
 239                 {
 240                     try
 241                     {
 242                         Reference< container::XNameAccess > xLib(
 243                             m_xLibContainer->createLibraryLink( aName, aStorageURL, bReadOnly ) );
 244                         if ( xLib.is() )
 245                             xElement.set( new BasicElementBase( rLocalName, xAttributes, this, m_pImport ) );
 246                     }
 247                     catch ( container::ElementExistException& e )
 248                     {
 249                         OSL_TRACE( "BasicLibrariesElement::startChildElement: caught ElementExceptionExist reason %s",
 250                             ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
 251                     }
 252                     catch ( lang::IllegalArgumentException& e )
 253                     {
 254                         OSL_TRACE( "BasicLibrariesElement::startChildElement: caught IllegalArgumentException reason %s",
 255                             ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
 256                     }
 257                 }
 258             }
 259         }
 260         else if ( rLocalName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "library-embedded" ) ) )
 261         {
 262             // TODO: create password protected libraries
 263
 264             if ( xAttributes.is() )
 265             {
 266                 ::rtl::OUString aName = xAttributes->getValueByUidName(
 267                     m_pImport->XMLNS_UID,
 268                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "name" ) ) );
 269
 270                 sal_Bool bReadOnly = sal_False;
 271                 getBoolAttr( &bReadOnly,
 272                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "readonly" ) ),
 273                     xAttributes, m_pImport->XMLNS_UID );
 274
 275                 if ( m_xLibContainer.is() )
 276                 {
 277                     try
 278                     {
 279                         Reference< container::XNameContainer > xLib;
 280                         if ( m_xLibContainer->hasByName( aName ) )
 281                         {
 282                             // Standard library
 283                             m_xLibContainer->getByName( aName ) >>= xLib;
 284                         }
 285                         else
 286                         {
 287                             xLib.set( m_xLibContainer->createLibrary( aName ) );
 288                         }
 289
 290                         if ( xLib.is() )
 291                             xElement.set( new BasicEmbeddedLibraryElement( rLocalName, xAttributes, this, m_pImport, m_xLibContainer, aName, bReadOnly ) );
 292                     }
 293                     catch ( lang::IllegalArgumentException& e )
 294                     {
 295                         OSL_TRACE( "BasicLibrariesElement::startChildElement: caught IllegalArgumentException reason %s",
 296                             ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
 297                     }
 298                 }
 299             }
 300         }
 301         else
 302         {
 303             throw xml::sax::SAXException(
 304                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "expected library-linked or library-embedded element!" ) ),
 305                 Reference< XInterface >(), Any() );
 306         }
 307
 308         return xElement;
 309     }
 310
 311     // -----------------------------------------------------------------------------
 312
 313     void BasicLibrariesElement::endElement()
 314         throw (xml::sax::SAXException, RuntimeException)
 315     {
 316     }
 317
 318
 319     // =============================================================================
 320     // BasicEmbeddedLibraryElement
 321     // =============================================================================
 322
 323     BasicEmbeddedLibraryElement::BasicEmbeddedLibraryElement( const ::rtl::OUString& rLocalName,
 324             const Reference< xml::input::XAttributes >& xAttributes,
 325             BasicElementBase* pParent, BasicImport* pImport,
 326             const Reference< script::XLibraryContainer2 >& rxLibContainer,
 327             const ::rtl::OUString& rLibName, bool bReadOnly )
 328         :BasicElementBase( rLocalName, xAttributes, pParent, pImport )
 329         ,m_xLibContainer( rxLibContainer )
 330         ,m_aLibName( rLibName )
 331         ,m_bReadOnly( bReadOnly )
 332     {
 333         try
 334         {
 335             if ( m_xLibContainer.is() && m_xLibContainer->hasByName( m_aLibName ) )
 336                 m_xLibContainer->getByName( m_aLibName ) >>= m_xLib;
 337         }
 338         catch ( lang::WrappedTargetException& e )
 339         {
 340             OSL_TRACE( "BasicEmbeddedLibraryElement CTOR: caught WrappedTargetException reason %s",
 341                 ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
 342         }
 343     }
 344
 345     // -----------------------------------------------------------------------------
 346     // XElement
 347     // -----------------------------------------------------------------------------
 348
 349     Reference< xml::input::XElement > BasicEmbeddedLibraryElement::startChildElement(
 350             sal_Int32 nUid, const ::rtl::OUString& rLocalName,
 351             const Reference< xml::input::XAttributes >& xAttributes )
 352         throw (xml::sax::SAXException, RuntimeException)
 353     {
 354         Reference< xml::input::XElement > xElement;
 355
 356         if ( nUid != m_pImport->XMLNS_UID )
 357         {
 358             throw xml::sax::SAXException(
 359                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "illegal namespace!" ) ),
 360                 Reference< XInterface >(), Any() );
 361         }
 362         else if ( rLocalName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "module" ) ) )
 363         {
 364             if ( xAttributes.is() )
 365             {
 366                 ::rtl::OUString aName = xAttributes->getValueByUidName(
 367                     m_pImport->XMLNS_UID,
 368                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "name" ) ) );
 369
 370                 if ( m_xLib.is() && aName.getLength() )
 371                     xElement.set( new BasicModuleElement( rLocalName, xAttributes, this, m_pImport, m_xLib, aName ) );
 372             }
 373         }
 374         else
 375         {
 376             throw xml::sax::SAXException(
 377                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "expected module element!" ) ),
 378                 Reference< XInterface >(), Any() );
 379         }
 380
 381         return xElement;
 382     }
 383
 384     // -----------------------------------------------------------------------------
 385
 386     void BasicEmbeddedLibraryElement::endElement()
 387         throw (xml::sax::SAXException, RuntimeException)
 388     {
 389         if ( m_xLibContainer.is() && m_xLibContainer->hasByName( m_aLibName ) && m_bReadOnly )
 390             m_xLibContainer->setLibraryReadOnly( m_aLibName, m_bReadOnly );
 391     }
 392
 393
 394     // =============================================================================
 395     // BasicModuleElement
 396     // =============================================================================
 397
 398     BasicModuleElement::BasicModuleElement( const ::rtl::OUString& rLocalName,
 399             const Reference< xml::input::XAttributes >& xAttributes,
 400             BasicElementBase* pParent, BasicImport* pImport,
 401             const Reference< container::XNameContainer >& rxLib, const ::rtl::OUString& rName )
 402         :BasicElementBase( rLocalName, xAttributes, pParent, pImport )
 403         ,m_xLib( rxLib )
 404         ,m_aName( rName )
 405     {
 406     }
 407
 408     // -----------------------------------------------------------------------------
 409     // XElement
 410     // -----------------------------------------------------------------------------
 411
 412     Reference< xml::input::XElement > BasicModuleElement::startChildElement(
 413             sal_Int32 nUid, const ::rtl::OUString& rLocalName,
 414             const Reference< xml::input::XAttributes >& xAttributes )
 415         throw (xml::sax::SAXException, RuntimeException)
 416     {
 417         // TODO: <byte-code>
 418
 419         Reference< xml::input::XElement > xElement;
 420
 421         if ( nUid != m_pImport->XMLNS_UID )
 422         {
 423             throw xml::sax::SAXException(
 424                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "illegal namespace!" ) ),
 425                 Reference< XInterface >(), Any() );
 426         }
 427         else if ( rLocalName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "source-code" ) ) )
 428         {
 429             // TODO: password protected libraries
 430
 431             if ( xAttributes.is() )
 432             {
 433                 if ( m_xLib.is() && m_aName.getLength() )
 434                     xElement.set( new BasicSourceCodeElement( rLocalName, xAttributes, this, m_pImport, m_xLib, m_aName ) );
 435             }
 436         }
 437         else
 438         {
 439             throw xml::sax::SAXException(
 440                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "expected source-code element!" ) ),
 441                 Reference< XInterface >(), Any() );
 442         }
 443
 444         return xElement;
 445     }
 446
 447     // -----------------------------------------------------------------------------
 448
 449     void BasicModuleElement::endElement()
 450         throw (xml::sax::SAXException, RuntimeException)
 451     {
 452     }
 453
 454
 455     // =============================================================================
 456     // BasicSourceCodeElement
 457     // =============================================================================
 458
 459     BasicSourceCodeElement::BasicSourceCodeElement( const ::rtl::OUString& rLocalName,
 460             const Reference< xml::input::XAttributes >& xAttributes,
 461             BasicElementBase* pParent, BasicImport* pImport,
 462             const Reference< container::XNameContainer >& rxLib, const ::rtl::OUString& rName )
 463         :BasicElementBase( rLocalName, xAttributes, pParent, pImport )
 464         ,m_xLib( rxLib )
 465         ,m_aName( rName )
 466     {
 467     }
 468
 469     // -----------------------------------------------------------------------------
 470     // XElement
 471     // -----------------------------------------------------------------------------
 472
 473     void BasicSourceCodeElement::characters( const ::rtl::OUString& rChars )
 474         throw (xml::sax::SAXException, RuntimeException)
 475     {
 476         m_aBuffer.append( rChars );
 477     }
 478
 479     // -----------------------------------------------------------------------------
 480
 481     void BasicSourceCodeElement::endElement()
 482         throw (xml::sax::SAXException, RuntimeException)
 483     {
 484         try
 485         {
 486             if ( m_xLib.is() && m_aName.getLength() )
 487             {
 488                 Any aElement;
 489                 aElement <<= m_aBuffer.makeStringAndClear();
 490                 m_xLib->insertByName( m_aName, aElement );
 491             }
 492         }
 493         catch ( container::ElementExistException& e )
 494         {
 495             OSL_TRACE( "BasicSourceCodeElement::endElement: caught ElementExceptionExist reason %s",
 496                 ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
 497         }
 498         catch ( lang::IllegalArgumentException& e )
 499         {
 500             OSL_TRACE( "BasicSourceCodeElement::endElement: caught IllegalArgumentException reason %s",
 501                 ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
 502         }
 503         catch ( lang::WrappedTargetException& e )
 504         {
 505             OSL_TRACE( "BasicSourceCodeElement::endElement: caught WrappedTargetException reason %s",
 506                 ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer );
 507         }
 508     }
 509
 510
 511     // =============================================================================
 512     // BasicImport
 513     // =============================================================================
 514
 515     BasicImport::BasicImport( const Reference< frame::XModel >& rxModel, sal_Bool bOasis )
 516         :m_xModel( rxModel )
 517         ,m_bOasis( bOasis )
 518     {
 519     }
 520
 521     // -----------------------------------------------------------------------------
 522
 523     BasicImport::~BasicImport()
 524     {
 525     }
 526
 527     // -----------------------------------------------------------------------------
 528     // XRoot
 529     // -----------------------------------------------------------------------------
 530
 531     void BasicImport::startDocument( const Reference< xml::input::XNamespaceMapping >& xNamespaceMapping )
 532         throw (xml::sax::SAXException, RuntimeException)
 533     {
 534         if ( xNamespaceMapping.is() )
 535         {
 536             ::rtl::OUString aURI;
 537             if ( m_bOasis )
 538                 aURI = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( XMLNS_OOO_URI ) );
 539             else
 540                 aURI = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( XMLNS_SCRIPT_URI ) );
 541             XMLNS_UID = xNamespaceMapping->getUidByUri( aURI );
 542             XMLNS_XLINK_UID = xNamespaceMapping->getUidByUri( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( XMLNS_XLINK_URI ) ) );
 543         }
 544     }
 545
 546     // -----------------------------------------------------------------------------
 547
 548     void BasicImport::endDocument()
 549         throw (xml::sax::SAXException, RuntimeException)
 550     {
 551     }
 552
 553     // -----------------------------------------------------------------------------
 554
 555 void BasicImport::processingInstruction( const ::rtl::OUString& /*rTarget*/, const ::rtl::OUString& /*rData*/ )
 556         throw (xml::sax::SAXException, RuntimeException)
 557     {
 558     }
 559
 560     // -----------------------------------------------------------------------------
 561
 562 void BasicImport::setDocumentLocator( const Reference< xml::sax::XLocator >& /*xLocator*/ )
 563         throw (xml::sax::SAXException, RuntimeException)
 564     {
 565     }
 566
 567     // -----------------------------------------------------------------------------
 568
 569     Reference< xml::input::XElement > BasicImport::startRootElement( sal_Int32 nUid, const ::rtl::OUString& rLocalName,
 570             Reference< xml::input::XAttributes > const & xAttributes )
 571         throw (xml::sax::SAXException, RuntimeException)
 572     {
 573         Reference< xml::input::XElement > xElement;
 574
 575         if ( nUid != XMLNS_UID )
 576         {
 577             throw xml::sax::SAXException(
 578                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "illegal namespace!" ) ),
 579                 Reference< XInterface >(), Any() );
 580         }
 581         else if ( rLocalName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "libraries" ) ) )
 582         {
 583             Reference< script::XLibraryContainer2 > xLibContainer;
 584
 585             // try the XEmbeddedScripts interface
 586             Reference< document::XEmbeddedScripts > xDocumentScripts( m_xModel, UNO_QUERY );
 587             if ( xDocumentScripts.is() )
 588                 xLibContainer.set( xDocumentScripts->getBasicLibraries().get() );
 589
 590             if ( !xLibContainer.is() )
 591             {
 592                 // try the "BasicLibraries" property (old-style, for compatibility)
 593                 Reference< beans::XPropertySet > xPSet( m_xModel, UNO_QUERY );
 594                 if ( xPSet.is() )
 595                     xPSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "BasicLibraries" ) ) ) >>= xLibContainer;
 596             }
 597
 598             OSL_ENSURE( xLibContainer.is(), "BasicImport::startRootElement: nowhere to import to!" );
 599
 600             if ( xLibContainer.is() )
 601             {
 602                 xElement.set( new BasicLibrariesElement( rLocalName, xAttributes, 0, this, xLibContainer ) );
 603             }
 604         }
 605         else
 606         {
 607             throw xml::sax::SAXException(
 608                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "illegal root element (expected libraries) given: " ) ) +
 609                 rLocalName, Reference< XInterface >(), Any() );
 610         }
 611
 612         return xElement;
 613     }
 614
 615
 616     // =============================================================================
 617     // component operations
 618     // =============================================================================
 619
 620     ::rtl::OUString getImplementationName_XMLBasicImporter()
 621     {
 622         static ::rtl::OUString* pImplName = 0;
 623         if ( !pImplName )
 624         {
 625             ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 626             if ( !pImplName )
 627             {
 628                 static ::rtl::OUString aImplName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.xmlscript.XMLBasicImporter" ) );
 629                 pImplName = &aImplName;
 630             }
 631         }
 632         return *pImplName;
 633     }
 634
 635     // -----------------------------------------------------------------------------
 636
 637     Sequence< ::rtl::OUString > getSupportedServiceNames_XMLBasicImporter()
 638     {
 639         static Sequence< ::rtl::OUString >* pNames = 0;
 640         if ( !pNames )
 641         {
 642             ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 643             if ( !pNames )
 644             {
 645                 static Sequence< ::rtl::OUString > aNames(1);
 646                 aNames.getArray()[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.document.XMLBasicImporter" ) );
 647                 pNames = &aNames;
 648             }
 649         }
 650         return *pNames;
 651     }
 652
 653     // -----------------------------------------------------------------------------
 654
 655     ::rtl::OUString getImplementationName_XMLOasisBasicImporter()
 656     {
 657         static ::rtl::OUString* pImplName = 0;
 658         if ( !pImplName )
 659         {
 660             ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 661             if ( !pImplName )
 662             {
 663                 static ::rtl::OUString aImplName( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.comp.xmlscript.XMLOasisBasicImporter" ) );
 664                 pImplName = &aImplName;
 665             }
 666         }
 667         return *pImplName;
 668     }
 669
 670     // -----------------------------------------------------------------------------
 671
 672     Sequence< ::rtl::OUString > getSupportedServiceNames_XMLOasisBasicImporter()
 673     {
 674         static Sequence< ::rtl::OUString >* pNames = 0;
 675         if ( !pNames )
 676         {
 677             ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
 678             if ( !pNames )
 679             {
 680                 static Sequence< ::rtl::OUString > aNames(1);
 681                 aNames.getArray()[0] = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.document.XMLOasisBasicImporter" ) );
 682                 pNames = &aNames;
 683             }
 684         }
 685         return *pNames;
 686     }
 687
 688
 689     // =============================================================================
 690     // XMLBasicImporterBase
 691     // =============================================================================
 692
 693     XMLBasicImporterBase::XMLBasicImporterBase( const Reference< XComponentContext >& rxContext, sal_Bool bOasis )
 694         :m_xContext( rxContext )
 695         ,m_bOasis( bOasis )
 696     {
 697     }
 698
 699     // -----------------------------------------------------------------------------
 700
 701     XMLBasicImporterBase::~XMLBasicImporterBase()
 702     {
 703     }
 704
 705     // -----------------------------------------------------------------------------
 706     // XServiceInfo
 707     // -----------------------------------------------------------------------------
 708
 709     sal_Bool XMLBasicImporterBase::supportsService( const ::rtl::OUString& rServiceName ) throw (RuntimeException)
 710     {
 711         Sequence< ::rtl::OUString > aNames( getSupportedServiceNames() );
 712         const ::rtl::OUString* pNames = aNames.getConstArray();
 713         const ::rtl::OUString* pEnd = pNames + aNames.getLength();
 714         for ( ; pNames != pEnd && !pNames->equals( rServiceName ); ++pNames )
 715             ;
 716
 717         return pNames != pEnd;
 718     }
 719
 720     // -----------------------------------------------------------------------------
 721     // XImporter
 722     // -----------------------------------------------------------------------------
 723
 724     void XMLBasicImporterBase::setTargetDocument( const Reference< XComponent >& rxDoc )
 725         throw (IllegalArgumentException, RuntimeException)
 726     {
 727         ::osl::MutexGuard aGuard( m_aMutex );
 728
 729         m_xModel.set( rxDoc, UNO_QUERY );
 730
 731         if ( !m_xModel.is() )
 732         {
 733             throw IllegalArgumentException(
 734                 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "XMLBasicExporter::setTargetDocument: no document model!" ) ),
 735                 Reference< XInterface >(), 1 );
 736         }
 737
 738         if ( m_xContext.is() )
 739         {
 740             Reference< XMultiComponentFactory > xSMgr( m_xContext->getServiceManager() );
 741             if ( xSMgr.is() )
 742             {
 743                 Reference < xml::input::XRoot > xRoot( new BasicImport( m_xModel, m_bOasis ) );
 744                 Sequence < Any > aArgs( 1 );
 745                 aArgs[0] <<= xRoot;
 746                 m_xHandler.set( xSMgr->createInstanceWithArgumentsAndContext(
 747                     ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.input.SaxDocumentHandler" ) ),
 748                     aArgs, m_xContext ), UNO_QUERY );
 749             }
 750         }
 751     }
 752
 753     // -----------------------------------------------------------------------------
 754     // XDocumentHandler
 755     // -----------------------------------------------------------------------------
 756
 757     void XMLBasicImporterBase::startDocument()
 758         throw (xml::sax::SAXException, RuntimeException)
 759     {
 760         ::osl::MutexGuard aGuard( m_aMutex );
 761
 762         if ( m_xHandler.is() )
 763             m_xHandler->startDocument();
 764     }
 765
 766     // -----------------------------------------------------------------------------
 767
 768     void XMLBasicImporterBase::endDocument()
 769         throw (xml::sax::SAXException, RuntimeException)
 770     {
 771         ::osl::MutexGuard aGuard( m_aMutex );
 772
 773         if ( m_xHandler.is() )
 774             m_xHandler->endDocument();
 775     }
 776
 777     // -----------------------------------------------------------------------------
 778
 779     void XMLBasicImporterBase::startElement( const ::rtl::OUString& aName,
 780             const Reference< xml::sax::XAttributeList >& xAttribs )
 781         throw (xml::sax::SAXException, RuntimeException)
 782     {
 783         ::osl::MutexGuard aGuard( m_aMutex );
 784
 785         if ( m_xHandler.is() )
 786             m_xHandler->startElement( aName, xAttribs );
 787     }
 788
 789     // -----------------------------------------------------------------------------
 790
 791     void XMLBasicImporterBase::endElement( const ::rtl::OUString& aName )
 792         throw (xml::sax::SAXException, RuntimeException)
 793     {
 794         ::osl::MutexGuard aGuard( m_aMutex );
 795
 796         if ( m_xHandler.is() )
 797             m_xHandler->endElement( aName );
 798     }
 799
 800     // -----------------------------------------------------------------------------
 801
 802     void XMLBasicImporterBase::characters( const ::rtl::OUString& aChars )
 803         throw (xml::sax::SAXException, RuntimeException)
 804     {
 805         ::osl::MutexGuard aGuard( m_aMutex );
 806
 807         if ( m_xHandler.is() )
 808             m_xHandler->characters( aChars );
 809     }
 810
 811     // -----------------------------------------------------------------------------
 812
 813     void XMLBasicImporterBase::ignorableWhitespace( const ::rtl::OUString& aWhitespaces )
 814         throw (xml::sax::SAXException, RuntimeException)
 815     {
 816         ::osl::MutexGuard aGuard( m_aMutex );
 817
 818         if ( m_xHandler.is() )
 819             m_xHandler->ignorableWhitespace( aWhitespaces );
 820     }
 821
 822     // -----------------------------------------------------------------------------
 823
 824     void XMLBasicImporterBase::processingInstruction( const ::rtl::OUString& aTarget,
 825             const ::rtl::OUString& aData )
 826         throw (xml::sax::SAXException, RuntimeException)
 827     {
 828         ::osl::MutexGuard aGuard( m_aMutex );
 829
 830         if ( m_xHandler.is() )
 831             m_xHandler->processingInstruction( aTarget, aData );
 832     }
 833
 834     // -----------------------------------------------------------------------------
 835
 836     void XMLBasicImporterBase::setDocumentLocator( const Reference< xml::sax::XLocator >& xLocator )
 837         throw (xml::sax::SAXException, RuntimeException)
 838     {
 839         ::osl::MutexGuard aGuard( m_aMutex );
 840
 841         if ( m_xHandler.is() )
 842             m_xHandler->setDocumentLocator( xLocator );
 843     }
 844
 845
 846     // =============================================================================
 847     // XMLBasicImporter
 848     // =============================================================================
 849
 850     XMLBasicImporter::XMLBasicImporter( const Reference< XComponentContext >& rxContext )
 851         :XMLBasicImporterBase( rxContext, sal_False )
 852     {
 853     }
 854
 855     // -----------------------------------------------------------------------------
 856
 857     XMLBasicImporter::~XMLBasicImporter()
 858     {
 859     }
 860
 861     // -----------------------------------------------------------------------------
 862     // XServiceInfo
 863     // -----------------------------------------------------------------------------
 864
 865     ::rtl::OUString XMLBasicImporter::getImplementationName(  ) throw (RuntimeException)
 866     {
 867         return getImplementationName_XMLBasicImporter();
 868     }
 869
 870     // -----------------------------------------------------------------------------
 871
 872     Sequence< ::rtl::OUString > XMLBasicImporter::getSupportedServiceNames(  ) throw (RuntimeException)
 873     {
 874         return getSupportedServiceNames_XMLBasicImporter();
 875     }
 876
 877
 878     // =============================================================================
 879     // XMLOasisBasicImporter
 880     // =============================================================================
 881
 882     XMLOasisBasicImporter::XMLOasisBasicImporter( const Reference< XComponentContext >& rxContext )
 883         :XMLBasicImporterBase( rxContext, sal_True )
 884     {
 885     }
 886
 887     // -----------------------------------------------------------------------------
 888
 889     XMLOasisBasicImporter::~XMLOasisBasicImporter()
 890     {
 891     }
 892
 893     // -----------------------------------------------------------------------------
 894     // XServiceInfo
 895     // -----------------------------------------------------------------------------
 896
 897     ::rtl::OUString XMLOasisBasicImporter::getImplementationName(  ) throw (RuntimeException)
 898     {
 899         return getImplementationName_XMLOasisBasicImporter();
 900     }
 901
 902     // -----------------------------------------------------------------------------
 903
 904     Sequence< ::rtl::OUString > XMLOasisBasicImporter::getSupportedServiceNames(  ) throw (RuntimeException)
 905     {
 906         return getSupportedServiceNames_XMLOasisBasicImporter();
 907     }
 908
 909
 910     // =============================================================================
 911     // component operations
 912     // =============================================================================
 913
 914     Reference< XInterface > SAL_CALL create_XMLBasicImporter(
 915         Reference< XComponentContext > const & xContext )
 916         SAL_THROW( () )
 917     {
 918         return static_cast< lang::XTypeProvider * >( new XMLBasicImporter( xContext ) );
 919     }
 920
 921     // -----------------------------------------------------------------------------
 922
 923     Reference< XInterface > SAL_CALL create_XMLOasisBasicImporter(
 924         Reference< XComponentContext > const & xContext )
 925         SAL_THROW( () )
 926     {
 927         return static_cast< lang::XTypeProvider * >( new XMLOasisBasicImporter( xContext ) );
 928     }
 929
 930     // -----------------------------------------------------------------------------
 931
 932 //.........................................................................
 933 }       // namespace xmlscript
 934 //.........................................................................