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 : explicit 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 2399 : SvXMLImportEventListener::SvXMLImportEventListener(SvXMLImport* pTempImport)
123 2399 : : pImport(pTempImport)
124 : {
125 2399 : }
126 :
127 4798 : SvXMLImportEventListener::~SvXMLImportEventListener()
128 : {
129 4798 : }
130 :
131 : // XEventListener
132 14 : void SAL_CALL SvXMLImportEventListener::disposing( const lang::EventObject& )
133 : throw(uno::RuntimeException, std::exception)
134 : {
135 14 : if (pImport)
136 : {
137 14 : pImport->DisposingModel();
138 14 : pImport = NULL;
139 : }
140 14 : }
141 :
142 : namespace
143 : {
144 :
145 : static OUString
146 6284 : getBuildIdsProperty(uno::Reference<beans::XPropertySet> const& xImportInfo)
147 : {
148 6284 : if (xImportInfo.is())
149 : {
150 : try
151 : {
152 : Reference< XPropertySetInfo > const xSetInfo(
153 4426 : xImportInfo->getPropertySetInfo());
154 4426 : if (xSetInfo.is() && xSetInfo->hasPropertyByName("BuildId"))
155 : {
156 4384 : OUString aBuildId;
157 4384 : xImportInfo->getPropertyValue("BuildId") >>= aBuildId;
158 4384 : return aBuildId;
159 42 : }
160 : }
161 0 : catch (Exception const&)
162 : {
163 : SAL_WARN("xmloff.core", "exception getting BuildId");
164 : DBG_UNHANDLED_EXCEPTION();
165 : }
166 : }
167 1900 : return OUString();
168 : }
169 :
170 : class DocumentInfo
171 : {
172 : private:
173 : sal_uInt16 mnGeneratorVersion;
174 :
175 : public:
176 514 : explicit DocumentInfo( const SvXMLImport& rImport )
177 514 : : mnGeneratorVersion( SvXMLImport::ProductVersionUnknown )
178 : {
179 : OUString const buildIds(
180 514 : getBuildIdsProperty(rImport.getImportInfo()));
181 514 : if (!buildIds.isEmpty())
182 : {
183 404 : sal_Int32 const ix = buildIds.indexOf(';');
184 404 : if (-1 != ix)
185 : {
186 377 : OUString const loVersion(buildIds.copy(ix + 1));
187 377 : if (!loVersion.isEmpty())
188 : {
189 377 : if ('3' == loVersion[0])
190 : {
191 28 : mnGeneratorVersion = SvXMLImport::LO_3x;
192 : }
193 : else
194 : {
195 : SAL_INFO_IF('4' != loVersion[0], "xmloff.core", "unknown LO version: " << loVersion);
196 956 : if ('4' == loVersion[0] && loVersion.getLength() > 1
197 607 : && (loVersion[1] == '0' || loVersion[1] == '1'))
198 : {
199 53 : mnGeneratorVersion = SvXMLImport::LO_41x; // 4.0/4.1
200 : }
201 592 : else if ('4' == loVersion[0]
202 296 : && loVersion.getLength() > 1 && loVersion[1] == '2')
203 : {
204 58 : mnGeneratorVersion = SvXMLImport::LO_42x; // 4.2
205 : }
206 : else
207 : {
208 238 : mnGeneratorVersion = SvXMLImport::LO_4x;
209 : }
210 : }
211 891 : return; // ignore buildIds
212 0 : }
213 : }
214 : }
215 : sal_Int32 nUPD, nBuild;
216 137 : if ( rImport.getBuildIds( nUPD, nBuild ) )
217 : {
218 27 : if ( nUPD >= 640 && nUPD <= 645 )
219 : {
220 1 : mnGeneratorVersion = SvXMLImport::OOo_1x;
221 : }
222 26 : else if ( nUPD == 680 )
223 : {
224 4 : mnGeneratorVersion = SvXMLImport::OOo_2x;
225 : }
226 22 : else if ( nUPD == 300 && nBuild <= 9379 )
227 : {
228 1 : mnGeneratorVersion = SvXMLImport::OOo_30x;
229 : }
230 21 : else if ( nUPD == 310 )
231 : {
232 0 : mnGeneratorVersion = SvXMLImport::OOo_31x;
233 : }
234 21 : else if ( nUPD == 320 )
235 : {
236 6 : mnGeneratorVersion = SvXMLImport::OOo_32x;
237 : }
238 15 : else if ( nUPD == 330 )
239 : {
240 6 : mnGeneratorVersion = SvXMLImport::OOo_33x;
241 : }
242 9 : else if ( nUPD == 340 )
243 : {
244 0 : mnGeneratorVersion = SvXMLImport::OOo_34x;
245 : }
246 9 : else if (nUPD == 400)
247 : {
248 1 : mnGeneratorVersion = SvXMLImport::AOO_40x;
249 : }
250 8 : else if (nUPD >= 410)
251 : {
252 : // effectively this means "latest", see use
253 : // in XMLGraphicsDefaultStyle::SetDefaults()!
254 2 : mnGeneratorVersion = SvXMLImport::AOO_4x;
255 : }
256 137 : }
257 : }
258 :
259 514 : ~DocumentInfo()
260 514 : {}
261 :
262 1662 : sal_uInt16 getGeneratorVersion() const
263 : {
264 1662 : 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 2980 : 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 2980 : , mpDocumentInfo() // lazy
316 : {
317 : SAL_WARN_IF(!mxComponentContext.is(), "xmloff.core", "SvXMLImport: no ComponentContext");
318 2980 : if (!mxComponentContext.is()) throw uno::RuntimeException();
319 2980 : }
320 :
321 2980 : ~SvXMLImport_Impl()
322 2980 : {
323 2980 : if( hBatsFontConv )
324 0 : DestroyFontToSubsFontConverter( hBatsFontConv );
325 2980 : if( hMathFontConv )
326 0 : DestroyFontToSubsFontConverter( hMathFontConv );
327 2980 : }
328 :
329 1662 : sal_uInt16 getGeneratorVersion( const SvXMLImport& rImport )
330 : {
331 1662 : if ( !mpDocumentInfo.get() )
332 : {
333 514 : mpDocumentInfo.reset( new DocumentInfo( rImport ) );
334 : }
335 :
336 1662 : return mpDocumentInfo->getGeneratorVersion();
337 : }
338 :
339 : ::comphelper::UnoInterfaceToUniqueIdentifierMapper maInterfaceToIdentifierMapper;
340 : };
341 :
342 1222 : SvXMLImportContext *SvXMLImport::CreateContext( sal_uInt16 nPrefix,
343 : const OUString& rLocalName,
344 : const uno::Reference< xml::sax::XAttributeList >& )
345 : {
346 1222 : return new SvXMLImportContext( *this, nPrefix, rLocalName );
347 : }
348 :
349 8 : SvXMLImportContext *SvXMLImport::CreateFastContext( sal_Int32 /*Element*/,
350 : const uno::Reference< xml::sax::XFastAttributeList >& /*xAttrList*/ )
351 : {
352 8 : return new SvXMLImportContext( *this );
353 : }
354 :
355 2980 : void SvXMLImport::_InitCtor()
356 : {
357 2980 : if( mnImportFlags != SvXMLImportFlags::NONE )
358 : {
359 : // implicit "xml" namespace prefix
360 2434 : mpNamespaceMap->Add( GetXMLToken(XML_XML), GetXMLToken(XML_N_XML), XML_NAMESPACE_XML );
361 2434 : mpNamespaceMap->Add( OUString( sXML_np__office ), GetXMLToken(XML_N_OFFICE), XML_NAMESPACE_OFFICE );
362 2434 : mpNamespaceMap->Add( OUString( sXML_np__office_ext ), GetXMLToken(XML_N_OFFICE_EXT), XML_NAMESPACE_OFFICE_EXT );
363 2434 : mpNamespaceMap->Add( OUString( sXML_np__ooo ), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO );
364 2434 : mpNamespaceMap->Add( OUString( sXML_np__style ), GetXMLToken(XML_N_STYLE), XML_NAMESPACE_STYLE );
365 2434 : mpNamespaceMap->Add( OUString( sXML_np__text ), GetXMLToken(XML_N_TEXT), XML_NAMESPACE_TEXT );
366 2434 : mpNamespaceMap->Add( OUString( sXML_np__table ), GetXMLToken(XML_N_TABLE), XML_NAMESPACE_TABLE );
367 2434 : mpNamespaceMap->Add( OUString( sXML_np__table_ext ), GetXMLToken(XML_N_TABLE_EXT), XML_NAMESPACE_TABLE_EXT );
368 2434 : mpNamespaceMap->Add( OUString( sXML_np__draw ), GetXMLToken(XML_N_DRAW), XML_NAMESPACE_DRAW );
369 2434 : mpNamespaceMap->Add( OUString( sXML_np__draw_ext ), GetXMLToken(XML_N_DRAW_EXT), XML_NAMESPACE_DRAW_EXT );
370 2434 : mpNamespaceMap->Add( OUString( sXML_np__dr3d ), GetXMLToken(XML_N_DR3D), XML_NAMESPACE_DR3D );
371 2434 : mpNamespaceMap->Add( OUString( sXML_np__fo ), GetXMLToken(XML_N_FO_COMPAT), XML_NAMESPACE_FO );
372 2434 : mpNamespaceMap->Add( OUString( sXML_np__xlink ), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK );
373 2434 : mpNamespaceMap->Add( OUString( sXML_np__dc ), GetXMLToken(XML_N_DC), XML_NAMESPACE_DC );
374 2434 : mpNamespaceMap->Add( OUString( sXML_np__dom ), GetXMLToken(XML_N_DOM), XML_NAMESPACE_DOM );
375 2434 : mpNamespaceMap->Add( OUString( sXML_np__meta ), GetXMLToken(XML_N_META), XML_NAMESPACE_META );
376 2434 : mpNamespaceMap->Add( OUString( sXML_np__number ), GetXMLToken(XML_N_NUMBER), XML_NAMESPACE_NUMBER );
377 2434 : mpNamespaceMap->Add( OUString( sXML_np__svg ), GetXMLToken(XML_N_SVG_COMPAT), XML_NAMESPACE_SVG );
378 2434 : mpNamespaceMap->Add( OUString( sXML_np__chart ), GetXMLToken(XML_N_CHART), XML_NAMESPACE_CHART );
379 2434 : mpNamespaceMap->Add( OUString( sXML_np__math ), GetXMLToken(XML_N_MATH), XML_NAMESPACE_MATH );
380 2434 : mpNamespaceMap->Add(OUString( sXML_np__form ), GetXMLToken(XML_N_FORM), XML_NAMESPACE_FORM );
381 2434 : mpNamespaceMap->Add( OUString( sXML_np__script ), GetXMLToken(XML_N_SCRIPT), XML_NAMESPACE_SCRIPT );
382 2434 : mpNamespaceMap->Add( OUString( sXML_np__config ), GetXMLToken(XML_N_CONFIG), XML_NAMESPACE_CONFIG );
383 2434 : mpNamespaceMap->Add( OUString( sXML_np__xforms ), GetXMLToken(XML_N_XFORMS_1_0), XML_NAMESPACE_XFORMS );
384 2434 : mpNamespaceMap->Add( OUString( sXML_np__formx ), GetXMLToken( XML_N_FORMX ), XML_NAMESPACE_FORMX );
385 2434 : mpNamespaceMap->Add( OUString( sXML_np__xsd ), GetXMLToken(XML_N_XSD), XML_NAMESPACE_XSD );
386 2434 : mpNamespaceMap->Add( OUString( sXML_np__xsi ), GetXMLToken(XML_N_XSI), XML_NAMESPACE_XFORMS );
387 2434 : mpNamespaceMap->Add( OUString( sXML_np__ooow ), GetXMLToken(XML_N_OOOW), XML_NAMESPACE_OOOW );
388 2434 : mpNamespaceMap->Add( OUString( sXML_np__oooc ), GetXMLToken(XML_N_OOOC), XML_NAMESPACE_OOOC );
389 2434 : mpNamespaceMap->Add( OUString( sXML_np__field ), GetXMLToken(XML_N_FIELD), XML_NAMESPACE_FIELD );
390 2434 : mpNamespaceMap->Add( OUString( sXML_np__of ), GetXMLToken(XML_N_OF), XML_NAMESPACE_OF );
391 2434 : mpNamespaceMap->Add( OUString( sXML_np__xhtml ), GetXMLToken(XML_N_XHTML), XML_NAMESPACE_XHTML );
392 2434 : mpNamespaceMap->Add( OUString( sXML_np__css3text ), GetXMLToken(XML_N_CSS3TEXT), XML_NAMESPACE_CSS3TEXT );
393 :
394 2434 : mpNamespaceMap->Add( "_calc_libo", GetXMLToken(XML_N_CALC_EXT), XML_NAMESPACE_CALC_EXT);
395 : mpNamespaceMap->Add( "_office_libo",
396 2434 : GetXMLToken(XML_N_LO_EXT), XML_NAMESPACE_LO_EXT);
397 : }
398 :
399 2980 : msPackageProtocol = "vnd.sun.star.Package:";
400 :
401 2980 : if (mxNumberFormatsSupplier.is())
402 0 : mpNumImport = new SvXMLNumFmtHelper(mxNumberFormatsSupplier, GetComponentContext());
403 :
404 2980 : if (mxModel.is() && !mxEventListener.is())
405 : {
406 0 : mxEventListener.set(new SvXMLImportEventListener(this));
407 0 : mxModel->addEventListener(mxEventListener);
408 : }
409 :
410 2980 : ::comphelper::UnoInterfaceToUniqueIdentifierMapper maInterfaceToIdentifierMapper;
411 :
412 2980 : }
413 :
414 2980 : SvXMLImport::SvXMLImport(
415 : const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& xContext,
416 : OUString const & implementationName, SvXMLImportFlags nImportFlags ) throw ()
417 2980 : : mpImpl( new SvXMLImport_Impl(xContext, implementationName) ),
418 2980 : mpNamespaceMap( new SvXMLNamespaceMap ),
419 :
420 : mpUnitConv( new SvXMLUnitConverter( xContext,
421 2980 : util::MeasureUnit::MM_100TH, util::MeasureUnit::MM_100TH) ),
422 :
423 2980 : mpContexts( new SvXMLImportContexts_Impl ),
424 2980 : mpFastContexts( new FastSvXMLImportContexts_Impl ),
425 : mpNumImport( NULL ),
426 : mpProgressBarHelper( NULL ),
427 : mpEventImportHelper( NULL ),
428 : mpXMLErrors( NULL ),
429 : mpStyleMap(0),
430 : mnImportFlags( nImportFlags ),
431 : mnErrorFlags(SvXMLErrorFlags::NO),
432 : mbIsFormsSupported( true ),
433 : mbIsTableShapeSupported( false ),
434 17880 : mbIsGraphicLoadOnDemandSupported( true )
435 : {
436 : SAL_WARN_IF( !xContext.is(), "xmloff.core", "got no service manager" );
437 2980 : _InitCtor();
438 2980 : }
439 :
440 5960 : SvXMLImport::~SvXMLImport() throw ()
441 : {
442 2980 : delete mpXMLErrors;
443 2980 : delete mpNamespaceMap;
444 2980 : delete mpUnitConv;
445 2980 : delete mpEventImportHelper;
446 2980 : delete mpFastContexts;
447 2980 : if( mpContexts )
448 : {
449 5960 : while( !mpContexts->empty() )
450 : {
451 0 : SvXMLImportContext *pContext = mpContexts->back();
452 0 : mpContexts->pop_back();
453 0 : if( pContext )
454 0 : pContext->ReleaseRef();
455 : }
456 2980 : delete mpContexts;
457 : }
458 :
459 : // #i9518# the import component might not be deleted until after the document has been closed,
460 : // so the stuff that accesses the document has been moved to endDocument.
461 :
462 : // pNumImport is allocated in the ctor, so it must also be deleted here in case the component
463 : // is created and deleted without actually importing.
464 2980 : delete mpNumImport;
465 2980 : delete mpProgressBarHelper;
466 :
467 2980 : delete mpImpl;
468 :
469 2980 : if (mxEventListener.is() && mxModel.is())
470 2385 : mxModel->removeEventListener(mxEventListener);
471 2980 : }
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 2613 : 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 2613 : if( !mxGraphicResolver.is() || !mxEmbeddedResolver.is() )
503 : {
504 1286 : Reference< lang::XMultiServiceFactory > xFactory( mxModel, UNO_QUERY );
505 1286 : if( xFactory.is() )
506 : {
507 : try
508 : {
509 1033 : if( !mxGraphicResolver.is() )
510 : {
511 1580 : mxGraphicResolver = Reference< XGraphicObjectResolver >::query(
512 790 : xFactory->createInstance(
513 : // #99870# Import... instead of Export...
514 1580 : "com.sun.star.document.ImportGraphicObjectResolver"));
515 790 : mpImpl->mbOwnGraphicResolver = mxGraphicResolver.is();
516 : }
517 :
518 1033 : if( !mxEmbeddedResolver.is() )
519 : {
520 2066 : mxEmbeddedResolver = Reference< XEmbeddedObjectResolver >::query(
521 1033 : xFactory->createInstance(
522 : // #99870# Import... instead of Export...
523 2066 : "com.sun.star.document.ImportEmbeddedObjectResolver"));
524 1033 : mpImpl->mbOwnEmbeddedResolver = mxEmbeddedResolver.is();
525 : }
526 : }
527 0 : catch( com::sun::star::uno::Exception& )
528 : {
529 : }
530 1286 : }
531 : }
532 2613 : }
533 :
534 2606 : 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 2606 : if (mpImpl->mpRDFaHelper.get())
544 : {
545 : const uno::Reference<rdf::XRepositorySupplier> xRS(mxModel,
546 6 : uno::UNO_QUERY);
547 6 : if (xRS.is())
548 : {
549 6 : mpImpl->mpRDFaHelper->InsertRDFa( xRS );
550 6 : }
551 : }
552 :
553 2606 : if (mpNumImport)
554 : {
555 1067 : delete mpNumImport;
556 1067 : mpNumImport = NULL;
557 : }
558 2606 : if (mxImportInfo.is())
559 : {
560 2273 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
561 2273 : if (xPropertySetInfo.is())
562 : {
563 2273 : if (mpProgressBarHelper)
564 : {
565 1415 : OUString sProgressMax(XML_PROGRESSMAX);
566 2830 : OUString sProgressCurrent(XML_PROGRESSCURRENT);
567 2830 : OUString sRepeat(XML_PROGRESSREPEAT);
568 2791 : if (xPropertySetInfo->hasPropertyByName(sProgressMax) &&
569 1376 : xPropertySetInfo->hasPropertyByName(sProgressCurrent))
570 : {
571 1376 : sal_Int32 nProgressMax(mpProgressBarHelper->GetReference());
572 1376 : sal_Int32 nProgressCurrent(mpProgressBarHelper->GetValue());
573 1376 : uno::Any aAny;
574 1376 : aAny <<= nProgressMax;
575 1376 : mxImportInfo->setPropertyValue(sProgressMax, aAny);
576 1376 : aAny <<= nProgressCurrent;
577 1376 : mxImportInfo->setPropertyValue(sProgressCurrent, aAny);
578 : }
579 1415 : if (xPropertySetInfo->hasPropertyByName(sRepeat))
580 1415 : mxImportInfo->setPropertyValue(sRepeat, css::uno::makeAny(mpProgressBarHelper->GetRepeat()));
581 : // pProgressBarHelper is deleted in dtor
582 : }
583 2273 : OUString sNumberStyles(XML_NUMBERSTYLES);
584 2273 : if (mxNumberStyles.is() && xPropertySetInfo->hasPropertyByName(sNumberStyles))
585 : {
586 344 : uno::Any aAny;
587 344 : aAny <<= mxNumberStyles;
588 344 : mxImportInfo->setPropertyValue(sNumberStyles, aAny);
589 2273 : }
590 2273 : }
591 : }
592 :
593 2606 : if( mxFontDecls.Is() )
594 1120 : static_cast<SvXMLStylesContext *>(&mxFontDecls)->Clear();
595 2606 : if( mxStyles.Is() )
596 543 : static_cast<SvXMLStylesContext *>(&mxStyles)->Clear();
597 2606 : if( mxAutoStyles.Is() )
598 1098 : static_cast<SvXMLStylesContext *>(&mxAutoStyles)->Clear();
599 2606 : if( mxMasterStyles.Is() )
600 344 : static_cast<SvXMLStylesContext *>(&mxMasterStyles)->Clear();
601 :
602 : // possible form-layer related knittings which can only be done when
603 : // the whole document exists
604 2606 : if ( mxFormImport.is() )
605 1233 : 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 2606 : mxShapeImport = NULL;
610 :
611 2606 : if( mpImpl->mbOwnGraphicResolver )
612 : {
613 780 : Reference< lang::XComponent > xComp( mxGraphicResolver, UNO_QUERY );
614 780 : xComp->dispose();
615 : }
616 :
617 2606 : if( mpImpl->mbOwnEmbeddedResolver )
618 : {
619 780 : Reference< lang::XComponent > xComp( mxEmbeddedResolver, UNO_QUERY );
620 780 : xComp->dispose();
621 : }
622 2606 : if( mpStyleMap )
623 : {
624 870 : mpStyleMap->release();
625 870 : mpStyleMap = 0;
626 : }
627 :
628 2606 : if ( mpXMLErrors != NULL )
629 : {
630 47 : mpXMLErrors->ThrowErrorAsSAXException( XMLERROR_FLAG_SEVERE );
631 : }
632 2606 : }
633 :
634 243606 : 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 243606 : 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 243606 : sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
643 822316 : for( sal_Int16 i=0; i < nAttrCount; i++ )
644 : {
645 578710 : const OUString& rAttrName = xAttrList->getNameByIndex( i );
646 578710 : if ( rAttrName == "office:version" )
647 : {
648 2401 : 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 2401 : 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 1728927 : else if( ( rAttrName.getLength() >= 5 ) &&
660 672181 : ( rAttrName.startsWith( GetXMLToken(XML_XMLNS) ) ) &&
661 95868 : ( rAttrName.getLength() == 5 || ':' == rAttrName[5] ) )
662 : {
663 47936 : if( !pRewindMap )
664 : {
665 2609 : pRewindMap = mpNamespaceMap;
666 2609 : mpNamespaceMap = new SvXMLNamespaceMap( *mpNamespaceMap );
667 : }
668 47936 : const OUString& rAttrValue = xAttrList->getValueByIndex( i );
669 :
670 47936 : OUString aPrefix( ( rAttrName.getLength() == 5 )
671 : ? OUString()
672 95872 : : rAttrName.copy( 6 ) );
673 : // Add namespace, but only if it is known.
674 47936 : 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 47936 : if( XML_NAMESPACE_UNKNOWN == nKey )
678 : {
679 4096 : OUString aTestName( rAttrValue );
680 4096 : if( SvXMLNamespaceMap::NormalizeURI( aTestName ) )
681 356 : nKey = mpNamespaceMap->AddIfKnown( aPrefix, aTestName );
682 : }
683 : // If that namespace is not known, too, add it as unknown
684 47936 : if( XML_NAMESPACE_UNKNOWN == nKey )
685 51892 : mpNamespaceMap->Add( aPrefix, rAttrValue );
686 :
687 : }
688 578710 : }
689 :
690 : // Get element's namespace and local name.
691 243606 : OUString aLocalName;
692 : sal_uInt16 nPrefix =
693 243606 : 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 243606 : sal_uInt16 nCount = mpContexts->size();
699 243606 : if( nCount > 0 )
700 : {
701 241062 : pContext = (*mpContexts)[nCount - 1]->CreateChildContext( nPrefix,
702 : aLocalName,
703 241062 : xAttrList );
704 : SAL_WARN_IF( !pContext || (pContext->GetPrefix() != nPrefix), "xmloff.core",
705 : "SvXMLImport::startElement: created context has wrong prefix" );
706 : }
707 : else
708 : {
709 2544 : pContext = CreateContext( nPrefix, aLocalName, xAttrList );
710 2544 : 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 243606 : if( !pContext )
725 0 : pContext = new SvXMLImportContext( *this, nPrefix, aLocalName );
726 :
727 243606 : pContext->AddFirstRef();
728 :
729 : // Remember old namespace map.
730 243606 : if( pRewindMap )
731 2609 : pContext->SetRewindMap( pRewindMap );
732 :
733 : // Call a startElement at the new context.
734 243606 : pContext->StartElement( xAttrList );
735 :
736 : // Push context on stack.
737 243606 : mpContexts->push_back( pContext );
738 243606 : }
739 :
740 243606 : 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 243606 : sal_uInt16 nCount = mpContexts->size();
748 : SAL_WARN_IF( nCount == 0, "xmloff.core", "SvXMLImport::endElement: no context left" );
749 243606 : if( nCount > 0 )
750 : {
751 : // Get topmost context and remove it from the stack.
752 243606 : SvXMLImportContext *pContext = mpContexts->back();
753 243606 : 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 243606 : pContext->EndElement();
766 :
767 : // Get a namespace map to rewind.
768 243606 : SvXMLNamespaceMap *pRewindMap = pContext->GetRewindMap();
769 :
770 : // Delete the current context.
771 243606 : pContext->ReleaseRef();
772 243606 : pContext = 0;
773 :
774 : // Rewind a namespace map.
775 243606 : if( pRewindMap )
776 : {
777 2609 : delete mpNamespaceMap;
778 2609 : mpNamespaceMap = pRewindMap;
779 : }
780 : }
781 243606 : }
782 :
783 136220 : void SAL_CALL SvXMLImport::characters( const OUString& rChars )
784 : throw(xml::sax::SAXException, uno::RuntimeException, std::exception)
785 : {
786 136220 : if( !mpContexts->empty() )
787 : {
788 136213 : mpContexts->back()->Characters( rChars );
789 : }
790 7 : else if ( !mpFastContexts->empty() )
791 : {
792 7 : mpFastContexts->back()->characters( rChars );
793 : }
794 136220 : }
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 2439 : void SAL_CALL SvXMLImport::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& rLocator )
808 : throw(xml::sax::SAXException, uno::RuntimeException, std::exception)
809 : {
810 2439 : mxLocator = rLocator;
811 2439 : }
812 :
813 : // XFastContextHandler
814 603 : 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 603 : uno::Reference<XFastContextHandler> xContext;
820 603 : sal_uInt16 nCount = mpFastContexts->size();
821 603 : if( nCount > 0 )
822 : {
823 535 : uno::Reference< XFastContextHandler > pHandler = (*mpFastContexts)[nCount - 1];
824 535 : xContext = pHandler->createFastChildContext( Element, Attribs );
825 : }
826 : else
827 68 : xContext.set( CreateFastContext( Element, Attribs ) );
828 :
829 603 : if ( !xContext.is() )
830 0 : xContext.set( new SvXMLImportContext( *this ) );
831 :
832 : // Call a startElement at the new context.
833 603 : xContext->startFastElement( Element, Attribs );
834 :
835 : // Push context on stack.
836 603 : mpFastContexts->push_back( xContext );
837 603 : }
838 :
839 48 : 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 48 : }
844 :
845 603 : void SAL_CALL SvXMLImport::endFastElement (sal_Int32 Element)
846 : throw (uno::RuntimeException, xml::sax::SAXException, std::exception)
847 : {
848 603 : sal_uInt16 nCount = mpFastContexts->size();
849 603 : if( nCount > 0 )
850 : {
851 603 : uno::Reference< XFastContextHandler > xContext = mpFastContexts->back();
852 603 : mpFastContexts->pop_back();
853 603 : xContext->endFastElement( Element );
854 603 : xContext = 0;
855 : }
856 603 : }
857 :
858 48 : void SAL_CALL SvXMLImport::endUnknownElement (const OUString &, const OUString &)
859 : throw (uno::RuntimeException, xml::sax::SAXException, std::exception)
860 : {
861 48 : }
862 :
863 : uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
864 603 : SvXMLImport::createFastChildContext (sal_Int32,
865 : const uno::Reference< xml::sax::XFastAttributeList > &)
866 : throw (uno::RuntimeException, xml::sax::SAXException, std::exception)
867 : {
868 603 : return this;
869 : }
870 :
871 : uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
872 48 : SvXMLImport::createUnknownChildContext (const OUString &, const OUString &,
873 : const uno::Reference< xml::sax::XFastAttributeList > &)
874 : throw (uno::RuntimeException, xml::sax::SAXException, std::exception)
875 : {
876 48 : return this;
877 : }
878 :
879 : // XExtendedDocumentHandler
880 0 : void SAL_CALL SvXMLImport::startCDATA() throw(xml::sax::SAXException, uno::RuntimeException, std::exception)
881 : {
882 0 : }
883 :
884 0 : void SAL_CALL SvXMLImport::endCDATA() throw(uno::RuntimeException, std::exception)
885 : {
886 0 : }
887 :
888 94 : void SAL_CALL SvXMLImport::comment( const OUString& )
889 : throw(xml::sax::SAXException, uno::RuntimeException, std::exception)
890 : {
891 94 : }
892 :
893 0 : void SAL_CALL SvXMLImport::allowLineBreak()
894 : throw(xml::sax::SAXException, uno::RuntimeException, std::exception)
895 : {
896 0 : }
897 :
898 4931 : void SAL_CALL SvXMLImport::unknown( const OUString& )
899 : throw(xml::sax::SAXException, uno::RuntimeException, std::exception)
900 : {
901 4931 : }
902 :
903 641 : void SvXMLImport::SetStatistics(const uno::Sequence< beans::NamedValue> &)
904 : {
905 641 : GetProgressBarHelper()->SetRepeat(false);
906 641 : GetProgressBarHelper()->SetReference(0);
907 641 : }
908 :
909 : // XImporter
910 2434 : void SAL_CALL SvXMLImport::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc )
911 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
912 : {
913 2434 : mxModel = uno::Reference< frame::XModel >::query( xDoc );
914 2434 : if( !mxModel.is() )
915 0 : throw lang::IllegalArgumentException();
916 :
917 : try
918 : {
919 : uno::Reference<document::XStorageBasedDocument> const xSBDoc(mxModel,
920 2434 : uno::UNO_QUERY_THROW);
921 : uno::Reference<embed::XStorage> const xStor(
922 4820 : xSBDoc->getDocumentStorage());
923 2386 : if (xStor.is())
924 : {
925 : mpImpl->mbIsOOoXML =
926 2133 : ::comphelper::OStorageHelper::GetXStorageFormat(xStor)
927 4266 : < SOFFICE_FILEFORMAT_8;
928 2434 : }
929 : }
930 48 : catch (uno::Exception const&)
931 : {
932 : SAL_WARN("xmloff.core", "exception caught");
933 : DBG_UNHANDLED_EXCEPTION();
934 : }
935 2434 : if (!mxEventListener.is())
936 : {
937 2399 : mxEventListener.set(new SvXMLImportEventListener(this));
938 2399 : mxModel->addEventListener(mxEventListener);
939 : }
940 :
941 : SAL_WARN_IF( mpNumImport, "xmloff.core", "number format import already exists." );
942 2434 : if( mpNumImport )
943 : {
944 0 : delete mpNumImport;
945 0 : mpNumImport = 0;
946 : }
947 2434 : }
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 2293 : 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 2293 : const sal_Int32 nAnyCount = aArguments.getLength();
966 2293 : const uno::Any* pAny = aArguments.getConstArray();
967 :
968 10252 : for( sal_Int32 nIndex = 0; nIndex < nAnyCount; nIndex++, pAny++ )
969 : {
970 7959 : Reference<XInterface> xValue;
971 7959 : *pAny >>= xValue;
972 :
973 : uno::Reference<task::XStatusIndicator> xTmpStatusIndicator(
974 15918 : xValue, UNO_QUERY );
975 7959 : if( xTmpStatusIndicator.is() )
976 1188 : mxStatusIndicator = xTmpStatusIndicator;
977 :
978 : uno::Reference<document::XGraphicObjectResolver> xTmpGraphicResolver(
979 15918 : xValue, UNO_QUERY );
980 7959 : if( xTmpGraphicResolver.is() )
981 1570 : mxGraphicResolver = xTmpGraphicResolver;
982 :
983 : uno::Reference<document::XEmbeddedObjectResolver> xTmpObjectResolver(
984 15918 : xValue, UNO_QUERY );
985 7959 : if( xTmpObjectResolver.is() )
986 1327 : mxEmbeddedResolver = xTmpObjectResolver;
987 :
988 15918 : uno::Reference<beans::XPropertySet> xTmpPropSet( xValue, UNO_QUERY );
989 7959 : if( xTmpPropSet.is() )
990 : {
991 2258 : mxImportInfo = xTmpPropSet;
992 2258 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
993 2258 : if (xPropertySetInfo.is())
994 : {
995 2258 : OUString sPropName(XML_NUMBERSTYLES);
996 2258 : if (xPropertySetInfo->hasPropertyByName(sPropName))
997 : {
998 1794 : uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
999 1794 : aAny >>= mxNumberStyles;
1000 : }
1001 :
1002 2258 : sPropName = "PrivateData";
1003 2258 : if (xPropertySetInfo->hasPropertyByName(sPropName))
1004 : {
1005 2223 : Reference < XInterface > xIfc;
1006 4446 : uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1007 2223 : aAny >>= xIfc;
1008 :
1009 2223 : StyleMap *pSMap = StyleMap::getImplementation( xIfc );
1010 2223 : if( pSMap )
1011 : {
1012 365 : mpStyleMap = pSMap;
1013 365 : mpStyleMap->acquire();
1014 2223 : }
1015 : }
1016 4516 : OUString sBaseURI;
1017 2258 : sPropName = "BaseURI";
1018 2258 : if (xPropertySetInfo->hasPropertyByName(sPropName))
1019 : {
1020 2258 : uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1021 2258 : aAny >>= sBaseURI;
1022 2258 : mpImpl->aBaseURL.SetURL( sBaseURI );
1023 2258 : mpImpl->aDocBase.SetURL( sBaseURI );
1024 : }
1025 4516 : OUString sRelPath;
1026 2258 : sPropName = "StreamRelPath";
1027 2258 : if( xPropertySetInfo->hasPropertyByName(sPropName) )
1028 : {
1029 2239 : uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1030 2239 : aAny >>= sRelPath;
1031 : }
1032 4516 : OUString sName;
1033 2258 : sPropName = "StreamName";
1034 2258 : if( xPropertySetInfo->hasPropertyByName(sPropName) )
1035 : {
1036 2243 : uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1037 2243 : aAny >>= sName;
1038 : }
1039 2258 : if( !sBaseURI.isEmpty() && !sName.isEmpty() )
1040 : {
1041 1974 : if( !sRelPath.isEmpty() )
1042 0 : mpImpl->aBaseURL.insertName( sRelPath );
1043 1974 : mpImpl->aBaseURL.insertName( sName );
1044 : }
1045 2258 : mpImpl->mStreamName = sName; // Note: may be empty (XSLT)
1046 : // Retrieve property <ShapePositionInHoriL2R> (#i28749#)
1047 2258 : sPropName = "ShapePositionInHoriL2R";
1048 2258 : if( xPropertySetInfo->hasPropertyByName(sPropName) )
1049 : {
1050 1147 : uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1051 1147 : aAny >>= (mpImpl->mbShapePositionInHoriL2R);
1052 : }
1053 2258 : sPropName = "TextDocInOOoFileFormat";
1054 2258 : if( xPropertySetInfo->hasPropertyByName(sPropName) )
1055 : {
1056 1147 : uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1057 1147 : aAny >>= (mpImpl->mbTextDocInOOoFileFormat);
1058 : }
1059 :
1060 2258 : sPropName = "SourceStorage";
1061 2258 : if( xPropertySetInfo->hasPropertyByName(sPropName) )
1062 4222 : mxImportInfo->getPropertyValue(sPropName) >>= mpImpl->mxSourceStorage;
1063 2258 : }
1064 : }
1065 7959 : }
1066 2293 : }
1067 :
1068 : // XServiceInfo
1069 4 : OUString SAL_CALL SvXMLImport::getImplementationName()
1070 : throw(uno::RuntimeException, std::exception)
1071 : {
1072 4 : 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 4 : uno::Sequence< OUString > SAL_CALL SvXMLImport::getSupportedServiceNames( )
1082 : throw(uno::RuntimeException, std::exception)
1083 : {
1084 4 : uno::Sequence<OUString> aSeq(2);
1085 4 : aSeq[0] = "com.sun.star.document.ImportFilter";
1086 4 : aSeq[1] = "com.sun.star.xml.XMLImportFilter";
1087 4 : return aSeq;
1088 : }
1089 :
1090 599 : XMLTextImportHelper* SvXMLImport::CreateTextImport()
1091 : {
1092 599 : return new XMLTextImportHelper( mxModel, *this );
1093 : }
1094 :
1095 324 : XMLShapeImportHelper* SvXMLImport::CreateShapeImport()
1096 : {
1097 324 : return new XMLShapeImportHelper( *this, mxModel );
1098 : }
1099 :
1100 1231 : SchXMLImportHelper* SvXMLImport::CreateChartImport()
1101 : {
1102 1231 : return new SchXMLImportHelper();
1103 : }
1104 :
1105 1233 : ::xmloff::OFormLayerXMLImport* SvXMLImport::CreateFormImport()
1106 : {
1107 1233 : return new ::xmloff::OFormLayerXMLImport(*this);
1108 : }
1109 :
1110 :
1111 : // Get or create fill/line/lineend-style-helper
1112 :
1113 :
1114 80 : const Reference< container::XNameContainer > & SvXMLImport::GetGradientHelper()
1115 : {
1116 80 : if( !mxGradientHelper.is() )
1117 : {
1118 33 : if( mxModel.is() )
1119 : {
1120 33 : Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1121 33 : if( xServiceFact.is() )
1122 : {
1123 : try
1124 : {
1125 99 : mxGradientHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1126 66 : "com.sun.star.drawing.GradientTable" ), UNO_QUERY);
1127 : }
1128 0 : catch( lang::ServiceNotRegisteredException& )
1129 : {}
1130 33 : }
1131 : }
1132 : }
1133 :
1134 80 : return mxGradientHelper;
1135 : }
1136 :
1137 41 : const Reference< container::XNameContainer > & SvXMLImport::GetHatchHelper()
1138 : {
1139 41 : if( !mxHatchHelper.is() )
1140 : {
1141 19 : if( mxModel.is() )
1142 : {
1143 19 : Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1144 19 : if( xServiceFact.is() )
1145 : {
1146 : try
1147 : {
1148 57 : mxHatchHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1149 38 : "com.sun.star.drawing.HatchTable" ), UNO_QUERY);
1150 : }
1151 0 : catch( lang::ServiceNotRegisteredException& )
1152 : {}
1153 19 : }
1154 : }
1155 : }
1156 :
1157 41 : return mxHatchHelper;
1158 : }
1159 :
1160 79 : const Reference< container::XNameContainer > & SvXMLImport::GetBitmapHelper()
1161 : {
1162 79 : if( !mxBitmapHelper.is() )
1163 : {
1164 31 : if( mxModel.is() )
1165 : {
1166 31 : Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1167 31 : if( xServiceFact.is() )
1168 : {
1169 : try
1170 : {
1171 93 : mxBitmapHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1172 62 : "com.sun.star.drawing.BitmapTable" ), UNO_QUERY);
1173 : }
1174 0 : catch( lang::ServiceNotRegisteredException& )
1175 : {}
1176 31 : }
1177 : }
1178 : }
1179 :
1180 79 : return mxBitmapHelper;
1181 : }
1182 :
1183 11 : const Reference< container::XNameContainer > & SvXMLImport::GetTransGradientHelper()
1184 : {
1185 11 : 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 11 : return mxTransGradientHelper;
1204 : }
1205 :
1206 118 : const Reference< container::XNameContainer > & SvXMLImport::GetMarkerHelper()
1207 : {
1208 118 : if( !mxMarkerHelper.is() )
1209 : {
1210 81 : if( mxModel.is() )
1211 : {
1212 81 : Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1213 81 : if( xServiceFact.is() )
1214 : {
1215 : try
1216 : {
1217 243 : mxMarkerHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1218 162 : "com.sun.star.drawing.MarkerTable" ), UNO_QUERY);
1219 : }
1220 0 : catch( lang::ServiceNotRegisteredException& )
1221 : {}
1222 81 : }
1223 : }
1224 : }
1225 :
1226 118 : return mxMarkerHelper;
1227 : }
1228 :
1229 31 : const Reference< container::XNameContainer > & SvXMLImport::GetDashHelper()
1230 : {
1231 31 : if( !mxDashHelper.is() )
1232 : {
1233 14 : if( mxModel.is() )
1234 : {
1235 14 : Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1236 14 : if( xServiceFact.is() )
1237 : {
1238 : try
1239 : {
1240 42 : mxDashHelper = Reference< container::XNameContainer >( xServiceFact->createInstance(
1241 28 : "com.sun.star.drawing.DashTable" ), UNO_QUERY);
1242 : }
1243 0 : catch( lang::ServiceNotRegisteredException& )
1244 : {}
1245 14 : }
1246 : }
1247 : }
1248 :
1249 31 : return mxDashHelper;
1250 : }
1251 :
1252 579 : 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 579 : const SvXMLImportFlags nTest = SvXMLImportFlags::META|SvXMLImportFlags::STYLES|SvXMLImportFlags::CONTENT|SvXMLImportFlags::SETTINGS;
1257 579 : if( (mnImportFlags & nTest) == nTest )
1258 0 : return false;
1259 :
1260 : // Some quick tests: Some may rely on the package structure!
1261 579 : sal_Int32 nLen = rURL.getLength();
1262 579 : if( (nLen > 0 && '/' == rURL[0]) )
1263 : // RFC2396 net_path or abs_path
1264 0 : return false;
1265 579 : else if( nLen > 1 && '.' == rURL[0] )
1266 : {
1267 176 : if( '.' == rURL[1] )
1268 : // ../: We are never going up one level, so we know
1269 : // it's not an external URI
1270 17 : return false;
1271 159 : else if( '/' == rURL[1] )
1272 : // we are remaining on a level, so it's an package URI
1273 159 : return true;
1274 : }
1275 :
1276 : // Now check for a RFC2396 schema
1277 403 : sal_Int32 nPos = 1;
1278 3559 : while( nPos < nLen )
1279 : {
1280 3156 : switch( rURL[nPos] )
1281 : {
1282 : case '/':
1283 : // a relative path segement
1284 399 : return true;
1285 : case ':':
1286 : // a schema
1287 4 : return false;
1288 : default:
1289 2753 : break;
1290 : // we don't care about any other characters
1291 : }
1292 2753 : ++nPos;
1293 : }
1294 :
1295 0 : return true;
1296 : }
1297 :
1298 455 : OUString SvXMLImport::ResolveGraphicObjectURL( const OUString& rURL,
1299 : bool bLoadOnDemand )
1300 : {
1301 455 : OUString sRet;
1302 :
1303 455 : if( IsPackageURL( rURL ) )
1304 : {
1305 434 : if( !bLoadOnDemand && mxGraphicResolver.is() )
1306 : {
1307 256 : OUString aTmp( msPackageProtocol );
1308 256 : aTmp += rURL;
1309 256 : sRet = mxGraphicResolver->resolveGraphicObjectURL( aTmp );
1310 : }
1311 :
1312 434 : if( sRet.isEmpty() )
1313 : {
1314 178 : sRet = msPackageProtocol;
1315 178 : sRet += rURL;
1316 : }
1317 : }
1318 :
1319 455 : if( sRet.isEmpty() )
1320 21 : sRet = GetAbsoluteReference( rURL );
1321 :
1322 455 : return sRet;
1323 : }
1324 :
1325 198 : Reference< XOutputStream > SvXMLImport::GetStreamForGraphicObjectURLFromBase64()
1326 : {
1327 198 : Reference< XOutputStream > xOStm;
1328 396 : Reference< document::XBinaryStreamResolver > xStmResolver( mxGraphicResolver, UNO_QUERY );
1329 :
1330 198 : if( xStmResolver.is() )
1331 198 : xOStm = xStmResolver->createOutputStream();
1332 :
1333 396 : return xOStm;
1334 : }
1335 :
1336 198 : OUString SvXMLImport::ResolveGraphicObjectURLFromBase64(
1337 : const Reference < XOutputStream >& rOut )
1338 : {
1339 198 : OUString sURL;
1340 396 : Reference< document::XBinaryStreamResolver > xStmResolver( mxGraphicResolver, UNO_QUERY );
1341 198 : if( xStmResolver.is() )
1342 198 : sURL = xStmResolver->resolveOutputStream( rOut );
1343 :
1344 396 : return sURL;
1345 : }
1346 :
1347 53 : OUString SvXMLImport::ResolveEmbeddedObjectURL(
1348 : const OUString& rURL,
1349 : const OUString& rClassId )
1350 : {
1351 53 : OUString sRet;
1352 :
1353 53 : if( IsPackageURL( rURL ) )
1354 : {
1355 53 : if ( mxEmbeddedResolver.is() )
1356 : {
1357 53 : OUString sURL( rURL );
1358 53 : if( !rClassId.isEmpty() )
1359 : {
1360 0 : sURL += "!" + rClassId;
1361 : }
1362 53 : sRet = mxEmbeddedResolver->resolveEmbeddedObjectURL( sURL );
1363 : }
1364 : }
1365 : else
1366 0 : sRet = GetAbsoluteReference( rURL );
1367 :
1368 53 : return sRet;
1369 : }
1370 :
1371 73 : Reference< embed::XStorage > SvXMLImport::GetSourceStorage()
1372 : {
1373 73 : 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 3716 : void SvXMLImport::AddStyleDisplayName( sal_uInt16 nFamily,
1409 : const OUString& rName,
1410 : const OUString& rDisplayName )
1411 : {
1412 3716 : if( !mpStyleMap )
1413 : {
1414 505 : mpStyleMap = new StyleMap;
1415 505 : mpStyleMap->acquire();
1416 505 : if( mxImportInfo.is() )
1417 : {
1418 369 : OUString sPrivateData( "PrivateData" );
1419 : Reference< beans::XPropertySetInfo > xPropertySetInfo =
1420 738 : mxImportInfo->getPropertySetInfo();
1421 738 : if( xPropertySetInfo.is() &&
1422 369 : xPropertySetInfo->hasPropertyByName(sPrivateData) )
1423 : {
1424 : Reference < XInterface > xIfc(
1425 368 : static_cast< XUnoTunnel *>( mpStyleMap ) );
1426 736 : Any aAny;
1427 368 : aAny <<= xIfc;
1428 736 : mxImportInfo->setPropertyValue( sPrivateData, aAny );
1429 369 : }
1430 : }
1431 : }
1432 :
1433 3716 : StyleMap::key_type aKey( nFamily, rName );
1434 7432 : StyleMap::value_type aValue( aKey, rDisplayName );
1435 3716 : ::std::pair<StyleMap::iterator,bool> aRes( mpStyleMap->insert( aValue ) );
1436 : SAL_WARN_IF( !aRes.second,
1437 : "xmloff.core",
1438 3716 : "duplicate style name of family " << nFamily << ": \"" << rName << "\"");
1439 :
1440 3716 : }
1441 :
1442 30388 : OUString SvXMLImport::GetStyleDisplayName( sal_uInt16 nFamily,
1443 : const OUString& rName ) const
1444 : {
1445 30388 : OUString sName( rName );
1446 30388 : if( mpStyleMap && !rName.isEmpty() )
1447 : {
1448 17110 : StyleMap::key_type aKey( nFamily, rName );
1449 17110 : StyleMap::const_iterator aIter = mpStyleMap->find( aKey );
1450 17110 : if( aIter != mpStyleMap->end() )
1451 4974 : sName = (*aIter).second;
1452 : }
1453 30388 : 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 11241 : ProgressBarHelper* SvXMLImport::GetProgressBarHelper()
1471 : {
1472 11241 : if (!mpProgressBarHelper)
1473 : {
1474 1539 : mpProgressBarHelper = new ProgressBarHelper(mxStatusIndicator, false);
1475 :
1476 1539 : if (mxImportInfo.is())
1477 : {
1478 1411 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
1479 1411 : if (xPropertySetInfo.is())
1480 : {
1481 1411 : OUString sProgressRange(XML_PROGRESSRANGE);
1482 2822 : OUString sProgressMax(XML_PROGRESSMAX);
1483 2822 : OUString sProgressCurrent(XML_PROGRESSCURRENT);
1484 2822 : OUString sRepeat(XML_PROGRESSREPEAT);
1485 4198 : if (xPropertySetInfo->hasPropertyByName(sProgressMax) &&
1486 2787 : xPropertySetInfo->hasPropertyByName(sProgressCurrent) &&
1487 1376 : xPropertySetInfo->hasPropertyByName(sProgressRange))
1488 : {
1489 1376 : uno::Any aAny;
1490 1376 : sal_Int32 nProgressMax(0);
1491 1376 : sal_Int32 nProgressCurrent(0);
1492 1376 : sal_Int32 nProgressRange(0);
1493 1376 : aAny = mxImportInfo->getPropertyValue(sProgressRange);
1494 1376 : if (aAny >>= nProgressRange)
1495 995 : mpProgressBarHelper->SetRange(nProgressRange);
1496 1376 : aAny = mxImportInfo->getPropertyValue(sProgressMax);
1497 1376 : if (aAny >>= nProgressMax)
1498 793 : mpProgressBarHelper->SetReference(nProgressMax);
1499 1376 : aAny = mxImportInfo->getPropertyValue(sProgressCurrent);
1500 1376 : if (aAny >>= nProgressCurrent)
1501 804 : mpProgressBarHelper->SetValue(nProgressCurrent);
1502 : }
1503 1411 : if (xPropertySetInfo->hasPropertyByName(sRepeat))
1504 : {
1505 0 : uno::Any aAny = mxImportInfo->getPropertyValue(sRepeat);
1506 0 : if (aAny.getValueType() == cppu::UnoType<bool>::get())
1507 0 : mpProgressBarHelper->SetRepeat(::cppu::any2bool(aAny));
1508 : else {
1509 : SAL_WARN( "xmloff.core", "why is it no boolean?" );
1510 0 : }
1511 1411 : }
1512 1411 : }
1513 : }
1514 : }
1515 11241 : return mpProgressBarHelper;
1516 : }
1517 :
1518 1306 : void SvXMLImport::AddNumberStyle(sal_Int32 nKey, const OUString& rName)
1519 : {
1520 1306 : if (!mxNumberStyles.is())
1521 293 : mxNumberStyles = uno::Reference< container::XNameContainer >( comphelper::NameContainer_createInstance( ::cppu::UnoType<sal_Int32>::get()) );
1522 1306 : if (mxNumberStyles.is())
1523 : {
1524 1306 : uno::Any aAny;
1525 1306 : aAny <<= nKey;
1526 : try
1527 : {
1528 1306 : 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 1306 : }
1535 : }
1536 : else {
1537 : SAL_WARN( "xmloff.core", "not possible to create NameContainer");
1538 : DBG_UNHANDLED_EXCEPTION();
1539 : }
1540 1306 : }
1541 :
1542 80 : XMLEventImportHelper& SvXMLImport::GetEventImport()
1543 : {
1544 80 : if (!mpEventImportHelper)
1545 : {
1546 : // construct event helper and register StarBasic handler and standard
1547 : // event tables
1548 20 : mpEventImportHelper = new XMLEventImportHelper();
1549 20 : OUString sStarBasic(GetXMLToken(XML_STARBASIC));
1550 : mpEventImportHelper->RegisterFactory(sStarBasic,
1551 20 : new XMLStarBasicContextFactory());
1552 40 : OUString sScript(GetXMLToken(XML_SCRIPT));
1553 : mpEventImportHelper->RegisterFactory(sScript,
1554 20 : new XMLScriptContextFactory());
1555 20 : mpEventImportHelper->AddTranslationTable(aStandardEventTable);
1556 :
1557 : // register StarBasic event handler with capitalized spelling
1558 40 : OUString sStarBasicCap( "StarBasic" );
1559 : mpEventImportHelper->RegisterFactory(sStarBasicCap,
1560 40 : new XMLStarBasicContextFactory());
1561 : }
1562 :
1563 80 : return *mpEventImportHelper;
1564 : }
1565 :
1566 1120 : void SvXMLImport::SetFontDecls( XMLFontStylesContext *pFontDecls )
1567 : {
1568 1120 : mxFontDecls = pFontDecls;
1569 1120 : }
1570 :
1571 543 : void SvXMLImport::SetStyles( SvXMLStylesContext *pStyles )
1572 : {
1573 543 : mxStyles = pStyles;
1574 543 : }
1575 :
1576 1098 : void SvXMLImport::SetAutoStyles( SvXMLStylesContext *pAutoStyles )
1577 : {
1578 1098 : if (pAutoStyles && mxNumberStyles.is() && (mnImportFlags & SvXMLImportFlags::CONTENT) )
1579 : {
1580 168 : uno::Reference<xml::sax::XAttributeList> xAttrList;
1581 336 : uno::Sequence< OUString > aNames = mxNumberStyles->getElementNames();
1582 168 : sal_uInt32 nCount(aNames.getLength());
1583 168 : if (nCount)
1584 : {
1585 168 : const OUString* pNames = aNames.getConstArray();
1586 168 : if ( pNames )
1587 : {
1588 : SvXMLStyleContext* pContext;
1589 168 : uno::Any aAny;
1590 168 : sal_Int32 nKey(0);
1591 1069 : for (sal_uInt32 i = 0; i < nCount; i++, pNames++)
1592 : {
1593 901 : aAny = mxNumberStyles->getByName(*pNames);
1594 901 : if (aAny >>= nKey)
1595 : {
1596 : pContext = new SvXMLNumFormatContext( *this, XML_NAMESPACE_NUMBER,
1597 901 : *pNames, xAttrList, nKey, *pAutoStyles );
1598 901 : pAutoStyles->AddStyle(*pContext);
1599 : }
1600 168 : }
1601 : }
1602 168 : }
1603 : }
1604 1098 : mxAutoStyles = pAutoStyles;
1605 1098 : GetTextImport()->SetAutoStyles( pAutoStyles );
1606 1098 : GetShapeImport()->SetAutoStylesContext( pAutoStyles );
1607 1098 : GetChartImport()->SetAutoStylesContext( pAutoStyles );
1608 1098 : GetFormImport()->setAutoStyleContext( pAutoStyles );
1609 1098 : }
1610 :
1611 344 : void SvXMLImport::SetMasterStyles( SvXMLStylesContext *pMasterStyles )
1612 : {
1613 344 : mxMasterStyles = pMasterStyles;
1614 344 : }
1615 :
1616 20181 : XMLFontStylesContext *SvXMLImport::GetFontDecls()
1617 : {
1618 20181 : return static_cast<XMLFontStylesContext *>(&mxFontDecls);
1619 : }
1620 :
1621 1861 : SvXMLStylesContext *SvXMLImport::GetStyles()
1622 : {
1623 1861 : return static_cast<SvXMLStylesContext *>(&mxStyles);
1624 : }
1625 :
1626 9275 : SvXMLStylesContext *SvXMLImport::GetAutoStyles()
1627 : {
1628 9275 : 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 1974 : const SvXMLStylesContext *SvXMLImport::GetAutoStyles() const
1642 : {
1643 1974 : return static_cast<const SvXMLStylesContext *>(&mxAutoStyles);
1644 : }
1645 :
1646 1463 : OUString SvXMLImport::GetAbsoluteReference(const OUString& rValue) const
1647 : {
1648 1463 : if( rValue.isEmpty() || rValue[0] == '#' )
1649 1305 : return rValue;
1650 :
1651 158 : INetURLObject aAbsURL;
1652 158 : if( mpImpl->aBaseURL.GetNewAbsURL( rValue, &aAbsURL ) )
1653 158 : return aAbsURL.GetMainURL( INetURLObject::DECODE_TO_IURI );
1654 : else
1655 0 : return rValue;
1656 : }
1657 :
1658 614 : bool SvXMLImport::IsODFVersionConsistent( const OUString& aODFVersion )
1659 : {
1660 : // the check returns sal_False only if the storage version could be retrieved
1661 614 : bool bResult = true;
1662 :
1663 614 : 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 602 : uno::Reference< document::XStorageBasedDocument > xDoc( mxModel, uno::UNO_QUERY_THROW );
1670 1172 : uno::Reference< embed::XStorage > xStor = xDoc->getDocumentStorage();
1671 1058 : uno::Reference< beans::XPropertySet > xStorProps( xStor, uno::UNO_QUERY_THROW );
1672 :
1673 : // the check should be done only for OASIS format
1674 488 : if (!IsOOoXML())
1675 : {
1676 487 : bool bRepairPackage = false;
1677 : try
1678 : {
1679 487 : xStorProps->getPropertyValue( "RepairPackage" )
1680 489 : >>= bRepairPackage;
1681 2 : } catch ( uno::Exception& )
1682 : {}
1683 :
1684 : // check only if not in Repair mode
1685 487 : if ( !bRepairPackage )
1686 : {
1687 487 : OUString aStorVersion;
1688 487 : xStorProps->getPropertyValue( "Version" )
1689 487 : >>= 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 487 : if ( !aStorVersion.isEmpty() )
1696 486 : bResult = aODFVersion.equals( aStorVersion );
1697 : else
1698 1 : xStorProps->setPropertyValue( "Version",
1699 1 : uno::makeAny( aODFVersion ) );
1700 :
1701 487 : if ( bResult )
1702 : {
1703 487 : bool bInconsistent = false;
1704 487 : xStorProps->getPropertyValue( "IsInconsistent" )
1705 489 : >>= bInconsistent;
1706 485 : bResult = !bInconsistent;
1707 487 : }
1708 : }
1709 602 : }
1710 : }
1711 116 : catch( uno::Exception& )
1712 : {}
1713 : }
1714 :
1715 614 : return bResult;
1716 : }
1717 :
1718 4021 : void SvXMLImport::_CreateNumberFormatsSupplier()
1719 : {
1720 : SAL_WARN_IF( mxNumberFormatsSupplier.is(), "xmloff.core", "number formats supplier already exists!" );
1721 4021 : if(mxModel.is())
1722 8042 : mxNumberFormatsSupplier =
1723 4021 : uno::Reference< util::XNumberFormatsSupplier> (mxModel, uno::UNO_QUERY);
1724 4021 : }
1725 :
1726 4029 : void SvXMLImport::_CreateDataStylesImport()
1727 : {
1728 : SAL_WARN_IF( mpNumImport != NULL, "xmloff.core", "data styles import already exists!" );
1729 : uno::Reference<util::XNumberFormatsSupplier> xNum =
1730 4029 : GetNumberFormatsSupplier();
1731 4029 : if ( xNum.is() )
1732 1067 : mpNumImport = new SvXMLNumFmtHelper(xNum, GetComponentContext() );
1733 4029 : }
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 : FontToSubsFontFlags::IMPORT|FontToSubsFontFlags::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 : FontToSubsFontFlags::IMPORT|FontToSubsFontFlags::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 277 : 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 277 : if ( ( nId & XMLERROR_FLAG_ERROR ) != 0 )
1779 118 : mnErrorFlags |= SvXMLErrorFlags::ERROR_OCCURRED;
1780 277 : if ( ( nId & XMLERROR_FLAG_WARNING ) != 0 )
1781 159 : mnErrorFlags |= SvXMLErrorFlags::WARNING_OCCURRED;
1782 277 : if ( ( nId & XMLERROR_FLAG_SEVERE ) != 0 )
1783 0 : mnErrorFlags |= SvXMLErrorFlags::DO_NOTHING;
1784 :
1785 : // create error list on demand
1786 277 : if ( mpXMLErrors == NULL )
1787 47 : mpXMLErrors = new XMLErrors();
1788 :
1789 : // save error information
1790 : // use document locator (if none supplied)
1791 : mpXMLErrors->AddRecord( nId, rMsgParams, rExceptionMessage,
1792 277 : rLocator.is() ? rLocator : mxLocator );
1793 277 : }
1794 :
1795 79 : void SvXMLImport::SetError(
1796 : sal_Int32 nId,
1797 : const Sequence<OUString>& rMsgParams)
1798 : {
1799 79 : OUString sEmpty;
1800 79 : SetError( nId, rMsgParams, sEmpty, NULL );
1801 79 : }
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 14 : void SvXMLImport::DisposingModel()
1833 : {
1834 14 : if( mxFontDecls.Is() )
1835 0 : static_cast<SvXMLStylesContext *>(&mxFontDecls)->Clear();
1836 14 : if( mxStyles.Is() )
1837 1 : static_cast<SvXMLStylesContext *>(&mxStyles)->Clear();
1838 14 : if( mxAutoStyles.Is() )
1839 0 : static_cast<SvXMLStylesContext *>(&mxAutoStyles)->Clear();
1840 14 : if( mxMasterStyles.Is() )
1841 0 : static_cast<SvXMLStylesContext *>(&mxMasterStyles)->Clear();
1842 :
1843 14 : mxModel.set(0);
1844 14 : mxEventListener.set(NULL);
1845 14 : }
1846 :
1847 24 : ::comphelper::UnoInterfaceToUniqueIdentifierMapper& SvXMLImport::getInterfaceToIdentifierMapper()
1848 : {
1849 24 : return mpImpl->maInterfaceToIdentifierMapper;
1850 : }
1851 :
1852 : uno::Reference< uno::XComponentContext >
1853 5527 : SvXMLImport::GetComponentContext() const
1854 : {
1855 5527 : return mpImpl->mxComponentContext;
1856 : }
1857 :
1858 1 : OUString SvXMLImport::GetBaseURL() const
1859 : {
1860 1 : return mpImpl->aBaseURL.GetMainURL( INetURLObject::NO_DECODE );
1861 : }
1862 :
1863 129 : OUString SvXMLImport::GetDocumentBase() const
1864 : {
1865 129 : return mpImpl->aDocBase.GetMainURL( INetURLObject::NO_DECODE );
1866 : }
1867 :
1868 94 : OUString SvXMLImport::GetStreamName() const
1869 : {
1870 94 : return mpImpl->mStreamName;
1871 : }
1872 :
1873 : // Convert drawing object positions from OOo file format to OASIS (#i28749#)
1874 3115 : bool SvXMLImport::IsShapePositionInHoriL2R() const
1875 : {
1876 3115 : return mpImpl->mbShapePositionInHoriL2R;
1877 : }
1878 :
1879 503 : bool SvXMLImport::IsTextDocInOOoFileFormat() const
1880 : {
1881 503 : 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 5770 : bool SvXMLImport::getBuildIds( sal_Int32& rUPD, sal_Int32& rBuild ) const
1890 : {
1891 5770 : bool bRet = false;
1892 5770 : OUString const aBuildId(getBuildIdsProperty(mxImportInfo));
1893 5770 : if (!aBuildId.isEmpty())
1894 : {
1895 3620 : sal_Int32 nIndex = aBuildId.indexOf('$');
1896 3620 : if (nIndex != -1)
1897 : {
1898 967 : rUPD = aBuildId.copy( 0, nIndex ).toInt32();
1899 967 : sal_Int32 nIndexEnd = aBuildId.indexOf(';', nIndex);
1900 : rBuild = (nIndexEnd == -1)
1901 1751 : ? aBuildId.copy(nIndex + 1).toInt32()
1902 1934 : : aBuildId.copy(nIndex + 1, nIndexEnd - nIndex - 1).toInt32();
1903 967 : bRet = true;
1904 : }
1905 : }
1906 5770 : return bRet;
1907 : }
1908 :
1909 1662 : sal_uInt16 SvXMLImport::getGeneratorVersion() const
1910 : {
1911 : // --> ORW
1912 1662 : return mpImpl->getGeneratorVersion( *this );
1913 : // <--
1914 : }
1915 :
1916 516 : bool SvXMLImport::isGeneratorVersionOlderThan(
1917 : sal_uInt16 const nOOoVersion, sal_uInt16 const nLOVersion)
1918 : {
1919 : assert( (nLOVersion & LO_flag));
1920 : assert(!(nOOoVersion & LO_flag));
1921 516 : const sal_uInt16 nGeneratorVersion(getGeneratorVersion());
1922 516 : return (nGeneratorVersion & LO_flag)
1923 : ? nGeneratorVersion < nLOVersion
1924 516 : : nGeneratorVersion < nOOoVersion;
1925 : }
1926 :
1927 :
1928 283 : OUString SvXMLImport::GetODFVersion() const
1929 : {
1930 283 : return mpImpl->aODFVersion;
1931 : }
1932 :
1933 960 : bool SvXMLImport::IsOOoXML() const
1934 : {
1935 960 : return mpImpl->mbIsOOoXML;
1936 : }
1937 :
1938 : // xml:id for RDF metadata
1939 1292 : void SvXMLImport::SetXmlId(uno::Reference<uno::XInterface> const & i_xIfc,
1940 : OUString const & i_rXmlId)
1941 : {
1942 1292 : if (!i_rXmlId.isEmpty()) {
1943 : try {
1944 : const uno::Reference<rdf::XMetadatable> xMeta(i_xIfc,
1945 94 : uno::UNO_QUERY);
1946 : //FIXME: not yet
1947 94 : if (xMeta.is()) {
1948 94 : const beans::StringPair mdref( GetStreamName(), i_rXmlId );
1949 : try {
1950 94 : xMeta->setMetadataReference(mdref);
1951 0 : } catch (lang::IllegalArgumentException &) {
1952 : // probably duplicate; ignore
1953 : SAL_INFO("xmloff.core", "SvXMLImport::SetXmlId: cannot set xml:id");
1954 94 : }
1955 94 : }
1956 0 : } catch (uno::Exception &) {
1957 : SAL_WARN("xmloff.core","SvXMLImport::SetXmlId: exception?");
1958 : }
1959 : }
1960 1292 : }
1961 :
1962 : ::xmloff::RDFaImportHelper &
1963 44 : SvXMLImport::GetRDFaImportHelper()
1964 : {
1965 44 : if (!mpImpl->mpRDFaHelper.get())
1966 : {
1967 6 : mpImpl->mpRDFaHelper.reset( new ::xmloff::RDFaImportHelper(*this) );
1968 : }
1969 44 : return *mpImpl->mpRDFaHelper;
1970 : }
1971 :
1972 : void
1973 36 : 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 36 : ::xmloff::RDFaImportHelper & rRDFaHelper( GetRDFaImportHelper() );
1982 : rRDFaHelper.ParseAndAddRDFa(i_xObject,
1983 36 : i_rAbout, i_rProperty, i_rContent, i_rDatatype);
1984 36 : }
1985 :
1986 13 : bool SvXMLImport::embeddedFontAlreadyProcessed( const OUString& url )
1987 : {
1988 13 : if( embeddedFontUrlsKnown.count( url ) != 0 )
1989 0 : return true;
1990 13 : embeddedFontUrlsKnown.insert( url );
1991 13 : return false;
1992 : }
1993 :
1994 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
