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