?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
warn on load when a document binds an event to a macro
[LibreOffice.git] / xmloff / source / core / xmlimp.cxx
blob525b557969dc03d429f9584ae7cbad12f1817aa9
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 <memory>
21 #include <string.h>
22
23 #include <tools/diagnose_ex.h>
24 #include <sal/log.hxx>
25 #include <com/sun/star/beans/XPropertySetInfo.hpp>
26 #include <tools/urlobj.hxx>
27 #include <vcl/graph.hxx>
28 #include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
29 #include <xmloff/nmspmap.hxx>
30 #include <xmloff/xmluconv.hxx>
31 #include <xmloff/xmlnmspe.hxx>
32 #include <xmloff/xmltoken.hxx>
33 #include <xmloff/XMLFontStylesContext.hxx>
34 #include <xmloff/xmlictxt.hxx>
35 #include <xmloff/xmlimp.hxx>
36 #include <xmloff/xmlnumfi.hxx>
37 #include <XMLEventImportHelper.hxx>
38 #include <XMLStarBasicContextFactory.hxx>
39 #include <XMLScriptContextFactory.hxx>
40 #include <StyleMap.hxx>
41 #include <xmloff/ProgressBarHelper.hxx>
42 #include <xmloff/xmlerror.hxx>
43 #include <com/sun/star/container/XNameContainer.hpp>
44 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
45 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
46 #include <com/sun/star/io/XOutputStream.hpp>
47 #include <com/sun/star/util/MeasureUnit.hpp>
48 #include <com/sun/star/util/XNumberFormatsSupplier.hpp>
49 #include <com/sun/star/frame/XModel.hpp>
50 #include <com/sun/star/document/XBinaryStreamResolver.hpp>
51 #include <com/sun/star/document/XStorageBasedDocument.hpp>
52 #include <com/sun/star/document/XGraphicStorageHandler.hpp>
53 #include <com/sun/star/document/XEmbeddedObjectResolver.hpp>
54 #include <com/sun/star/graphic/GraphicProvider.hpp>
55 #include <com/sun/star/xml/sax/XLocator.hpp>
56 #include <com/sun/star/xml/sax/FastParser.hpp>
57 #include <com/sun/star/xml/sax/SAXException.hpp>
58 #include <com/sun/star/packages/zip/ZipIOException.hpp>
59 #include <comphelper/fileformat.h>
60 #include <comphelper/namecontainer.hxx>
61 #include <comphelper/servicehelper.hxx>
62 #include <cppuhelper/implbase.hxx>
63 #include <cppuhelper/supportsservice.hxx>
64 #include <comphelper/extract.hxx>
65 #include <comphelper/documentconstants.hxx>
66 #include <comphelper/documentinfo.hxx>
67 #include <comphelper/storagehelper.hxx>
68 #include <comphelper/attributelist.hxx>
69 #include <unotools/fontcvt.hxx>
70 #include <xmloff/fasttokenhandler.hxx>
71 #include <vcl/GraphicExternalLink.hxx>
72
73 #include <com/sun/star/rdf/XMetadatable.hpp>
74 #include <com/sun/star/rdf/XRepositorySupplier.hpp>
75 #include <RDFaImportHelper.hxx>
76
77 using ::com::sun::star::beans::XPropertySetInfo;
78
79 using namespace ::com::sun::star;
80 using namespace ::com::sun::star::uno;
81 using namespace ::com::sun::star::util;
82 using namespace ::com::sun::star::io;
83 using namespace ::com::sun::star::container;
84 using namespace ::com::sun::star::document;
85 using namespace ::xmloff::token;
86
87 css::uno::Reference< css::xml::sax::XFastTokenHandler > SvXMLImport::xTokenHandler( new FastTokenHandler() );
88 std::unordered_map< sal_Int32, std::pair< OUString, OUString > > SvXMLImport::aNamespaceMap;
89 std::unordered_map< OUString, OUString > SvXMLImport::aNamespaceURIPrefixMap;
90 const OUString SvXMLImport::aDefaultNamespace = OUString("");
91 const OUString SvXMLImport::aNamespaceSeparator = OUString(":");
92 bool SvXMLImport::bIsNSMapsInitialized = false;
93
94 class SvXMLImportEventListener : public cppu::WeakImplHelper< css::lang::XEventListener >
95 {
96 private:
97 SvXMLImport* pImport;
98
99 public:
100 explicit SvXMLImportEventListener(SvXMLImport* pImport);
101
102 // XEventListener
103 virtual void SAL_CALL disposing(const lang::EventObject& rEventObject) override;
104 };
105
106 SvXMLImportEventListener::SvXMLImportEventListener(SvXMLImport* pTempImport)
107 : pImport(pTempImport)
108 {
109 }
110
111 // XEventListener
112 void SAL_CALL SvXMLImportEventListener::disposing( const lang::EventObject& )
113 {
114 if (pImport)
115 {
116 pImport->DisposingModel();
117 pImport = nullptr;
118 }
119 }
120
121 namespace
122 {
123
124 OUString
125 getBuildIdsProperty(uno::Reference<beans::XPropertySet> const& xImportInfo)
126 {
127 if (xImportInfo.is())
128 {
129 try
130 {
131 Reference< XPropertySetInfo > const xSetInfo(
132 xImportInfo->getPropertySetInfo());
133 if (xSetInfo.is() && xSetInfo->hasPropertyByName("BuildId"))
134 {
135 OUString aBuildId;
136 xImportInfo->getPropertyValue("BuildId") >>= aBuildId;
137 return aBuildId;
138 }
139 }
140 catch (Exception const&)
141 {
142 DBG_UNHANDLED_EXCEPTION("xmloff.core", "exception getting BuildId");
143 }
144 }
145 return OUString();
146 }
147
148 class DocumentInfo
149 {
150 private:
151 sal_uInt16 mnGeneratorVersion;
152
153 public:
154 explicit DocumentInfo( const SvXMLImport& rImport )
155 : mnGeneratorVersion( SvXMLImport::ProductVersionUnknown )
156 {
157 OUString const buildIds(
158 getBuildIdsProperty(rImport.getImportInfo()));
159 if (!buildIds.isEmpty())
160 {
161 sal_Int32 const ix = buildIds.indexOf(';');
162 if (-1 != ix)
163 {
164 OUString const loVersion(buildIds.copy(ix + 1));
165 if (!loVersion.isEmpty())
166 {
167 if ('3' == loVersion[0])
168 {
169 mnGeneratorVersion = SvXMLImport::LO_3x;
170 }
171 else if ('4' == loVersion[0])
172 {
173 if (loVersion.getLength() > 1
174 && (loVersion[1] == '0' || loVersion[1] == '1'))
175 {
176 mnGeneratorVersion = SvXMLImport::LO_41x; // 4.0/4.1
177 }
178 else if (loVersion.getLength() > 1 && '2' == loVersion[1])
179 {
180 mnGeneratorVersion = SvXMLImport::LO_42x; // 4.2
181 }
182 else if (loVersion.getLength() > 1 && '3' == loVersion[1])
183 {
184 mnGeneratorVersion = SvXMLImport::LO_43x; // 4.3
185 }
186 else if (loVersion.getLength() > 1 && '4' == loVersion[1])
187 {
188 mnGeneratorVersion = SvXMLImport::LO_44x; // 4.4
189 }
190 }
191 else if ('5' == loVersion[0])
192 {
193 mnGeneratorVersion = SvXMLImport::LO_5x;
194 }
195 else if ('6' == loVersion[0])
196 {
197 mnGeneratorVersion = SvXMLImport::LO_6x;
198 }
199 else
200 {
201 SAL_INFO("xmloff.core", "unknown LO version: " << loVersion);
202 }
203 return; // ignore buildIds
204 }
205 }
206 }
207 sal_Int32 nUPD, nBuild;
208 if ( rImport.getBuildIds( nUPD, nBuild ) )
209 {
210 if ( nUPD >= 640 && nUPD <= 645 )
211 {
212 mnGeneratorVersion = SvXMLImport::OOo_1x;
213 }
214 else if ( nUPD == 680 )
215 {
216 mnGeneratorVersion = SvXMLImport::OOo_2x;
217 }
218 else if ( nUPD == 300 && nBuild <= 9379 )
219 {
220 mnGeneratorVersion = SvXMLImport::OOo_30x;
221 }
222 else if ( nUPD == 310 )
223 {
224 mnGeneratorVersion = SvXMLImport::OOo_31x;
225 }
226 else if ( nUPD == 320 )
227 {
228 mnGeneratorVersion = SvXMLImport::OOo_32x;
229 }
230 else if ( nUPD == 330 )
231 {
232 mnGeneratorVersion = SvXMLImport::OOo_33x;
233 }
234 else if ( nUPD == 340 )
235 {
236 mnGeneratorVersion = SvXMLImport::OOo_34x;
237 }
238 else if (nUPD == 400 || nUPD == 401)
239 {
240 mnGeneratorVersion = SvXMLImport::AOO_40x;
241 }
242 else if (nUPD >= 410)
243 {
244 // effectively this means "latest", see use
245 // in XMLGraphicsDefaultStyle::SetDefaults()!
246 mnGeneratorVersion = SvXMLImport::AOO_4x;
247 }
248 }
249 }
250
251 sal_uInt16 getGeneratorVersion() const
252 {
253 return mnGeneratorVersion;
254 }
255 };
256
257 }
258
259 class SvXMLImport_Impl
260 {
261 public:
262 FontToSubsFontConverter hBatsFontConv;
263 FontToSubsFontConverter hMathFontConv;
264
265 bool mbOwnGraphicResolver;
266 bool mbOwnEmbeddedResolver;
267 INetURLObject aBaseURL;
268 INetURLObject aDocBase;
269
270 /// name of stream in package, e.g., "content.xml"
271 OUString mStreamName;
272
273 OUString aODFVersion;
274
275 bool mbIsOOoXML;
276
277 // Boolean, indicating that position attributes
278 // of shapes are given in horizontal left-to-right layout. This is the case
279 // for the OpenOffice.org file format. (#i28749#)
280 bool mbShapePositionInHoriL2R;
281 bool mbTextDocInOOoFileFormat;
282
283 const uno::Reference< uno::XComponentContext > mxComponentContext;
284 OUString const implementationName;
285
286 uno::Reference< embed::XStorage > mxSourceStorage;
287
288 std::unique_ptr< xmloff::RDFaImportHelper > mpRDFaHelper;
289
290 std::unique_ptr< DocumentInfo > mpDocumentInfo;
291
292 SvXMLImport_Impl( const uno::Reference< uno::XComponentContext >& rxContext,
293 OUString const & theImplementationName)
294 : hBatsFontConv( nullptr )
295 , hMathFontConv( nullptr )
296 , mbOwnGraphicResolver( false )
297 , mbOwnEmbeddedResolver( false )
298 , mbIsOOoXML(false)
299 // Convert drawing object positions from OOo file format to OASIS (#i28749#)
300 , mbShapePositionInHoriL2R( false )
301 , mbTextDocInOOoFileFormat( false )
302 , mxComponentContext( rxContext )
303 , implementationName(theImplementationName)
304 , mpRDFaHelper() // lazy
305 , mpDocumentInfo() // lazy
306 {
307 SAL_WARN_IF(!mxComponentContext.is(), "xmloff.core", "SvXMLImport: no ComponentContext");
308 if (!mxComponentContext.is()) throw uno::RuntimeException();
309 }
310
311 sal_uInt16 getGeneratorVersion( const SvXMLImport& rImport )
312 {
313 if (!mpDocumentInfo)
314 {
315 mpDocumentInfo.reset( new DocumentInfo( rImport ) );
316 }
317
318 return mpDocumentInfo->getGeneratorVersion();
319 }
320
321 ::comphelper::UnoInterfaceToUniqueIdentifierMapper maInterfaceToIdentifierMapper;
322 };
323
324 SvXMLImportContext *SvXMLImport::CreateDocumentContext(sal_uInt16 const nPrefix,
325 const OUString& rLocalName,
326 const uno::Reference< xml::sax::XAttributeList >& )
327 {
328 return new SvXMLImportContext( *this, nPrefix, rLocalName );
329 }
330
331 SvXMLImportContext *SvXMLImport::CreateFastContext( sal_Int32 /*Element*/,
332 const uno::Reference< xml::sax::XFastAttributeList >& /*xAttrList*/ )
333 {
334 return new SvXMLImportContext( *this );
335 }
336
337 void SvXMLImport::InitCtor_()
338 {
339 if( mnImportFlags != SvXMLImportFlags::NONE )
340 {
341 // implicit "xml" namespace prefix
342 mpNamespaceMap->Add( GetXMLToken(XML_XML), GetXMLToken(XML_N_XML), XML_NAMESPACE_XML );
343 mpNamespaceMap->Add( "_office", GetXMLToken(XML_N_OFFICE), XML_NAMESPACE_OFFICE );
344 mpNamespaceMap->Add( "_office_ooo", GetXMLToken(XML_N_OFFICE_EXT), XML_NAMESPACE_OFFICE_EXT );
345 mpNamespaceMap->Add( "_ooo", GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO );
346 mpNamespaceMap->Add( "_style", GetXMLToken(XML_N_STYLE), XML_NAMESPACE_STYLE );
347 mpNamespaceMap->Add( "_text", GetXMLToken(XML_N_TEXT), XML_NAMESPACE_TEXT );
348 mpNamespaceMap->Add( "_table", GetXMLToken(XML_N_TABLE), XML_NAMESPACE_TABLE );
349 mpNamespaceMap->Add( "_table_ooo", GetXMLToken(XML_N_TABLE_EXT), XML_NAMESPACE_TABLE_EXT );
350 mpNamespaceMap->Add( "_draw", GetXMLToken(XML_N_DRAW), XML_NAMESPACE_DRAW );
351 mpNamespaceMap->Add( "_draw_ooo", GetXMLToken(XML_N_DRAW_EXT), XML_NAMESPACE_DRAW_EXT );
352 mpNamespaceMap->Add( "_dr3d", GetXMLToken(XML_N_DR3D), XML_NAMESPACE_DR3D );
353 mpNamespaceMap->Add( "_fo", GetXMLToken(XML_N_FO_COMPAT), XML_NAMESPACE_FO );
354 mpNamespaceMap->Add( "_xlink", GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK );
355 mpNamespaceMap->Add( "_dc", GetXMLToken(XML_N_DC), XML_NAMESPACE_DC );
356 mpNamespaceMap->Add( "_dom", GetXMLToken(XML_N_DOM), XML_NAMESPACE_DOM );
357 mpNamespaceMap->Add( "_meta", GetXMLToken(XML_N_META), XML_NAMESPACE_META );
358 mpNamespaceMap->Add( "_number", GetXMLToken(XML_N_NUMBER), XML_NAMESPACE_NUMBER );
359 mpNamespaceMap->Add( "_svg", GetXMLToken(XML_N_SVG_COMPAT), XML_NAMESPACE_SVG );
360 mpNamespaceMap->Add( "_chart", GetXMLToken(XML_N_CHART), XML_NAMESPACE_CHART );
361 mpNamespaceMap->Add( "_math", GetXMLToken(XML_N_MATH), XML_NAMESPACE_MATH );
362 mpNamespaceMap->Add( "_form", GetXMLToken(XML_N_FORM), XML_NAMESPACE_FORM );
363 mpNamespaceMap->Add( "_script", GetXMLToken(XML_N_SCRIPT), XML_NAMESPACE_SCRIPT );
364 mpNamespaceMap->Add( "_config", GetXMLToken(XML_N_CONFIG), XML_NAMESPACE_CONFIG );
365 mpNamespaceMap->Add( "_xforms", GetXMLToken(XML_N_XFORMS_1_0), XML_NAMESPACE_XFORMS );
366 mpNamespaceMap->Add( "_formx", GetXMLToken( XML_N_FORMX ), XML_NAMESPACE_FORMX );
367 mpNamespaceMap->Add( "_xsd", GetXMLToken(XML_N_XSD), XML_NAMESPACE_XSD );
368 mpNamespaceMap->Add( "_xsi", GetXMLToken(XML_N_XSI), XML_NAMESPACE_XFORMS );
369 mpNamespaceMap->Add( "_ooow", GetXMLToken(XML_N_OOOW), XML_NAMESPACE_OOOW );
370 mpNamespaceMap->Add( "_oooc", GetXMLToken(XML_N_OOOC), XML_NAMESPACE_OOOC );
371 mpNamespaceMap->Add( "_field", GetXMLToken(XML_N_FIELD), XML_NAMESPACE_FIELD );
372 mpNamespaceMap->Add( "_of", GetXMLToken(XML_N_OF), XML_NAMESPACE_OF );
373 mpNamespaceMap->Add( "_xhtml", GetXMLToken(XML_N_XHTML), XML_NAMESPACE_XHTML );
374 mpNamespaceMap->Add( "_css3text", GetXMLToken(XML_N_CSS3TEXT), XML_NAMESPACE_CSS3TEXT );
375
376 mpNamespaceMap->Add( "_calc_libo", GetXMLToken(XML_N_CALC_EXT), XML_NAMESPACE_CALC_EXT);
377 mpNamespaceMap->Add( "_office_libo",
378 GetXMLToken(XML_N_LO_EXT), XML_NAMESPACE_LO_EXT);
379 }
380
381 if (mxNumberFormatsSupplier.is())
382 mpNumImport = std::make_unique<SvXMLNumFmtHelper>(mxNumberFormatsSupplier, GetComponentContext());
383
384 if (mxModel.is() && !mxEventListener.is())
385 {
386 mxEventListener.set(new SvXMLImportEventListener(this));
387 mxModel->addEventListener(mxEventListener);
388 }
389 }
390
391 SvXMLImport::SvXMLImport(
392 const css::uno::Reference< css::uno::XComponentContext >& xContext,
393 OUString const & implementationName, SvXMLImportFlags nImportFlags )
394 : mpImpl( new SvXMLImport_Impl(xContext, implementationName) ),
395 mpNamespaceMap( new SvXMLNamespaceMap ),
396
397 mpUnitConv( new SvXMLUnitConverter( xContext,
398 util::MeasureUnit::MM_100TH, util::MeasureUnit::MM_100TH) ),
399
400 mnImportFlags( nImportFlags ),
401 isFastContext( false ),
402 maNamespaceHandler( new SvXMLImportFastNamespaceHandler() ),
403 mbIsFormsSupported( true ),
404 mbIsTableShapeSupported( false ),
405 mbNotifyMacroEventRead( false )
406 {
407 SAL_WARN_IF( !xContext.is(), "xmloff.core", "got no service manager" );
408 InitCtor_();
409 mxParser = xml::sax::FastParser::create( xContext );
410 setNamespaceHandler( maNamespaceHandler.get() );
411 setTokenHandler( xTokenHandler );
412 if ( !bIsNSMapsInitialized )
413 {
414 initializeNamespaceMaps();
415 bIsNSMapsInitialized = true;
416 }
417 registerNamespaces();
418 }
419
420 void SvXMLImport::cleanup() throw ()
421 {
422 if (mxEventListener.is() && mxModel.is())
423 mxModel->removeEventListener(mxEventListener);
424 // clear context stacks first in case of parse error because the context
425 // class dtors are full of application logic
426 while (!maFastContexts.empty())
427 {
428 if (SvXMLStylesContext* pStylesContext = dynamic_cast<SvXMLStylesContext*>(maFastContexts.top().get()))
429 pStylesContext->Clear();
430 maFastContexts.pop();
431 }
432 while (!maContexts.empty())
433 {
434 if (SvXMLStylesContext* pStylesContext = dynamic_cast<SvXMLStylesContext*>(maContexts.top().get()))
435 pStylesContext->Clear();
436 maContexts.pop();
437 }
438 mxTextImport.clear(); // XMLRedlineImportHelper needs model
439 DisposingModel();
440 }
441
442 SvXMLImport::~SvXMLImport() throw ()
443 {
444 cleanup();
445 }
446
447 namespace
448 {
449 class theSvXMLImportUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSvXMLImportUnoTunnelId> {};
450 }
451
452 // XUnoTunnel
453 sal_Int64 SAL_CALL SvXMLImport::getSomething( const uno::Sequence< sal_Int8 >& rId )
454 {
455 if( rId.getLength() == 16 &&
456 0 == memcmp( theSvXMLImportUnoTunnelId::get().getSeq().getConstArray(),
457 rId.getConstArray(), 16 ) )
458 {
459 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
460 }
461 return 0;
462 }
463
464 namespace
465 {
466 class setFastDocumentHandlerGuard
467 {
468 private:
469 css::uno::Reference<css::xml::sax::XFastParser> mxParser;
470 public:
471 setFastDocumentHandlerGuard(const css::uno::Reference<css::xml::sax::XFastParser>& Parser,
472 const css::uno::Reference<css::xml::sax::XFastDocumentHandler>& Handler)
473 : mxParser(Parser)
474 {
475 mxParser->setFastDocumentHandler(Handler);
476 }
477 //guarantee restoration of null document handler
478 ~setFastDocumentHandlerGuard()
479 {
480 mxParser->setFastDocumentHandler(nullptr);
481 }
482 };
483 }
484
485 // XFastParser
486 void SAL_CALL SvXMLImport::parseStream( const xml::sax::InputSource& aInputSource )
487 {
488 setFastDocumentHandlerGuard aDocumentHandlerGuard(mxParser, mxFastDocumentHandler.is() ? mxFastDocumentHandler : this);
489 mxParser->parseStream(aInputSource);
490 }
491
492 void SAL_CALL SvXMLImport::setFastDocumentHandler( const uno::Reference< xml::sax::XFastDocumentHandler >& Handler )
493 {
494 mxFastDocumentHandler = Handler;
495 }
496
497 void SAL_CALL SvXMLImport::setTokenHandler( const uno::Reference< xml::sax::XFastTokenHandler >& Handler )
498 {
499 mxParser->setTokenHandler( Handler );
500 }
501
502 void SAL_CALL SvXMLImport::registerNamespace( const OUString& NamespaceURL, sal_Int32 NamespaceToken )
503 {
504 mxParser->registerNamespace( NamespaceURL, NamespaceToken );
505 }
506
507 OUString SAL_CALL SvXMLImport::getNamespaceURL( const OUString& rPrefix )
508 {
509 return mxParser->getNamespaceURL( rPrefix );
510 }
511
512 void SAL_CALL SvXMLImport::setErrorHandler( const uno::Reference< xml::sax::XErrorHandler >& Handler )
513 {
514 mxParser->setErrorHandler( Handler );
515 }
516
517 void SAL_CALL SvXMLImport::setEntityResolver( const uno::Reference< xml::sax::XEntityResolver >& Resolver )
518 {
519 mxParser->setEntityResolver( Resolver );
520 }
521
522 void SAL_CALL SvXMLImport::setLocale( const lang::Locale& rLocale )
523 {
524 mxParser->setLocale( rLocale );
525 }
526
527 void SAL_CALL SvXMLImport::setNamespaceHandler( const uno::Reference< xml::sax::XFastNamespaceHandler >& Handler)
528 {
529 mxParser->setNamespaceHandler( Handler );
530 }
531
532
533 void SAL_CALL SvXMLImport::startDocument()
534 {
535 SAL_INFO( "xmloff.core", "{ SvXMLImport::startDocument" );
536 if (!mxGraphicStorageHandler.is() || !mxEmbeddedResolver.is())
537 {
538 Reference< lang::XMultiServiceFactory > xFactory( mxModel, UNO_QUERY );
539 if( xFactory.is() )
540 {
541 try
542 {
543 if (!mxGraphicStorageHandler.is())
544 {
545 // #99870# Import... instead of Export...
546 mxGraphicStorageHandler.set(
547 xFactory->createInstance("com.sun.star.document.ImportGraphicStorageHandler"),
548 UNO_QUERY);
549 mpImpl->mbOwnGraphicResolver = mxGraphicStorageHandler.is();
550 }
551
552 if( !mxEmbeddedResolver.is() )
553 {
554 // #99870# Import... instead of Export...
555 mxEmbeddedResolver.set(
556 xFactory->createInstance("com.sun.star.document.ImportEmbeddedObjectResolver"),
557 UNO_QUERY);
558 mpImpl->mbOwnEmbeddedResolver = mxEmbeddedResolver.is();
559 }
560 }
561 catch( css::uno::Exception& )
562 {
563 }
564 }
565 }
566 }
567
568 void SAL_CALL SvXMLImport::endDocument()
569 {
570 SAL_INFO( "xmloff.core", "} SvXMLImport::endDocument" );
571 // #i9518# All the stuff that accesses the document has to be done here, not in the dtor,
572 // because the SvXMLImport dtor might not be called until after the document has been closed.
573
574 GetTextImport()->MapCrossRefHeadingFieldsHorribly();
575
576 if (mpImpl->mpRDFaHelper)
577 {
578 const uno::Reference<rdf::XRepositorySupplier> xRS(mxModel,
579 uno::UNO_QUERY);
580 if (xRS.is())
581 {
582 mpImpl->mpRDFaHelper->InsertRDFa( xRS );
583 }
584 }
585
586 mpNumImport.reset();
587 if (mxImportInfo.is())
588 {
589 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
590 if (xPropertySetInfo.is())
591 {
592 if (bool(mpProgressBarHelper))
593 {
594 OUString sProgressMax(XML_PROGRESSMAX);
595 OUString sProgressCurrent(XML_PROGRESSCURRENT);
596 OUString sRepeat(XML_PROGRESSREPEAT);
597 if (xPropertySetInfo->hasPropertyByName(sProgressMax) &&
598 xPropertySetInfo->hasPropertyByName(sProgressCurrent))
599 {
600 sal_Int32 nProgressMax(mpProgressBarHelper->GetReference());
601 sal_Int32 nProgressCurrent(mpProgressBarHelper->GetValue());
602 mxImportInfo->setPropertyValue(sProgressMax, uno::Any(nProgressMax));
603 mxImportInfo->setPropertyValue(sProgressCurrent, uno::Any(nProgressCurrent));
604 }
605 if (xPropertySetInfo->hasPropertyByName(sRepeat))
606 mxImportInfo->setPropertyValue(sRepeat, css::uno::makeAny(mpProgressBarHelper->GetRepeat()));
607 // pProgressBarHelper is deleted in dtor
608 }
609 OUString sNumberStyles(XML_NUMBERSTYLES);
610 if (mxNumberStyles.is() && xPropertySetInfo->hasPropertyByName(sNumberStyles))
611 {
612 mxImportInfo->setPropertyValue(sNumberStyles, Any(mxNumberStyles));
613 }
614 }
615 }
616
617 if( mxFontDecls.is() )
618 static_cast<SvXMLStylesContext *>(mxFontDecls.get())->Clear();
619 if( mxStyles.is() )
620 static_cast<SvXMLStylesContext *>(mxStyles.get())->Clear();
621 if( mxAutoStyles.is() )
622 static_cast<SvXMLStylesContext *>(mxAutoStyles.get())->Clear();
623 if( mxMasterStyles.is() )
624 static_cast<SvXMLStylesContext *>(mxMasterStyles.get())->Clear();
625
626 // possible form-layer related knittings which can only be done when
627 // the whole document exists
628 if ( mxFormImport.is() )
629 mxFormImport->documentDone();
630
631 // The shape import helper does the z-order sorting in the dtor,
632 // so it must be deleted here, too.
633 mxShapeImport = nullptr;
634
635 if( mpImpl->mbOwnGraphicResolver )
636 {
637 Reference<lang::XComponent> xComp(mxGraphicStorageHandler, UNO_QUERY);
638 xComp->dispose();
639 }
640
641 if( mpImpl->mbOwnEmbeddedResolver )
642 {
643 Reference< lang::XComponent > xComp( mxEmbeddedResolver, UNO_QUERY );
644 xComp->dispose();
645 }
646 mpStyleMap.clear();
647
648 if ( bool( mpXMLErrors ) )
649 {
650 mpXMLErrors->ThrowErrorAsSAXException( XMLERROR_FLAG_SEVERE );
651 }
652 }
653
654 std::unique_ptr<SvXMLNamespaceMap> SvXMLImport::processNSAttributes(
655 const uno::Reference< xml::sax::XAttributeList >& xAttrList)
656 {
657 std::unique_ptr<SvXMLNamespaceMap> pRewindMap;
658 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
659 for( sal_Int16 i=0; i < nAttrCount; i++ )
660 {
661 const OUString& rAttrName = xAttrList->getNameByIndex( i );
662 if ( rAttrName == "office:version" )
663 {
664 mpImpl->aODFVersion = xAttrList->getValueByIndex( i );
665
666 // the ODF version in content.xml and manifest.xml must be the same starting from ODF1.2
667 if ( mpImpl->mStreamName == "content.xml" && !IsODFVersionConsistent( mpImpl->aODFVersion ) )
668 {
669 throw xml::sax::SAXException("Inconsistent ODF versions in content.xml and manifest.xml!",
670 uno::Reference< uno::XInterface >(),
671 uno::makeAny(
672 packages::zip::ZipIOException("Inconsistent ODF versions in content.xml and manifest.xml!" ) ) );
673 }
674 }
675 else if( ( rAttrName.getLength() >= 5 ) &&
676 ( rAttrName.startsWith( GetXMLToken(XML_XMLNS) ) ) &&
677 ( rAttrName.getLength() == 5 || ':' == rAttrName[5] ) )
678 {
679 if( !pRewindMap )
680 {
681 pRewindMap = std::move(mpNamespaceMap);
682 mpNamespaceMap.reset(new SvXMLNamespaceMap(*pRewindMap));
683 }
684 const OUString& rAttrValue = xAttrList->getValueByIndex( i );
685
686 OUString aPrefix( ( rAttrName.getLength() == 5 )
687 ? OUString()
688 : rAttrName.copy( 6 ) );
689 // Add namespace, but only if it is known.
690 sal_uInt16 nKey = mpNamespaceMap->AddIfKnown( aPrefix, rAttrValue );
691 // If namespace is unknown, try to match a name with similar
692 // TC Id and version
693 if( XML_NAMESPACE_UNKNOWN == nKey )
694 {
695 OUString aTestName( rAttrValue );
696 if( SvXMLNamespaceMap::NormalizeURI( aTestName ) )
697 nKey = mpNamespaceMap->AddIfKnown( aPrefix, aTestName );
698 }
699 // If that namespace is not known, too, add it as unknown
700 if( XML_NAMESPACE_UNKNOWN == nKey )
701 mpNamespaceMap->Add( aPrefix, rAttrValue );
702
703 }
704 }
705 return pRewindMap;
706 }
707
708 void SAL_CALL SvXMLImport::startElement( const OUString& rName,
709 const uno::Reference< xml::sax::XAttributeList >& xAttrList )
710 {
711 // SAL_INFO("svg", "startElement " << rName);
712 // Process namespace attributes. This must happen before creating the
713 // context, because namespace declaration apply to the element name itself.
714 std::unique_ptr<SvXMLNamespaceMap> pRewindMap(processNSAttributes(xAttrList));
715
716 // Get element's namespace and local name.
717 OUString aLocalName;
718 sal_uInt16 nPrefix =
719 mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName );
720
721 // If there are contexts already, call a CreateChildContext at the topmost
722 // context. Otherwise, create a default context.
723 SvXMLImportContextRef xContext;
724 if(!maContexts.empty())
725 {
726 xContext = maContexts.top()->CreateChildContext(nPrefix, aLocalName, xAttrList);
727 SAL_WARN_IF( !xContext.is() || (xContext->GetPrefix() != nPrefix), "xmloff.core",
728 "SvXMLImport::startElement: created context has wrong prefix" );
729 }
730 else
731 {
732 xContext.set(CreateDocumentContext(nPrefix, aLocalName, xAttrList));
733 if( (nPrefix & XML_NAMESPACE_UNKNOWN_FLAG) != 0 &&
734 dynamic_cast< const SvXMLImportContext*>(xContext.get()) != nullptr )
735 {
736 Reference<xml::sax::XLocator> xDummyLocator;
737 Sequence < OUString > aParams { rName };
738
739 SetError( XMLERROR_FLAG_SEVERE|XMLERROR_UNKNOWN_ROOT,
740 aParams, "Root element unknown", xDummyLocator );
741 }
742 }
743
744 SAL_WARN_IF( !xContext.is(), "xmloff.core", "SvXMLImport::startElement: missing context" );
745 if( !xContext.is() )
746 xContext.set(new SvXMLImportContext( *this, nPrefix, aLocalName ));
747
748 // Remember old namespace map.
749 if( pRewindMap )
750 xContext->PutRewindMap(std::move(pRewindMap));
751
752 // Call a startElement at the new context.
753 xContext->StartElement( xAttrList );
754
755 // Push context on stack.
756 maContexts.push(xContext);
757 }
758
759 void SAL_CALL SvXMLImport::endElement( const OUString&
760 #ifdef DBG_UTIL
761 rName
762 #endif
763 )
764 {
765 if (maContexts.empty())
766 {
767 SAL_WARN("xmloff.core", "SvXMLImport::endElement: no context left");
768 return;
769 }
770
771 std::unique_ptr<SvXMLNamespaceMap> pRewindMap;
772
773 {
774 // Get topmost context and remove it from the stack.
775 SvXMLImportContextRef xContext = maContexts.top();
776 maContexts.pop();
777
778 #ifdef DBG_UTIL
779 // Non product only: check if endElement call matches startELement call.
780 OUString aLocalName;
781 sal_uInt16 nPrefix =
782 mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName );
783 SAL_WARN_IF( xContext->GetPrefix() != nPrefix, "xmloff.core", "SvXMLImport::endElement: popped context has wrong prefix" );
784 SAL_WARN_IF( xContext->GetLocalName() != aLocalName, "xmloff.core", "SvXMLImport::endElement: popped context has wrong lname" );
785 #endif
786
787 // Call a EndElement at the current context.
788 xContext->EndElement();
789 // Get a namespace map to rewind.
790 pRewindMap = xContext->TakeRewindMap();
791 // note: delete xContext *before* rewinding namespace map!
792 }
793
794 // Rewind a namespace map.
795 if (pRewindMap)
796 {
797 mpNamespaceMap.reset();
798 mpNamespaceMap = std::move(pRewindMap);
799 }
800 }
801
802 void SAL_CALL SvXMLImport::characters( const OUString& rChars )
803 {
804 if ( !maFastContexts.empty() )
805 {
806 maFastContexts.top()->characters( rChars );
807 }
808 else if( !maContexts.empty() )
809 {
810 maContexts.top()->Characters( rChars );
811 }
812 }
813
814 void SvXMLImport::Characters( const OUString& rChars )
815 {
816 if( !maContexts.empty() )
817 {
818 maContexts.top()->Characters( rChars );
819 }
820 }
821
822 void SAL_CALL SvXMLImport::ignorableWhitespace( const OUString& )
823 {
824 }
825
826 void SAL_CALL SvXMLImport::processingInstruction( const OUString&,
827 const OUString& )
828 {
829 }
830
831 void SAL_CALL SvXMLImport::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& rLocator )
832 {
833 mxLocator = rLocator;
834 }
835
836 // XFastContextHandler
837 void SAL_CALL SvXMLImport::startFastElement (sal_Int32 Element,
838 const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
839 {
840 if ( Attribs.is() )
841 {
842 sax_fastparser::FastAttributeList *pAttribList =
843 sax_fastparser::FastAttributeList::castToFastAttributeList( Attribs );
844 auto &aIter( pAttribList->find( XML_ELEMENT( OFFICE, XML_VERSION ) ) );
845 if( aIter != pAttribList->end() )
846 {
847 mpImpl->aODFVersion = aIter.toString();
848
849 // the ODF version in content.xml and manifest.xml must be the same starting from ODF1.2
850 if ( mpImpl->mStreamName == "content.xml" && !IsODFVersionConsistent( mpImpl->aODFVersion ) )
851 {
852 throw xml::sax::SAXException("Inconsistent ODF versions in content.xml and manifest.xml!",
853 uno::Reference< uno::XInterface >(),
854 uno::makeAny(
855 packages::zip::ZipIOException("Inconsistent ODF versions in content.xml and manifest.xml!" ) ) );
856 }
857 }
858 }
859
860 //Namespace handling is unnecessary. It is done by the fastparser itself.
861 uno::Reference<XFastContextHandler> xContext;
862 if (!maFastContexts.empty())
863 {
864 uno::Reference<XFastContextHandler> pHandler = maFastContexts.top();
865 xContext = pHandler->createFastChildContext( Element, Attribs );
866 }
867 else
868 xContext.set( CreateFastContext( Element, Attribs ) );
869
870 if ( !xContext.is() )
871 xContext.set( new SvXMLImportContext( *this ) );
872
873 isFastContext = true;
874
875 // Call a startElement at the new context.
876 xContext->startFastElement( Element, Attribs );
877
878 if ( isFastContext )
879 {
880 if ( maNamespaceAttrList.is() )
881 maNamespaceAttrList->Clear();
882 else
883 maNamespaceAttrList = new comphelper::AttributeList;
884
885 maNamespaceHandler->addNSDeclAttributes( maNamespaceAttrList );
886 std::unique_ptr<SvXMLNamespaceMap> pRewindMap(
887 processNSAttributes( maNamespaceAttrList.get() ));
888 assert( dynamic_cast<SvXMLImportContext*>( xContext.get() ) != nullptr );
889 SvXMLImportContext *pContext = static_cast<SvXMLImportContext*>( xContext.get() );
890 if (pRewindMap)
891 pContext->PutRewindMap(std::move(pRewindMap));
892 maContexts.push(pContext);
893 }
894
895 // Push context on stack.
896 maFastContexts.push(xContext);
897 }
898
899 void SAL_CALL SvXMLImport::startUnknownElement (const OUString & rPrefix, const OUString & rLocalName,
900 const uno::Reference< xml::sax::XFastAttributeList > & Attribs)
901 {
902 uno::Reference<XFastContextHandler> xContext;
903 if (!maFastContexts.empty())
904 {
905 uno::Reference<XFastContextHandler> pHandler = maFastContexts.top();
906 xContext = pHandler->createUnknownChildContext( rPrefix, rLocalName, Attribs );
907 }
908 else
909 xContext.set( CreateFastContext( -1, Attribs ) );
910
911 if ( !xContext.is() )
912 xContext.set( new SvXMLImportContext( *this ) );
913
914 xContext->startUnknownElement( rPrefix, rLocalName, Attribs );
915 maFastContexts.push(xContext);
916 }
917
918 void SAL_CALL SvXMLImport::endFastElement (sal_Int32 Element)
919 {
920 if (!maFastContexts.empty())
921 {
922 uno::Reference<XFastContextHandler> xContext = maFastContexts.top();
923 maFastContexts.pop();
924 isFastContext = true;
925 xContext->endFastElement( Element );
926 if (isFastContext)
927 maContexts.pop();
928
929 xContext = nullptr;
930 }
931 }
932
933 void SAL_CALL SvXMLImport::endUnknownElement (const OUString & rPrefix, const OUString & rLocalName)
934 {
935 if (!maFastContexts.empty())
936 {
937 uno::Reference<XFastContextHandler> xContext = maFastContexts.top();
938 maFastContexts.pop();
939 xContext->endUnknownElement( rPrefix, rLocalName );
940 xContext = nullptr;
941 }
942 }
943
944 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
945 SvXMLImport::createFastChildContext (sal_Int32,
946 const uno::Reference< xml::sax::XFastAttributeList > &)
947 {
948 return this;
949 }
950
951 uno::Reference< xml::sax::XFastContextHandler > SAL_CALL
952 SvXMLImport::createUnknownChildContext (const OUString &, const OUString &,
953 const uno::Reference< xml::sax::XFastAttributeList > &)
954 {
955 return this;
956 }
957
958 // XExtendedDocumentHandler
959 void SAL_CALL SvXMLImport::startCDATA()
960 {
961 }
962
963 void SAL_CALL SvXMLImport::endCDATA()
964 {
965 }
966
967 void SAL_CALL SvXMLImport::comment( const OUString& )
968 {
969 }
970
971 void SAL_CALL SvXMLImport::allowLineBreak()
972 {
973 }
974
975 void SAL_CALL SvXMLImport::unknown( const OUString& )
976 {
977 }
978
979 void SvXMLImport::SetStatistics(const uno::Sequence< beans::NamedValue> &)
980 {
981 GetProgressBarHelper()->SetRepeat(false);
982 GetProgressBarHelper()->SetReference(0);
983 }
984
985 // XImporter
986 void SAL_CALL SvXMLImport::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc )
987 {
988 mxModel.set( xDoc, UNO_QUERY );
989 if( !mxModel.is() )
990 throw lang::IllegalArgumentException();
991
992 try
993 {
994 uno::Reference<document::XStorageBasedDocument> const xSBDoc(mxModel, uno::UNO_QUERY);
995 uno::Reference<embed::XStorage> const xStor(xSBDoc.is() ? xSBDoc->getDocumentStorage()
996 : nullptr);
997 if (xStor.is())
998 {
999 mpImpl->mbIsOOoXML =
1000 ::comphelper::OStorageHelper::GetXStorageFormat(xStor)
1001 < SOFFICE_FILEFORMAT_8;
1002 }
1003 }
1004 catch (uno::Exception const&)
1005 {
1006 DBG_UNHANDLED_EXCEPTION("xmloff.core");
1007 }
1008 if (!mxEventListener.is())
1009 {
1010 mxEventListener.set(new SvXMLImportEventListener(this));
1011 mxModel->addEventListener(mxEventListener);
1012 }
1013
1014 SAL_WARN_IF( bool(mpNumImport), "xmloff.core", "number format import already exists." );
1015 mpNumImport.reset();
1016 }
1017
1018 // XFilter
1019 sal_Bool SAL_CALL SvXMLImport::filter( const uno::Sequence< beans::PropertyValue >& )
1020 {
1021 return false;
1022 }
1023
1024 void SAL_CALL SvXMLImport::cancel( )
1025 {
1026 }
1027
1028 // XInitialize
1029 void SAL_CALL SvXMLImport::initialize( const uno::Sequence< uno::Any >& aArguments )
1030 {
1031 for( const auto& rAny : aArguments )
1032 {
1033 Reference<XInterface> xValue;
1034 rAny >>= xValue;
1035
1036 uno::Reference<task::XStatusIndicator> xTmpStatusIndicator(
1037 xValue, UNO_QUERY );
1038 if( xTmpStatusIndicator.is() )
1039 mxStatusIndicator = xTmpStatusIndicator;
1040
1041 uno::Reference<document::XGraphicStorageHandler> xGraphicStorageHandler(xValue, UNO_QUERY);
1042 if (xGraphicStorageHandler.is())
1043 mxGraphicStorageHandler = xGraphicStorageHandler;
1044
1045 uno::Reference<document::XEmbeddedObjectResolver> xTmpObjectResolver(
1046 xValue, UNO_QUERY );
1047 if( xTmpObjectResolver.is() )
1048 mxEmbeddedResolver = xTmpObjectResolver;
1049
1050 uno::Reference<beans::XPropertySet> xTmpPropSet( xValue, UNO_QUERY );
1051 if( xTmpPropSet.is() )
1052 {
1053 mxImportInfo = xTmpPropSet;
1054 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
1055 if (xPropertySetInfo.is())
1056 {
1057 OUString sPropName(XML_NUMBERSTYLES);
1058 if (xPropertySetInfo->hasPropertyByName(sPropName))
1059 {
1060 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1061 aAny >>= mxNumberStyles;
1062 }
1063
1064 sPropName = "PrivateData";
1065 if (xPropertySetInfo->hasPropertyByName(sPropName))
1066 {
1067 Reference < XInterface > xIfc;
1068 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1069 aAny >>= xIfc;
1070
1071 StyleMap *pSMap = comphelper::getUnoTunnelImplementation<StyleMap>( xIfc );
1072 if( pSMap )
1073 {
1074 mpStyleMap = pSMap;
1075 }
1076 }
1077 OUString sBaseURI;
1078 sPropName = "BaseURI";
1079 if (xPropertySetInfo->hasPropertyByName(sPropName))
1080 {
1081 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1082 aAny >>= sBaseURI;
1083 mpImpl->aBaseURL.SetURL( sBaseURI );
1084 mpImpl->aDocBase.SetURL( sBaseURI );
1085 }
1086 OUString sRelPath;
1087 sPropName = "StreamRelPath";
1088 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1089 {
1090 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1091 aAny >>= sRelPath;
1092 }
1093 OUString sName;
1094 sPropName = "StreamName";
1095 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1096 {
1097 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1098 aAny >>= sName;
1099 }
1100 if( !sBaseURI.isEmpty() && !sName.isEmpty() )
1101 {
1102 if( !sRelPath.isEmpty() )
1103 mpImpl->aBaseURL.insertName( sRelPath );
1104 mpImpl->aBaseURL.insertName( sName );
1105 }
1106 mpImpl->mStreamName = sName; // Note: may be empty (XSLT)
1107 // Retrieve property <ShapePositionInHoriL2R> (#i28749#)
1108 sPropName = "ShapePositionInHoriL2R";
1109 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1110 {
1111 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1112 aAny >>= mpImpl->mbShapePositionInHoriL2R;
1113 }
1114 sPropName = "TextDocInOOoFileFormat";
1115 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1116 {
1117 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName);
1118 aAny >>= mpImpl->mbTextDocInOOoFileFormat;
1119 }
1120
1121 sPropName = "SourceStorage";
1122 if( xPropertySetInfo->hasPropertyByName(sPropName) )
1123 mxImportInfo->getPropertyValue(sPropName) >>= mpImpl->mxSourceStorage;
1124 }
1125 }
1126 }
1127
1128 uno::Reference<lang::XInitialization> const xInit(mxParser, uno::UNO_QUERY_THROW);
1129 uno::Sequence<uno::Any> args(1);
1130 args[0] <<= OUString("IgnoreMissingNSDecl");
1131 xInit->initialize( args );
1132 }
1133
1134 // XServiceInfo
1135 OUString SAL_CALL SvXMLImport::getImplementationName()
1136 {
1137 return mpImpl->implementationName;
1138 }
1139
1140 sal_Bool SAL_CALL SvXMLImport::supportsService( const OUString& rServiceName )
1141 {
1142 return cppu::supportsService(this, rServiceName);
1143 }
1144
1145 uno::Sequence< OUString > SAL_CALL SvXMLImport::getSupportedServiceNames( )
1146 {
1147 uno::Sequence<OUString> aSeq(2);
1148 aSeq[0] = "com.sun.star.document.ImportFilter";
1149 aSeq[1] = "com.sun.star.xml.XMLImportFilter";
1150 return aSeq;
1151 }
1152
1153 XMLTextImportHelper* SvXMLImport::CreateTextImport()
1154 {
1155 return new XMLTextImportHelper( mxModel, *this );
1156 }
1157
1158 XMLShapeImportHelper* SvXMLImport::CreateShapeImport()
1159 {
1160 return new XMLShapeImportHelper( *this, mxModel );
1161 }
1162
1163 SchXMLImportHelper* SvXMLImport::CreateChartImport()
1164 {
1165 return new SchXMLImportHelper();
1166 }
1167
1168 ::xmloff::OFormLayerXMLImport* SvXMLImport::CreateFormImport()
1169 {
1170 return new ::xmloff::OFormLayerXMLImport(*this);
1171 }
1172
1173
1174 // Get or create fill/line/lineend-style-helper
1175
1176
1177 const Reference< container::XNameContainer > & SvXMLImport::GetGradientHelper()
1178 {
1179 if( !mxGradientHelper.is() )
1180 {
1181 if( mxModel.is() )
1182 {
1183 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1184 if( xServiceFact.is() )
1185 {
1186 try
1187 {
1188 mxGradientHelper.set( xServiceFact->createInstance(
1189 "com.sun.star.drawing.GradientTable" ), UNO_QUERY);
1190 }
1191 catch( lang::ServiceNotRegisteredException& )
1192 {}
1193 }
1194 }
1195 }
1196
1197 return mxGradientHelper;
1198 }
1199
1200 const Reference< container::XNameContainer > & SvXMLImport::GetHatchHelper()
1201 {
1202 if( !mxHatchHelper.is() )
1203 {
1204 if( mxModel.is() )
1205 {
1206 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1207 if( xServiceFact.is() )
1208 {
1209 try
1210 {
1211 mxHatchHelper.set( xServiceFact->createInstance(
1212 "com.sun.star.drawing.HatchTable" ), UNO_QUERY);
1213 }
1214 catch( lang::ServiceNotRegisteredException& )
1215 {}
1216 }
1217 }
1218 }
1219
1220 return mxHatchHelper;
1221 }
1222
1223 const Reference< container::XNameContainer > & SvXMLImport::GetBitmapHelper()
1224 {
1225 if( !mxBitmapHelper.is() )
1226 {
1227 if( mxModel.is() )
1228 {
1229 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1230 if( xServiceFact.is() )
1231 {
1232 try
1233 {
1234 mxBitmapHelper.set( xServiceFact->createInstance(
1235 "com.sun.star.drawing.BitmapTable" ), UNO_QUERY);
1236 }
1237 catch( lang::ServiceNotRegisteredException& )
1238 {}
1239 }
1240 }
1241 }
1242
1243 return mxBitmapHelper;
1244 }
1245
1246 const Reference< container::XNameContainer > & SvXMLImport::GetTransGradientHelper()
1247 {
1248 if( !mxTransGradientHelper.is() )
1249 {
1250 if( mxModel.is() )
1251 {
1252 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1253 if( xServiceFact.is() )
1254 {
1255 try
1256 {
1257 mxTransGradientHelper.set( xServiceFact->createInstance(
1258 "com.sun.star.drawing.TransparencyGradientTable" ), UNO_QUERY);
1259 }
1260 catch( lang::ServiceNotRegisteredException& )
1261 {}
1262 }
1263 }
1264 }
1265
1266 return mxTransGradientHelper;
1267 }
1268
1269 const Reference< container::XNameContainer > & SvXMLImport::GetMarkerHelper()
1270 {
1271 if( !mxMarkerHelper.is() )
1272 {
1273 if( mxModel.is() )
1274 {
1275 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1276 if( xServiceFact.is() )
1277 {
1278 try
1279 {
1280 mxMarkerHelper.set( xServiceFact->createInstance( "com.sun.star.drawing.MarkerTable" ), UNO_QUERY);
1281 }
1282 catch( lang::ServiceNotRegisteredException& )
1283 {}
1284 }
1285 }
1286 }
1287
1288 return mxMarkerHelper;
1289 }
1290
1291 const Reference< container::XNameContainer > & SvXMLImport::GetDashHelper()
1292 {
1293 if( !mxDashHelper.is() && mxModel.is() )
1294 {
1295 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY);
1296 if( xServiceFact.is() )
1297 {
1298 try
1299 {
1300 mxDashHelper.set( xServiceFact->createInstance( "com.sun.star.drawing.DashTable" ), UNO_QUERY);
1301 }
1302 catch( lang::ServiceNotRegisteredException& )
1303 {}
1304 }
1305 }
1306
1307 return mxDashHelper;
1308 }
1309
1310 bool SvXMLImport::IsPackageURL( const OUString& rURL ) const
1311 {
1312
1313 // if, and only if, only parts are imported, then we're in a package
1314 const SvXMLImportFlags nTest = SvXMLImportFlags::META|SvXMLImportFlags::STYLES|SvXMLImportFlags::CONTENT|SvXMLImportFlags::SETTINGS;
1315 if( (mnImportFlags & nTest) == nTest )
1316 return false;
1317
1318 // TODO: from this point extract to own static function
1319
1320 // Some quick tests: Some may rely on the package structure!
1321 sal_Int32 nLen = rURL.getLength();
1322 if( nLen > 0 && '/' == rURL[0] )
1323 // RFC2396 net_path or abs_path
1324 return false;
1325 else if( nLen > 1 && '.' == rURL[0] )
1326 {
1327 if( '.' == rURL[1] )
1328 // ../: We are never going up one level, so we know
1329 // it's not an external URI
1330 return false;
1331 else if( '/' == rURL[1] )
1332 // we are remaining on a level, so it's a package URI
1333 return true;
1334 }
1335
1336 // Now check for a RFC2396 schema
1337 sal_Int32 nPos = 1;
1338 while( nPos < nLen )
1339 {
1340 switch( rURL[nPos] )
1341 {
1342 case '/':
1343 // a relative path segment
1344 return true;
1345 case ':':
1346 // a schema
1347 return false;
1348 default:
1349 break;
1350 // we don't care about any other characters
1351 }
1352 ++nPos;
1353 }
1354
1355 return true;
1356 }
1357
1358 uno::Reference<graphic::XGraphic> SvXMLImport::loadGraphicByURL(OUString const & rURL)
1359 {
1360 uno::Reference<graphic::XGraphic> xGraphic;
1361
1362 if (mxGraphicStorageHandler.is())
1363 {
1364 if (IsPackageURL(rURL))
1365 {
1366 xGraphic = mxGraphicStorageHandler->loadGraphic(rURL);
1367 }
1368 else
1369 {
1370 OUString const & rAbsoluteURL = GetAbsoluteReference(rURL);
1371 GraphicExternalLink aExternalLink(rAbsoluteURL);
1372 Graphic aGraphic(aExternalLink);
1373 xGraphic = aGraphic.GetXGraphic();
1374 }
1375 }
1376
1377 return xGraphic;
1378 }
1379
1380 uno::Reference<graphic::XGraphic> SvXMLImport::loadGraphicFromBase64(uno::Reference<io::XOutputStream> const & rxOutputStream)
1381 {
1382 uno::Reference<graphic::XGraphic> xGraphic;
1383
1384 if (mxGraphicStorageHandler.is())
1385 {
1386 xGraphic = mxGraphicStorageHandler->loadGraphicFromOutputStream(rxOutputStream);
1387 }
1388
1389 return xGraphic;
1390 }
1391
1392 Reference< XOutputStream > SvXMLImport::GetStreamForGraphicObjectURLFromBase64()
1393 {
1394 Reference< XOutputStream > xOStm;
1395 Reference< document::XBinaryStreamResolver > xStmResolver(mxGraphicStorageHandler, UNO_QUERY);
1396
1397 if( xStmResolver.is() )
1398 xOStm = xStmResolver->createOutputStream();
1399
1400 return xOStm;
1401 }
1402
1403 OUString SvXMLImport::ResolveEmbeddedObjectURL(
1404 const OUString& rURL,
1405 const OUString& rClassId )
1406 {
1407 OUString sRet;
1408
1409 if( IsPackageURL( rURL ) )
1410 {
1411 if ( mxEmbeddedResolver.is() )
1412 {
1413 OUString sURL( rURL );
1414 if( !rClassId.isEmpty() )
1415 {
1416 sURL += "!" + rClassId;
1417 }
1418 sRet = mxEmbeddedResolver->resolveEmbeddedObjectURL( sURL );
1419 }
1420 }
1421 else
1422 sRet = GetAbsoluteReference( rURL );
1423
1424 return sRet;
1425 }
1426
1427 Reference< embed::XStorage > const & SvXMLImport::GetSourceStorage()
1428 {
1429 return mpImpl->mxSourceStorage;
1430 }
1431
1432 Reference < XOutputStream >
1433 SvXMLImport::GetStreamForEmbeddedObjectURLFromBase64()
1434 {
1435 Reference < XOutputStream > xOLEStream;
1436
1437 if( mxEmbeddedResolver.is() )
1438 {
1439 Reference< XNameAccess > xNA( mxEmbeddedResolver, UNO_QUERY );
1440 if( xNA.is() )
1441 {
1442 Any aAny = xNA->getByName( "Obj12345678" );
1443 aAny >>= xOLEStream;
1444 }
1445 }
1446
1447 return xOLEStream;
1448 }
1449
1450 OUString SvXMLImport::ResolveEmbeddedObjectURLFromBase64()
1451 {
1452 OUString sRet;
1453
1454 if( mxEmbeddedResolver.is() )
1455 {
1456 sRet = mxEmbeddedResolver->resolveEmbeddedObjectURL( "Obj12345678" );
1457 }
1458
1459 return sRet;
1460 }
1461
1462 void SvXMLImport::AddStyleDisplayName( sal_uInt16 nFamily,
1463 const OUString& rName,
1464 const OUString& rDisplayName )
1465 {
1466 if( !mpStyleMap.is() )
1467 {
1468 mpStyleMap = new StyleMap;
1469 if( mxImportInfo.is() )
1470 {
1471 OUString sPrivateData( "PrivateData" );
1472 Reference< beans::XPropertySetInfo > xPropertySetInfo =
1473 mxImportInfo->getPropertySetInfo();
1474 if( xPropertySetInfo.is() &&
1475 xPropertySetInfo->hasPropertyByName(sPrivateData) )
1476 {
1477 Reference < XInterface > xIfc(
1478 static_cast< XUnoTunnel *>( mpStyleMap.get() ) );
1479 mxImportInfo->setPropertyValue( sPrivateData, Any(xIfc) );
1480 }
1481 }
1482 }
1483
1484 StyleMap::key_type aKey( nFamily, rName );
1485 StyleMap::value_type aValue( aKey, rDisplayName );
1486 ::std::pair<StyleMap::iterator,bool> aRes( mpStyleMap->insert( aValue ) );
1487 SAL_WARN_IF( !aRes.second,
1488 "xmloff.core",
1489 "duplicate style name of family " << nFamily << ": \"" << rName << "\"");
1490
1491 }
1492
1493 OUString SvXMLImport::GetStyleDisplayName( sal_uInt16 nFamily,
1494 const OUString& rName ) const
1495 {
1496 OUString sName( rName );
1497 if( mpStyleMap.is() && !rName.isEmpty() )
1498 {
1499 StyleMap::key_type aKey( nFamily, rName );
1500 StyleMap::const_iterator aIter = mpStyleMap->find( aKey );
1501 if( aIter != mpStyleMap->end() )
1502 sName = (*aIter).second;
1503 }
1504 return sName;
1505 }
1506
1507 void SvXMLImport::SetViewSettings(const css::uno::Sequence<css::beans::PropertyValue>&)
1508 {
1509 }
1510
1511 void SvXMLImport::SetConfigurationSettings(const css::uno::Sequence<css::beans::PropertyValue>&)
1512 {
1513 }
1514
1515 void SvXMLImport::SetDocumentSpecificSettings(const OUString&, const uno::Sequence<beans::PropertyValue>&)
1516 {
1517 }
1518
1519 ProgressBarHelper* SvXMLImport::GetProgressBarHelper()
1520 {
1521 if (!mpProgressBarHelper)
1522 {
1523 mpProgressBarHelper = std::make_unique<ProgressBarHelper>(mxStatusIndicator, false);
1524
1525 if (mxImportInfo.is())
1526 {
1527 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo();
1528 if (xPropertySetInfo.is())
1529 {
1530 OUString sProgressRange(XML_PROGRESSRANGE);
1531 OUString sProgressMax(XML_PROGRESSMAX);
1532 OUString sProgressCurrent(XML_PROGRESSCURRENT);
1533 OUString sRepeat(XML_PROGRESSREPEAT);
1534 if (xPropertySetInfo->hasPropertyByName(sProgressMax) &&
1535 xPropertySetInfo->hasPropertyByName(sProgressCurrent) &&
1536 xPropertySetInfo->hasPropertyByName(sProgressRange))
1537 {
1538 uno::Any aAny;
1539 sal_Int32 nProgressMax(0);
1540 sal_Int32 nProgressCurrent(0);
1541 sal_Int32 nProgressRange(0);
1542 aAny = mxImportInfo->getPropertyValue(sProgressRange);
1543 if (aAny >>= nProgressRange)
1544 mpProgressBarHelper->SetRange(nProgressRange);
1545 aAny = mxImportInfo->getPropertyValue(sProgressMax);
1546 if (aAny >>= nProgressMax)
1547 mpProgressBarHelper->SetReference(nProgressMax);
1548 aAny = mxImportInfo->getPropertyValue(sProgressCurrent);
1549 if (aAny >>= nProgressCurrent)
1550 mpProgressBarHelper->SetValue(nProgressCurrent);
1551 }
1552 if (xPropertySetInfo->hasPropertyByName(sRepeat))
1553 {
1554 uno::Any aAny = mxImportInfo->getPropertyValue(sRepeat);
1555 if (aAny.getValueType() == cppu::UnoType<bool>::get())
1556 mpProgressBarHelper->SetRepeat(::cppu::any2bool(aAny));
1557 else {
1558 SAL_WARN( "xmloff.core", "why is it no boolean?" );
1559 }
1560 }
1561 }
1562 }
1563 }
1564 return mpProgressBarHelper.get();
1565 }
1566
1567 void SvXMLImport::AddNumberStyle(sal_Int32 nKey, const OUString& rName)
1568 {
1569 if (!mxNumberStyles.is())
1570 mxNumberStyles.set( comphelper::NameContainer_createInstance( ::cppu::UnoType<sal_Int32>::get()) );
1571 if (mxNumberStyles.is())
1572 {
1573 try
1574 {
1575 mxNumberStyles->insertByName(rName, Any(nKey));
1576 }
1577 catch ( uno::Exception& )
1578 {
1579 DBG_UNHANDLED_EXCEPTION( "xmloff.core", "Numberformat could not be inserted");
1580 }
1581 }
1582 else {
1583 SAL_WARN( "xmloff.core", "not possible to create NameContainer");
1584 }
1585 }
1586
1587 XMLEventImportHelper& SvXMLImport::GetEventImport()
1588 {
1589 if (!mpEventImportHelper)
1590 {
1591 // construct event helper and register StarBasic handler and standard
1592 // event tables
1593 mpEventImportHelper = std::make_unique<XMLEventImportHelper>();
1594 const OUString& sStarBasic(GetXMLToken(XML_STARBASIC));
1595 mpEventImportHelper->RegisterFactory(sStarBasic,
1596 std::make_unique<XMLStarBasicContextFactory>());
1597 const OUString& sScript(GetXMLToken(XML_SCRIPT));
1598 mpEventImportHelper->RegisterFactory(sScript,
1599 std::make_unique<XMLScriptContextFactory>());
1600 mpEventImportHelper->AddTranslationTable(aStandardEventTable);
1601
1602 // register StarBasic event handler with capitalized spelling
1603 mpEventImportHelper->RegisterFactory("StarBasic",
1604 std::make_unique<XMLStarBasicContextFactory>());
1605 }
1606
1607 return *mpEventImportHelper;
1608 }
1609
1610 void SvXMLImport::SetFontDecls( XMLFontStylesContext *pFontDecls )
1611 {
1612 if (mxFontDecls.is())
1613 static_cast<SvXMLStylesContext*>(mxFontDecls.get())->Clear();
1614 mxFontDecls = pFontDecls;
1615 }
1616
1617 void SvXMLImport::SetStyles( SvXMLStylesContext *pStyles )
1618 {
1619 if (mxStyles.is())
1620 static_cast<SvXMLStylesContext*>(mxStyles.get())->Clear();
1621 mxStyles = pStyles;
1622 }
1623
1624 void SvXMLImport::SetAutoStyles( SvXMLStylesContext *pAutoStyles )
1625 {
1626 if (pAutoStyles && mxNumberStyles.is() && (mnImportFlags & SvXMLImportFlags::CONTENT) )
1627 {
1628 uno::Reference<xml::sax::XAttributeList> xAttrList;
1629 for (const auto& name : mxNumberStyles->getElementNames())
1630 {
1631 uno::Any aAny(mxNumberStyles->getByName(name));
1632 sal_Int32 nKey(0);
1633 if (aAny >>= nKey)
1634 {
1635 SvXMLStyleContext* pContext = new SvXMLNumFormatContext(
1636 *this, XML_NAMESPACE_NUMBER, name, xAttrList, nKey, *pAutoStyles);
1637 pAutoStyles->AddStyle(*pContext);
1638 }
1639 }
1640 }
1641 if (mxAutoStyles.is())
1642 static_cast<SvXMLStylesContext*>(mxAutoStyles.get())->Clear();
1643 mxAutoStyles = pAutoStyles;
1644 GetTextImport()->SetAutoStyles( pAutoStyles );
1645 GetShapeImport()->SetAutoStylesContext( pAutoStyles );
1646 GetChartImport()->SetAutoStylesContext( pAutoStyles );
1647 GetFormImport()->setAutoStyleContext( pAutoStyles );
1648 }
1649
1650 void SvXMLImport::SetMasterStyles( SvXMLStylesContext *pMasterStyles )
1651 {
1652 if (mxMasterStyles.is())
1653 static_cast<SvXMLStylesContext*>(mxMasterStyles.get())->Clear();
1654 mxMasterStyles = pMasterStyles;
1655 }
1656
1657 XMLFontStylesContext *SvXMLImport::GetFontDecls()
1658 {
1659 return static_cast<XMLFontStylesContext *>(mxFontDecls.get());
1660 }
1661
1662 SvXMLStylesContext *SvXMLImport::GetStyles()
1663 {
1664 return static_cast<SvXMLStylesContext *>(mxStyles.get());
1665 }
1666
1667 SvXMLStylesContext *SvXMLImport::GetAutoStyles()
1668 {
1669 return static_cast<SvXMLStylesContext *>(mxAutoStyles.get());
1670 }
1671
1672 const XMLFontStylesContext *SvXMLImport::GetFontDecls() const
1673 {
1674 return static_cast<const XMLFontStylesContext *>(mxFontDecls.get());
1675 }
1676
1677 const SvXMLStylesContext *SvXMLImport::GetStyles() const
1678 {
1679 return static_cast<const SvXMLStylesContext *>(mxStyles.get());
1680 }
1681
1682 const SvXMLStylesContext *SvXMLImport::GetAutoStyles() const
1683 {
1684 return static_cast<const SvXMLStylesContext *>(mxAutoStyles.get());
1685 }
1686
1687 OUString SvXMLImport::GetAbsoluteReference(const OUString& rValue) const
1688 {
1689 if( rValue.isEmpty() || rValue[0] == '#' )
1690 return rValue;
1691
1692 INetURLObject aAbsURL;
1693 if( mpImpl->aBaseURL.GetNewAbsURL( rValue, &aAbsURL ) )
1694 return aAbsURL.GetMainURL( INetURLObject::DecodeMechanism::ToIUri );
1695 else
1696 return rValue;
1697 }
1698
1699 bool SvXMLImport::IsODFVersionConsistent( const OUString& aODFVersion )
1700 {
1701 // the check returns sal_False only if the storage version could be retrieved
1702 bool bResult = true;
1703
1704 if ( !aODFVersion.isEmpty() && aODFVersion.compareTo( ODFVER_012_TEXT ) >= 0 )
1705 {
1706 // check the consistency only for the ODF1.2 and later ( according to content.xml )
1707 // manifest.xml might have no version, it should be checked here and the correct version should be set
1708 try
1709 {
1710 uno::Reference< document::XStorageBasedDocument > xDoc( mxModel, uno::UNO_QUERY_THROW );
1711 uno::Reference< embed::XStorage > xStor = xDoc->getDocumentStorage();
1712 uno::Reference< beans::XPropertySet > xStorProps( xStor, uno::UNO_QUERY_THROW );
1713
1714 // the check should be done only for OASIS format
1715 if (!IsOOoXML())
1716 {
1717 bool bRepairPackage = false;
1718 try
1719 {
1720 xStorProps->getPropertyValue( "RepairPackage" )
1721 >>= bRepairPackage;
1722 } catch ( uno::Exception& )
1723 {}
1724
1725 // check only if not in Repair mode
1726 if ( !bRepairPackage )
1727 {
1728 OUString aStorVersion;
1729 xStorProps->getPropertyValue( "Version" )
1730 >>= aStorVersion;
1731
1732 // if the storage version is set in manifest.xml, it must be the same as in content.xml
1733 // if not, set it explicitly to be used further ( it will work even for readonly storage )
1734 // This workaround is not nice, but I see no other way to handle it, since there are
1735 // ODF1.2 documents without version in manifest.xml
1736 if ( !aStorVersion.isEmpty() )
1737 bResult = aODFVersion == aStorVersion;
1738 else
1739 xStorProps->setPropertyValue( "Version",
1740 uno::makeAny( aODFVersion ) );
1741
1742 if ( bResult )
1743 {
1744 bool bInconsistent = false;
1745 xStorProps->getPropertyValue( "IsInconsistent" )
1746 >>= bInconsistent;
1747 bResult = !bInconsistent;
1748 }
1749 }
1750 }
1751 }
1752 catch( uno::Exception& )
1753 {}
1754 }
1755
1756 return bResult;
1757 }
1758
1759 void SvXMLImport::CreateNumberFormatsSupplier_()
1760 {
1761 SAL_WARN_IF( mxNumberFormatsSupplier.is(), "xmloff.core", "number formats supplier already exists!" );
1762 if(mxModel.is())
1763 mxNumberFormatsSupplier =
1764 uno::Reference< util::XNumberFormatsSupplier> (mxModel, uno::UNO_QUERY);
1765 }
1766
1767 void SvXMLImport::CreateDataStylesImport_()
1768 {
1769 SAL_WARN_IF( bool(mpNumImport), "xmloff.core", "data styles import already exists!" );
1770 uno::Reference<util::XNumberFormatsSupplier> xNum =
1771 GetNumberFormatsSupplier();
1772 if ( xNum.is() )
1773 mpNumImport = std::make_unique<SvXMLNumFmtHelper>(xNum, GetComponentContext() );
1774 }
1775
1776 sal_Unicode SvXMLImport::ConvStarBatsCharToStarSymbol( sal_Unicode c )
1777 {
1778 sal_Unicode cNew = c;
1779 if( !mpImpl->hBatsFontConv )
1780 {
1781 mpImpl->hBatsFontConv = CreateFontToSubsFontConverter( "StarBats",
1782 FontToSubsFontFlags::IMPORT );
1783 SAL_WARN_IF( !mpImpl->hBatsFontConv, "xmloff.core", "Got no symbol font converter" );
1784 }
1785 if( mpImpl->hBatsFontConv )
1786 {
1787 cNew = ConvertFontToSubsFontChar( mpImpl->hBatsFontConv, c );
1788 }
1789
1790 return cNew;
1791 }
1792
1793 sal_Unicode SvXMLImport::ConvStarMathCharToStarSymbol( sal_Unicode c )
1794 {
1795 sal_Unicode cNew = c;
1796 if( !mpImpl->hMathFontConv )
1797 {
1798 mpImpl->hMathFontConv = CreateFontToSubsFontConverter( "StarMath",
1799 FontToSubsFontFlags::IMPORT );
1800 SAL_WARN_IF( !mpImpl->hMathFontConv, "xmloff.core", "Got no symbol font converter" );
1801 }
1802 if( mpImpl->hMathFontConv )
1803 {
1804 cNew = ConvertFontToSubsFontChar( mpImpl->hMathFontConv, c );
1805 }
1806
1807 return cNew;
1808 }
1809
1810 void SvXMLImport::SetError(
1811 sal_Int32 nId,
1812 const Sequence<OUString>& rMsgParams,
1813 const OUString& rExceptionMessage,
1814 const Reference<xml::sax::XLocator>& rLocator )
1815 {
1816 // create error list on demand
1817 if ( !mpXMLErrors )
1818 mpXMLErrors = std::make_unique<XMLErrors>();
1819
1820 // save error information
1821 // use document locator (if none supplied)
1822 mpXMLErrors->AddRecord( nId, rMsgParams, rExceptionMessage,
1823 rLocator.is() ? rLocator : mxLocator );
1824 }
1825
1826 void SvXMLImport::SetError(
1827 sal_Int32 nId,
1828 const Sequence<OUString>& rMsgParams)
1829 {
1830 SetError( nId, rMsgParams, "", nullptr );
1831 }
1832
1833 void SvXMLImport::SetError(
1834 sal_Int32 nId)
1835 {
1836 Sequence<OUString> aSeq(0);
1837 SetError( nId, aSeq );
1838 }
1839
1840 void SvXMLImport::SetError(
1841 sal_Int32 nId,
1842 const OUString& rMsg1)
1843 {
1844 Sequence<OUString> aSeq { rMsg1 };
1845 SetError( nId, aSeq );
1846 }
1847
1848 void SvXMLImport::SetError(
1849 sal_Int32 nId,
1850 const OUString& rMsg1,
1851 const OUString& rMsg2)
1852 {
1853 Sequence<OUString> aSeq(2);
1854 OUString* pSeq = aSeq.getArray();
1855 pSeq[0] = rMsg1;
1856 pSeq[1] = rMsg2;
1857 SetError( nId, aSeq );
1858 }
1859
1860 void SvXMLImport::DisposingModel()
1861 {
1862 if( mxFontDecls.is() )
1863 static_cast<SvXMLStylesContext *>(mxFontDecls.get())->Clear();
1864 if( mxStyles.is() )
1865 static_cast<SvXMLStylesContext *>(mxStyles.get())->Clear();
1866 if( mxAutoStyles.is() )
1867 static_cast<SvXMLStylesContext *>(mxAutoStyles.get())->Clear();
1868 if( mxMasterStyles.is() )
1869 static_cast<SvXMLStylesContext *>(mxMasterStyles.get())->Clear();
1870
1871 mxModel.set(nullptr);
1872 mxEventListener.set(nullptr);
1873 }
1874
1875 ::comphelper::UnoInterfaceToUniqueIdentifierMapper& SvXMLImport::getInterfaceToIdentifierMapper()
1876 {
1877 return mpImpl->maInterfaceToIdentifierMapper;
1878 }
1879
1880 uno::Reference< uno::XComponentContext > const &
1881 SvXMLImport::GetComponentContext() const
1882 {
1883 return mpImpl->mxComponentContext;
1884 }
1885
1886 OUString SvXMLImport::GetBaseURL() const
1887 {
1888 return mpImpl->aBaseURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );
1889 }
1890
1891 OUString SvXMLImport::GetDocumentBase() const
1892 {
1893 return mpImpl->aDocBase.GetMainURL( INetURLObject::DecodeMechanism::NONE );
1894 }
1895
1896 // Convert drawing object positions from OOo file format to OASIS (#i28749#)
1897 bool SvXMLImport::IsShapePositionInHoriL2R() const
1898 {
1899 return mpImpl->mbShapePositionInHoriL2R;
1900 }
1901
1902 bool SvXMLImport::IsTextDocInOOoFileFormat() const
1903 {
1904 return mpImpl->mbTextDocInOOoFileFormat;
1905 }
1906
1907 void SvXMLImport::initXForms()
1908 {
1909 // dummy method; to be implemented by derived classes supporting XForms
1910 }
1911
1912 bool SvXMLImport::getBuildIds( sal_Int32& rUPD, sal_Int32& rBuild ) const
1913 {
1914 bool bRet = false;
1915 OUString const aBuildId(getBuildIdsProperty(mxImportInfo));
1916 if (!aBuildId.isEmpty())
1917 {
1918 sal_Int32 nIndex = aBuildId.indexOf('$');
1919 if (nIndex != -1)
1920 {
1921 rUPD = aBuildId.copy( 0, nIndex ).toInt32();
1922 sal_Int32 nIndexEnd = aBuildId.indexOf(';', nIndex);
1923 rBuild = (nIndexEnd == -1)
1924 ? aBuildId.copy(nIndex + 1).toInt32()
1925 : aBuildId.copy(nIndex + 1, nIndexEnd - nIndex - 1).toInt32();
1926 bRet = true;
1927 }
1928 }
1929 return bRet;
1930 }
1931
1932 sal_uInt16 SvXMLImport::getGeneratorVersion() const
1933 {
1934 // --> ORW
1935 return mpImpl->getGeneratorVersion( *this );
1936 // <--
1937 }
1938
1939 bool SvXMLImport::isGeneratorVersionOlderThan(
1940 sal_uInt16 const nOOoVersion, sal_uInt16 const nLOVersion)
1941 {
1942 assert( (nLOVersion & LO_flag));
1943 assert(!(nOOoVersion & LO_flag));
1944 const sal_uInt16 nGeneratorVersion(getGeneratorVersion());
1945 return (nGeneratorVersion & LO_flag)
1946 ? nGeneratorVersion < nLOVersion
1947 : nGeneratorVersion < nOOoVersion;
1948 }
1949
1950
1951 OUString const & SvXMLImport::GetODFVersion() const
1952 {
1953 return mpImpl->aODFVersion;
1954 }
1955
1956 bool SvXMLImport::IsOOoXML() const
1957 {
1958 return mpImpl->mbIsOOoXML;
1959 }
1960
1961 // xml:id for RDF metadata
1962 void SvXMLImport::SetXmlId(uno::Reference<uno::XInterface> const & i_xIfc,
1963 OUString const & i_rXmlId)
1964 {
1965 if (!i_rXmlId.isEmpty()) {
1966 try {
1967 const uno::Reference<rdf::XMetadatable> xMeta(i_xIfc,
1968 uno::UNO_QUERY);
1969 //FIXME: not yet
1970 if (xMeta.is()) {
1971 const beans::StringPair mdref( mpImpl->mStreamName, i_rXmlId );
1972 try {
1973 xMeta->setMetadataReference(mdref);
1974 } catch (lang::IllegalArgumentException &) {
1975 // probably duplicate; ignore
1976 SAL_INFO("xmloff.core", "SvXMLImport::SetXmlId: cannot set xml:id");
1977 }
1978 }
1979 } catch (uno::Exception &) {
1980 css::uno::Any ex( cppu::getCaughtException() );
1981 SAL_WARN("xmloff.core","SvXMLImport::SetXmlId: exception " << exceptionToString(ex));
1982 }
1983 }
1984 }
1985
1986 ::xmloff::RDFaImportHelper &
1987 SvXMLImport::GetRDFaImportHelper()
1988 {
1989 if (!mpImpl->mpRDFaHelper)
1990 {
1991 mpImpl->mpRDFaHelper.reset( new ::xmloff::RDFaImportHelper(*this) );
1992 }
1993 return *mpImpl->mpRDFaHelper;
1994 }
1995
1996 void
1997 SvXMLImport::AddRDFa(const uno::Reference<rdf::XMetadatable>& i_xObject,
1998 OUString const & i_rAbout,
1999 OUString const & i_rProperty,
2000 OUString const & i_rContent,
2001 OUString const & i_rDatatype)
2002 {
2003 // N.B.: we only get called if i_xObject had xhtml:about attribute
2004 // (an empty attribute value is valid)
2005 ::xmloff::RDFaImportHelper & rRDFaHelper( GetRDFaImportHelper() );
2006 rRDFaHelper.ParseAndAddRDFa(i_xObject,
2007 i_rAbout, i_rProperty, i_rContent, i_rDatatype);
2008 }
2009
2010 bool SvXMLImport::embeddedFontAlreadyProcessed( const OUString& url )
2011 {
2012 if( embeddedFontUrlsKnown.count( url ) != 0 )
2013 return true;
2014 embeddedFontUrlsKnown.insert( url );
2015 return false;
2016 }
2017
2018 const OUString SvXMLImport::getNameFromToken( sal_Int32 nToken )
2019 {
2020 uno::Sequence< sal_Int8 > aSeq = xTokenHandler->getUTF8Identifier( nToken & TOKEN_MASK );
2021 return OUString( reinterpret_cast< const char* >(
2022 aSeq.getConstArray() ), aSeq.getLength(), RTL_TEXTENCODING_UTF8 );
2023 }
2024
2025 const OUString SvXMLImport::getNamespacePrefixFromToken(sal_Int32 nToken, const SvXMLNamespaceMap* pMap)
2026 {
2027 sal_Int32 nNamespaceToken = ( nToken & NMSP_MASK ) >> NMSP_SHIFT;
2028 auto aIter( aNamespaceMap.find( nNamespaceToken ) );
2029 if( aIter != aNamespaceMap.end() )
2030 {
2031 if (pMap)
2032 {
2033 OUString sRet = pMap->GetPrefixByKey(pMap->GetKeyByName((*aIter).second.second));
2034 if (!sRet.isEmpty())
2035 return sRet;
2036 }
2037 return (*aIter).second.first;
2038 }
2039 else
2040 return OUString();
2041 }
2042
2043 const OUString SvXMLImport::getNamespaceURIFromToken( sal_Int32 nToken )
2044 {
2045 sal_Int32 nNamespaceToken = ( nToken & NMSP_MASK ) >> NMSP_SHIFT;
2046 auto aIter( aNamespaceMap.find( nNamespaceToken ) );
2047 if( aIter != aNamespaceMap.end() )
2048 return (*aIter).second.second;
2049 else
2050 return OUString();
2051 }
2052
2053 const OUString SvXMLImport::getNamespacePrefixFromURI( const OUString& rURI )
2054 {
2055 auto aIter( aNamespaceURIPrefixMap.find(rURI) );
2056 if( aIter != aNamespaceURIPrefixMap.end() )
2057 return (*aIter).second;
2058 else
2059 return OUString();
2060 }
2061
2062 void SvXMLImport::initializeNamespaceMaps()
2063 {
2064 auto mapTokenToNamespace = [&]( sal_Int32 nToken, sal_Int32 nPrefix, sal_Int32 nNamespace )
2065 {
2066 if ( nToken >= 0 )
2067 {
2068 const OUString& sNamespace = GetXMLToken( static_cast<XMLTokenEnum>( nNamespace ) );
2069 const OUString& sPrefix = GetXMLToken( static_cast<XMLTokenEnum>( nPrefix ) );
2070 aNamespaceMap[ nToken + 1 ] = std::make_pair( sPrefix, sNamespace );
2071 aNamespaceURIPrefixMap.emplace( sNamespace, sPrefix );
2072 }
2073 };
2074
2075 mapTokenToNamespace( XML_NAMESPACE_OFFICE, XML_NP_OFFICE, XML_N_OFFICE );
2076 mapTokenToNamespace( XML_OLD_NAMESPACE_OFFICE, XML_NP_OFFICE, XML_N_OFFICE_OLD );
2077 mapTokenToNamespace( XML_NAMESPACE_OFFICE_OOO, XML_NP_OFFICE, XML_N_OFFICE_OOO );
2078 mapTokenToNamespace( XML_NAMESPACE_STYLE, XML_NP_STYLE, XML_N_STYLE );
2079 mapTokenToNamespace( XML_OLD_NAMESPACE_STYLE, XML_NP_STYLE, XML_N_STYLE_OLD );
2080 mapTokenToNamespace( XML_NAMESPACE_STYLE_OOO, XML_NP_STYLE, XML_N_STYLE_OOO );
2081 mapTokenToNamespace( XML_NAMESPACE_TEXT, XML_NP_TEXT, XML_N_TEXT );
2082 mapTokenToNamespace( XML_OLD_NAMESPACE_TEXT, XML_NP_TEXT, XML_N_TEXT_OLD );
2083 mapTokenToNamespace( XML_NAMESPACE_TEXT_OOO, XML_NP_TEXT, XML_N_TEXT_OOO );
2084 mapTokenToNamespace( XML_NAMESPACE_TABLE, XML_NP_TABLE, XML_N_TABLE );
2085 mapTokenToNamespace( XML_OLD_NAMESPACE_TABLE, XML_NP_TABLE, XML_N_TABLE_OLD );
2086 mapTokenToNamespace( XML_NAMESPACE_TABLE_OOO, XML_NP_TABLE, XML_N_TABLE_OOO );
2087 mapTokenToNamespace( XML_NAMESPACE_DRAW, XML_NP_DRAW, XML_N_DRAW );
2088 mapTokenToNamespace( XML_OLD_NAMESPACE_DRAW, XML_NP_DRAW, XML_N_DRAW_OLD );
2089 mapTokenToNamespace( XML_NAMESPACE_DRAW_OOO, XML_NP_DRAW, XML_N_DRAW_OOO );
2090 mapTokenToNamespace( XML_NAMESPACE_FO, XML_NP_FO, XML_N_FO );
2091 mapTokenToNamespace( XML_OLD_NAMESPACE_FO, XML_NP_FO, XML_N_FO_OLD );
2092 mapTokenToNamespace( XML_NAMESPACE_FO_COMPAT, XML_NP_FO, XML_N_FO_COMPAT );
2093 mapTokenToNamespace( XML_NAMESPACE_XLINK, XML_NP_XLINK, XML_N_XLINK );
2094 mapTokenToNamespace( XML_OLD_NAMESPACE_XLINK, XML_NP_XLINK, XML_N_XLINK_OLD );
2095 mapTokenToNamespace( XML_NAMESPACE_DC, XML_NP_DC, XML_N_DC );
2096 mapTokenToNamespace( XML_NAMESPACE_META, XML_NP_META, XML_N_META );
2097 mapTokenToNamespace( XML_OLD_NAMESPACE_META, XML_NP_META, XML_N_META_OLD );
2098 mapTokenToNamespace( XML_NAMESPACE_META_OOO, XML_NP_META, XML_N_META_OOO );
2099 mapTokenToNamespace( XML_NAMESPACE_NUMBER, XML_NP_NUMBER, XML_N_NUMBER );
2100 mapTokenToNamespace( XML_OLD_NAMESPACE_NUMBER, XML_NP_NUMBER, XML_N_NUMBER_OLD );
2101 mapTokenToNamespace( XML_NAMESPACE_NUMBER_OOO, XML_NP_NUMBER, XML_N_NUMBER_OOO );
2102 mapTokenToNamespace( XML_NAMESPACE_PRESENTATION, XML_NP_PRESENTATION, XML_N_PRESENTATION );
2103 mapTokenToNamespace( XML_OLD_NAMESPACE_PRESENTATION, XML_NP_PRESENTATION, XML_N_PRESENTATION_OLD );
2104 mapTokenToNamespace( XML_NAMESPACE_PRESENTATION_OOO, XML_NP_PRESENTATION, XML_N_PRESENTATION_OOO );
2105 mapTokenToNamespace( XML_NAMESPACE_SVG, XML_NP_SVG, XML_N_SVG );
2106 mapTokenToNamespace( XML_NAMESPACE_SVG_COMPAT, XML_NP_SVG, XML_N_SVG_COMPAT );
2107 mapTokenToNamespace( XML_NAMESPACE_CHART, XML_NP_CHART, XML_N_CHART );
2108 mapTokenToNamespace( XML_OLD_NAMESPACE_CHART, XML_NP_CHART, XML_N_CHART_OLD );
2109 mapTokenToNamespace( XML_NAMESPACE_CHART_OOO, XML_NP_CHART, XML_N_CHART_OOO );
2110 mapTokenToNamespace( XML_NAMESPACE_DR3D, XML_NP_DR3D, XML_N_DR3D );
2111 mapTokenToNamespace( XML_NAMESPACE_DR3D_OOO, XML_NP_DR3D, XML_N_DR3D_OOO );
2112 mapTokenToNamespace( XML_NAMESPACE_MATH, XML_NP_MATH, XML_N_MATH );
2113 mapTokenToNamespace( XML_NAMESPACE_VERSIONS_LIST, XML_NP_VERSIONS_LIST, XML_N_VERSIONS_LIST );
2114 mapTokenToNamespace( XML_NAMESPACE_FORM, XML_NP_FORM, XML_N_FORM );
2115 mapTokenToNamespace( XML_NAMESPACE_FORM_OOO, XML_NP_FORM, XML_N_FORM_OOO );
2116 mapTokenToNamespace( XML_NAMESPACE_SCRIPT, XML_NP_SCRIPT, XML_N_SCRIPT );
2117 mapTokenToNamespace( XML_NAMESPACE_SCRIPT_OOO, XML_NP_SCRIPT, XML_N_SCRIPT_OOO );
2118 mapTokenToNamespace( XML_NAMESPACE_BLOCKLIST, XML_NP_BLOCK_LIST, XML_N_BLOCK_LIST );
2119 mapTokenToNamespace( XML_NAMESPACE_CONFIG, XML_NP_CONFIG, XML_N_CONFIG );
2120 mapTokenToNamespace( XML_NAMESPACE_CONFIG_OOO, XML_NP_CONFIG, XML_N_CONFIG_OOO );
2121 mapTokenToNamespace( XML_NAMESPACE_OOO, XML_NP_OOO, XML_N_OOO );
2122 mapTokenToNamespace( XML_NAMESPACE_OOOW, XML_NP_OOOW, XML_N_OOOW );
2123 mapTokenToNamespace( XML_NAMESPACE_OOOC, XML_NP_OOOC, XML_N_OOOC );
2124 mapTokenToNamespace( XML_NAMESPACE_DOM, XML_NP_DOM, XML_N_DOM );
2125 mapTokenToNamespace( XML_NAMESPACE_DB, XML_NP_DB, XML_N_DB );
2126 mapTokenToNamespace( XML_NAMESPACE_DB_OASIS, XML_NP_DB, XML_N_DB_OASIS );
2127 mapTokenToNamespace( XML_NAMESPACE_DLG, XML_NP_DLG, XML_N_DLG );
2128 mapTokenToNamespace( XML_NAMESPACE_XFORMS, XML_NP_XFORMS_1_0, XML_N_XFORMS_1_0 );
2129 mapTokenToNamespace( XML_NAMESPACE_XSD, XML_NP_XSD, XML_N_XSD );
2130 mapTokenToNamespace( XML_NAMESPACE_XSI, XML_NP_XSI, XML_N_XSI );
2131 mapTokenToNamespace( XML_NAMESPACE_SMIL, XML_NP_SMIL, XML_N_SMIL );
2132 mapTokenToNamespace( XML_OLD_NAMESPACE_SMIL, XML_NP_SMIL, XML_N_SMIL_OLD );
2133 mapTokenToNamespace( XML_NAMESPACE_SMIL_COMPAT, XML_NP_SMIL, XML_N_SMIL_COMPAT );
2134 mapTokenToNamespace( XML_NAMESPACE_ANIMATION, XML_NP_ANIMATION, XML_N_ANIMATION );
2135 mapTokenToNamespace( XML_NAMESPACE_REPORT, XML_NP_RPT, XML_N_RPT );
2136 mapTokenToNamespace( XML_NAMESPACE_REPORT_OASIS, XML_NP_RPT, XML_N_RPT_OASIS );
2137 mapTokenToNamespace( XML_NAMESPACE_OF, XML_NP_OF, XML_N_OF );
2138 mapTokenToNamespace( XML_NAMESPACE_XHTML, XML_NP_XHTML, XML_N_XHTML );
2139 mapTokenToNamespace( XML_NAMESPACE_GRDDL, XML_NP_GRDDL, XML_N_GRDDL );
2140 mapTokenToNamespace( XML_NAMESPACE_OFFICE_EXT, XML_NP_OFFICE_EXT, XML_N_OFFICE_EXT );
2141 mapTokenToNamespace( XML_NAMESPACE_TABLE_EXT, XML_NP_TABLE_EXT, XML_N_TABLE_EXT );
2142 mapTokenToNamespace( XML_NAMESPACE_CHART_EXT, XML_NP_CHART_EXT, XML_N_CHART_EXT );
2143 mapTokenToNamespace( XML_NAMESPACE_DRAW_EXT, XML_NP_DRAW_EXT, XML_N_DRAW_EXT );
2144 mapTokenToNamespace( XML_NAMESPACE_CALC_EXT, XML_NP_CALC_EXT, XML_N_CALC_EXT );
2145 mapTokenToNamespace( XML_NAMESPACE_LO_EXT, XML_NP_LO_EXT, XML_N_LO_EXT );
2146 mapTokenToNamespace( XML_NAMESPACE_CSS3TEXT, XML_NP_CSS3TEXT, XML_N_CSS3TEXT );
2147 mapTokenToNamespace( XML_NAMESPACE_FIELD, XML_NP_FIELD, XML_N_FIELD );
2148 mapTokenToNamespace( XML_NAMESPACE_FORMX, XML_NP_FORMX, XML_N_FORMX );
2149 }
2150
2151 void SvXMLImport::registerNamespaces()
2152 {
2153 for( auto const &aNamespaceEntry : aNamespaceMap )
2154 {
2155 // aNamespaceMap = { Token : ( NamespacePrefix, NamespaceURI ) }
2156 registerNamespace( aNamespaceEntry.second.second, aNamespaceEntry.first << NMSP_SHIFT );
2157 }
2158 }
2159
2160 void SvXMLImport::NotifyMacroEventRead()
2161 {
2162 if (mbNotifyMacroEventRead)
2163 return;
2164
2165 comphelper::DocumentInfo::notifyMacroEventRead(mxModel);
2166
2167 mbNotifyMacroEventRead = true;
2168 }
2169
2170 SvXMLImportFastNamespaceHandler::SvXMLImportFastNamespaceHandler()
2171 {
2172 }
2173
2174 void SvXMLImportFastNamespaceHandler::addNSDeclAttributes( rtl::Reference < comphelper::AttributeList > const & rAttrList )
2175 {
2176 for(const auto& aNamespaceDefine : m_aNamespaceDefines)
2177 {
2178 OUString& rPrefix = aNamespaceDefine->m_aPrefix;
2179 OUString& rNamespaceURI = aNamespaceDefine->m_aNamespaceURI;
2180 OUString sDecl;
2181 if ( rPrefix.isEmpty() )
2182 sDecl = "xmlns";
2183 else
2184 sDecl = "xmlns:" + rPrefix;
2185 rAttrList->AddAttribute( sDecl, "CDATA", rNamespaceURI );
2186 }
2187 m_aNamespaceDefines.clear();
2188 }
2189
2190 void SvXMLImportFastNamespaceHandler::registerNamespace( const OUString& rNamespacePrefix, const OUString& rNamespaceURI )
2191 {
2192 // Elements with default namespace parsed by FastParser have namespace prefix.
2193 // A default namespace needs to be registered with the prefix, to maintain the compatibility.
2194 if ( rNamespacePrefix.isEmpty() )
2195 m_aNamespaceDefines.push_back( std::make_unique<NamespaceDefine>(
2196 SvXMLImport::getNamespacePrefixFromURI( rNamespaceURI ), rNamespaceURI) );
2197
2198 m_aNamespaceDefines.push_back( std::make_unique<NamespaceDefine>(
2199 rNamespacePrefix, rNamespaceURI) );
2200 }
2201
2202 OUString SvXMLImportFastNamespaceHandler::getNamespaceURI( const OUString&/* rNamespacePrefix */ )
2203 {
2204 return OUString();
2205 }
2206
2207 SvXMLLegacyToFastDocHandler::SvXMLLegacyToFastDocHandler( const rtl::Reference< SvXMLImport > & rImport )
2208 : mrImport( rImport ),
2209 mxFastAttributes( new sax_fastparser::FastAttributeList( SvXMLImport::xTokenHandler.get(),
2210 dynamic_cast< sax_fastparser::FastTokenHandlerBase *>( SvXMLImport::xTokenHandler.get() ) ) )
2211 {
2212 }
2213
2214 void SAL_CALL SvXMLLegacyToFastDocHandler::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc )
2215 {
2216 mrImport->setTargetDocument( xDoc );
2217 }
2218
2219 void SAL_CALL SvXMLLegacyToFastDocHandler::startDocument()
2220 {
2221 mrImport->startDocument();
2222 }
2223
2224 void SAL_CALL SvXMLLegacyToFastDocHandler::endDocument()
2225 {
2226 mrImport->endDocument();
2227 }
2228
2229 void SAL_CALL SvXMLLegacyToFastDocHandler::startElement( const OUString& rName,
2230 const uno::Reference< xml::sax::XAttributeList >& xAttrList )
2231 {
2232 mrImport->processNSAttributes(xAttrList);
2233 OUString aLocalName;
2234 sal_uInt16 nPrefix = mrImport->mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName );
2235 Sequence< sal_Int8 > aLocalNameSeq( reinterpret_cast<sal_Int8 const *>(
2236 OUStringToOString( aLocalName, RTL_TEXTENCODING_UTF8 ).getStr()), aLocalName.getLength() );
2237 sal_Int32 mnElement = NAMESPACE_TOKEN( nPrefix ) | SvXMLImport::xTokenHandler->getTokenFromUTF8( aLocalNameSeq );
2238 mxFastAttributes->clear();
2239
2240 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0;
2241 for( sal_Int16 i=0; i < nAttrCount; i++ )
2242 {
2243 OUString aLocalAttrName;
2244 OUString aNamespace;
2245 const OUString& rAttrName = xAttrList->getNameByIndex( i );
2246 const OUString& rAttrValue = xAttrList->getValueByIndex( i );
2247 sal_uInt16 const nAttrPrefix(mrImport->mpNamespaceMap->GetKeyByAttrName(
2248 rAttrName, nullptr, &aLocalAttrName, &aNamespace));
2249 if( XML_NAMESPACE_XMLNS != nAttrPrefix )
2250 {
2251 Sequence< sal_Int8 > aAttrSeq( reinterpret_cast<sal_Int8 const *>(
2252 OUStringToOString( aLocalAttrName, RTL_TEXTENCODING_UTF8 ).getStr()), aLocalAttrName.getLength() );
2253 auto const nToken(SvXMLImport::xTokenHandler->getTokenFromUTF8(aAttrSeq));
2254 if (nToken == xmloff::XML_TOKEN_INVALID)
2255 {
2256 mxFastAttributes->addUnknown(aNamespace,
2257 OUStringToOString(rAttrName, RTL_TEXTENCODING_UTF8),
2258 OUStringToOString(rAttrValue, RTL_TEXTENCODING_UTF8));
2259 }
2260 else
2261 {
2262 sal_Int32 const nAttr = NAMESPACE_TOKEN(nAttrPrefix) | nToken;
2263 mxFastAttributes->add(nAttr, OUStringToOString(rAttrValue, RTL_TEXTENCODING_UTF8).getStr());
2264 }
2265 }
2266 }
2267 mrImport->startFastElement( mnElement, mxFastAttributes.get() );
2268 }
2269
2270 void SAL_CALL SvXMLLegacyToFastDocHandler::endElement( const OUString& rName )
2271 {
2272 OUString aLocalName;
2273 sal_uInt16 nPrefix = mrImport->mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName );
2274 Sequence< sal_Int8 > aLocalNameSeq( reinterpret_cast<sal_Int8 const *>(
2275 OUStringToOString( aLocalName, RTL_TEXTENCODING_UTF8 ).getStr()), aLocalName.getLength() );
2276 sal_Int32 mnElement = NAMESPACE_TOKEN( nPrefix ) | SvXMLImport::xTokenHandler->getTokenFromUTF8( aLocalNameSeq );
2277 mrImport->endFastElement( mnElement );
2278 }
2279
2280 void SAL_CALL SvXMLLegacyToFastDocHandler::characters( const OUString& aChars )
2281 {
2282 mrImport->characters( aChars );
2283 }
2284
2285 void SAL_CALL SvXMLLegacyToFastDocHandler::ignorableWhitespace( const OUString& aWhitespaces )
2286 {
2287 mrImport->ignorableWhitespace( aWhitespaces );
2288 }
2289
2290 void SAL_CALL SvXMLLegacyToFastDocHandler::processingInstruction( const OUString& aTarget,
2291 const OUString& aData)
2292 {
2293 mrImport->processingInstruction( aTarget, aData );
2294 }
2295
2296 void SAL_CALL SvXMLLegacyToFastDocHandler::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& rLocator )
2297 {
2298 mrImport->setDocumentLocator( rLocator );
2299 }
2300
2301
2302
2303 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE