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