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