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_xmloff.hxx"
26 #include <com/sun/star/beans/XPropertySetInfo.hpp>
27 #include <tools/debug.hxx>
28 #include <tools/urlobj.hxx>
29 #include <osl/mutex.hxx>
30 #include <rtl/uuid.h>
31 #include <rtl/memory.h>
32 #include <svl/svarray.hxx>
33 #include "unointerfacetouniqueidentifiermapper.hxx"
34 #include <xmloff/nmspmap.hxx>
35 #include <xmloff/xmluconv.hxx>
36 #include "xmloff/xmlnmspe.hxx"
37 #include <xmloff/xmltoken.hxx>
38 #include <xmloff/XMLFontStylesContext.hxx>
39 #include <xmloff/xmlictxt.hxx>
40 #include <xmloff/xmlimp.hxx>
41 #include <xmloff/xmlnumfi.hxx>
42 #include "XMLEventImportHelper.hxx"
43 #include "XMLStarBasicContextFactory.hxx"
44 #include "XMLScriptContextFactory.hxx"
45 #include "StyleMap.hxx"
46 #include <xmloff/ProgressBarHelper.hxx>
47 #include <xmloff/xmltoken.hxx>
48 #include "xmloff/xmlerror.hxx"
49 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
50 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
51 #include <com/sun/star/io/XOutputStream.hpp>
52 #include <com/sun/star/document/XBinaryStreamResolver.hpp>
53 #include <com/sun/star/document/XStorageBasedDocument.hpp>
54 #include <com/sun/star/xml/sax/XLocator.hpp>
55 #include <com/sun/star/packages/zip/ZipIOException.hpp>
56 #include <comphelper/namecontainer.hxx>
57 #include <rtl/logfile.hxx>
58 #include <tools/string.hxx> // used in StartElement for logging
59 #include <cppuhelper/implbase1.hxx>
60 #include <comphelper/extract.hxx>
61 #include <comphelper/processfactory.hxx>
62 #include <comphelper/documentconstants.hxx>
63 #include <comphelper/storagehelper.hxx>
64 #include <unotools/fontcvt.hxx>
65
66 #include <com/sun/star/rdf/XMetadatable.hpp>
67 #include <com/sun/star/rdf/XRepositorySupplier.hpp>
68 #include "RDFaImportHelper.hxx"
69
70 #define LOGFILE_AUTHOR "unknown"
71
72 using ::com::sun::star::beans::XPropertySetInfo;
73
74 using ::rtl::OUString;
75 using ::rtl::OUStringBuffer;
76
77 using namespace ::osl;
78 using namespace ::com::sun::star;
79 using namespace ::com::sun::star::frame;
80 using namespace ::com::sun::star::uno;
81 using namespace ::com::sun::star::util;
82 using namespace ::com::sun::star::io;
83 using namespace ::com::sun::star::container;
84 using namespace ::com::sun::star::document;
85 using namespace ::xmloff::token;
86
87 sal_Char __READONLY_DATA sXML_np__office[] = "_office";
88 sal_Char __READONLY_DATA sXML_np__office_ext[] = "_office_ooo";
89 sal_Char __READONLY_DATA sXML_np__ooo[] = "_ooo";
90 sal_Char __READONLY_DATA sXML_np__ooow[] = "_ooow";
91 sal_Char __READONLY_DATA sXML_np__oooc[] = "_oooc";
92 sal_Char __READONLY_DATA sXML_np__of[] = "_of";
93 sal_Char __READONLY_DATA sXML_np__style[] = "_style";
94 sal_Char __READONLY_DATA sXML_np__text[] = "_text";
95 sal_Char __READONLY_DATA sXML_np__text_ext[] = "_text_ooo";
96 sal_Char __READONLY_DATA sXML_np__table[] = "_table";
97 sal_Char __READONLY_DATA sXML_np__table_ext[] = "_table_ooo";
98 sal_Char __READONLY_DATA sXML_np__draw[] = "_draw";
99 sal_Char __READONLY_DATA sXML_np__draw_ext[] = "_draw_ooo";
100 sal_Char __READONLY_DATA sXML_np__dr3d[] = "_dr3d";
101 sal_Char __READONLY_DATA sXML_np__fo[] = "_fo";
102 sal_Char __READONLY_DATA sXML_np__xlink[] = "_xlink";
103 sal_Char __READONLY_DATA sXML_np__dc[] = "_dc";
104 sal_Char __READONLY_DATA sXML_np__dom[] = "_dom";
105 sal_Char __READONLY_DATA sXML_np__meta[] = "_meta";
106 sal_Char __READONLY_DATA sXML_np__number[] = "_number";
107 sal_Char __READONLY_DATA sXML_np__svg[] = "_svg";
108 sal_Char __READONLY_DATA sXML_np__chart[] = "_chart";
109 sal_Char __READONLY_DATA sXML_np__math[] = "_math";
110 sal_Char __READONLY_DATA sXML_np__form[] = "_form";
111 sal_Char __READONLY_DATA sXML_np__script[] = "_script";
112 sal_Char __READONLY_DATA sXML_np__config[] = "_config";
113 sal_Char __READONLY_DATA sXML_np__db[] = "_db";
114 sal_Char __READONLY_DATA sXML_np__xforms[] = "_xforms";
115 sal_Char __READONLY_DATA sXML_np__xsd[] = "_xsd";
116 sal_Char __READONLY_DATA sXML_np__xsi[] = "_xsi";
117 sal_Char __READONLY_DATA sXML_np__field[] = "_field";
118 sal_Char __READONLY_DATA sXML_np__xhtml[] = "_xhtml";
119
120 sal_Char __READONLY_DATA sXML_np__fo_old[] = "__fo";
121 sal_Char __READONLY_DATA sXML_np__xlink_old[] = "__xlink";
122 sal_Char __READONLY_DATA sXML_np__office_old[] = "__office";
123 sal_Char __READONLY_DATA sXML_np__style_old[] = "__style";
124 sal_Char __READONLY_DATA sXML_np__text_old[] = "__text";
125 sal_Char __READONLY_DATA sXML_np__table_old[] = "__table";
126 sal_Char __READONLY_DATA sXML_np__meta_old[] = "__meta";
127
128
129
130 class SvXMLImportEventListener : public cppu::WeakImplHelper1<
131 com::sun::star::lang::XEventListener >
132 {
133 private:
134 SvXMLImport* pImport;
135
136 public:
137 SvXMLImportEventListener(SvXMLImport* pImport);
138 virtual ~SvXMLImportEventListener();
139
140 // XEventListener
141 virtual void SAL_CALL disposing(const lang::EventObject& rEventObject) throw(::com::sun::star::uno::RuntimeException);
142 };
143
SvXMLImportEventListener(SvXMLImport * pTempImport)144 SvXMLImportEventListener::SvXMLImportEventListener(SvXMLImport* pTempImport)
145 : pImport(pTempImport)
146 {
147 }
148
~SvXMLImportEventListener()149 SvXMLImportEventListener::~SvXMLImportEventListener()
150 {
151 }
152
153 // XEventListener
disposing(const lang::EventObject &)154 void SAL_CALL SvXMLImportEventListener::disposing( const lang::EventObject& )
155 throw(uno::RuntimeException)
156 {
157 if (pImport)
158 {
159 pImport->DisposingModel();
160 pImport = NULL;
161 }
162 }
163
164 //==============================================================================
165 // --> ORW
166 namespace
167 {
168 class DocumentInfo
169 {
170 private:
171 sal_uInt16 mnGeneratorVersion;
172
173 public:
DocumentInfo(const SvXMLImport & rImport)174 DocumentInfo( const SvXMLImport& rImport )
175 : mnGeneratorVersion( SvXMLImport::ProductVersionUnknown )
176 {
177 sal_Int32 nUPD, nBuild;
178 if ( rImport.getBuildIds( nUPD, nBuild ) )
179 {
180 if ( nUPD >= 640 && nUPD <= 645 )
181 {
182 mnGeneratorVersion = SvXMLImport::OOo_1x;
183 }
184 else if ( nUPD == 680 )
185 {
186 mnGeneratorVersion = SvXMLImport::OOo_2x;
187 }
188 else if ( nUPD == 300 && nBuild <= 9379 )
189 {
190 mnGeneratorVersion = SvXMLImport::OOo_30x;
191 }
192 else if ( nUPD == 310 )
193 {
194 mnGeneratorVersion = SvXMLImport::OOo_31x;
195 }
196 else if ( nUPD == 320 )
197 {
198 mnGeneratorVersion = SvXMLImport::OOo_32x;
199 }
200 else if ( nUPD == 330 )
201 {
202 mnGeneratorVersion = SvXMLImport::OOo_33x;
203 }
204 else if ( nUPD == 340 )
205 {
206 mnGeneratorVersion = SvXMLImport::OOo_34x;
207 }
208 }
209 }
210
~DocumentInfo()211 ~DocumentInfo()
212 {}
213
getGeneratorVersion() const214 sal_uInt16 getGeneratorVersion() const
215 {
216 return mnGeneratorVersion;
217 }
218 };
219 }
220 // <--
221
222 class SvXMLImport_Impl
223 {
224 public:
225 FontToSubsFontConverter hBatsFontConv;
226 FontToSubsFontConverter hMathFontConv;
227
228 bool mbOwnGraphicResolver;
229 bool mbOwnEmbeddedResolver;
230 INetURLObject aBaseURL;
231 INetURLObject aDocBase;
232
233 /// name of stream in package, e.g., "content.xml"
234 ::rtl::OUString mStreamName;
235
236 ::rtl::OUString aODFVersion;
237
238 // --> OD 2004-08-10 #i28749# - boolean, indicating that position attributes
239 // of shapes are given in horizontal left-to-right layout. This is the case
240 // for the OpenOffice.org file format.
241 sal_Bool mbShapePositionInHoriL2R;
242 // <--
243 // --> OD 2007-12-19 #152540#
244 sal_Bool mbTextDocInOOoFileFormat;
245 // <--
246
247 const uno::Reference< uno::XComponentContext > mxComponentContext;
248
249 std::auto_ptr< xmloff::RDFaImportHelper > mpRDFaHelper;
250
251 // --> ORW
252 std::auto_ptr< DocumentInfo > mpDocumentInfo;
253 // <--
254
SvXMLImport_Impl()255 SvXMLImport_Impl()
256 : hBatsFontConv( 0 )
257 , hMathFontConv( 0 )
258 , mbOwnGraphicResolver( false )
259 , mbOwnEmbeddedResolver( false )
260 , mStreamName()
261 , mbShapePositionInHoriL2R( sal_False )
262 , mbTextDocInOOoFileFormat( sal_False )
263 , mxComponentContext( ::comphelper::getProcessComponentContext() )
264 , mpRDFaHelper() // lazy
265 // --> ORW
266 , mpDocumentInfo() // lazy
267 // <--
268 {
269 OSL_ENSURE(mxComponentContext.is(), "SvXMLImport: no ComponentContext");
270 if (!mxComponentContext.is()) throw uno::RuntimeException();
271 }
272
~SvXMLImport_Impl()273 ~SvXMLImport_Impl()
274 {
275 if( hBatsFontConv )
276 DestroyFontToSubsFontConverter( hBatsFontConv );
277 if( hMathFontConv )
278 DestroyFontToSubsFontConverter( hMathFontConv );
279 }
280
281 // --> ORW
getGeneratorVersion(const SvXMLImport & rImport)282 sal_uInt16 getGeneratorVersion( const SvXMLImport& rImport )
283 {
284 if ( !mpDocumentInfo.get() )
285 {
286 mpDocumentInfo.reset( new DocumentInfo( rImport ) );
287 }
288
289 return mpDocumentInfo->getGeneratorVersion();
290 }
291 // <--
292
293 ::comphelper::UnoInterfaceToUniqueIdentifierMapper maInterfaceToIdentifierMapper;
294 };
295
296 typedef SvXMLImportContext *SvXMLImportContextPtr;
297 SV_DECL_PTRARR( SvXMLImportContexts_Impl, SvXMLImportContextPtr, 20, 5 )
SV_IMPL_PTRARR(SvXMLImportContexts_Impl,SvXMLImportContextPtr)298 SV_IMPL_PTRARR( SvXMLImportContexts_Impl, SvXMLImportContextPtr )
299
300 SvXMLImportContext *SvXMLImport::CreateContext( sal_uInt16 nPrefix,
301 const OUString& rLocalName,
302 const uno::Reference< xml::sax::XAttributeList >& )
303 {
304 return new SvXMLImportContext( *this, nPrefix, rLocalName );
305 }
306
_InitCtor()307 void SvXMLImport::_InitCtor()
308 {
309 if( mnImportFlags != 0 )
310 {
311 // implicit "xml" namespace prefix
312 mpNamespaceMap->Add( GetXMLToken(XML_XML), GetXMLToken(XML_N_XML), XML_NAMESPACE_XML );
313 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__office ) ),
314 GetXMLToken(XML_N_OFFICE),
315 XML_NAMESPACE_OFFICE );
316 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__office_ext ) ),
317 GetXMLToken(XML_N_OFFICE_EXT),
318 XML_NAMESPACE_OFFICE_EXT );
319 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__ooo ) ), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO );
320 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__style) ),
321 GetXMLToken(XML_N_STYLE),
322 XML_NAMESPACE_STYLE );
323 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__text) ),
324 GetXMLToken(XML_N_TEXT),
325 XML_NAMESPACE_TEXT );
326 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__text_ext ) ),
327 GetXMLToken(XML_N_TEXT_EXT),
328 XML_NAMESPACE_TEXT_EXT );
329 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__table ) ),
330 GetXMLToken(XML_N_TABLE),
331 XML_NAMESPACE_TABLE );
332 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__table_ext ) ),
333 GetXMLToken(XML_N_TABLE_EXT),
334 XML_NAMESPACE_TABLE_EXT );
335 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__draw ) ),
336 GetXMLToken(XML_N_DRAW),
337 XML_NAMESPACE_DRAW );
338 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__draw_ext ) ),
339 GetXMLToken(XML_N_DRAW_EXT),
340 XML_NAMESPACE_DRAW_EXT );
341 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM (sXML_np__dr3d ) ),
342 GetXMLToken(XML_N_DR3D),
343 XML_NAMESPACE_DR3D );
344 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__fo) ),
345 GetXMLToken(XML_N_FO_COMPAT),
346 XML_NAMESPACE_FO );
347 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xlink) ),
348 GetXMLToken(XML_N_XLINK),
349 XML_NAMESPACE_XLINK );
350 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__dc) ),
351 GetXMLToken(XML_N_DC),
352 XML_NAMESPACE_DC );
353 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__dom ) ),
354 GetXMLToken(XML_N_DOM),
355 XML_NAMESPACE_DOM );
356 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__meta) ),
357 GetXMLToken(XML_N_META),
358 XML_NAMESPACE_META );
359 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__number) ),
360 GetXMLToken(XML_N_NUMBER),
361 XML_NAMESPACE_NUMBER );
362 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__svg) ),
363 GetXMLToken(XML_N_SVG_COMPAT),
364 XML_NAMESPACE_SVG );
365 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__chart) ),
366 GetXMLToken(XML_N_CHART),
367 XML_NAMESPACE_CHART );
368 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__math) ),
369 GetXMLToken(XML_N_MATH),
370 XML_NAMESPACE_MATH );
371 mpNamespaceMap->Add(OUString(RTL_CONSTASCII_USTRINGPARAM( sXML_np__form )),
372 GetXMLToken(XML_N_FORM),
373 XML_NAMESPACE_FORM );
374 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__script) ),
375 GetXMLToken(XML_N_SCRIPT),
376 XML_NAMESPACE_SCRIPT );
377 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__config) ),
378 GetXMLToken(XML_N_CONFIG),
379 XML_NAMESPACE_CONFIG );
380 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xforms) ),
381 GetXMLToken(XML_N_XFORMS_1_0),
382 XML_NAMESPACE_XFORMS );
383 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xsd) ),
384 GetXMLToken(XML_N_XSD),
385 XML_NAMESPACE_XSD );
386 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xsi) ),
387 GetXMLToken(XML_N_XSI),
388 XML_NAMESPACE_XFORMS );
389 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__ooow ) ), GetXMLToken(XML_N_OOOW), XML_NAMESPACE_OOOW );
390 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__oooc ) ), GetXMLToken(XML_N_OOOC), XML_NAMESPACE_OOOC );
391 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__field ) ), GetXMLToken(XML_N_FIELD), XML_NAMESPACE_FIELD );
392 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__of ) ),
393 GetXMLToken(XML_N_OF), XML_NAMESPACE_OF );
394 mpNamespaceMap->Add(
395 OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xhtml ) ),
396 GetXMLToken(XML_N_XHTML), XML_NAMESPACE_XHTML );
397 }
398
399 msPackageProtocol = OUString( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.Package:" ) );
400
401 if (mxNumberFormatsSupplier.is())
402 mpNumImport = new SvXMLNumFmtHelper(mxNumberFormatsSupplier, getServiceFactory());
403
404 if (mxModel.is() && !mxEventListener.is())
405 {
406 mxEventListener.set(new SvXMLImportEventListener(this));
407 mxModel->addEventListener(mxEventListener);
408 }
409
410 ::comphelper::UnoInterfaceToUniqueIdentifierMapper maInterfaceToIdentifierMapper;
411
412 }
413
414 // #110680#
SvXMLImport(const::com::sun::star::uno::Reference<::com::sun::star::lang::XMultiServiceFactory> & xServiceFactory,sal_uInt16 nImportFlags)415 SvXMLImport::SvXMLImport(
416 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory,
417 sal_uInt16 nImportFlags ) throw ()
418 : mpImpl( new SvXMLImport_Impl() ),
419 mpNamespaceMap( new SvXMLNamespaceMap ),
420
421 // #110680#
422 // pUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM ) ),
423 mpUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM, xServiceFactory ) ),
424
425 mpContexts( new SvXMLImportContexts_Impl ),
426 mpNumImport( NULL ),
427 mpProgressBarHelper( NULL ),
428 mpEventImportHelper( NULL ),
429 mpXMLErrors( NULL ),
430 mpStyleMap(0),
431 mnImportFlags( nImportFlags ),
432 mnErrorFlags(0),
433 // #110680#
434 mxServiceFactory(xServiceFactory),
435 mbIsFormsSupported( sal_True ),
436 mbIsTableShapeSupported( false ),
437 mbIsGraphicLoadOnDemandSupported( true )
438 {
439 DBG_ASSERT( mxServiceFactory.is(), "got no service manager" );
440 _InitCtor();
441 }
442
443 // #110680#
SvXMLImport(const::com::sun::star::uno::Reference<::com::sun::star::lang::XMultiServiceFactory> & xServiceFactory,const Reference<XModel> & rModel)444 SvXMLImport::SvXMLImport(
445 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory,
446 const Reference< XModel > & rModel ) throw ()
447 : mxModel( rModel ),
448 mxNumberFormatsSupplier (rModel, uno::UNO_QUERY),
449 mpImpl( new SvXMLImport_Impl() ),
450 mpNamespaceMap( new SvXMLNamespaceMap ),
451 // #110680#
452 // pUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM ) ),
453 mpUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM, xServiceFactory ) ),
454 mpContexts( new SvXMLImportContexts_Impl ),
455 mpNumImport( NULL ),
456 mpProgressBarHelper( NULL ),
457 mpEventImportHelper( NULL ),
458 mpXMLErrors( NULL ),
459 mpStyleMap(0),
460 mnImportFlags( IMPORT_ALL ),
461 mnErrorFlags(0),
462 // #110680#
463 mxServiceFactory(xServiceFactory),
464 mbIsFormsSupported( sal_True ),
465 mbIsTableShapeSupported( false ),
466 mbIsGraphicLoadOnDemandSupported( true )
467 {
468 DBG_ASSERT( mxServiceFactory.is(), "got no service manager" );
469 _InitCtor();
470 }
471
472 // #110680#
SvXMLImport(const::com::sun::star::uno::Reference<::com::sun::star::lang::XMultiServiceFactory> & xServiceFactory,const Reference<XModel> & rModel,const::com::sun::star::uno::Reference<::com::sun::star::document::XGraphicObjectResolver> & rGraphicObjects)473 SvXMLImport::SvXMLImport(
474 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory,
475 const Reference< XModel > & rModel,
476 const ::com::sun::star::uno::Reference< ::com::sun::star::document::XGraphicObjectResolver > & rGraphicObjects ) throw ()
477 : mxModel( rModel ),
478 mxNumberFormatsSupplier (rModel, uno::UNO_QUERY),
479 mxGraphicResolver( rGraphicObjects ),
480 mpImpl( new SvXMLImport_Impl() ),
481 mpNamespaceMap( new SvXMLNamespaceMap ),
482 // #110680#
483 // pUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM ) ),
484 mpUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM, xServiceFactory ) ),
485 mpContexts( new SvXMLImportContexts_Impl ),
486 mpNumImport( NULL ),
487 mpProgressBarHelper( NULL ),
488 mpEventImportHelper( NULL ),
489 mpXMLErrors( NULL ),
490 mpStyleMap(0),
491 mnImportFlags( IMPORT_ALL ),
492 mnErrorFlags(0),
493 // #110680#
494 mxServiceFactory(xServiceFactory),
495 mbIsFormsSupported( sal_True ),
496 mbIsGraphicLoadOnDemandSupported( true )
497 {
498 DBG_ASSERT( mxServiceFactory.is(), "got no service manager" );
499 _InitCtor();
500 }
501
~SvXMLImport()502 SvXMLImport::~SvXMLImport() throw ()
503 {
504 delete mpXMLErrors;
505 delete mpNamespaceMap;
506 delete mpUnitConv;
507 delete mpEventImportHelper;
508 if( mpContexts )
509 {
510 while( mpContexts->Count() )
511 {
512 sal_uInt16 n = mpContexts->Count() - 1;
513 SvXMLImportContext *pContext = (*mpContexts)[n];
514 mpContexts->Remove( n, 1 );
515 if( pContext )
516 pContext->ReleaseRef();
517 }
518 delete mpContexts;
519 }
520
521 // delete pImageMapImportHelper;
522
523 // #i9518# the import component might not be deleted until after the document has been closed,
524 // so the stuff that accesses the document has been moved to endDocument.
525
526 // pNumImport is allocated in the ctor, so it must also be deleted here in case the component
527 // is created and deleted without actually importing.
528 delete mpNumImport;
529 delete mpProgressBarHelper;
530
531 xmloff::token::ResetTokens();
532
533 if( mpImpl )
534 delete mpImpl;
535
536 if (mxEventListener.is() && mxModel.is())
537 mxModel->removeEventListener(mxEventListener);
538 }
539
540 // XUnoTunnel & co
getUnoTunnelId()541 const uno::Sequence< sal_Int8 > & SvXMLImport::getUnoTunnelId() throw()
542 {
543 static uno::Sequence< sal_Int8 > * pSeq = 0;
544 if( !pSeq )
545 {
546 Guard< Mutex > aGuard( Mutex::getGlobalMutex() );
547 if( !pSeq )
548 {
549 static uno::Sequence< sal_Int8 > aSeq( 16 );
550 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True );
551 pSeq = &aSeq;
552 }
553 }
554 return *pSeq;
555 }
556
getImplementation(uno::Reference<uno::XInterface> xInt)557 SvXMLImport* SvXMLImport::getImplementation( uno::Reference< uno::XInterface > xInt ) throw()
558 {
559 uno::Reference< lang::XUnoTunnel > xUT( xInt, uno::UNO_QUERY );
560 if( xUT.is() )
561 {
562 return
563 reinterpret_cast<SvXMLImport*>(
564 sal::static_int_cast<sal_IntPtr>(
565 xUT->getSomething( SvXMLImport::getUnoTunnelId())));
566 }
567 else
568 return NULL;
569 }
570
571 // XUnoTunnel
getSomething(const uno::Sequence<sal_Int8> & rId)572 sal_Int64 SAL_CALL SvXMLImport::getSomething( const uno::Sequence< sal_Int8 >& rId )
573 throw( uno::RuntimeException )
574 {
575 if( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(),
576 rId.getConstArray(), 16 ) )
577 {
578 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
579 }
580 return 0;
581 }
582
startDocument(void)583 void SAL_CALL SvXMLImport::startDocument( void )
584 throw( xml::sax::SAXException, uno::RuntimeException )
585 {
586 RTL_LOGFILE_TRACE_AUTHOR( "xmloff", LOGFILE_AUTHOR, "{ SvXMLImport::startDocument" );
587
588 if( !mxGraphicResolver.is() || !mxEmbeddedResolver.is() )
589 {
590 Reference< lang::XMultiServiceFactory > xFactory( mxModel, UNO_QUERY );
591 if( xFactory.is() )
592 {
593 try
594 {
595 if( !mxGraphicResolver.is() )
596 {
597 mxGraphicResolver = Reference< XGraphicObjectResolver >::query(
598 xFactory->createInstance(
599 OUString(RTL_CONSTASCII_USTRINGPARAM(
600 // #99870# Import... instead of Export...
601 "com.sun.star.document.ImportGraphicObjectResolver"))));
602 mpImpl->mbOwnGraphicResolver = mxGraphicResolver.is();
603 }
604
605 if( !mxEmbeddedResolver.is() )
606 {
607 mxEmbeddedResolver = Reference< XEmbeddedObjectResolver >::query(
608 xFactory->createInstance(
609 OUString(RTL_CONSTASCII_USTRINGPARAM(
610 // #99870# Import... instead of Export...
611 "com.sun.star.document.ImportEmbeddedObjectResolver"))));
612 mpImpl->mbOwnEmbeddedResolver = mxEmbeddedResolver.is();
613 }
614 }
615 catch( com::sun::star::uno::Exception& )
616 {
617 }
618 }
619 }
620 }
621
endDocument(void)622 void SAL_CALL SvXMLImport::endDocument( void )
623 throw( xml::sax::SAXException, uno::RuntimeException)
624 {
625 RTL_LOGFILE_TRACE_AUTHOR( "xmloff", LOGFILE_AUTHOR, "} SvXMLImport::startDocument" );
626
627 // #i9518# All the stuff that accesses the document has to be done here, not in the dtor,
628 // because the SvXMLImport dtor might not be called until after the document has been closed.
629
630 if (mpImpl->mpRDFaHelper.get())
631 {
632 const uno::Reference<rdf::XRepositorySupplier> xRS(mxModel,
633 uno::UNO_QUERY);
634 if (xRS.is())
635 {
636 mpImpl->mpRDFaHelper->InsertRDFa( xRS );
637 }
638 }
639
640 if (mpNumImport)
641 {
642 delete mpNumImport;
643 mpNumImport = NULL;
644 }
645 if (mxImportInfo.is())
646 {
647 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
648 if (xPropertySetInfo.is())
649 {
650 if (mpProgressBarHelper)
651 {
652 OUString sProgressMax(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSMAX));
653 OUString sProgressCurrent(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSCURRENT));
654 OUString sRepeat(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSREPEAT));
655 if (xPropertySetInfo->hasPropertyByName(sProgressMax) &&
656 xPropertySetInfo->hasPropertyByName(sProgressCurrent))
657 {
658 sal_Int32 nProgressMax(mpProgressBarHelper->GetReference());
659 sal_Int32 nProgressCurrent(mpProgressBarHelper->GetValue());
660 uno::Any aAny;
661 aAny <<= nProgressMax;
662 mxImportInfo->setPropertyValue(sProgressMax, aAny);
663 aAny <<= nProgressCurrent;
664 mxImportInfo->setPropertyValue(sProgressCurrent, aAny);
665 }
666 if (xPropertySetInfo->hasPropertyByName(sRepeat))
667 mxImportInfo->setPropertyValue(sRepeat, cppu::bool2any(mpProgressBarHelper->GetRepeat()));
668 // pProgressBarHelper is deleted in dtor
669 }
670 OUString sNumberStyles(RTL_CONSTASCII_USTRINGPARAM(XML_NUMBERSTYLES));
671 if (mxNumberStyles.is() && xPropertySetInfo->hasPropertyByName(sNumberStyles))
672 {
673 uno::Any aAny;
674 aAny <<= mxNumberStyles;
675 mxImportInfo->setPropertyValue(sNumberStyles, aAny);
676 }
677 }
678 }
679
680 if( mxFontDecls.Is() )
681 ((SvXMLStylesContext *)&mxFontDecls)->Clear();
682 if( mxStyles.Is() )
683 ((SvXMLStylesContext *)&mxStyles)->Clear();
684 if( mxAutoStyles.Is() )
685 ((SvXMLStylesContext *)&mxAutoStyles)->Clear();
686 if( mxMasterStyles.Is() )
687 ((SvXMLStylesContext *)&mxMasterStyles)->Clear();
688
689 // possible form-layer related knittings which can only be done when
690 // the whole document exists
691 if ( mxFormImport.is() )
692 mxFormImport->documentDone();
693
694 // The shape import helper does the z-order sorting in the dtor,
695 // so it must be deleted here, too.
696 mxShapeImport = NULL;
697
698 if( mpImpl->mbOwnGraphicResolver )
699 {
700 Reference< lang::XComponent > xComp( mxGraphicResolver, UNO_QUERY );
701 xComp->dispose();
702 }
703
704 if( mpImpl->mbOwnEmbeddedResolver )
705 {
706 Reference< lang::XComponent > xComp( mxEmbeddedResolver, UNO_QUERY );
707 xComp->dispose();
708 }
709 if( mpStyleMap )
710 {
711 mpStyleMap->release();
712 mpStyleMap = 0;
713 }
714
715 if ( mpXMLErrors != NULL )
716 {
717 mpXMLErrors->ThrowErrorAsSAXException( XMLERROR_FLAG_SEVERE );
718 }
719 }
720
startElement(const OUString & rName,const uno::Reference<xml::sax::XAttributeList> & xAttrList)721 void SAL_CALL SvXMLImport::startElement( const OUString& rName,
722 const uno::Reference< xml::sax::XAttributeList >& xAttrList )
723 throw(xml::sax::SAXException, uno::RuntimeException)
724 {
725 SvXMLNamespaceMap *pRewindMap = 0;
726
727 // Process namespace attributes. This must happen before creating the
728 // context, because namespace decaration apply to the element name itself.
729 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
730 for( sal_Int16 i=0; i < nAttrCount; i++ )
731 {
732 const OUString& rAttrName = xAttrList->getNameByIndex( i );
733 if ( rAttrName.equalsAscii("office:version") )
734 {
735 mpImpl->aODFVersion = xAttrList->getValueByIndex( i );
736
737 // the ODF version in content.xml and manifest.xml must be the same starting from ODF1.2
738 if ( mpImpl->mStreamName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "content.xml" ) ) )
739 && !IsODFVersionConsistent( mpImpl->aODFVersion ) )
740 {
741 throw xml::sax::SAXException(
742 ::rtl::OUString(
743 RTL_CONSTASCII_USTRINGPARAM( "Inconsistent ODF versions in content.xml and manifest.xml!" ) ),
744 uno::Reference< uno::XInterface >(),
745 uno::makeAny(
746 packages::zip::ZipIOException(
747 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(
748 "Inconsistent ODF versions in content.xml and manifest.xml!" ) ),
749 Reference< XInterface >() ) ) );
750 }
751 }
752 else if( ( rAttrName.getLength() >= 5 ) &&
753 ( rAttrName.compareTo( GetXMLToken(XML_XMLNS), 5 ) == 0 ) &&
754 ( rAttrName.getLength() == 5 || ':' == rAttrName[5] ) )
755 {
756 if( !pRewindMap )
757 {
758 pRewindMap = mpNamespaceMap;
759 mpNamespaceMap = new SvXMLNamespaceMap( *mpNamespaceMap );
760 }
761 const OUString& rAttrValue = xAttrList->getValueByIndex( i );
762
763 OUString aPrefix( ( rAttrName.getLength() == 5 )
764 ? OUString()
765 : rAttrName.copy( 6 ) );
766 // Add namespace, but only if it is known.
767 sal_uInt16 nKey = mpNamespaceMap->AddIfKnown( aPrefix, rAttrValue );
768 // If namespace is unknwon, try to match a name with similar
769 // TC Id an version
770 if( XML_NAMESPACE_UNKNOWN == nKey )
771 {
772 OUString aTestName( rAttrValue );
773 if( SvXMLNamespaceMap::NormalizeURI( aTestName ) )
774 nKey = mpNamespaceMap->AddIfKnown( aPrefix, aTestName );
775 }
776 // If that namespace is not known, too, add it as unknown
777 if( XML_NAMESPACE_UNKNOWN == nKey )
778 mpNamespaceMap->Add( aPrefix, rAttrValue );
779
780 }
781 }
782
783 // Get element's namespace and local name.
784 OUString aLocalName;
785 sal_uInt16 nPrefix =
786 mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName );
787
788 // If there are contexts already, call a CreateChildContext at the topmost
789 // context. Otherwise, create a default context.
790 SvXMLImportContext *pContext;
791 sal_uInt16 nCount = mpContexts->Count();
792 if( nCount > 0 )
793 {
794 pContext = (*mpContexts)[nCount - 1]->CreateChildContext( nPrefix,
795 aLocalName,
796 xAttrList );
797 DBG_ASSERT( pContext && pContext->GetPrefix() == nPrefix,
798 "SvXMLImport::startElement: created context has wrong prefix" );
799 }
800 else
801 {
802 #ifdef TIMELOG
803 // If we do profiling, we want a trace message for the first element
804 // in order to identify the stream.
805 ByteString aString( (String)rName, RTL_TEXTENCODING_ASCII_US );
806 RTL_LOGFILE_TRACE_AUTHOR1( "xmloff", LOGFILE_AUTHOR,
807 "SvXMLImport::StartElement( \"%s\", ... )",
808 aString.GetBuffer() );
809 #endif
810
811 pContext = CreateContext( nPrefix, aLocalName, xAttrList );
812 if( (nPrefix & XML_NAMESPACE_UNKNOWN_FLAG) != 0 &&
813 IS_TYPE( SvXMLImportContext, pContext ) )
814 {
815 OUString aMsg( RTL_CONSTASCII_USTRINGPARAM( "Root element unknown" ) );
816 Reference<xml::sax::XLocator> xDummyLocator;
817 Sequence < OUString > aParams(1);
818 aParams.getArray()[0] = rName;
819
820 SetError( XMLERROR_FLAG_SEVERE|XMLERROR_UNKNWON_ROOT,
821 aParams, aMsg, xDummyLocator );
822 }
823 }
824
825 DBG_ASSERT( pContext, "SvXMLImport::startElement: missing context" );
826 if( !pContext )
827 pContext = new SvXMLImportContext( *this, nPrefix, aLocalName );
828
829 pContext->AddRef();
830
831 // Remeber old namespace map.
832 if( pRewindMap )
833 pContext->SetRewindMap( pRewindMap );
834
835 // Call a startElement at the new context.
836 pContext->StartElement( xAttrList );
837
838 // Push context on stack.
839 mpContexts->Insert( pContext, nCount );
840 }
841
endElement(const OUString & rName)842 void SAL_CALL SvXMLImport::endElement( const OUString&
843 #ifdef DBG_UTIL
844 rName
845 #endif
846 )
847 throw(xml::sax::SAXException, uno::RuntimeException)
848 {
849 sal_uInt16 nCount = mpContexts->Count();
850 DBG_ASSERT( nCount, "SvXMLImport::endElement: no context left" );
851 if( nCount > 0 )
852 {
853 // Get topmost context and remove it from the stack.
854 SvXMLImportContext *pContext = (*mpContexts)[nCount-1];
855 mpContexts->Remove( nCount-1, 1 );
856
857 #ifdef DBG_UTIL
858 // Non product only: check if endElement call matches startELement call.
859 OUString aLocalName;
860 sal_uInt16 nPrefix =
861 mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName );
862 DBG_ASSERT( pContext->GetPrefix() == nPrefix,
863 "SvXMLImport::endElement: popped context has wrong prefix" );
864 DBG_ASSERT( pContext->GetLocalName() == aLocalName,
865 "SvXMLImport::endElement: popped context has wrong lname" );
866 #endif
867
868 // Call a EndElement at the current context.
869 pContext->EndElement();
870
871 // Get a namespace map to rewind.
872 SvXMLNamespaceMap *pRewindMap = pContext->GetRewindMap();
873
874 // Delete the current context.
875 pContext->ReleaseRef();
876 pContext = 0;
877
878 // Rewind a namespace map.
879 if( pRewindMap )
880 {
881 delete mpNamespaceMap;
882 mpNamespaceMap = pRewindMap;
883 }
884 }
885 }
886
characters(const OUString & rChars)887 void SAL_CALL SvXMLImport::characters( const OUString& rChars )
888 throw(xml::sax::SAXException, uno::RuntimeException)
889 {
890 sal_uInt16 nCount = mpContexts->Count();
891 if( nCount > 0 )
892 {
893 (*mpContexts)[nCount - 1]->Characters( rChars );
894 }
895 }
896
ignorableWhitespace(const OUString &)897 void SAL_CALL SvXMLImport::ignorableWhitespace( const OUString& )
898 throw(xml::sax::SAXException, uno::RuntimeException)
899 {
900 }
901
processingInstruction(const OUString &,const OUString &)902 void SAL_CALL SvXMLImport::processingInstruction( const OUString&,
903 const OUString& )
904 throw(xml::sax::SAXException, uno::RuntimeException)
905 {
906 }
907
setDocumentLocator(const uno::Reference<xml::sax::XLocator> & rLocator)908 void SAL_CALL SvXMLImport::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& rLocator )
909 throw(xml::sax::SAXException, uno::RuntimeException)
910 {
911 mxLocator = rLocator;
912 }
913
914 // XExtendedDocumentHandler
startCDATA(void)915 void SAL_CALL SvXMLImport::startCDATA( void ) throw(xml::sax::SAXException, uno::RuntimeException)
916 {
917 }
918
endCDATA(void)919 void SAL_CALL SvXMLImport::endCDATA( void ) throw(uno::RuntimeException)
920 {
921 }
922
comment(const OUString &)923 void SAL_CALL SvXMLImport::comment( const OUString& )
924 throw(xml::sax::SAXException, uno::RuntimeException)
925 {
926 }
927
allowLineBreak(void)928 void SAL_CALL SvXMLImport::allowLineBreak( void )
929 throw(xml::sax::SAXException, uno::RuntimeException)
930 {
931 }
932
unknown(const OUString &)933 void SAL_CALL SvXMLImport::unknown( const OUString& )
934 throw(xml::sax::SAXException, uno::RuntimeException)
935 {
936 }
937
SetStatistics(const uno::Sequence<beans::NamedValue> &)938 void SvXMLImport::SetStatistics(const uno::Sequence< beans::NamedValue> &)
939 {
940 GetProgressBarHelper()->SetRepeat(sal_False);
941 GetProgressBarHelper()->SetReference(0);
942 }
943
944 ///////////////////////////////////////////////////////////////////////
945
946 // XImporter
setTargetDocument(const uno::Reference<lang::XComponent> & xDoc)947 void SAL_CALL SvXMLImport::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc )
948 throw(lang::IllegalArgumentException, uno::RuntimeException)
949 {
950 mxModel = uno::Reference< frame::XModel >::query( xDoc );
951 if( !mxModel.is() )
952 throw lang::IllegalArgumentException();
953 if (mxModel.is() && !mxEventListener.is())
954 {
955 mxEventListener.set(new SvXMLImportEventListener(this));
956 mxModel->addEventListener(mxEventListener);
957 }
958
959 DBG_ASSERT( !mpNumImport, "number format import already exists." );
960 if( mpNumImport )
961 {
962 delete mpNumImport;
963 mpNumImport = 0;
964 }
965 }
966
967 // XFilter
filter(const uno::Sequence<beans::PropertyValue> &)968 sal_Bool SAL_CALL SvXMLImport::filter( const uno::Sequence< beans::PropertyValue >& )
969 throw (uno::RuntimeException)
970 {
971 return sal_False;
972 }
973
cancel()974 void SAL_CALL SvXMLImport::cancel( )
975 throw (uno::RuntimeException)
976 {
977 }
978
979 // XInitialize
initialize(const uno::Sequence<uno::Any> & aArguments)980 void SAL_CALL SvXMLImport::initialize( const uno::Sequence< uno::Any >& aArguments )
981 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException)
982 {
983 const sal_Int32 nAnyCount = aArguments.getLength();
984 const uno::Any* pAny = aArguments.getConstArray();
985
986 for( sal_Int32 nIndex = 0; nIndex < nAnyCount; nIndex++, pAny++ )
987 {
988 Reference<XInterface> xValue;
989 *pAny >>= xValue;
990
991 uno::Reference<task::XStatusIndicator> xTmpStatusIndicator(
992 xValue, UNO_QUERY );
993 if( xTmpStatusIndicator.is() )
994 mxStatusIndicator = xTmpStatusIndicator;
995
996 uno::Reference<document::XGraphicObjectResolver> xTmpGraphicResolver(
997 xValue, UNO_QUERY );
998 if( xTmpGraphicResolver.is() )
999 mxGraphicResolver = xTmpGraphicResolver;
1000
1001 uno::Reference<document::XEmbeddedObjectResolver> xTmpObjectResolver(
1002 xValue, UNO_QUERY );
1003 if( xTmpObjectResolver.is() )
1004 mxEmbeddedResolver = xTmpObjectResolver;
1005
1006 uno::Reference<beans::XPropertySet> xTmpPropSet( xValue, UNO_QUERY );
1007 if( xTmpPropSet.is() )
1008 {
1009 mxImportInfo = xTmpPropSet;
1010 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
1011 if (xPropertySetInfo.is())
1012 {
1013 OUString sPropName(RTL_CONSTASCII_USTRINGPARAM(XML_NUMBERSTYLES));
1014 if (xPropertySetInfo->hasPropertyByName(sPropName))
1015 {
1016 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1017 aAny >>= mxNumberStyles;
1018 }
1019
1020 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("PrivateData" ) );
1021 if (xPropertySetInfo->hasPropertyByName(sPropName))
1022 {
1023 Reference < XInterface > xIfc;
1024 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1025 aAny >>= xIfc;
1026
1027 StyleMap *pSMap = StyleMap::getImplementation( xIfc );
1028 if( pSMap )
1029 {
1030 mpStyleMap = pSMap;
1031 mpStyleMap->acquire();
1032 }
1033 }
1034 OUString sBaseURI;
1035 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("BaseURI" ) );
1036 if (xPropertySetInfo->hasPropertyByName(sPropName))
1037 {
1038 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1039 aAny >>= sBaseURI;
1040 mpImpl->aBaseURL.SetURL( sBaseURI );
1041 mpImpl->aDocBase.SetURL( sBaseURI );
1042 }
1043 OUString sRelPath;
1044 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("StreamRelPath" ) );
1045 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1046 {
1047 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1048 aAny >>= sRelPath;
1049 }
1050 OUString sName;
1051 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("StreamName" ) );
1052 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1053 {
1054 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1055 aAny >>= sName;
1056 }
1057 if( sBaseURI.getLength() && sName.getLength() )
1058 {
1059 if( sRelPath.getLength() )
1060 mpImpl->aBaseURL.insertName( sRelPath );
1061 mpImpl->aBaseURL.insertName( sName );
1062 }
1063 mpImpl->mStreamName = sName; // Note: may be empty (XSLT)
1064 // --> OD 2004-08-10 #i28749# - retrieve property <ShapePositionInHoriL2R>
1065 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("ShapePositionInHoriL2R" ) );
1066 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1067 {
1068 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1069 aAny >>= (mpImpl->mbShapePositionInHoriL2R);
1070 }
1071 // <--
1072 // --> OD 2007-12-19 #152540#
1073 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("TextDocInOOoFileFormat" ) );
1074 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1075 {
1076 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1077 aAny >>= (mpImpl->mbTextDocInOOoFileFormat);
1078 }
1079 // <--
1080 }
1081 }
1082 }
1083 }
1084
1085 // XServiceInfo
getImplementationName()1086 OUString SAL_CALL SvXMLImport::getImplementationName()
1087 throw(uno::RuntimeException)
1088 {
1089 OUString aStr;
1090 return aStr;
1091 }
1092
supportsService(const OUString & rServiceName)1093 sal_Bool SAL_CALL SvXMLImport::supportsService( const OUString& rServiceName )
1094 throw(::com::sun::star::uno::RuntimeException)
1095 {
1096 return
1097 rServiceName.equalsAsciiL(
1098 "com.sun.star.document.ImportFilter",
1099 sizeof("com.sun.star.document.ImportFilter")-1 ) ||
1100 rServiceName.equalsAsciiL(
1101 "com.sun.star.xml.XMLImportFilter",
1102 sizeof("com.sun.star.xml.XMLImportFilter")-1);
1103 }
1104
getSupportedServiceNames()1105 uno::Sequence< OUString > SAL_CALL SvXMLImport::getSupportedServiceNames( )
1106 throw(uno::RuntimeException)
1107 {
1108 uno::Sequence<OUString> aSeq(2);
1109 aSeq[0] = OUString(
1110 RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.ImportFilter"));
1111 aSeq[1] = OUString(
1112 RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.XMLImportFilter"));
1113 return aSeq;
1114 }
1115
1116 ///////////////////////////////////////////////////////////////////////
1117
CreateTextImport()1118 XMLTextImportHelper* SvXMLImport::CreateTextImport()
1119 {
1120 return new XMLTextImportHelper( mxModel, *this );
1121 }
1122
CreateShapeImport()1123 XMLShapeImportHelper* SvXMLImport::CreateShapeImport()
1124 {
1125 return new XMLShapeImportHelper( *this, mxModel );
1126 }
1127
1128 #ifndef SVX_LIGHT
CreateChartImport()1129 SchXMLImportHelper* SvXMLImport::CreateChartImport()
1130 {
1131 return new SchXMLImportHelper();
1132 }
1133 #endif
1134
1135 #ifndef SVX_LIGHT
CreateFormImport()1136 ::xmloff::OFormLayerXMLImport* SvXMLImport::CreateFormImport()
1137 {
1138 return new ::xmloff::OFormLayerXMLImport(*this);
1139 }
1140 #endif // #ifndef SVX_LIGHT
1141
1142
1143 ///////////////////////////////////////////////////////////////////////////////
1144 //
1145 // Get or create fill/line/lineend-style-helper
1146 //
1147
GetGradientHelper()1148 const Reference< container::XNameContainer > & SvXMLImport::GetGradientHelper()
1149 {
1150 if( !mxGradientHelper.is() )
1151 {
1152 if( mxModel.is() )
1153 {
1154 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1155 if( xServiceFact.is() )
1156 {
1157 try
1158 {
1159 mxGradientHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1160 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.GradientTable" ) ) ), UNO_QUERY);
1161 }
1162 catch( lang::ServiceNotRegisteredException& )
1163 {}
1164 }
1165 }
1166 }
1167
1168 return mxGradientHelper;
1169 }
1170
GetHatchHelper()1171 const Reference< container::XNameContainer > & SvXMLImport::GetHatchHelper()
1172 {
1173 if( !mxHatchHelper.is() )
1174 {
1175 if( mxModel.is() )
1176 {
1177 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1178 if( xServiceFact.is() )
1179 {
1180 try
1181 {
1182 mxHatchHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1183 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.HatchTable" ) ) ), UNO_QUERY);
1184 }
1185 catch( lang::ServiceNotRegisteredException& )
1186 {}
1187 }
1188 }
1189 }
1190
1191 return mxHatchHelper;
1192 }
1193
GetBitmapHelper()1194 const Reference< container::XNameContainer > & SvXMLImport::GetBitmapHelper()
1195 {
1196 if( !mxBitmapHelper.is() )
1197 {
1198 if( mxModel.is() )
1199 {
1200 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1201 if( xServiceFact.is() )
1202 {
1203 try
1204 {
1205 mxBitmapHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1206 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.BitmapTable" ) ) ), UNO_QUERY);
1207 }
1208 catch( lang::ServiceNotRegisteredException& )
1209 {}
1210 }
1211 }
1212 }
1213
1214 return mxBitmapHelper;
1215 }
1216
GetTransGradientHelper()1217 const Reference< container::XNameContainer > & SvXMLImport::GetTransGradientHelper()
1218 {
1219 if( !mxTransGradientHelper.is() )
1220 {
1221 if( mxModel.is() )
1222 {
1223 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1224 if( xServiceFact.is() )
1225 {
1226 try
1227 {
1228 mxTransGradientHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1229 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.TransparencyGradientTable" ) ) ), UNO_QUERY);
1230 }
1231 catch( lang::ServiceNotRegisteredException& )
1232 {}
1233 }
1234 }
1235 }
1236
1237 return mxTransGradientHelper;
1238 }
1239
GetMarkerHelper()1240 const Reference< container::XNameContainer > & SvXMLImport::GetMarkerHelper()
1241 {
1242 if( !mxMarkerHelper.is() )
1243 {
1244 if( mxModel.is() )
1245 {
1246 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1247 if( xServiceFact.is() )
1248 {
1249 try
1250 {
1251 mxMarkerHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1252 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.MarkerTable" ) ) ), UNO_QUERY);
1253 }
1254 catch( lang::ServiceNotRegisteredException& )
1255 {}
1256 }
1257 }
1258 }
1259
1260 return mxMarkerHelper;
1261 }
1262
GetDashHelper()1263 const Reference< container::XNameContainer > & SvXMLImport::GetDashHelper()
1264 {
1265 if( !mxDashHelper.is() )
1266 {
1267 if( mxModel.is() )
1268 {
1269 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1270 if( xServiceFact.is() )
1271 {
1272 try
1273 {
1274 mxDashHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1275 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.DashTable" ) ) ), UNO_QUERY);
1276 }
1277 catch( lang::ServiceNotRegisteredException& )
1278 {}
1279 }
1280 }
1281 }
1282
1283 return mxDashHelper;
1284 }
1285
IsPackageURL(const::rtl::OUString & rURL) const1286 sal_Bool SvXMLImport::IsPackageURL( const ::rtl::OUString& rURL ) const
1287 {
1288
1289 // if, and only if, only parts are imported, then we're in a package
1290 const sal_uInt32 nTest = IMPORT_META|IMPORT_STYLES|IMPORT_CONTENT|IMPORT_SETTINGS;
1291 if( (mnImportFlags & nTest) == nTest )
1292 return sal_False;
1293
1294 // Some quick tests: Some may rely on the package structure!
1295 sal_Int32 nLen = rURL.getLength();
1296 if( (nLen > 0 && '/' == rURL[0]) )
1297 // RFC2396 net_path or abs_path
1298 return sal_False;
1299 else if( nLen > 1 && '.' == rURL[0] )
1300 {
1301 if( '.' == rURL[1] )
1302 // ../: We are never going up one level, so we know
1303 // it's not an external URI
1304 return sal_False;
1305 else if( '/' == rURL[1] )
1306 // we are remaining on a level, so it's an package URI
1307 return sal_True;
1308 }
1309
1310 // Now check for a RFC2396 schema
1311 sal_Int32 nPos = 1;
1312 while( nPos < nLen )
1313 {
1314 switch( rURL[nPos] )
1315 {
1316 case '/':
1317 // a relative path segement
1318 return sal_True;
1319 case ':':
1320 // a schema
1321 return sal_False;
1322 default:
1323 break;
1324 // we don't care about any other characters
1325 }
1326 ++nPos;
1327 }
1328
1329 return sal_True;
1330 }
1331
ResolveGraphicObjectURL(const::rtl::OUString & rURL,sal_Bool bLoadOnDemand)1332 ::rtl::OUString SvXMLImport::ResolveGraphicObjectURL( const ::rtl::OUString& rURL,
1333 sal_Bool bLoadOnDemand )
1334 {
1335 ::rtl::OUString sRet;
1336
1337 if( IsPackageURL( rURL ) )
1338 {
1339 if( !bLoadOnDemand && mxGraphicResolver.is() )
1340 {
1341 ::rtl::OUString aTmp( msPackageProtocol );
1342 aTmp += rURL;
1343 sRet = mxGraphicResolver->resolveGraphicObjectURL( aTmp );
1344 }
1345
1346 if( !sRet.getLength() )
1347 {
1348 sRet = msPackageProtocol;
1349 sRet += rURL;
1350 }
1351 }
1352
1353 if( !sRet.getLength() )
1354 sRet = GetAbsoluteReference( rURL );
1355
1356 return sRet;
1357 }
1358
GetStreamForGraphicObjectURLFromBase64()1359 Reference< XOutputStream > SvXMLImport::GetStreamForGraphicObjectURLFromBase64()
1360 {
1361 Reference< XOutputStream > xOStm;
1362 Reference< document::XBinaryStreamResolver > xStmResolver( mxGraphicResolver, UNO_QUERY );
1363
1364 if( xStmResolver.is() )
1365 xOStm = xStmResolver->createOutputStream();
1366
1367 return xOStm;
1368 }
1369
ResolveGraphicObjectURLFromBase64(const Reference<XOutputStream> & rOut)1370 ::rtl::OUString SvXMLImport::ResolveGraphicObjectURLFromBase64(
1371 const Reference < XOutputStream >& rOut )
1372 {
1373 OUString sURL;
1374 Reference< document::XBinaryStreamResolver > xStmResolver( mxGraphicResolver, UNO_QUERY );
1375 if( xStmResolver.is() )
1376 sURL = xStmResolver->resolveOutputStream( rOut );
1377
1378 return sURL;
1379 }
1380
ResolveEmbeddedObjectURL(const::rtl::OUString & rURL,const::rtl::OUString & rClassId)1381 ::rtl::OUString SvXMLImport::ResolveEmbeddedObjectURL(
1382 const ::rtl::OUString& rURL,
1383 const ::rtl::OUString& rClassId )
1384 {
1385 ::rtl::OUString sRet;
1386
1387 if( IsPackageURL( rURL ) )
1388 {
1389 if ( mxEmbeddedResolver.is() )
1390 {
1391 OUString sURL( rURL );
1392 if( rClassId.getLength() )
1393 {
1394 sURL += OUString( sal_Unicode('!') );
1395 sURL += rClassId;
1396 }
1397 sRet = mxEmbeddedResolver->resolveEmbeddedObjectURL( sURL );
1398 }
1399 }
1400 else
1401 sRet = GetAbsoluteReference( rURL );
1402
1403 return sRet;
1404 }
1405
1406 Reference < XOutputStream >
GetStreamForEmbeddedObjectURLFromBase64()1407 SvXMLImport::GetStreamForEmbeddedObjectURLFromBase64()
1408 {
1409 Reference < XOutputStream > xOLEStream;
1410
1411 if( mxEmbeddedResolver.is() )
1412 {
1413 Reference< XNameAccess > xNA( mxEmbeddedResolver, UNO_QUERY );
1414 if( xNA.is() )
1415 {
1416 OUString aURL( RTL_CONSTASCII_USTRINGPARAM( "Obj12345678" ) );
1417 Any aAny = xNA->getByName( aURL );
1418 aAny >>= xOLEStream;
1419 }
1420 }
1421
1422 return xOLEStream;
1423 }
1424
ResolveEmbeddedObjectURLFromBase64()1425 ::rtl::OUString SvXMLImport::ResolveEmbeddedObjectURLFromBase64()
1426 {
1427 ::rtl::OUString sRet;
1428
1429 if( mxEmbeddedResolver.is() )
1430 {
1431 OUString aURL( RTL_CONSTASCII_USTRINGPARAM( "Obj12345678" ) );
1432 sRet = mxEmbeddedResolver->resolveEmbeddedObjectURL( aURL );
1433 }
1434
1435 return sRet;
1436 }
1437
AddStyleDisplayName(sal_uInt16 nFamily,const OUString & rName,const OUString & rDisplayName)1438 void SvXMLImport::AddStyleDisplayName( sal_uInt16 nFamily,
1439 const OUString& rName,
1440 const OUString& rDisplayName )
1441 {
1442 if( !mpStyleMap )
1443 {
1444 mpStyleMap = new StyleMap;
1445 mpStyleMap->acquire();
1446 if( mxImportInfo.is() )
1447 {
1448 OUString sPrivateData(
1449 RTL_CONSTASCII_USTRINGPARAM("PrivateData" ) );
1450 Reference< beans::XPropertySetInfo > xPropertySetInfo =
1451 mxImportInfo->getPropertySetInfo();
1452 if( xPropertySetInfo.is() &&
1453 xPropertySetInfo->hasPropertyByName(sPrivateData) )
1454 {
1455 Reference < XInterface > xIfc(
1456 static_cast< XUnoTunnel *>( mpStyleMap ) );
1457 Any aAny;
1458 aAny <<= xIfc;
1459 mxImportInfo->setPropertyValue( sPrivateData, aAny );
1460 }
1461 }
1462 }
1463
1464 StyleMap::key_type aKey( nFamily, rName );
1465 StyleMap::value_type aValue( aKey, rDisplayName );
1466 ::std::pair<StyleMap::iterator,bool> aRes( mpStyleMap->insert( aValue ) );
1467 OSL_ENSURE( aRes.second, "duplicate style name" );
1468
1469 }
1470
GetStyleDisplayName(sal_uInt16 nFamily,const OUString & rName) const1471 OUString SvXMLImport::GetStyleDisplayName( sal_uInt16 nFamily,
1472 const OUString& rName ) const
1473 {
1474 OUString sName( rName );
1475 if( mpStyleMap && rName.getLength() )
1476 {
1477 StyleMap::key_type aKey( nFamily, rName );
1478 StyleMap::const_iterator aIter = mpStyleMap->find( aKey );
1479 if( aIter != mpStyleMap->end() )
1480 sName = (*aIter).second;
1481 }
1482 return sName;
1483 }
1484
SetViewSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue> &)1485 void SvXMLImport::SetViewSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue>&)
1486 {
1487 }
1488
SetConfigurationSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue> &)1489 void SvXMLImport::SetConfigurationSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue>&)
1490 {
1491 }
1492
SetDocumentSpecificSettings(const::rtl::OUString & _rSettingsGroupName,const uno::Sequence<beans::PropertyValue> & _rSettings)1493 void SvXMLImport::SetDocumentSpecificSettings(const ::rtl::OUString& _rSettingsGroupName, const uno::Sequence<beans::PropertyValue>& _rSettings)
1494 {
1495 (void)_rSettingsGroupName;
1496 (void)_rSettings;
1497 }
1498
GetProgressBarHelper()1499 ProgressBarHelper* SvXMLImport::GetProgressBarHelper()
1500 {
1501 if (!mpProgressBarHelper)
1502 {
1503 mpProgressBarHelper = new ProgressBarHelper(mxStatusIndicator, sal_False);
1504
1505 if (mxImportInfo.is())
1506 {
1507 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
1508 if (xPropertySetInfo.is())
1509 {
1510 OUString sProgressRange(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSRANGE));
1511 OUString sProgressMax(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSMAX));
1512 OUString sProgressCurrent(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSCURRENT));
1513 OUString sRepeat(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSREPEAT));
1514 if (xPropertySetInfo->hasPropertyByName(sProgressMax) &&
1515 xPropertySetInfo->hasPropertyByName(sProgressCurrent) &&
1516 xPropertySetInfo->hasPropertyByName(sProgressRange))
1517 {
1518 uno::Any aAny;
1519 sal_Int32 nProgressMax(0);
1520 sal_Int32 nProgressCurrent(0);
1521 sal_Int32 nProgressRange(0);
1522 aAny = mxImportInfo->getPropertyValue(sProgressRange);
1523 if (aAny >>= nProgressRange)
1524 mpProgressBarHelper->SetRange(nProgressRange);
1525 aAny = mxImportInfo->getPropertyValue(sProgressMax);
1526 if (aAny >>= nProgressMax)
1527 mpProgressBarHelper->SetReference(nProgressMax);
1528 aAny = mxImportInfo->getPropertyValue(sProgressCurrent);
1529 if (aAny >>= nProgressCurrent)
1530 mpProgressBarHelper->SetValue(nProgressCurrent);
1531 }
1532 if (xPropertySetInfo->hasPropertyByName(sRepeat))
1533 {
1534 uno::Any aAny = mxImportInfo->getPropertyValue(sRepeat);
1535 if (aAny.getValueType() == getBooleanCppuType())
1536 mpProgressBarHelper->SetRepeat(::cppu::any2bool(aAny));
1537 else {
1538 DBG_ERRORFILE("why is it no boolean?");
1539 }
1540 }
1541 }
1542 }
1543 }
1544 return mpProgressBarHelper;
1545 }
1546
AddNumberStyle(sal_Int32 nKey,const OUString & rName)1547 void SvXMLImport::AddNumberStyle(sal_Int32 nKey, const OUString& rName)
1548 {
1549 if (!mxNumberStyles.is())
1550 mxNumberStyles = uno::Reference< container::XNameContainer >( comphelper::NameContainer_createInstance( ::getCppuType((const sal_Int32*)0)) );
1551 if (mxNumberStyles.is())
1552 {
1553 uno::Any aAny;
1554 aAny <<= nKey;
1555 try
1556 {
1557 mxNumberStyles->insertByName(rName, aAny);
1558 }
1559 catch ( uno::Exception& )
1560 {
1561 DBG_ERROR("Numberformat could not be inserted");
1562 }
1563 }
1564 else {
1565 DBG_ERROR("not possible to create NameContainer");
1566 }
1567 }
1568
GetEventImport()1569 XMLEventImportHelper& SvXMLImport::GetEventImport()
1570 {
1571 #ifndef SVX_LIGHT
1572 if (!mpEventImportHelper)
1573 {
1574 // construct event helper and register StarBasic handler and standard
1575 // event tables
1576 mpEventImportHelper = new XMLEventImportHelper();
1577 OUString sStarBasic(GetXMLToken(XML_STARBASIC));
1578 mpEventImportHelper->RegisterFactory(sStarBasic,
1579 new XMLStarBasicContextFactory());
1580 OUString sScript(GetXMLToken(XML_SCRIPT));
1581 mpEventImportHelper->RegisterFactory(sScript,
1582 new XMLScriptContextFactory());
1583 mpEventImportHelper->AddTranslationTable(aStandardEventTable);
1584
1585 // register StarBasic event handler with capitalized spelling
1586 OUString sStarBasicCap(RTL_CONSTASCII_USTRINGPARAM("StarBasic"));
1587 mpEventImportHelper->RegisterFactory(sStarBasicCap,
1588 new XMLStarBasicContextFactory());
1589 }
1590 #endif
1591
1592 return *mpEventImportHelper;
1593 }
1594
SetFontDecls(XMLFontStylesContext * pFontDecls)1595 void SvXMLImport::SetFontDecls( XMLFontStylesContext *pFontDecls )
1596 {
1597 mxFontDecls = pFontDecls;
1598 GetTextImport()->SetFontDecls( pFontDecls );
1599 }
1600
SetStyles(SvXMLStylesContext * pStyles)1601 void SvXMLImport::SetStyles( SvXMLStylesContext *pStyles )
1602 {
1603 mxStyles = pStyles;
1604 }
1605
SetAutoStyles(SvXMLStylesContext * pAutoStyles)1606 void SvXMLImport::SetAutoStyles( SvXMLStylesContext *pAutoStyles )
1607 {
1608 if (pAutoStyles && mxNumberStyles.is() && (mnImportFlags & IMPORT_CONTENT) )
1609 {
1610 uno::Reference<xml::sax::XAttributeList> xAttrList;
1611 uno::Sequence< ::rtl::OUString > aNames = mxNumberStyles->getElementNames();
1612 sal_uInt32 nCount(aNames.getLength());
1613 if (nCount)
1614 {
1615 const OUString* pNames = aNames.getConstArray();
1616 if ( pNames )
1617 {
1618 SvXMLStyleContext* pContext;
1619 uno::Any aAny;
1620 sal_Int32 nKey(0);
1621 for (sal_uInt32 i = 0; i < nCount; i++, pNames++)
1622 {
1623 aAny = mxNumberStyles->getByName(*pNames);
1624 if (aAny >>= nKey)
1625 {
1626 pContext = new SvXMLNumFormatContext( *this, XML_NAMESPACE_NUMBER,
1627 *pNames, xAttrList, nKey, *pAutoStyles );
1628 pAutoStyles->AddStyle(*pContext);
1629 }
1630 }
1631 }
1632 }
1633 }
1634 mxAutoStyles = pAutoStyles;
1635 GetTextImport()->SetAutoStyles( pAutoStyles );
1636 GetShapeImport()->SetAutoStylesContext( pAutoStyles );
1637 #ifndef SVX_LIGHT
1638 GetChartImport()->SetAutoStylesContext( pAutoStyles );
1639 GetFormImport()->setAutoStyleContext( pAutoStyles );
1640 #endif
1641 }
1642
SetMasterStyles(SvXMLStylesContext * pMasterStyles)1643 void SvXMLImport::SetMasterStyles( SvXMLStylesContext *pMasterStyles )
1644 {
1645 mxMasterStyles = pMasterStyles;
1646 }
1647
GetFontDecls()1648 XMLFontStylesContext *SvXMLImport::GetFontDecls()
1649 {
1650 return (XMLFontStylesContext *)&mxFontDecls;
1651 }
1652
GetStyles()1653 SvXMLStylesContext *SvXMLImport::GetStyles()
1654 {
1655 return (SvXMLStylesContext *)&mxStyles;
1656 }
1657
GetAutoStyles()1658 SvXMLStylesContext *SvXMLImport::GetAutoStyles()
1659 {
1660 return (SvXMLStylesContext *)&mxAutoStyles;
1661 }
1662
GetMasterStyles()1663 SvXMLStylesContext *SvXMLImport::GetMasterStyles()
1664 {
1665 return (SvXMLStylesContext *)&mxMasterStyles;
1666 }
1667
GetFontDecls() const1668 const XMLFontStylesContext *SvXMLImport::GetFontDecls() const
1669 {
1670 return (const XMLFontStylesContext *)&mxFontDecls;
1671 }
1672
GetStyles() const1673 const SvXMLStylesContext *SvXMLImport::GetStyles() const
1674 {
1675 return (const SvXMLStylesContext *)&mxStyles;
1676 }
1677
GetAutoStyles() const1678 const SvXMLStylesContext *SvXMLImport::GetAutoStyles() const
1679 {
1680 return (const SvXMLStylesContext *)&mxAutoStyles;
1681 }
1682
GetMasterStyles() const1683 const SvXMLStylesContext *SvXMLImport::GetMasterStyles() const
1684 {
1685 return (const SvXMLStylesContext *)&mxMasterStyles;
1686 }
1687
GetAbsoluteReference(const OUString & rValue) const1688 OUString SvXMLImport::GetAbsoluteReference(const OUString& rValue) const
1689 {
1690 if( rValue.getLength() == 0 || rValue[0] == '#' )
1691 return rValue;
1692
1693 INetURLObject aAbsURL;
1694 if( mpImpl->aBaseURL.GetNewAbsURL( rValue, &aAbsURL ) )
1695 return aAbsURL.GetMainURL( INetURLObject::DECODE_TO_IURI );
1696 else
1697 return rValue;
1698 }
1699
IsODFVersionConsistent(const::rtl::OUString & aODFVersion)1700 sal_Bool SvXMLImport::IsODFVersionConsistent( const ::rtl::OUString& aODFVersion )
1701 {
1702 // the check returns sal_False only if the storage version could be retrieved
1703 sal_Bool bResult = sal_True;
1704
1705 if ( aODFVersion.getLength() && aODFVersion.compareTo( ODFVER_012_TEXT ) >= 0 )
1706 {
1707 // check the consistency only for the ODF1.2 and later ( according to content.xml )
1708 // manifest.xml might have no version, it should be checked here and the correct version should be set
1709 try
1710 {
1711 uno::Reference< document::XStorageBasedDocument > xDoc( mxModel, uno::UNO_QUERY_THROW );
1712 uno::Reference< embed::XStorage > xStor = xDoc->getDocumentStorage();
1713 uno::Reference< beans::XPropertySet > xStorProps( xStor, uno::UNO_QUERY_THROW );
1714
1715 // the check should be done only for OASIS format
1716 ::rtl::OUString aMediaType;
1717 xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ) ) >>= aMediaType;
1718 if ( ::comphelper::OStorageHelper::GetXStorageFormat( xStor ) >= SOFFICE_FILEFORMAT_8 )
1719 {
1720 sal_Bool bRepairPackage = sal_False;
1721 try
1722 {
1723 xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RepairPackage" ) ) )
1724 >>= bRepairPackage;
1725 } catch ( uno::Exception& )
1726 {}
1727
1728 // check only if not in Repair mode
1729 if ( !bRepairPackage )
1730 {
1731 ::rtl::OUString aStorVersion;
1732 xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ) )
1733 >>= aStorVersion;
1734
1735 // if the storage version is set in manifest.xml, it must be the same as in content.xml
1736 // if not, set it explicitly to be used further ( it will work even for readonly storage )
1737 // This workaround is not nice, but I see no other way to handle it, since there are
1738 // ODF1.2 documents without version in manifest.xml
1739 if ( aStorVersion.getLength() )
1740 bResult = aODFVersion.equals( aStorVersion );
1741 else
1742 xStorProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ),
1743 uno::makeAny( aODFVersion ) );
1744
1745 if ( bResult )
1746 {
1747 sal_Bool bInconsistent = sal_False;
1748 xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsInconsistent" ) ) )
1749 >>= bInconsistent;
1750 bResult = !bInconsistent;
1751 }
1752 }
1753 }
1754 }
1755 catch( uno::Exception& )
1756 {}
1757 }
1758
1759 return bResult;
1760 }
1761
_CreateNumberFormatsSupplier()1762 void SvXMLImport::_CreateNumberFormatsSupplier()
1763 {
1764 DBG_ASSERT( !mxNumberFormatsSupplier.is(),
1765 "number formats supplier already exists!" );
1766 if(mxModel.is())
1767 mxNumberFormatsSupplier =
1768 uno::Reference< util::XNumberFormatsSupplier> (mxModel, uno::UNO_QUERY);
1769 }
1770
1771
_CreateDataStylesImport()1772 void SvXMLImport::_CreateDataStylesImport()
1773 {
1774 DBG_ASSERT( mpNumImport == NULL, "data styles import already exists!" );
1775 uno::Reference<util::XNumberFormatsSupplier> xNum =
1776 GetNumberFormatsSupplier();
1777 if ( xNum.is() )
1778 mpNumImport = new SvXMLNumFmtHelper(xNum, getServiceFactory());
1779 }
1780
1781
ConvStarBatsCharToStarSymbol(sal_Unicode c)1782 sal_Unicode SvXMLImport::ConvStarBatsCharToStarSymbol( sal_Unicode c )
1783 {
1784 sal_Unicode cNew = c;
1785 if( !mpImpl->hBatsFontConv )
1786 {
1787 OUString sStarBats( RTL_CONSTASCII_USTRINGPARAM( "StarBats" ) );
1788 mpImpl->hBatsFontConv = CreateFontToSubsFontConverter( sStarBats,
1789 FONTTOSUBSFONT_IMPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS );
1790 OSL_ENSURE( mpImpl->hBatsFontConv, "Got no symbol font converter" );
1791 }
1792 if( mpImpl->hBatsFontConv )
1793 {
1794 cNew = ConvertFontToSubsFontChar( mpImpl->hBatsFontConv, c );
1795 }
1796
1797 return cNew;
1798 }
1799
ConvStarMathCharToStarSymbol(sal_Unicode c)1800 sal_Unicode SvXMLImport::ConvStarMathCharToStarSymbol( sal_Unicode c )
1801 {
1802 sal_Unicode cNew = c;
1803 if( !mpImpl->hMathFontConv )
1804 {
1805 OUString sStarMath( RTL_CONSTASCII_USTRINGPARAM( "StarMath" ) );
1806 mpImpl->hMathFontConv = CreateFontToSubsFontConverter( sStarMath,
1807 FONTTOSUBSFONT_IMPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS );
1808 OSL_ENSURE( mpImpl->hMathFontConv, "Got no symbol font converter" );
1809 }
1810 if( mpImpl->hMathFontConv )
1811 {
1812 cNew = ConvertFontToSubsFontChar( mpImpl->hMathFontConv, c );
1813 }
1814
1815 return cNew;
1816 }
1817
1818
1819
SetError(sal_Int32 nId,const Sequence<OUString> & rMsgParams,const OUString & rExceptionMessage,const Reference<xml::sax::XLocator> & rLocator)1820 void SvXMLImport::SetError(
1821 sal_Int32 nId,
1822 const Sequence<OUString>& rMsgParams,
1823 const OUString& rExceptionMessage,
1824 const Reference<xml::sax::XLocator>& rLocator )
1825 {
1826 // maintain error flags
1827 if ( ( nId & XMLERROR_FLAG_ERROR ) != 0 )
1828 mnErrorFlags |= ERROR_ERROR_OCCURED;
1829 if ( ( nId & XMLERROR_FLAG_WARNING ) != 0 )
1830 mnErrorFlags |= ERROR_WARNING_OCCURED;
1831 if ( ( nId & XMLERROR_FLAG_SEVERE ) != 0 )
1832 mnErrorFlags |= ERROR_DO_NOTHING;
1833
1834 // create error list on demand
1835 if ( mpXMLErrors == NULL )
1836 mpXMLErrors = new XMLErrors();
1837
1838 // save error information
1839 // use document locator (if none supplied)
1840 mpXMLErrors->AddRecord( nId, rMsgParams, rExceptionMessage,
1841 rLocator.is() ? rLocator : mxLocator );
1842 }
1843
SetError(sal_Int32 nId,const Sequence<OUString> & rMsgParams)1844 void SvXMLImport::SetError(
1845 sal_Int32 nId,
1846 const Sequence<OUString>& rMsgParams)
1847 {
1848 OUString sEmpty;
1849 SetError( nId, rMsgParams, sEmpty, NULL );
1850 }
1851
SetError(sal_Int32 nId)1852 void SvXMLImport::SetError(
1853 sal_Int32 nId)
1854 {
1855 Sequence<OUString> aSeq(0);
1856 SetError( nId, aSeq );
1857 }
1858
SetError(sal_Int32 nId,const OUString & rMsg1)1859 void SvXMLImport::SetError(
1860 sal_Int32 nId,
1861 const OUString& rMsg1)
1862 {
1863 Sequence<OUString> aSeq(1);
1864 OUString* pSeq = aSeq.getArray();
1865 pSeq[0] = rMsg1;
1866 SetError( nId, aSeq );
1867 }
1868
SetError(sal_Int32 nId,const OUString & rMsg1,const OUString & rMsg2)1869 void SvXMLImport::SetError(
1870 sal_Int32 nId,
1871 const OUString& rMsg1,
1872 const OUString& rMsg2)
1873 {
1874 Sequence<OUString> aSeq(2);
1875 OUString* pSeq = aSeq.getArray();
1876 pSeq[0] = rMsg1;
1877 pSeq[1] = rMsg2;
1878 SetError( nId, aSeq );
1879 }
1880
SetError(sal_Int32 nId,const OUString & rMsg1,const OUString & rMsg2,const OUString & rMsg3)1881 void SvXMLImport::SetError(
1882 sal_Int32 nId,
1883 const OUString& rMsg1,
1884 const OUString& rMsg2,
1885 const OUString& rMsg3)
1886 {
1887 Sequence<OUString> aSeq(3);
1888 OUString* pSeq = aSeq.getArray();
1889 pSeq[0] = rMsg1;
1890 pSeq[1] = rMsg2;
1891 pSeq[2] = rMsg3;
1892 SetError( nId, aSeq );
1893 }
1894
SetError(sal_Int32 nId,const OUString & rMsg1,const OUString & rMsg2,const OUString & rMsg3,const OUString & rMsg4)1895 void SvXMLImport::SetError(
1896 sal_Int32 nId,
1897 const OUString& rMsg1,
1898 const OUString& rMsg2,
1899 const OUString& rMsg3,
1900 const OUString& rMsg4)
1901 {
1902 Sequence<OUString> aSeq(4);
1903 OUString* pSeq = aSeq.getArray();
1904 pSeq[0] = rMsg1;
1905 pSeq[1] = rMsg2;
1906 pSeq[2] = rMsg3;
1907 pSeq[3] = rMsg4;
1908 SetError( nId, aSeq );
1909 }
1910
GetErrors()1911 XMLErrors* SvXMLImport::GetErrors()
1912 {
1913 return mpXMLErrors;
1914 }
1915
DisposingModel()1916 void SvXMLImport::DisposingModel()
1917 {
1918 if( mxFontDecls.Is() )
1919 ((SvXMLStylesContext *)&mxFontDecls)->Clear();
1920 if( mxStyles.Is() )
1921 ((SvXMLStylesContext *)&mxStyles)->Clear();
1922 if( mxAutoStyles.Is() )
1923 ((SvXMLStylesContext *)&mxAutoStyles)->Clear();
1924 if( mxMasterStyles.Is() )
1925 ((SvXMLStylesContext *)&mxMasterStyles)->Clear();
1926
1927 mxModel.set(0);
1928 mxEventListener.set(NULL);
1929 }
1930
getInterfaceToIdentifierMapper()1931 ::comphelper::UnoInterfaceToUniqueIdentifierMapper& SvXMLImport::getInterfaceToIdentifierMapper()
1932 {
1933 return mpImpl->maInterfaceToIdentifierMapper;
1934 }
1935
getServiceFactory()1936 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > SvXMLImport::getServiceFactory()
1937 {
1938 // #110680#
1939 return mxServiceFactory;
1940 }
1941
1942 uno::Reference< uno::XComponentContext >
GetComponentContext() const1943 SvXMLImport::GetComponentContext() const
1944 {
1945 return mpImpl->mxComponentContext;
1946 }
1947
GetBaseURL() const1948 String SvXMLImport::GetBaseURL() const
1949 {
1950 return mpImpl->aBaseURL.GetMainURL( INetURLObject::NO_DECODE );
1951 }
1952
GetDocumentBase() const1953 String SvXMLImport::GetDocumentBase() const
1954 {
1955 return mpImpl->aDocBase.GetMainURL( INetURLObject::NO_DECODE );
1956 }
1957
GetStreamName() const1958 ::rtl::OUString SvXMLImport::GetStreamName() const
1959 {
1960 return mpImpl->mStreamName;
1961 }
1962
1963 // --> OD 2004-08-10 #i28749#
IsShapePositionInHoriL2R() const1964 sal_Bool SvXMLImport::IsShapePositionInHoriL2R() const
1965 {
1966 return mpImpl->mbShapePositionInHoriL2R;
1967 }
1968 // <--
1969
1970 // --> OD 2007-12-19 #152540#
IsTextDocInOOoFileFormat() const1971 sal_Bool SvXMLImport::IsTextDocInOOoFileFormat() const
1972 {
1973 return mpImpl->mbTextDocInOOoFileFormat;
1974 }
1975
1976 // <--
1977
initXForms()1978 void SvXMLImport::initXForms()
1979 {
1980 // dummy method; to be implemented by derived classes supporting XForms
1981 }
1982
getBuildIds(sal_Int32 & rUPD,sal_Int32 & rBuild) const1983 bool SvXMLImport::getBuildIds( sal_Int32& rUPD, sal_Int32& rBuild ) const
1984 {
1985 bool bRet = false;
1986 if( mxImportInfo.is() ) try
1987 {
1988 const OUString aPropName(RTL_CONSTASCII_USTRINGPARAM("BuildId"));
1989 Reference< XPropertySetInfo > xSetInfo( mxImportInfo->getPropertySetInfo() );
1990 if( xSetInfo.is() && xSetInfo->hasPropertyByName( aPropName ) )
1991 {
1992 OUString aBuildId;
1993 mxImportInfo->getPropertyValue( aPropName ) >>= aBuildId;
1994 if( aBuildId.getLength() )
1995 {
1996 sal_Int32 nIndex = aBuildId.indexOf('$');
1997 if( nIndex != -1 )
1998 {
1999 rUPD = aBuildId.copy( 0, nIndex ).toInt32();
2000 rBuild = aBuildId.copy( nIndex+1 ).toInt32();
2001 bRet = true;
2002 }
2003 }
2004 }
2005 }
2006 catch( Exception& )
2007 {
2008 }
2009 return bRet;
2010 }
2011
getGeneratorVersion() const2012 sal_uInt16 SvXMLImport::getGeneratorVersion() const
2013 {
2014 // --> ORW
2015 return mpImpl->getGeneratorVersion( *this );
2016 // <--
2017 }
2018
isGraphicLoadOnDemandSupported() const2019 bool SvXMLImport::isGraphicLoadOnDemandSupported() const
2020 {
2021 return mbIsGraphicLoadOnDemandSupported;
2022 }
2023
GetODFVersion() const2024 ::rtl::OUString SvXMLImport::GetODFVersion() const
2025 {
2026 return mpImpl->aODFVersion;
2027 }
2028
2029 // xml:id for RDF metadata
SetXmlId(uno::Reference<uno::XInterface> const & i_xIfc,::rtl::OUString const & i_rXmlId)2030 void SvXMLImport::SetXmlId(uno::Reference<uno::XInterface> const & i_xIfc,
2031 ::rtl::OUString const & i_rXmlId)
2032 {
2033 if (i_rXmlId.getLength() > 0) {
2034 try {
2035 const uno::Reference<rdf::XMetadatable> xMeta(i_xIfc,
2036 uno::UNO_QUERY);
2037 //FIXME: not yet
2038 // OSL_ENSURE(xMeta.is(), "xml:id: not XMetadatable");
2039 if (xMeta.is()) {
2040 const beans::StringPair mdref( GetStreamName(), i_rXmlId );
2041 try {
2042 xMeta->setMetadataReference(mdref);
2043 } catch (lang::IllegalArgumentException &) {
2044 // probably duplicate; ignore
2045 OSL_TRACE("SvXMLImport::SetXmlId: cannot set xml:id");
2046 }
2047 }
2048 } catch (uno::Exception &) {
2049 OSL_ENSURE(false, "SvXMLImport::SetXmlId: exception?");
2050 }
2051 }
2052 }
2053
2054 SAL_DLLPRIVATE ::xmloff::RDFaImportHelper &
GetRDFaImportHelper()2055 SvXMLImport::GetRDFaImportHelper()
2056 {
2057 if (!mpImpl->mpRDFaHelper.get())
2058 {
2059 mpImpl->mpRDFaHelper.reset( new ::xmloff::RDFaImportHelper(*this) );
2060 }
2061 return *mpImpl->mpRDFaHelper;
2062 }
2063
2064 void
AddRDFa(uno::Reference<rdf::XMetadatable> i_xObject,::rtl::OUString const & i_rAbout,::rtl::OUString const & i_rProperty,::rtl::OUString const & i_rContent,::rtl::OUString const & i_rDatatype)2065 SvXMLImport::AddRDFa(uno::Reference<rdf::XMetadatable> i_xObject,
2066 ::rtl::OUString const & i_rAbout,
2067 ::rtl::OUString const & i_rProperty,
2068 ::rtl::OUString const & i_rContent,
2069 ::rtl::OUString const & i_rDatatype)
2070 {
2071 // N.B.: we only get called if i_xObject had xhtml:about attribute
2072 // (an empty attribute value is valid)
2073 ::xmloff::RDFaImportHelper & rRDFaHelper( GetRDFaImportHelper() );
2074 rRDFaHelper.ParseAndAddRDFa(i_xObject,
2075 i_rAbout, i_rProperty, i_rContent, i_rDatatype);
2076 }
2077
2078