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 <sal/config.h>
21 :
22 : #include <stack>
23 : #include <string.h>
24 :
25 : #include <officecfg/Office/Common.hxx>
26 : #include <xmloff/unointerfacetouniqueidentifiermapper.hxx>
27 : #include <osl/mutex.hxx>
28 : #include <tools/urlobj.hxx>
29 : #include <comphelper/genericpropertyset.hxx>
30 : #include <com/sun/star/container/XNameAccess.hpp>
31 : #include <com/sun/star/io/XInputStream.hpp>
32 : #include <com/sun/star/document/XBinaryStreamResolver.hpp>
33 : #include <com/sun/star/xml/sax/SAXInvalidCharacterException.hpp>
34 : #include <com/sun/star/uri/XUriReferenceFactory.hpp>
35 : #include <com/sun/star/uri/UriReferenceFactory.hpp>
36 : #include <com/sun/star/util/MeasureUnit.hpp>
37 : #include <i18nlangtag/languagetag.hxx>
38 : #include <comphelper/processfactory.hxx>
39 : #include <xmloff/attrlist.hxx>
40 : #include <xmloff/nmspmap.hxx>
41 : #include <xmloff/xmluconv.hxx>
42 : #include <xmloff/xmlnmspe.hxx>
43 : #include <xmloff/xmltoken.hxx>
44 : #include <xmloff/xmlexp.hxx>
45 : #include <xmloff/xmlnumfe.hxx>
46 : #include <xmloff/xmlmetae.hxx>
47 : #include <xmloff/XMLSettingsExportContext.hxx>
48 : #include <xmloff/families.hxx>
49 : #include <xmloff/XMLEventExport.hxx>
50 : #include "XMLStarBasicExportHandler.hxx"
51 : #include "XMLScriptExportHandler.hxx"
52 : #include <xmloff/SettingsExportHelper.hxx>
53 : #include <com/sun/star/container/XIndexContainer.hpp>
54 : #include <com/sun/star/document/XEventsSupplier.hpp>
55 : #include <com/sun/star/document/XViewDataSupplier.hpp>
56 : #include <xmloff/GradientStyle.hxx>
57 : #include <xmloff/HatchStyle.hxx>
58 : #include <xmloff/ImageStyle.hxx>
59 : #include <TransGradientStyle.hxx>
60 : #include <xmloff/MarkerStyle.hxx>
61 : #include <xmloff/DashStyle.hxx>
62 : #include <xmloff/XMLFontAutoStylePool.hxx>
63 : #include "XMLImageMapExport.hxx"
64 : #include "XMLBase64Export.hxx"
65 : #include <xmloff/xmlerror.hxx>
66 : #include <com/sun/star/lang/ServiceNotRegisteredException.hpp>
67 : #include <com/sun/star/lang/XMultiServiceFactory.hpp>
68 : #include <com/sun/star/beans/PropertyAttribute.hpp>
69 : #include <xmloff/XMLFilterServiceNames.h>
70 : #include <xmloff/XMLEmbeddedObjectExportFilter.hxx>
71 : #include "XMLBasicExportFilter.hxx"
72 : #include <cppuhelper/exc_hlp.hxx>
73 : #include <cppuhelper/implbase1.hxx>
74 : #include <cppuhelper/supportsservice.hxx>
75 : #include <comphelper/extract.hxx>
76 : #include <comphelper/servicehelper.hxx>
77 : #include "PropertySetMerger.hxx"
78 :
79 : #include <svl/urihelper.hxx>
80 : #include <xmloff/xformsexport.hxx>
81 :
82 : #include <unotools/docinfohelper.hxx>
83 : #include <unotools/bootstrap.hxx>
84 : #include <unotools/configmgr.hxx>
85 : #include <com/sun/star/document/XDocumentProperties.hpp>
86 : #include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
87 : #include <com/sun/star/document/XMLOasisBasicExporter.hpp>
88 : #include <com/sun/star/embed/XEncryptionProtectedSource2.hpp>
89 : #include <com/sun/star/rdf/XMetadatable.hpp>
90 : #include "RDFaExportHelper.hxx"
91 :
92 : #include <comphelper/xmltools.hxx>
93 :
94 : using namespace ::osl;
95 : using namespace ::com::sun::star;
96 : using namespace ::com::sun::star::uno;
97 : using namespace ::com::sun::star::frame;
98 : using namespace ::com::sun::star::container;
99 : using namespace ::com::sun::star::lang;
100 : using namespace ::com::sun::star::document;
101 : using namespace ::com::sun::star::beans;
102 : using namespace ::com::sun::star::xml::sax;
103 : using namespace ::com::sun::star::io;
104 : using namespace ::xmloff::token;
105 :
106 : sal_Char const sXML_1_1[] = "1.1";
107 : sal_Char const sXML_1_2[] = "1.2";
108 :
109 : #define XML_MODEL_SERVICE_WRITER "com.sun.star.text.TextDocument"
110 : #define XML_MODEL_SERVICE_CALC "com.sun.star.sheet.SpreadsheetDocument"
111 : #define XML_MODEL_SERVICE_DRAW "com.sun.star.drawing.DrawingDocument"
112 : #define XML_MODEL_SERVICE_IMPRESS "com.sun.star.presentation.PresentationDocument"
113 : #define XML_MODEL_SERVICE_MATH "com.sun.star.formula.FormulaProperties"
114 : #define XML_MODEL_SERVICE_CHART "com.sun.star.chart.ChartDocument"
115 :
116 : #define XML_USEPRETTYPRINTING "UsePrettyPrinting"
117 :
118 : namespace {
119 :
120 : struct XMLServiceMapEntry_Impl
121 : {
122 : const sal_Char *sModelService;
123 : sal_Int32 nModelServiceLen;
124 : const sal_Char *sFilterService;
125 : sal_Int32 nFilterServiceLen;
126 : };
127 :
128 : }
129 :
130 : #define SERVICE_MAP_ENTRY( app ) \
131 : { XML_MODEL_SERVICE_##app, sizeof(XML_MODEL_SERVICE_##app)-1, \
132 : XML_EXPORT_FILTER_##app, sizeof(XML_EXPORT_FILTER_##app)-1 }
133 :
134 : const XMLServiceMapEntry_Impl aServiceMap[] =
135 : {
136 : SERVICE_MAP_ENTRY( WRITER ),
137 : SERVICE_MAP_ENTRY( CALC ),
138 : SERVICE_MAP_ENTRY( IMPRESS ),// Impress supports DrawingDocument, too, so
139 : SERVICE_MAP_ENTRY( DRAW ), // it must appear before Draw
140 : SERVICE_MAP_ENTRY( MATH ),
141 : SERVICE_MAP_ENTRY( CHART ),
142 : { 0, 0, 0, 0 }
143 : };
144 :
145 : class SettingsExportFacade : public ::xmloff::XMLSettingsExportContext
146 : {
147 : public:
148 773 : explicit SettingsExportFacade( SvXMLExport& i_rExport )
149 773 : :m_rExport( i_rExport )
150 : {
151 773 : }
152 :
153 773 : virtual ~SettingsExportFacade()
154 773 : {
155 773 : }
156 :
157 : virtual void AddAttribute( enum ::xmloff::token::XMLTokenEnum i_eName,
158 : const OUString& i_rValue ) SAL_OVERRIDE;
159 : virtual void AddAttribute( enum ::xmloff::token::XMLTokenEnum i_eName,
160 : enum ::xmloff::token::XMLTokenEnum i_eValue ) SAL_OVERRIDE;
161 :
162 : virtual void StartElement( enum ::xmloff::token::XMLTokenEnum i_eName,
163 : const bool i_bIgnoreWhitespace ) SAL_OVERRIDE;
164 : virtual void EndElement( const bool i_bIgnoreWhitespace ) SAL_OVERRIDE;
165 :
166 : virtual void Characters( const OUString& i_rCharacters ) SAL_OVERRIDE;
167 :
168 : virtual ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >
169 : GetComponentContext() const SAL_OVERRIDE;
170 : private:
171 : SvXMLExport& m_rExport;
172 : ::std::stack< OUString > m_aElements;
173 : };
174 :
175 45035 : void SettingsExportFacade::AddAttribute( enum ::xmloff::token::XMLTokenEnum i_eName, const OUString& i_rValue )
176 : {
177 45035 : m_rExport.AddAttribute( XML_NAMESPACE_CONFIG, i_eName, i_rValue );
178 45035 : }
179 :
180 43583 : void SettingsExportFacade::AddAttribute( enum ::xmloff::token::XMLTokenEnum i_eName, enum ::xmloff::token::XMLTokenEnum i_eValue )
181 : {
182 43583 : m_rExport.AddAttribute( XML_NAMESPACE_CONFIG, i_eName, i_eValue );
183 43583 : }
184 :
185 45120 : void SettingsExportFacade::StartElement( enum ::xmloff::token::XMLTokenEnum i_eName, const bool i_bIgnoreWhitespace )
186 : {
187 45120 : const OUString sElementName( m_rExport.GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_CONFIG, GetXMLToken( i_eName ) ) );
188 45120 : m_rExport.StartElement( sElementName, i_bIgnoreWhitespace );
189 45120 : m_aElements.push( sElementName );
190 45120 : }
191 :
192 45120 : void SettingsExportFacade::EndElement( const bool i_bIgnoreWhitespace )
193 : {
194 45120 : const OUString sElementName( m_aElements.top() );
195 45120 : m_rExport.EndElement( sElementName, i_bIgnoreWhitespace );
196 45120 : m_aElements.pop();
197 45120 : }
198 :
199 42498 : void SettingsExportFacade::Characters( const OUString& i_rCharacters )
200 : {
201 42498 : m_rExport.GetDocHandler()->characters( i_rCharacters );
202 42498 : }
203 :
204 1253 : Reference< XComponentContext > SettingsExportFacade::GetComponentContext() const
205 : {
206 1253 : return m_rExport.getComponentContext();
207 : }
208 :
209 : class SvXMLExportEventListener : public cppu::WeakImplHelper1<
210 : com::sun::star::lang::XEventListener >
211 : {
212 : private:
213 : SvXMLExport* pExport;
214 :
215 : public:
216 : explicit SvXMLExportEventListener(SvXMLExport* pExport);
217 : virtual ~SvXMLExportEventListener();
218 :
219 : // XEventListener
220 : virtual void SAL_CALL disposing(const lang::EventObject& rEventObject) throw(::com::sun::star::uno::RuntimeException, std::exception) SAL_OVERRIDE;
221 : };
222 :
223 2560 : SvXMLExportEventListener::SvXMLExportEventListener(SvXMLExport* pTempExport)
224 2560 : : pExport(pTempExport)
225 : {
226 2560 : }
227 :
228 5120 : SvXMLExportEventListener::~SvXMLExportEventListener()
229 : {
230 5120 : }
231 :
232 : // XEventListener
233 26 : void SAL_CALL SvXMLExportEventListener::disposing( const lang::EventObject& )
234 : throw(uno::RuntimeException, std::exception)
235 : {
236 26 : if (pExport)
237 : {
238 26 : pExport->DisposingModel();
239 26 : pExport = NULL;
240 : }
241 26 : }
242 :
243 2602 : class SvXMLExport_Impl
244 : {
245 : public:
246 : SvXMLExport_Impl();
247 :
248 : ::comphelper::UnoInterfaceToUniqueIdentifierMapper maInterfaceToIdentifierMapper;
249 : uno::Reference< uri::XUriReferenceFactory > mxUriReferenceFactory;
250 : OUString msPackageURI;
251 : OUString msPackageURIScheme;
252 : // Written OpenDocument file format doesn't fit to the created text document (#i69627#)
253 : bool mbOutlineStyleAsNormalListStyle;
254 : bool mbSaveBackwardCompatibleODF;
255 :
256 : uno::Reference< embed::XStorage > mxTargetStorage;
257 :
258 : SvtSaveOptions maSaveOptions;
259 :
260 : /// relative path of stream in package, e.g. "someobject/content.xml"
261 : OUString mStreamPath;
262 :
263 : /// name of stream in package, e.g., "content.xml"
264 : OUString mStreamName;
265 :
266 : OUString maSrcShellID;
267 : OUString maDestShellID;
268 :
269 : /// stack of backed up namespace maps
270 : /// long: depth at which namespace map has been backed up into the stack
271 : ::std::stack< ::std::pair< SvXMLNamespaceMap *, long > > mNamespaceMaps;
272 : /// counts depth (number of open elements/start tags)
273 : long mDepth;
274 :
275 : ::std::unique_ptr< ::xmloff::RDFaExportHelper> mpRDFaHelper;
276 :
277 : bool mbExportTextNumberElement;
278 : bool mbNullDateInitialized;
279 :
280 2560 : void SetSchemeOf( const OUString& rOrigFileName )
281 : {
282 2560 : sal_Int32 nSep = rOrigFileName.indexOf(':');
283 2560 : if( nSep != -1 )
284 573 : msPackageURIScheme = rOrigFileName.copy( 0, nSep );
285 2560 : }
286 : };
287 :
288 2602 : SvXMLExport_Impl::SvXMLExport_Impl()
289 : // Written OpenDocument file format doesn't fit to the created text document (#i69627#)
290 : : mbOutlineStyleAsNormalListStyle( false )
291 : ,mbSaveBackwardCompatibleODF( true )
292 : ,mStreamName()
293 : ,mNamespaceMaps()
294 : ,mDepth(0)
295 : ,mpRDFaHelper() // lazy
296 : ,mbExportTextNumberElement( false )
297 2602 : ,mbNullDateInitialized( false )
298 : {
299 2602 : mxUriReferenceFactory = uri::UriReferenceFactory::create( comphelper::getProcessComponentContext() );
300 2602 : }
301 :
302 0 : void SvXMLExport::SetDocHandler( const uno::Reference< xml::sax::XDocumentHandler > &rHandler )
303 : {
304 0 : mxHandler = rHandler;
305 0 : mxExtHandler = uno::Reference<xml::sax::XExtendedDocumentHandler>( mxHandler, UNO_QUERY );
306 0 : }
307 :
308 2602 : void SvXMLExport::_InitCtor()
309 : {
310 : // note: it is not necessary to add XML_NP_XML (it is declared implicitly)
311 2602 : if( getExportFlags() & ~SvXMLExportFlags::OASIS )
312 : {
313 2573 : mpNamespaceMap->Add( GetXMLToken(XML_NP_OFFICE), GetXMLToken(XML_N_OFFICE), XML_NAMESPACE_OFFICE );
314 2573 : mpNamespaceMap->Add( GetXMLToken(XML_NP_OOO), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO );
315 : }
316 2602 : if( getExportFlags() & (SvXMLExportFlags::STYLES|SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::AUTOSTYLES|SvXMLExportFlags::FONTDECLS) )
317 : {
318 880 : mpNamespaceMap->Add( GetXMLToken(XML_NP_FO), GetXMLToken(XML_N_FO_COMPAT), XML_NAMESPACE_FO );
319 : }
320 2602 : if( getExportFlags() & (SvXMLExportFlags::META|SvXMLExportFlags::STYLES|SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::AUTOSTYLES|SvXMLExportFlags::CONTENT|SvXMLExportFlags::SCRIPTS|SvXMLExportFlags::SETTINGS) )
321 : {
322 2573 : mpNamespaceMap->Add( GetXMLToken(XML_NP_XLINK), GetXMLToken(XML_N_XLINK), XML_NAMESPACE_XLINK );
323 : }
324 2602 : if( getExportFlags() & SvXMLExportFlags::SETTINGS )
325 : {
326 789 : mpNamespaceMap->Add( GetXMLToken(XML_NP_CONFIG), GetXMLToken(XML_N_CONFIG), XML_NAMESPACE_CONFIG );
327 : }
328 :
329 2602 : if( getExportFlags() & (SvXMLExportFlags::META|SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::CONTENT) )
330 : {
331 1526 : mpNamespaceMap->Add( GetXMLToken(XML_NP_DC), GetXMLToken(XML_N_DC), XML_NAMESPACE_DC );
332 1526 : mpNamespaceMap->Add( GetXMLToken(XML_NP_META), GetXMLToken(XML_N_META), XML_NAMESPACE_META );
333 : }
334 2602 : if( getExportFlags() & (SvXMLExportFlags::STYLES|SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::AUTOSTYLES|SvXMLExportFlags::CONTENT|SvXMLExportFlags::FONTDECLS) )
335 : {
336 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_STYLE), GetXMLToken(XML_N_STYLE), XML_NAMESPACE_STYLE );
337 : }
338 :
339 : // namespaces for documents
340 2602 : if( getExportFlags() & (SvXMLExportFlags::STYLES|SvXMLExportFlags::AUTOSTYLES|SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::CONTENT) )
341 : {
342 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_DC), GetXMLToken(XML_N_DC), XML_NAMESPACE_DC );
343 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_TEXT), GetXMLToken(XML_N_TEXT), XML_NAMESPACE_TEXT );
344 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_DRAW), GetXMLToken(XML_N_DRAW), XML_NAMESPACE_DRAW );
345 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_DR3D), GetXMLToken(XML_N_DR3D), XML_NAMESPACE_DR3D );
346 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_SVG), GetXMLToken(XML_N_SVG_COMPAT), XML_NAMESPACE_SVG );
347 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_CHART), GetXMLToken(XML_N_CHART), XML_NAMESPACE_CHART );
348 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_RPT), GetXMLToken(XML_N_RPT), XML_NAMESPACE_REPORT );
349 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_TABLE), GetXMLToken(XML_N_TABLE), XML_NAMESPACE_TABLE );
350 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_NUMBER),GetXMLToken(XML_N_NUMBER), XML_NAMESPACE_NUMBER );
351 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_OOOW), GetXMLToken(XML_N_OOOW), XML_NAMESPACE_OOOW );
352 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_OOOC), GetXMLToken(XML_N_OOOC), XML_NAMESPACE_OOOC );
353 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_OF), GetXMLToken(XML_N_OF), XML_NAMESPACE_OF );
354 :
355 1442 : if (getDefaultVersion() > SvtSaveOptions::ODFVER_012)
356 : {
357 : mpNamespaceMap->Add(
358 1442 : GetXMLToken(XML_NP_TABLE_EXT), GetXMLToken(XML_N_TABLE_EXT), XML_NAMESPACE_TABLE_EXT);
359 : mpNamespaceMap->Add(
360 1442 : GetXMLToken(XML_NP_CALC_EXT), GetXMLToken(XML_N_CALC_EXT), XML_NAMESPACE_CALC_EXT);
361 : mpNamespaceMap->Add(
362 1442 : GetXMLToken(XML_NP_DRAW_EXT), GetXMLToken(XML_N_DRAW_EXT), XML_NAMESPACE_DRAW_EXT);
363 : mpNamespaceMap->Add(
364 1442 : GetXMLToken(XML_NP_LO_EXT), GetXMLToken(XML_N_LO_EXT),
365 1442 : XML_NAMESPACE_LO_EXT);
366 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_FIELD), GetXMLToken(XML_N_FIELD), XML_NAMESPACE_FIELD );
367 : }
368 : }
369 2602 : if( getExportFlags() & (SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::CONTENT) )
370 : {
371 1173 : mpNamespaceMap->Add( GetXMLToken(XML_NP_MATH), GetXMLToken(XML_N_MATH), XML_NAMESPACE_MATH );
372 1173 : mpNamespaceMap->Add( GetXMLToken(XML_NP_FORM), GetXMLToken(XML_N_FORM), XML_NAMESPACE_FORM );
373 : }
374 2602 : if( getExportFlags() & (SvXMLExportFlags::STYLES|SvXMLExportFlags::AUTOSTYLES|SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::CONTENT|SvXMLExportFlags::SCRIPTS) )
375 : {
376 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_SCRIPT), GetXMLToken(XML_N_SCRIPT), XML_NAMESPACE_SCRIPT );
377 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_DOM), GetXMLToken(XML_N_DOM), XML_NAMESPACE_DOM );
378 : }
379 2602 : if( getExportFlags() & SvXMLExportFlags::CONTENT )
380 : {
381 1056 : mpNamespaceMap->Add( GetXMLToken(XML_NP_XFORMS_1_0), GetXMLToken(XML_N_XFORMS_1_0), XML_NAMESPACE_XFORMS );
382 1056 : mpNamespaceMap->Add( GetXMLToken(XML_NP_XSD), GetXMLToken(XML_N_XSD), XML_NAMESPACE_XSD );
383 1056 : mpNamespaceMap->Add( GetXMLToken(XML_NP_XSI), GetXMLToken(XML_N_XSI), XML_NAMESPACE_XSI );
384 1056 : mpNamespaceMap->Add( GetXMLToken(XML_NP_FORMX), GetXMLToken(XML_N_FORMX), XML_NAMESPACE_FORMX );
385 : }
386 :
387 : // RDFa: needed for content and header/footer styles
388 2602 : if( getExportFlags() & (SvXMLExportFlags::STYLES|SvXMLExportFlags::AUTOSTYLES|SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::CONTENT) )
389 : {
390 1442 : mpNamespaceMap->Add( GetXMLToken(XML_NP_XHTML),
391 2884 : GetXMLToken(XML_N_XHTML), XML_NAMESPACE_XHTML );
392 : }
393 : // GRDDL: to convert RDFa and meta.xml to RDF
394 2602 : if( getExportFlags() & (SvXMLExportFlags::META|SvXMLExportFlags::STYLES|SvXMLExportFlags::AUTOSTYLES|SvXMLExportFlags::MASTERSTYLES|SvXMLExportFlags::CONTENT) )
395 : {
396 1795 : mpNamespaceMap->Add( GetXMLToken(XML_NP_GRDDL),
397 3590 : GetXMLToken(XML_N_GRDDL), XML_NAMESPACE_GRDDL );
398 : }
399 : // CSS Text Level 3 for distributed text justification.
400 2602 : if ( getExportFlags() & (SvXMLExportFlags::STYLES|SvXMLExportFlags::AUTOSTYLES|SvXMLExportFlags::MASTERSTYLES) )
401 : {
402 : mpNamespaceMap->Add(
403 880 : GetXMLToken(XML_NP_CSS3TEXT), GetXMLToken(XML_N_CSS3TEXT), XML_NAMESPACE_CSS3TEXT );
404 : }
405 :
406 2602 : mxAttrList = static_cast<xml::sax::XAttributeList*>(mpAttrList);
407 :
408 2602 : msGraphicObjectProtocol = "vnd.sun.star.GraphicObject:";
409 2602 : msEmbeddedObjectProtocol = "vnd.sun.star.EmbeddedObject:";
410 :
411 2602 : if (mxModel.is() && !mxEventListener.is())
412 : {
413 0 : mxEventListener.set( new SvXMLExportEventListener(this));
414 0 : mxModel->addEventListener(mxEventListener);
415 : }
416 :
417 : // Determine model type (#i51726#)
418 2602 : _DetermineModelType();
419 :
420 : // cl: but only if we do export to current oasis format, old openoffice format *must* always be compatible
421 2602 : if( getExportFlags() & SvXMLExportFlags::OASIS )
422 : {
423 : mpImpl->mbSaveBackwardCompatibleODF =
424 : officecfg::Office::Common::Save::Document::
425 2550 : SaveBackwardCompatibleODF::get( comphelper::getProcessComponentContext() );
426 : }
427 2602 : }
428 :
429 : // Shapes in Writer cannot be named via context menu (#i51726#)
430 5176 : void SvXMLExport::_DetermineModelType()
431 : {
432 5176 : meModelType = SvtModuleOptions::EFactory::UNKNOWN_FACTORY;
433 :
434 5176 : if ( mxModel.is() )
435 : {
436 2574 : meModelType = SvtModuleOptions::ClassifyFactoryByModel( mxModel );
437 : }
438 5176 : }
439 :
440 2579 : SvXMLExport::SvXMLExport(
441 : sal_Int16 const eDefaultMeasureUnit /*css::util::MeasureUnit*/,
442 : const uno::Reference< uno::XComponentContext >& xContext,
443 : OUString const & implementationName,
444 : const enum XMLTokenEnum eClass, SvXMLExportFlags nExportFlags )
445 2579 : : mpImpl( new SvXMLExport_Impl ),
446 : m_xContext(xContext), m_implementationName(implementationName),
447 2579 : mpAttrList( new SvXMLAttributeList ),
448 2579 : mpNamespaceMap( new SvXMLNamespaceMap ),
449 : mpUnitConv( new SvXMLUnitConverter( xContext,
450 2579 : util::MeasureUnit::MM_100TH, eDefaultMeasureUnit) ),
451 : mpNumExport(0L),
452 : mpProgressBarHelper( NULL ),
453 : mpEventExport( NULL ),
454 : mpImageMapExport( NULL ),
455 : mpXMLErrors( NULL ),
456 : mbExtended( false ),
457 : meClass( eClass ),
458 : mnExportFlags( nExportFlags ),
459 : mnErrorFlags( SvXMLErrorFlags::NO ),
460 2579 : msWS( GetXMLToken(XML_WS) ),
461 15474 : mbSaveLinkedSections(true)
462 : {
463 : SAL_WARN_IF( !xContext.is(), "xmloff.core", "got no service manager" );
464 2579 : _InitCtor();
465 2579 : }
466 :
467 23 : SvXMLExport::SvXMLExport(
468 : const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& xContext,
469 : OUString const & implementationName,
470 : const OUString &rFileName,
471 : sal_Int16 const eDefaultMeasureUnit /*css::util::MeasureUnit*/,
472 : const uno::Reference< xml::sax::XDocumentHandler > & rHandler)
473 23 : : mpImpl( new SvXMLExport_Impl ),
474 : m_xContext(xContext), m_implementationName(implementationName),
475 : mxHandler( rHandler ),
476 : mxExtHandler( rHandler, uno::UNO_QUERY ),
477 23 : mpAttrList( new SvXMLAttributeList ),
478 : msOrigFileName( rFileName ),
479 23 : mpNamespaceMap( new SvXMLNamespaceMap ),
480 : mpUnitConv( new SvXMLUnitConverter( xContext,
481 23 : util::MeasureUnit::MM_100TH, eDefaultMeasureUnit) ),
482 : mpNumExport(0L),
483 : mpProgressBarHelper( NULL ),
484 : mpEventExport( NULL ),
485 : mpImageMapExport( NULL ),
486 : mpXMLErrors( NULL ),
487 : mbExtended( false ),
488 : meClass( XML_TOKEN_INVALID ),
489 : mnExportFlags( SvXMLExportFlags::NONE ),
490 : mnErrorFlags( SvXMLErrorFlags::NO ),
491 23 : msWS( GetXMLToken(XML_WS) ),
492 138 : mbSaveLinkedSections(true)
493 : {
494 : SAL_WARN_IF( !xContext.is(), "xmloff.core", "got no service manager" );
495 23 : mpImpl->SetSchemeOf( msOrigFileName );
496 23 : _InitCtor();
497 :
498 23 : if (mxNumberFormatsSupplier.is())
499 0 : mpNumExport = new SvXMLNumFmtExport(*this, mxNumberFormatsSupplier);
500 23 : }
501 :
502 0 : SvXMLExport::SvXMLExport(
503 : const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& xContext,
504 : OUString const & implementationName,
505 : const OUString &rFileName,
506 : const uno::Reference< xml::sax::XDocumentHandler > & rHandler,
507 : const Reference< XModel >& rModel,
508 : FieldUnit const eDefaultFieldUnit)
509 0 : : mpImpl( new SvXMLExport_Impl ),
510 : m_xContext(xContext), m_implementationName(implementationName),
511 : mxModel( rModel ),
512 : mxHandler( rHandler ),
513 : mxExtHandler( rHandler, uno::UNO_QUERY ),
514 : mxNumberFormatsSupplier (rModel, uno::UNO_QUERY),
515 0 : mpAttrList( new SvXMLAttributeList ),
516 : msOrigFileName( rFileName ),
517 0 : mpNamespaceMap( new SvXMLNamespaceMap ),
518 : mpUnitConv( new SvXMLUnitConverter( xContext,
519 : util::MeasureUnit::MM_100TH,
520 0 : SvXMLUnitConverter::GetMeasureUnit(eDefaultFieldUnit)) ),
521 : mpNumExport(0L),
522 : mpProgressBarHelper( NULL ),
523 : mpEventExport( NULL ),
524 : mpImageMapExport( NULL ),
525 : mpXMLErrors( NULL ),
526 : mbExtended( false ),
527 : meClass( XML_TOKEN_INVALID ),
528 : mnExportFlags( SvXMLExportFlags::NONE ),
529 : mnErrorFlags( SvXMLErrorFlags::NO ),
530 0 : msWS( GetXMLToken(XML_WS) ),
531 0 : mbSaveLinkedSections(true)
532 : {
533 : SAL_WARN_IF(!xContext.is(), "xmloff.core", "got no service manager" );
534 0 : mpImpl->SetSchemeOf( msOrigFileName );
535 0 : _InitCtor();
536 :
537 0 : if (mxNumberFormatsSupplier.is())
538 0 : mpNumExport = new SvXMLNumFmtExport(*this, mxNumberFormatsSupplier);
539 0 : }
540 :
541 5204 : SvXMLExport::~SvXMLExport()
542 : {
543 2602 : delete mpXMLErrors;
544 2602 : delete mpImageMapExport;
545 2602 : delete mpEventExport;
546 2602 : delete mpNamespaceMap;
547 2602 : delete mpUnitConv;
548 2602 : if (mpProgressBarHelper || mpNumExport)
549 : {
550 1432 : if (mxExportInfo.is())
551 : {
552 1412 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxExportInfo->getPropertySetInfo();
553 1412 : if (xPropertySetInfo.is())
554 : {
555 1412 : if (mpProgressBarHelper)
556 : {
557 350 : OUString sProgressMax(XML_PROGRESSMAX);
558 700 : OUString sProgressCurrent(XML_PROGRESSCURRENT);
559 700 : OUString sRepeat(XML_PROGRESSREPEAT);
560 698 : if (xPropertySetInfo->hasPropertyByName(sProgressMax) &&
561 348 : xPropertySetInfo->hasPropertyByName(sProgressCurrent))
562 : {
563 348 : sal_Int32 nProgressMax(mpProgressBarHelper->GetReference());
564 348 : sal_Int32 nProgressCurrent(mpProgressBarHelper->GetValue());
565 348 : uno::Any aAny;
566 348 : aAny <<= nProgressMax;
567 348 : mxExportInfo->setPropertyValue(sProgressMax, aAny);
568 348 : aAny <<= nProgressCurrent;
569 348 : mxExportInfo->setPropertyValue(sProgressCurrent, aAny);
570 : }
571 350 : if (xPropertySetInfo->hasPropertyByName(sRepeat))
572 350 : mxExportInfo->setPropertyValue(sRepeat, css::uno::makeAny(mpProgressBarHelper->GetRepeat()));
573 : }
574 1412 : if (mpNumExport && (mnExportFlags & (SvXMLExportFlags::AUTOSTYLES | SvXMLExportFlags::STYLES)))
575 : {
576 836 : OUString sWrittenNumberFormats(XML_WRITTENNUMBERSTYLES);
577 836 : if (xPropertySetInfo->hasPropertyByName(sWrittenNumberFormats))
578 : {
579 200 : uno::Sequence<sal_Int32> aWasUsed;
580 200 : mpNumExport->GetWasUsed(aWasUsed);
581 400 : uno::Any aAny;
582 200 : aAny <<= aWasUsed;
583 400 : mxExportInfo->setPropertyValue(sWrittenNumberFormats, aAny);
584 836 : }
585 : }
586 1412 : }
587 : }
588 1432 : delete mpProgressBarHelper;
589 1432 : delete mpNumExport;
590 : }
591 :
592 2602 : if (mxEventListener.is() && mxModel.is())
593 2534 : mxModel->removeEventListener(mxEventListener);
594 :
595 2602 : delete mpImpl;
596 2602 : }
597 :
598 : // XExporter
599 2577 : void SAL_CALL SvXMLExport::setSourceDocument( const uno::Reference< lang::XComponent >& xDoc )
600 : throw(lang::IllegalArgumentException, uno::RuntimeException, std::exception)
601 : {
602 2577 : mxModel = uno::Reference< frame::XModel >::query( xDoc );
603 2577 : if( !mxModel.is() )
604 3 : throw lang::IllegalArgumentException();
605 2574 : if (mxModel.is() && ! mxEventListener.is())
606 : {
607 2560 : mxEventListener.set( new SvXMLExportEventListener(this));
608 2560 : mxModel->addEventListener(mxEventListener);
609 : }
610 :
611 2574 : if(!mxNumberFormatsSupplier.is() )
612 : {
613 2376 : mxNumberFormatsSupplier.set(mxModel, css::uno::UNO_QUERY);
614 2376 : if(mxNumberFormatsSupplier.is() && mxHandler.is())
615 1191 : mpNumExport = new SvXMLNumFmtExport(*this, mxNumberFormatsSupplier);
616 : }
617 2574 : if (mxExportInfo.is())
618 : {
619 2534 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxExportInfo->getPropertySetInfo();
620 2534 : if (xPropertySetInfo.is())
621 : {
622 2534 : OUString sUsePrettyPrinting(XML_USEPRETTYPRINTING);
623 2534 : if (xPropertySetInfo->hasPropertyByName(sUsePrettyPrinting))
624 : {
625 2534 : uno::Any aAny = mxExportInfo->getPropertyValue(sUsePrettyPrinting);
626 2534 : if (::cppu::any2bool(aAny))
627 0 : mnExportFlags |= SvXMLExportFlags::PRETTY;
628 : else
629 2534 : mnExportFlags &= ~SvXMLExportFlags::PRETTY;
630 : }
631 :
632 2534 : if (mpNumExport && (mnExportFlags & (SvXMLExportFlags::AUTOSTYLES | SvXMLExportFlags::STYLES)))
633 : {
634 836 : OUString sWrittenNumberFormats(XML_WRITTENNUMBERSTYLES);
635 836 : if (xPropertySetInfo->hasPropertyByName(sWrittenNumberFormats))
636 : {
637 200 : uno::Any aAny = mxExportInfo->getPropertyValue(sWrittenNumberFormats);
638 400 : uno::Sequence<sal_Int32> aWasUsed;
639 200 : if(aAny >>= aWasUsed)
640 300 : mpNumExport->SetWasUsed(aWasUsed);
641 836 : }
642 2534 : }
643 2534 : }
644 : }
645 :
646 2574 : if ( mpImpl->mbSaveBackwardCompatibleODF )
647 39 : mnExportFlags |= SvXMLExportFlags::SAVEBACKWARDCOMPATIBLE;
648 : else
649 2535 : mnExportFlags &= ~SvXMLExportFlags::SAVEBACKWARDCOMPATIBLE;
650 :
651 : // namespaces for user defined attributes
652 2574 : Reference< XMultiServiceFactory > xFactory( mxModel, UNO_QUERY );
653 2574 : if( xFactory.is() )
654 : {
655 : try
656 : {
657 : Reference < XInterface > xIfc =
658 1540 : xFactory->createInstance("com.sun.star.xml.NamespaceMap");
659 962 : if( xIfc.is() )
660 : {
661 861 : Reference< XNameAccess > xNamespaceMap( xIfc, UNO_QUERY );
662 861 : if( xNamespaceMap.is() )
663 : {
664 861 : Sequence< OUString > aPrefixes( xNamespaceMap->getElementNames() );
665 :
666 861 : OUString* pPrefix = aPrefixes.getArray();
667 861 : const sal_Int32 nCount = aPrefixes.getLength();
668 : sal_Int32 nIndex;
669 1722 : OUString aURL;
670 :
671 861 : for( nIndex = 0; nIndex < nCount; ++nIndex, ++pPrefix )
672 : {
673 0 : if( xNamespaceMap->getByName( *pPrefix ) >>= aURL )
674 0 : _GetNamespaceMap().Add( *pPrefix, aURL, XML_NAMESPACE_UNKNOWN );
675 861 : }
676 861 : }
677 962 : }
678 : }
679 289 : catch(const com::sun::star::uno::Exception&)
680 : {
681 : }
682 : }
683 :
684 : // Determine model type (#i51726#)
685 2574 : _DetermineModelType();
686 2574 : }
687 :
688 : // XInitialize
689 2576 : void SAL_CALL SvXMLExport::initialize( const uno::Sequence< uno::Any >& aArguments )
690 : throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException, std::exception)
691 : {
692 : // #93186# we need to queryInterface every single Any with any expected outcome. This variable hold the queryInterface results.
693 :
694 2576 : const sal_Int32 nAnyCount = aArguments.getLength();
695 2576 : const uno::Any* pAny = aArguments.getConstArray();
696 :
697 9067 : for( sal_Int32 nIndex = 0; nIndex < nAnyCount; nIndex++, pAny++ )
698 : {
699 6491 : Reference<XInterface> xValue;
700 6491 : *pAny >>= xValue;
701 :
702 : // status indicator
703 12982 : uno::Reference<task::XStatusIndicator> xTmpStatus( xValue, UNO_QUERY );
704 6491 : if ( xTmpStatus.is() )
705 10 : mxStatusIndicator = xTmpStatus;
706 :
707 : // graphic resolver
708 : uno::Reference<document::XGraphicObjectResolver> xTmpGraphic(
709 12982 : xValue, UNO_QUERY );
710 6491 : if ( xTmpGraphic.is() )
711 1048 : mxGraphicResolver = xTmpGraphic;
712 :
713 : // object resolver
714 : uno::Reference<document::XEmbeddedObjectResolver> xTmpObjectResolver(
715 12982 : xValue, UNO_QUERY );
716 6491 : if ( xTmpObjectResolver.is() )
717 241 : mxEmbeddedResolver = xTmpObjectResolver;
718 :
719 : // document handler
720 : uno::Reference<xml::sax::XDocumentHandler> xTmpDocHandler(
721 12982 : xValue, UNO_QUERY );
722 6491 : if( xTmpDocHandler.is() )
723 : {
724 2563 : mxHandler = xTmpDocHandler;
725 2563 : *pAny >>= mxExtHandler;
726 :
727 2563 : if (mxNumberFormatsSupplier.is() && mpNumExport == NULL)
728 0 : mpNumExport = new SvXMLNumFmtExport(*this, mxNumberFormatsSupplier);
729 : }
730 :
731 : // property set to transport data across
732 : uno::Reference<beans::XPropertySet> xTmpPropertySet(
733 12982 : xValue, UNO_QUERY );
734 6491 : if( xTmpPropertySet.is() )
735 2537 : mxExportInfo = xTmpPropertySet;
736 6491 : }
737 :
738 2576 : if( mxExportInfo.is() )
739 : {
740 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo =
741 2537 : mxExportInfo->getPropertySetInfo();
742 : OUString sPropName(
743 5074 : "BaseURI" );
744 2537 : if( xPropertySetInfo->hasPropertyByName(sPropName) )
745 : {
746 2537 : uno::Any aAny = mxExportInfo->getPropertyValue(sPropName);
747 2537 : aAny >>= msOrigFileName;
748 2537 : mpImpl->msPackageURI = msOrigFileName;
749 2537 : mpImpl->SetSchemeOf( msOrigFileName );
750 : }
751 5074 : OUString sRelPath;
752 2537 : sPropName = "StreamRelPath";
753 2537 : if( xPropertySetInfo->hasPropertyByName(sPropName) )
754 : {
755 2532 : uno::Any aAny = mxExportInfo->getPropertyValue(sPropName);
756 2532 : aAny >>= sRelPath;
757 : }
758 5074 : OUString sName;
759 2537 : sPropName = "StreamName";
760 2537 : if( xPropertySetInfo->hasPropertyByName(sPropName) )
761 : {
762 2535 : uno::Any aAny = mxExportInfo->getPropertyValue(sPropName);
763 2535 : aAny >>= sName;
764 : }
765 2537 : if( !msOrigFileName.isEmpty() && !sName.isEmpty() )
766 : {
767 571 : INetURLObject aBaseURL( msOrigFileName );
768 571 : if( !sRelPath.isEmpty() )
769 68 : aBaseURL.insertName( sRelPath );
770 571 : aBaseURL.insertName( sName );
771 571 : msOrigFileName = aBaseURL.GetMainURL(INetURLObject::DECODE_TO_IURI);
772 : }
773 2537 : mpImpl->mStreamName = sName; // Note: may be empty (XSLT)
774 :
775 : // Written OpenDocument file format doesn't fit to the created text document (#i69627#)
776 : const OUString sOutlineStyleAsNormalListStyle(
777 5074 : "OutlineStyleAsNormalListStyle" );
778 2537 : if( xPropertySetInfo->hasPropertyByName( sOutlineStyleAsNormalListStyle ) )
779 : {
780 278 : uno::Any aAny = mxExportInfo->getPropertyValue( sOutlineStyleAsNormalListStyle );
781 278 : aAny >>= (mpImpl->mbOutlineStyleAsNormalListStyle);
782 : }
783 :
784 5074 : OUString sTargetStorage( "TargetStorage" );
785 2537 : if( xPropertySetInfo->hasPropertyByName( sTargetStorage ) )
786 603 : mxExportInfo->getPropertyValue( sTargetStorage ) >>= mpImpl->mxTargetStorage;
787 :
788 : const OUString sExportTextNumberElement(
789 5074 : "ExportTextNumberElement" );
790 2537 : if( xPropertySetInfo->hasPropertyByName( sExportTextNumberElement ) )
791 : {
792 2 : uno::Any aAny = mxExportInfo->getPropertyValue( sExportTextNumberElement );
793 2 : aAny >>= (mpImpl->mbExportTextNumberElement);
794 2537 : }
795 : }
796 :
797 2576 : }
798 :
799 : // XFilter
800 2539 : sal_Bool SAL_CALL SvXMLExport::filter( const uno::Sequence< beans::PropertyValue >& aDescriptor ) throw(uno::RuntimeException, std::exception)
801 : {
802 : // check for xHandler first... should have been supplied in initialize
803 2539 : if( !mxHandler.is() )
804 0 : return sal_False;
805 :
806 : try
807 : {
808 2539 : const sal_Int32 nPropCount = aDescriptor.getLength();
809 :
810 : const SvXMLExportFlags nTest =
811 2539 : SvXMLExportFlags::META|SvXMLExportFlags::STYLES|SvXMLExportFlags::CONTENT|SvXMLExportFlags::SETTINGS;
812 2539 : if( (mnExportFlags & nTest) == nTest && msOrigFileName.isEmpty() )
813 : {
814 : // evaluate descriptor only for flat files and if a base URI
815 : // has not been provided already
816 :
817 2 : const beans::PropertyValue* pProps = aDescriptor.getConstArray();
818 4 : for( sal_Int32 nIndex = 0; nIndex < nPropCount; nIndex++, pProps++ )
819 : {
820 2 : const OUString& rPropName = pProps->Name;
821 2 : const Any& rValue = pProps->Value;
822 :
823 2 : if ( rPropName == "FileName" )
824 : {
825 0 : if( !(rValue >>= msOrigFileName ) )
826 0 : return sal_False;
827 : }
828 2 : else if ( rPropName == "FilterName" )
829 : {
830 2 : if( !(rValue >>= msFilterName ) )
831 0 : return sal_False;
832 : }
833 : }
834 : }
835 :
836 2539 : const beans::PropertyValue* pProps = aDescriptor.getConstArray();
837 7980 : for (sal_Int32 nIndex = 0; nIndex < nPropCount; ++nIndex, ++pProps)
838 : {
839 5441 : const OUString& rPropName = pProps->Name;
840 5441 : const Any& rValue = pProps->Value;
841 :
842 5441 : if (rPropName == "SourceShellID")
843 : {
844 807 : if (!(rValue >>= mpImpl->maSrcShellID))
845 0 : return false;
846 : }
847 4634 : else if (rPropName == "DestinationShellID")
848 : {
849 807 : if (!(rValue >>= mpImpl->maDestShellID))
850 0 : return false;
851 : }
852 : }
853 :
854 :
855 2539 : exportDoc( meClass );
856 : }
857 0 : catch(const uno::Exception& e)
858 : {
859 : // We must catch exceptions, because according to the
860 : // API definition export must not throw one!
861 0 : css::uno::Any ex(cppu::getCaughtException());
862 : SetError( XMLERROR_FLAG_ERROR | XMLERROR_FLAG_SEVERE | XMLERROR_API,
863 : Sequence<OUString>(),
864 0 : ex.getValueTypeName() + ": \"" + e.Message + "\"", NULL );
865 : }
866 :
867 : // return true only if no error occurred
868 2539 : return (GetErrorFlags() & (SvXMLErrorFlags::DO_NOTHING|SvXMLErrorFlags::ERROR_OCCURRED)) == SvXMLErrorFlags::NO;
869 : }
870 :
871 1 : void SAL_CALL SvXMLExport::cancel() throw(uno::RuntimeException, std::exception)
872 : {
873 : // stop export
874 1 : Sequence<OUString> aEmptySeq;
875 1 : SetError(XMLERROR_CANCEL|XMLERROR_FLAG_SEVERE, aEmptySeq);
876 1 : }
877 :
878 13 : OUString SAL_CALL SvXMLExport::getName( )
879 : throw (::com::sun::star::uno::RuntimeException, std::exception)
880 : {
881 13 : return msFilterName;
882 : }
883 :
884 0 : void SAL_CALL SvXMLExport::setName( const OUString& )
885 : throw (::com::sun::star::uno::RuntimeException, std::exception)
886 : {
887 : // do nothing, because it is not possible to set the FilterName
888 0 : }
889 :
890 : // XServiceInfo
891 21 : OUString SAL_CALL SvXMLExport::getImplementationName( ) throw(uno::RuntimeException, std::exception)
892 : {
893 21 : return m_implementationName;
894 : }
895 :
896 0 : sal_Bool SAL_CALL SvXMLExport::supportsService( const OUString& rServiceName ) throw(uno::RuntimeException, std::exception)
897 : {
898 0 : return cppu::supportsService(this, rServiceName);
899 : }
900 :
901 15 : uno::Sequence< OUString > SAL_CALL SvXMLExport::getSupportedServiceNames( )
902 : throw(uno::RuntimeException, std::exception)
903 : {
904 15 : uno::Sequence<OUString> aSeq(2);
905 15 : aSeq[0] = "com.sun.star.document.ExportFilter";
906 15 : aSeq[1] = "com.sun.star.xml.XMLExportFilter";
907 15 : return aSeq;
908 : }
909 :
910 : OUString
911 25 : SvXMLExport::EnsureNamespace(OUString const & i_rNamespace,
912 : OUString const & i_rPreferredPrefix)
913 : {
914 25 : OUString sPrefix;
915 25 : sal_uInt16 nKey( _GetNamespaceMap().GetKeyByName( i_rNamespace ) );
916 25 : if( XML_NAMESPACE_UNKNOWN == nKey )
917 : {
918 : // There is no prefix for the namespace, so
919 : // we have to generate one and have to add it.
920 17 : sPrefix = i_rPreferredPrefix;
921 17 : nKey = _GetNamespaceMap().GetKeyByPrefix( sPrefix );
922 17 : sal_Int32 n( 0 );
923 17 : OUStringBuffer buf;
924 34 : while( nKey != USHRT_MAX )
925 : {
926 0 : buf.append( i_rPreferredPrefix );
927 0 : buf.append( ++n );
928 0 : sPrefix = buf.makeStringAndClear();
929 0 : nKey = _GetNamespaceMap().GetKeyByPrefix( sPrefix );
930 : }
931 :
932 34 : if (mpImpl->mNamespaceMaps.empty()
933 17 : || (mpImpl->mNamespaceMaps.top().second != mpImpl->mDepth))
934 : {
935 : // top was created for lower depth... need a new namespace map!
936 : mpImpl->mNamespaceMaps.push(
937 17 : ::std::make_pair(mpNamespaceMap, mpImpl->mDepth) );
938 17 : mpNamespaceMap = new SvXMLNamespaceMap( *mpNamespaceMap );
939 : }
940 :
941 : // add the namespace to the map and as attribute
942 17 : mpNamespaceMap->Add( sPrefix, i_rNamespace );
943 17 : buf.append( GetXMLToken(XML_XMLNS) );
944 17 : buf.append( ':' );
945 17 : buf.append( sPrefix );
946 17 : AddAttribute( buf.makeStringAndClear(), i_rNamespace );
947 : }
948 : else
949 : {
950 : // If there is a prefix for the namespace, reuse that.
951 8 : sPrefix = _GetNamespaceMap().GetPrefixByKey( nKey );
952 : }
953 25 : return sPrefix;
954 : }
955 :
956 0 : void SvXMLExport::AddAttributeASCII( sal_uInt16 nPrefixKey,
957 : const sal_Char *pName,
958 : const sal_Char *pValue )
959 : {
960 0 : OUString sName( OUString::createFromAscii( pName ) );
961 0 : OUString sValue( OUString::createFromAscii( pValue ) );
962 :
963 : mpAttrList->AddAttribute(
964 0 : _GetNamespaceMap().GetQNameByKey( nPrefixKey, sName ), sValue );
965 0 : }
966 :
967 34 : void SvXMLExport::AddAttribute( sal_uInt16 nPrefixKey, const sal_Char *pName,
968 : const OUString& rValue )
969 : {
970 34 : OUString sName( OUString::createFromAscii( pName ) );
971 :
972 : mpAttrList->AddAttribute(
973 34 : _GetNamespaceMap().GetQNameByKey( nPrefixKey, sName ), rValue );
974 34 : }
975 :
976 1732 : void SvXMLExport::AddAttribute( sal_uInt16 nPrefixKey, const OUString& rName,
977 : const OUString& rValue )
978 : {
979 : mpAttrList->AddAttribute(
980 1732 : _GetNamespaceMap().GetQNameByKey( nPrefixKey, rName ), rValue );
981 1732 : }
982 :
983 117321 : void SvXMLExport::AddAttribute( sal_uInt16 nPrefixKey,
984 : enum XMLTokenEnum eName,
985 : const OUString& rValue )
986 : {
987 : mpAttrList->AddAttribute(
988 234642 : _GetNamespaceMap().GetQNameByKey( nPrefixKey, GetXMLToken(eName) ),
989 234642 : rValue );
990 117321 : }
991 :
992 61416 : void SvXMLExport::AddAttribute( sal_uInt16 nPrefixKey,
993 : enum XMLTokenEnum eName,
994 : enum XMLTokenEnum eValue)
995 : {
996 : mpAttrList->AddAttribute(
997 122832 : _GetNamespaceMap().GetQNameByKey( nPrefixKey, GetXMLToken(eName) ),
998 184248 : GetXMLToken(eValue) );
999 61416 : }
1000 :
1001 1753 : void SvXMLExport::AddAttribute( const OUString& rQName,
1002 : const OUString& rValue )
1003 : {
1004 : mpAttrList->AddAttribute(
1005 : rQName,
1006 1753 : rValue );
1007 1753 : }
1008 :
1009 584 : void SvXMLExport::AddAttribute( const OUString& rQName,
1010 : enum ::xmloff::token::XMLTokenEnum eValue )
1011 : {
1012 : mpAttrList->AddAttribute(
1013 : rQName,
1014 584 : GetXMLToken(eValue) );
1015 584 : }
1016 :
1017 2 : void SvXMLExport::AddLanguageTagAttributes( sal_uInt16 nPrefix, sal_uInt16 nPrefixRfc,
1018 : const ::com::sun::star::lang::Locale& rLocale, bool bWriteEmpty,
1019 : enum ::xmloff::token::XMLTokenEnum eClass )
1020 : {
1021 2 : if (rLocale.Variant.isEmpty())
1022 : {
1023 : // Per convention The BCP 47 string is always stored in Variant, if
1024 : // that is empty we have a plain language-country combination, no need
1025 : // to convert to LanguageTag first. Also catches the case of empty
1026 : // locale denoting system locale.
1027 : xmloff::token::XMLTokenEnum eLanguage, eCountry;
1028 2 : switch (eClass)
1029 : {
1030 : default:
1031 : case XML_LANGUAGE:
1032 2 : eLanguage = XML_LANGUAGE;
1033 2 : eCountry = XML_COUNTRY;
1034 2 : break;
1035 : case XML_LANGUAGE_ASIAN:
1036 0 : eLanguage = XML_LANGUAGE_ASIAN;
1037 0 : eCountry = XML_COUNTRY_ASIAN;
1038 0 : if (nPrefix == XML_NAMESPACE_FO)
1039 0 : nPrefix = XML_NAMESPACE_STYLE;
1040 0 : break;
1041 : case XML_LANGUAGE_COMPLEX:
1042 0 : eLanguage = XML_LANGUAGE_COMPLEX;
1043 0 : eCountry = XML_COUNTRY_COMPLEX;
1044 0 : if (nPrefix == XML_NAMESPACE_FO)
1045 0 : nPrefix = XML_NAMESPACE_STYLE;
1046 0 : break;
1047 : }
1048 2 : if (bWriteEmpty || !rLocale.Language.isEmpty())
1049 2 : AddAttribute( nPrefix, eLanguage, rLocale.Language);
1050 2 : if (bWriteEmpty || !rLocale.Country.isEmpty())
1051 2 : AddAttribute( nPrefix, eCountry, rLocale.Country);
1052 : }
1053 : else
1054 : {
1055 0 : LanguageTag aLanguageTag( rLocale);
1056 0 : AddLanguageTagAttributes( nPrefix, nPrefixRfc, aLanguageTag, bWriteEmpty, eClass);
1057 : }
1058 2 : }
1059 :
1060 340 : void SvXMLExport::AddLanguageTagAttributes( sal_uInt16 nPrefix, sal_uInt16 nPrefixRfc,
1061 : const LanguageTag& rLanguageTag, bool bWriteEmpty, xmloff::token::XMLTokenEnum eClass )
1062 : {
1063 : xmloff::token::XMLTokenEnum eLanguage, eScript, eCountry, eRfcLanguageTag;
1064 340 : switch (eClass)
1065 : {
1066 : default:
1067 : case XML_LANGUAGE:
1068 340 : eLanguage = XML_LANGUAGE;
1069 340 : eScript = XML_SCRIPT;
1070 340 : eCountry = XML_COUNTRY;
1071 340 : eRfcLanguageTag = XML_RFC_LANGUAGE_TAG;
1072 340 : break;
1073 : case XML_LANGUAGE_ASIAN:
1074 0 : eLanguage = XML_LANGUAGE_ASIAN;
1075 0 : eScript = XML_SCRIPT_ASIAN;
1076 0 : eCountry = XML_COUNTRY_ASIAN;
1077 0 : eRfcLanguageTag = XML_RFC_LANGUAGE_TAG_ASIAN;
1078 0 : if (nPrefix == XML_NAMESPACE_FO)
1079 0 : nPrefix = XML_NAMESPACE_STYLE;
1080 0 : break;
1081 : case XML_LANGUAGE_COMPLEX:
1082 0 : eLanguage = XML_LANGUAGE_COMPLEX;
1083 0 : eScript = XML_SCRIPT_COMPLEX;
1084 0 : eCountry = XML_COUNTRY_COMPLEX;
1085 0 : eRfcLanguageTag = XML_RFC_LANGUAGE_TAG_COMPLEX;
1086 0 : if (nPrefix == XML_NAMESPACE_FO)
1087 0 : nPrefix = XML_NAMESPACE_STYLE;
1088 0 : break;
1089 : }
1090 340 : if (rLanguageTag.isIsoODF())
1091 : {
1092 340 : if (bWriteEmpty || !rLanguageTag.isSystemLocale())
1093 : {
1094 340 : AddAttribute( nPrefix, eLanguage, rLanguageTag.getLanguage());
1095 340 : if (rLanguageTag.hasScript() && getDefaultVersion() >= SvtSaveOptions::ODFVER_012)
1096 0 : AddAttribute( nPrefix, eScript, rLanguageTag.getScript());
1097 340 : if (bWriteEmpty || !rLanguageTag.getCountry().isEmpty())
1098 340 : AddAttribute( nPrefix, eCountry, rLanguageTag.getCountry());
1099 : }
1100 : }
1101 : else
1102 : {
1103 0 : if (getDefaultVersion() >= SvtSaveOptions::ODFVER_012)
1104 0 : AddAttribute( nPrefixRfc, eRfcLanguageTag, rLanguageTag.getBcp47());
1105 : // Also in case of non-pure-ISO tag store best matching fo: attributes
1106 : // for consumers not handling *:rfc-language-tag, ensuring that only
1107 : // valid ISO codes are stored. Here the bWriteEmpty parameter has no
1108 : // meaning.
1109 0 : OUString aLanguage, aScript, aCountry;
1110 0 : rLanguageTag.getIsoLanguageScriptCountry( aLanguage, aScript, aCountry);
1111 0 : if (!aLanguage.isEmpty())
1112 : {
1113 0 : AddAttribute( nPrefix, eLanguage, aLanguage);
1114 0 : if (!aScript.isEmpty() && getDefaultVersion() >= SvtSaveOptions::ODFVER_012)
1115 0 : AddAttribute( nPrefix, eScript, aScript);
1116 0 : if (!aCountry.isEmpty())
1117 0 : AddAttribute( nPrefix, eCountry, aCountry);
1118 0 : }
1119 : }
1120 340 : }
1121 :
1122 4 : void SvXMLExport::AddAttributeList( const uno::Reference< xml::sax::XAttributeList >& xAttrList )
1123 : {
1124 4 : if( xAttrList.is())
1125 4 : mpAttrList->AppendAttributeList( xAttrList );
1126 4 : }
1127 :
1128 124343 : void SvXMLExport::ClearAttrList()
1129 : {
1130 124343 : mpAttrList->Clear();
1131 124343 : }
1132 :
1133 : #ifdef DBG_UTIL
1134 : void SvXMLExport::CheckAttrList()
1135 : {
1136 : SAL_WARN_IF( mpAttrList->getLength(), "xmloff.core", "XMLExport::CheckAttrList: list is not empty" );
1137 : }
1138 : #endif
1139 :
1140 346 : void SvXMLExport::ImplExportMeta()
1141 : {
1142 346 : CheckAttrList();
1143 :
1144 346 : _ExportMeta();
1145 346 : }
1146 :
1147 773 : void SvXMLExport::ImplExportSettings()
1148 : {
1149 773 : CheckAttrList();
1150 :
1151 773 : ::std::list< SettingsGroup > aSettings;
1152 773 : sal_Int32 nSettingsCount = 0;
1153 :
1154 : // view settings
1155 1546 : uno::Sequence< beans::PropertyValue > aViewSettings;
1156 773 : GetViewSettingsAndViews( aViewSettings );
1157 773 : aSettings.push_back( SettingsGroup( XML_VIEW_SETTINGS, aViewSettings ) );
1158 773 : nSettingsCount += aViewSettings.getLength();
1159 :
1160 : // configuration settings
1161 1546 : uno::Sequence<beans::PropertyValue> aConfigSettings;
1162 773 : GetConfigurationSettings( aConfigSettings );
1163 773 : aSettings.push_back( SettingsGroup( XML_CONFIGURATION_SETTINGS, aConfigSettings ) );
1164 773 : nSettingsCount += aConfigSettings.getLength();
1165 :
1166 : // any document specific settings
1167 773 : nSettingsCount += GetDocumentSpecificSettings( aSettings );
1168 :
1169 : {
1170 : SvXMLElementExport aElem( *this,
1171 : nSettingsCount != 0,
1172 : XML_NAMESPACE_OFFICE, XML_SETTINGS,
1173 773 : true, true );
1174 :
1175 1546 : SettingsExportFacade aSettingsExportContext( *this );
1176 1546 : XMLSettingsExportHelper aSettingsExportHelper( aSettingsExportContext );
1177 :
1178 6957 : for ( ::std::list< SettingsGroup >::const_iterator settings = aSettings.begin();
1179 4638 : settings != aSettings.end();
1180 : ++settings
1181 : )
1182 : {
1183 1546 : if ( !settings->aSettings.getLength() )
1184 189 : continue;
1185 :
1186 1357 : OUString sSettingsName( GetXMLToken( settings->eGroupName ) );
1187 2714 : OUString sQName = GetNamespaceMap().GetQNameByKey( XML_NAMESPACE_OOO, sSettingsName );
1188 1357 : aSettingsExportHelper.exportAllSettings( settings->aSettings, sQName );
1189 2130 : }
1190 773 : }
1191 773 : }
1192 :
1193 386 : void SvXMLExport::ImplExportStyles( bool )
1194 : {
1195 386 : CheckAttrList();
1196 :
1197 : {
1198 : // <style:styles>
1199 : SvXMLElementExport aElem( *this, XML_NAMESPACE_OFFICE, XML_STYLES,
1200 386 : true, true );
1201 :
1202 386 : _ExportStyles( false );
1203 : }
1204 :
1205 : // transfer style names (+ families) TO other components (if appropriate)
1206 386 : if( ( !( mnExportFlags & SvXMLExportFlags::CONTENT ) ) && mxExportInfo.is() )
1207 : {
1208 382 : static OUString sStyleNames( "StyleNames" );
1209 382 : static OUString sStyleFamilies( "StyleFamilies" );
1210 382 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxExportInfo->getPropertySetInfo();
1211 382 : if ( xPropertySetInfo->hasPropertyByName( sStyleNames ) && xPropertySetInfo->hasPropertyByName( sStyleFamilies ) )
1212 : {
1213 113 : Sequence<sal_Int32> aStyleFamilies;
1214 226 : Sequence<OUString> aStyleNames;
1215 113 : mxAutoStylePool->GetRegisteredNames( aStyleFamilies, aStyleNames );
1216 113 : mxExportInfo->setPropertyValue( sStyleNames, makeAny( aStyleNames ) );
1217 113 : mxExportInfo->setPropertyValue( sStyleFamilies,
1218 226 : makeAny( aStyleFamilies ) );
1219 382 : }
1220 : }
1221 386 : }
1222 :
1223 595 : void SvXMLExport::ImplExportAutoStyles( bool )
1224 : {
1225 : // transfer style names (+ families) FROM other components (if appropriate)
1226 595 : OUString sStyleNames( "StyleNames" );
1227 1190 : OUString sStyleFamilies( "StyleFamilies" );
1228 2380 : if( ( !( mnExportFlags & SvXMLExportFlags::STYLES ) )
1229 478 : && mxExportInfo.is()
1230 1073 : && mxExportInfo->getPropertySetInfo()->hasPropertyByName( sStyleNames )
1231 2493 : && mxExportInfo->getPropertySetInfo()->hasPropertyByName( sStyleFamilies ) )
1232 : {
1233 113 : Sequence<sal_Int32> aStyleFamilies;
1234 113 : mxExportInfo->getPropertyValue( sStyleFamilies ) >>= aStyleFamilies;
1235 226 : Sequence<OUString> aStyleNames;
1236 113 : mxExportInfo->getPropertyValue( sStyleNames ) >>= aStyleNames;
1237 226 : mxAutoStylePool->RegisterNames( aStyleFamilies, aStyleNames );
1238 : }
1239 :
1240 : {
1241 : // <style:automatic-styles>
1242 : SvXMLElementExport aElem( *this, XML_NAMESPACE_OFFICE,
1243 595 : XML_AUTOMATIC_STYLES, true, true );
1244 :
1245 595 : _ExportAutoStyles();
1246 595 : }
1247 595 : }
1248 :
1249 117 : void SvXMLExport::ImplExportMasterStyles( bool )
1250 : {
1251 : {
1252 : // <style:master-styles>
1253 : SvXMLElementExport aElem( *this, XML_NAMESPACE_OFFICE, XML_MASTER_STYLES,
1254 117 : true, true );
1255 :
1256 117 : _ExportMasterStyles();
1257 : }
1258 :
1259 117 : }
1260 :
1261 482 : void SvXMLExport::ImplExportContent()
1262 : {
1263 482 : CheckAttrList();
1264 :
1265 482 : CheckAttrList();
1266 :
1267 : {
1268 : SvXMLElementExport aElemrnt( *this, XML_NAMESPACE_OFFICE, XML_BODY,
1269 482 : true, true );
1270 : {
1271 482 : XMLTokenEnum eClass = meClass;
1272 482 : if( XML_TEXT_GLOBAL == eClass )
1273 : {
1274 : AddAttribute( XML_NAMESPACE_TEXT, XML_GLOBAL,
1275 0 : GetXMLToken( XML_TRUE ) );
1276 0 : eClass = XML_TEXT;
1277 : }
1278 482 : if ( XML_GRAPHICS == eClass )
1279 8 : eClass = XML_DRAWING;
1280 : // <office:body ...>
1281 482 : SetBodyAttributes();
1282 : SvXMLElementExport aElem( *this, meClass != XML_TOKEN_INVALID,
1283 : XML_NAMESPACE_OFFICE, eClass,
1284 482 : true, true );
1285 :
1286 482 : _ExportContent();
1287 482 : }
1288 : }
1289 482 : }
1290 :
1291 380 : void SvXMLExport::SetBodyAttributes()
1292 : {
1293 380 : }
1294 :
1295 : static void
1296 1975 : lcl_AddGrddl(SvXMLExport & rExport, const SvXMLExportFlags /*nExportMode*/)
1297 : {
1298 : // check version >= 1.2
1299 1975 : switch (rExport.getDefaultVersion()) {
1300 : case SvtSaveOptions::ODFVER_011: // fall through
1301 1975 : case SvtSaveOptions::ODFVER_010: return;
1302 1975 : default: break;
1303 : }
1304 :
1305 : // #i115030#: disabled, the XSLT is not finished, and not available via HTTP
1306 : #if 0
1307 : if (SvXMLExportFlags::SETTINGS != nExportMode) // meta, content, styles
1308 : {
1309 : rExport.AddAttribute( XML_NAMESPACE_GRDDL, XML_TRANSFORMATION,
1310 : OUString("http://FIXME") );
1311 : }
1312 : #endif
1313 : }
1314 :
1315 2562 : void SvXMLExport::addChaffWhenEncryptedStorage()
1316 : {
1317 2562 : uno::Reference< embed::XEncryptionProtectedSource2 > xEncr(mpImpl->mxTargetStorage, uno::UNO_QUERY);
1318 :
1319 2562 : if (xEncr.is() && xEncr->hasEncryptionData() && mxExtHandler.is())
1320 : {
1321 3 : mxExtHandler->comment(OStringToOUString(comphelper::xml::makeXMLChaff(), RTL_TEXTENCODING_ASCII_US));
1322 2562 : }
1323 2562 : }
1324 :
1325 1975 : sal_uInt32 SvXMLExport::exportDoc( enum ::xmloff::token::XMLTokenEnum eClass )
1326 : {
1327 1975 : bool bOwnGraphicResolver = false;
1328 1975 : bool bOwnEmbeddedResolver = false;
1329 :
1330 1975 : if( !mxGraphicResolver.is() || !mxEmbeddedResolver.is() )
1331 : {
1332 1595 : Reference< XMultiServiceFactory > xFactory( mxModel, UNO_QUERY );
1333 1595 : if( xFactory.is() )
1334 : {
1335 : try
1336 : {
1337 842 : if( !mxGraphicResolver.is() )
1338 : {
1339 70 : mxGraphicResolver = Reference< XGraphicObjectResolver >::query(
1340 35 : xFactory->createInstance(
1341 70 : OUString( "com.sun.star.document.ExportGraphicObjectResolver")));
1342 35 : bOwnGraphicResolver = mxGraphicResolver.is();
1343 : }
1344 :
1345 842 : if( !mxEmbeddedResolver.is() )
1346 : {
1347 1684 : mxEmbeddedResolver = Reference< XEmbeddedObjectResolver >::query(
1348 842 : xFactory->createInstance(
1349 1684 : OUString( "com.sun.star.document.ExportEmbeddedObjectResolver")));
1350 842 : bOwnEmbeddedResolver = mxEmbeddedResolver.is();
1351 : }
1352 : }
1353 0 : catch(const com::sun::star::uno::Exception&)
1354 : {
1355 : }
1356 1595 : }
1357 : }
1358 1975 : if( (getExportFlags() & SvXMLExportFlags::OASIS) == SvXMLExportFlags::NONE )
1359 : {
1360 : try
1361 : {
1362 : ::comphelper::PropertyMapEntry const aInfoMap[] =
1363 : {
1364 : { OUString("Class"), 0,
1365 4 : ::cppu::UnoType<OUString>::get(),
1366 : PropertyAttribute::MAYBEVOID, 0},
1367 : { OUString(), 0, css::uno::Type(), 0, 0 }
1368 16 : };
1369 : Reference< XPropertySet > xConvPropSet(
1370 : ::comphelper::GenericPropertySet_CreateInstance(
1371 8 : new ::comphelper::PropertySetInfo( aInfoMap ) ) );
1372 :
1373 8 : Any aAny;
1374 4 : aAny <<= GetXMLToken( eClass );
1375 4 : xConvPropSet->setPropertyValue(
1376 4 : OUString("Class"), aAny );
1377 :
1378 : Reference< XPropertySet > xPropSet =
1379 4 : mxExportInfo.is()
1380 : ? PropertySetMerger_CreateInstance( mxExportInfo,
1381 : xConvPropSet )
1382 8 : : xConvPropSet;
1383 :
1384 8 : Sequence<Any> aArgs( 3 );
1385 4 : aArgs[0] <<= mxHandler;
1386 4 : aArgs[1] <<= xPropSet;
1387 4 : aArgs[2] <<= mxModel;
1388 :
1389 : // get filter component
1390 : Reference< xml::sax::XDocumentHandler > xTmpDocHandler(
1391 8 : m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext("com.sun.star.comp.Oasis2OOoTransformer", aArgs, m_xContext),
1392 8 : UNO_QUERY);
1393 : SAL_WARN_IF(!xTmpDocHandler.is(), "xmloff.core", "can't instantiate OASIS transformer component" );
1394 4 : if( xTmpDocHandler.is() )
1395 : {
1396 4 : mxHandler = xTmpDocHandler;
1397 4 : mxExtHandler = uno::Reference<xml::sax::XExtendedDocumentHandler>( mxHandler, UNO_QUERY );
1398 12 : }
1399 : }
1400 0 : catch(const com::sun::star::uno::Exception&)
1401 : {
1402 : }
1403 : }
1404 :
1405 1975 : mxHandler->startDocument();
1406 :
1407 1975 : addChaffWhenEncryptedStorage();
1408 :
1409 : // <office:document ...>
1410 1975 : CheckAttrList();
1411 :
1412 : // namespace attributes
1413 : // ( The namespace decls should be first attributes in the element;
1414 : // some faulty XML parsers (JAXP1.1) have a problem with this,
1415 : // also it's more elegant )
1416 1975 : sal_uInt16 nPos = mpNamespaceMap->GetFirstKey();
1417 37784 : while( USHRT_MAX != nPos )
1418 : {
1419 : mpAttrList->AddAttribute( mpNamespaceMap->GetAttrNameByKey( nPos ),
1420 33834 : mpNamespaceMap->GetNameByKey( nPos ) );
1421 33834 : nPos = mpNamespaceMap->GetNextKey( nPos );
1422 : }
1423 :
1424 : // office:version = ...
1425 1975 : if( !mbExtended )
1426 : {
1427 1975 : const sal_Char* pVersion = 0;
1428 1975 : switch( getDefaultVersion() )
1429 : {
1430 1975 : case SvtSaveOptions::ODFVER_LATEST: pVersion = sXML_1_2; break;
1431 0 : case SvtSaveOptions::ODFVER_012_EXT_COMPAT: pVersion = sXML_1_2; break;
1432 0 : case SvtSaveOptions::ODFVER_012: pVersion = sXML_1_2; break;
1433 0 : case SvtSaveOptions::ODFVER_011: pVersion = sXML_1_1; break;
1434 0 : case SvtSaveOptions::ODFVER_010: break;
1435 :
1436 : default:
1437 : SAL_WARN("xmloff.core", "xmloff::SvXMLExport::exportDoc(), unexpected odf default version!");
1438 : }
1439 :
1440 1975 : if( pVersion )
1441 : AddAttribute( XML_NAMESPACE_OFFICE, XML_VERSION,
1442 1975 : OUString::createFromAscii(pVersion) );
1443 : }
1444 :
1445 : {
1446 1975 : enum XMLTokenEnum eRootService = XML_TOKEN_INVALID;
1447 1975 : const SvXMLExportFlags nExportMode = mnExportFlags & (SvXMLExportFlags::META|SvXMLExportFlags::STYLES|SvXMLExportFlags::CONTENT|SvXMLExportFlags::SETTINGS);
1448 :
1449 1975 : lcl_AddGrddl(*this, nExportMode);
1450 :
1451 1975 : if( SvXMLExportFlags::META == nExportMode )
1452 : {
1453 : // export only meta
1454 342 : eRootService = XML_DOCUMENT_META;
1455 : }
1456 1633 : else if ( SvXMLExportFlags::SETTINGS == nExportMode )
1457 : {
1458 : // export only settings
1459 769 : eRootService = XML_DOCUMENT_SETTINGS;
1460 : }
1461 864 : else if( SvXMLExportFlags::STYLES == nExportMode )
1462 : {
1463 : // export only styles
1464 382 : eRootService = XML_DOCUMENT_STYLES;
1465 : }
1466 482 : else if( SvXMLExportFlags::CONTENT == nExportMode )
1467 : {
1468 : // export only content
1469 478 : eRootService = XML_DOCUMENT_CONTENT;
1470 : }
1471 : else
1472 : {
1473 : // the god'ol one4all element
1474 4 : eRootService = XML_DOCUMENT;
1475 : // office:mimetype = ... (only for stream containing the content)
1476 4 : if( eClass != XML_TOKEN_INVALID )
1477 : {
1478 4 : OUString aTmp( "application/vnd.oasis.opendocument." );
1479 4 : aTmp += GetXMLToken( eClass );
1480 4 : AddAttribute( XML_NAMESPACE_OFFICE, XML_MIMETYPE, aTmp );
1481 : }
1482 : }
1483 :
1484 1975 : SvXMLElementExport aElem( *this, XML_NAMESPACE_OFFICE, eRootService, true, true );
1485 :
1486 : // meta information
1487 1975 : if( mnExportFlags & SvXMLExportFlags::META )
1488 346 : ImplExportMeta();
1489 :
1490 : // settings
1491 1975 : if( mnExportFlags & SvXMLExportFlags::SETTINGS )
1492 773 : ImplExportSettings();
1493 :
1494 : // scripts
1495 1975 : if( mnExportFlags & SvXMLExportFlags::SCRIPTS )
1496 213 : _ExportScripts();
1497 :
1498 : // font declerations
1499 1975 : if( mnExportFlags & SvXMLExportFlags::FONTDECLS )
1500 595 : _ExportFontDecls();
1501 :
1502 : // styles
1503 1975 : if( mnExportFlags & SvXMLExportFlags::STYLES )
1504 386 : ImplExportStyles( false );
1505 :
1506 : // autostyles
1507 1975 : if( mnExportFlags & SvXMLExportFlags::AUTOSTYLES )
1508 595 : ImplExportAutoStyles( false );
1509 :
1510 : // masterstyles
1511 1975 : if( mnExportFlags & SvXMLExportFlags::MASTERSTYLES )
1512 117 : ImplExportMasterStyles( false );
1513 :
1514 : // contnt
1515 1975 : if( mnExportFlags & SvXMLExportFlags::CONTENT )
1516 482 : ImplExportContent();
1517 : }
1518 :
1519 1975 : mxHandler->endDocument();
1520 :
1521 1975 : if( bOwnGraphicResolver )
1522 : {
1523 35 : Reference< XComponent > xComp( mxGraphicResolver, UNO_QUERY );
1524 35 : xComp->dispose();
1525 : }
1526 :
1527 1975 : if( bOwnEmbeddedResolver )
1528 : {
1529 35 : Reference< XComponent > xComp( mxEmbeddedResolver, UNO_QUERY );
1530 35 : xComp->dispose();
1531 : }
1532 :
1533 1975 : return 0;
1534 : }
1535 :
1536 561 : void SvXMLExport::ResetNamespaceMap()
1537 : {
1538 561 : delete mpNamespaceMap; mpNamespaceMap = new SvXMLNamespaceMap;
1539 561 : }
1540 :
1541 807 : OUString SvXMLExport::GetSourceShellID() const
1542 : {
1543 807 : return mpImpl->maSrcShellID;
1544 : }
1545 :
1546 807 : OUString SvXMLExport::GetDestinationShellID() const
1547 : {
1548 807 : return mpImpl->maDestShellID;
1549 : }
1550 :
1551 346 : void SvXMLExport::_ExportMeta()
1552 : {
1553 346 : OUString generator( ::utl::DocInfoHelper::GetGeneratorString() );
1554 : Reference< XDocumentPropertiesSupplier > xDocPropsSupplier(mxModel,
1555 692 : UNO_QUERY);
1556 346 : if (xDocPropsSupplier.is()) {
1557 : Reference<XDocumentProperties> xDocProps(
1558 346 : xDocPropsSupplier->getDocumentProperties());
1559 346 : if (!xDocProps.is()) throw;
1560 : // update generator here
1561 346 : xDocProps->setGenerator(generator);
1562 346 : SvXMLMetaExport * pMeta = new SvXMLMetaExport(*this, xDocProps);
1563 692 : uno::Reference<xml::sax::XDocumentHandler> xMeta(pMeta);
1564 692 : pMeta->Export();
1565 : } else {
1566 : // office:meta
1567 : SvXMLElementExport aElem( *this, XML_NAMESPACE_OFFICE, XML_META,
1568 0 : true, true );
1569 : {
1570 : // BM: #i60323# export generator even if xInfoProp is empty (which is the
1571 : // case for charts). The generator does not depend on xInfoProp
1572 : SvXMLElementExport anElem( *this, XML_NAMESPACE_META, XML_GENERATOR,
1573 0 : true, true );
1574 0 : Characters(generator);
1575 0 : }
1576 346 : }
1577 346 : }
1578 :
1579 213 : void SvXMLExport::_ExportScripts()
1580 : {
1581 213 : SvXMLElementExport aElement( *this, XML_NAMESPACE_OFFICE, XML_SCRIPTS, true, true );
1582 :
1583 : // export Basic macros (only for FlatXML)
1584 213 : if ( mnExportFlags & SvXMLExportFlags::EMBEDDED )
1585 : {
1586 4 : OUString aValue( GetNamespaceMap().GetPrefixByKey( XML_NAMESPACE_OOO ) );
1587 4 : aValue += ":Basic";
1588 4 : AddAttribute( XML_NAMESPACE_SCRIPT, XML_LANGUAGE, aValue );
1589 :
1590 8 : SvXMLElementExport aElem( *this, XML_NAMESPACE_OFFICE, XML_SCRIPT, true, true );
1591 :
1592 : // initialize Basic
1593 4 : if ( mxModel.is() )
1594 : {
1595 4 : Reference< beans::XPropertySet > xPSet( mxModel, UNO_QUERY );
1596 4 : if ( xPSet.is() )
1597 4 : xPSet->getPropertyValue("BasicLibraries");
1598 : }
1599 :
1600 8 : Reference < XDocumentHandler > xHdl( new XMLBasicExportFilter( mxHandler ) );
1601 8 : Reference< document::XXMLBasicExporter > xExporter = document::XMLOasisBasicExporter::createWithHandler( m_xContext, xHdl );
1602 :
1603 8 : Reference< XComponent > xComp( mxModel, UNO_QUERY );
1604 4 : xExporter->setSourceDocument( xComp );
1605 8 : Sequence< PropertyValue > aMediaDesc( 0 );
1606 8 : xExporter->filter( aMediaDesc );
1607 : }
1608 :
1609 : // export document events
1610 426 : Reference< document::XEventsSupplier > xEvents( GetModel(), UNO_QUERY );
1611 426 : GetEventExport().Export( xEvents, true );
1612 213 : }
1613 :
1614 595 : void SvXMLExport::_ExportFontDecls()
1615 : {
1616 595 : if( mxFontAutoStylePool.is() )
1617 326 : mxFontAutoStylePool->exportXML();
1618 595 : }
1619 :
1620 386 : void SvXMLExport::_ExportStyles( bool )
1621 : {
1622 386 : uno::Reference< lang::XMultiServiceFactory > xFact( GetModel(), uno::UNO_QUERY );
1623 386 : if( xFact.is())
1624 : {
1625 : // export (fill-)gradient-styles
1626 : try
1627 : {
1628 386 : uno::Reference< container::XNameAccess > xGradient( xFact->createInstance("com.sun.star.drawing.GradientTable"), uno::UNO_QUERY );
1629 386 : if( xGradient.is() )
1630 : {
1631 386 : XMLGradientStyleExport aGradientStyle( *this );
1632 :
1633 386 : if( xGradient->hasElements() )
1634 : {
1635 4 : uno::Sequence< OUString > aNamesSeq ( xGradient->getElementNames() );
1636 4 : sal_Int32 nCount = aNamesSeq.getLength();
1637 10 : for( sal_Int32 i=0; i<nCount; i++ )
1638 : {
1639 6 : const OUString& rStrName = aNamesSeq[ i ];
1640 :
1641 : try
1642 : {
1643 6 : uno::Any aValue = xGradient->getByName( rStrName );
1644 :
1645 6 : aGradientStyle.exportXML( rStrName, aValue );
1646 : }
1647 0 : catch(const container::NoSuchElementException&)
1648 : {
1649 : }
1650 4 : }
1651 386 : }
1652 386 : }
1653 : }
1654 0 : catch(const lang::ServiceNotRegisteredException&)
1655 : {
1656 : }
1657 :
1658 : // export (fill-)hatch-styles
1659 : try
1660 : {
1661 386 : uno::Reference< container::XNameAccess > xHatch( xFact->createInstance("com.sun.star.drawing.HatchTable"), uno::UNO_QUERY );
1662 386 : if( xHatch.is() )
1663 : {
1664 386 : XMLHatchStyleExport aHatchStyle( *this );
1665 :
1666 386 : if( xHatch->hasElements() )
1667 : {
1668 3 : uno::Sequence< OUString > aNamesSeq ( xHatch->getElementNames() );
1669 3 : sal_Int32 nCount = aNamesSeq.getLength();
1670 10 : for( sal_Int32 i=0; i<nCount; i++ )
1671 : {
1672 7 : const OUString& rStrName = aNamesSeq[ i ];
1673 :
1674 : try
1675 : {
1676 7 : uno::Any aValue = xHatch->getByName( rStrName );
1677 :
1678 7 : aHatchStyle.exportXML( rStrName, aValue );
1679 : }
1680 0 : catch(const container::NoSuchElementException&)
1681 : {}
1682 3 : }
1683 386 : }
1684 386 : }
1685 : }
1686 0 : catch(const lang::ServiceNotRegisteredException&)
1687 : {
1688 : }
1689 :
1690 : // export (fill-)bitmap-styles
1691 : try
1692 : {
1693 386 : uno::Reference< container::XNameAccess > xBitmap( xFact->createInstance("com.sun.star.drawing.BitmapTable"), uno::UNO_QUERY );
1694 386 : if( xBitmap.is() )
1695 : {
1696 386 : XMLImageStyle aImageStyle;
1697 :
1698 386 : if( xBitmap->hasElements() )
1699 : {
1700 9 : uno::Sequence< OUString > aNamesSeq ( xBitmap->getElementNames() );
1701 9 : sal_Int32 nCount = aNamesSeq.getLength();
1702 19 : for( sal_Int32 i=0; i<nCount; i++ )
1703 : {
1704 10 : const OUString& rStrName = aNamesSeq[ i ];
1705 :
1706 : try
1707 : {
1708 10 : uno::Any aValue = xBitmap->getByName( rStrName );
1709 :
1710 10 : aImageStyle.exportXML( rStrName, aValue, *this );
1711 : }
1712 0 : catch(const container::NoSuchElementException&)
1713 : {
1714 : }
1715 9 : }
1716 386 : }
1717 386 : }
1718 : }
1719 0 : catch(const lang::ServiceNotRegisteredException&)
1720 : {
1721 : }
1722 :
1723 : // export transparency-gradient -styles
1724 : try
1725 : {
1726 386 : uno::Reference< container::XNameAccess > xTransGradient( xFact->createInstance("com.sun.star.drawing.TransparencyGradientTable"), uno::UNO_QUERY );
1727 386 : if( xTransGradient.is() )
1728 : {
1729 386 : XMLTransGradientStyleExport aTransGradientstyle( *this );
1730 :
1731 386 : if( xTransGradient->hasElements() )
1732 : {
1733 1 : uno::Sequence< OUString > aNamesSeq ( xTransGradient->getElementNames() );
1734 1 : sal_Int32 nCount = aNamesSeq.getLength();
1735 2 : for( sal_Int32 i=0; i<nCount; i++ )
1736 : {
1737 1 : const OUString& rStrName = aNamesSeq[ i ];
1738 :
1739 : try
1740 : {
1741 1 : uno::Any aValue = xTransGradient->getByName( rStrName );
1742 :
1743 1 : aTransGradientstyle.exportXML( rStrName, aValue );
1744 : }
1745 0 : catch(const container::NoSuchElementException&)
1746 : {
1747 : }
1748 1 : }
1749 386 : }
1750 386 : }
1751 : }
1752 0 : catch(const lang::ServiceNotRegisteredException&)
1753 : {
1754 : }
1755 :
1756 : // export marker-styles
1757 : try
1758 : {
1759 386 : uno::Reference< container::XNameAccess > xMarker( xFact->createInstance("com.sun.star.drawing.MarkerTable"), uno::UNO_QUERY );
1760 386 : if( xMarker.is() )
1761 : {
1762 386 : XMLMarkerStyleExport aMarkerStyle( *this );
1763 :
1764 386 : if( xMarker->hasElements() )
1765 : {
1766 17 : uno::Sequence< OUString > aNamesSeq ( xMarker->getElementNames() );
1767 17 : sal_Int32 nCount = aNamesSeq.getLength();
1768 36 : for( sal_Int32 i=0; i<nCount; i++ )
1769 : {
1770 19 : const OUString& rStrName = aNamesSeq[ i ];
1771 :
1772 : try
1773 : {
1774 19 : uno::Any aValue = xMarker->getByName( rStrName );
1775 :
1776 19 : aMarkerStyle.exportXML( rStrName, aValue );
1777 : }
1778 0 : catch(const container::NoSuchElementException&)
1779 : {
1780 : }
1781 17 : }
1782 386 : }
1783 386 : }
1784 : }
1785 0 : catch(const lang::ServiceNotRegisteredException&)
1786 : {
1787 : }
1788 :
1789 : // export dash-styles
1790 : try
1791 : {
1792 386 : uno::Reference< container::XNameAccess > xDashes( xFact->createInstance("com.sun.star.drawing.DashTable"), uno::UNO_QUERY );
1793 386 : if( xDashes.is() )
1794 : {
1795 386 : XMLDashStyleExport aDashStyle( *this );
1796 :
1797 386 : if( xDashes->hasElements() )
1798 : {
1799 2 : uno::Sequence< OUString > aNamesSeq ( xDashes->getElementNames() );
1800 2 : sal_Int32 nCount = aNamesSeq.getLength();
1801 8 : for( sal_Int32 i=0; i<nCount; i++ )
1802 : {
1803 6 : const OUString& rStrName = aNamesSeq[ i ];
1804 :
1805 : try
1806 : {
1807 6 : uno::Any aValue = xDashes->getByName( rStrName );
1808 :
1809 6 : aDashStyle.exportXML( rStrName, aValue );
1810 : }
1811 0 : catch(const container::NoSuchElementException&)
1812 : {
1813 : }
1814 2 : }
1815 386 : }
1816 386 : }
1817 : }
1818 0 : catch(const lang::ServiceNotRegisteredException&)
1819 : {
1820 : }
1821 386 : }
1822 386 : }
1823 :
1824 915 : XMLTextParagraphExport* SvXMLExport::CreateTextParagraphExport()
1825 : {
1826 915 : return new XMLTextParagraphExport( *this, *(GetAutoStylePool().get()) );
1827 : }
1828 :
1829 318 : XMLShapeExport* SvXMLExport::CreateShapeExport()
1830 : {
1831 318 : return new XMLShapeExport(*this);
1832 : }
1833 :
1834 857 : SvXMLAutoStylePoolP* SvXMLExport::CreateAutoStylePool()
1835 : {
1836 857 : return new SvXMLAutoStylePoolP(*this);
1837 : }
1838 :
1839 0 : XMLPageExport* SvXMLExport::CreatePageExport()
1840 : {
1841 0 : return new XMLPageExport( *this );
1842 : }
1843 :
1844 4 : SchXMLExportHelper* SvXMLExport::CreateChartExport()
1845 : {
1846 4 : return new SchXMLExportHelper(*this,*GetAutoStylePool().get());
1847 : }
1848 :
1849 354 : XMLFontAutoStylePool* SvXMLExport::CreateFontAutoStylePool()
1850 : {
1851 354 : return new XMLFontAutoStylePool( *this );
1852 : }
1853 :
1854 124 : xmloff::OFormLayerXMLExport* SvXMLExport::CreateFormExport()
1855 : {
1856 124 : return new xmloff::OFormLayerXMLExport(*this);
1857 : }
1858 :
1859 773 : void SvXMLExport::GetViewSettingsAndViews(uno::Sequence<beans::PropertyValue>& rProps)
1860 : {
1861 773 : GetViewSettings(rProps);
1862 773 : uno::Reference<document::XViewDataSupplier> xViewDataSupplier(GetModel(), uno::UNO_QUERY);
1863 773 : if(xViewDataSupplier.is())
1864 : {
1865 677 : uno::Reference<container::XIndexAccess> xIndexAccess;
1866 677 : xViewDataSupplier->setViewData( xIndexAccess ); // make sure we get a newly created sequence
1867 677 : xIndexAccess = xViewDataSupplier->getViewData();
1868 677 : bool bAdd = false;
1869 1354 : uno::Any aAny;
1870 677 : if(xIndexAccess.is() && xIndexAccess->hasElements() )
1871 : {
1872 71 : sal_Int32 nCount = xIndexAccess->getCount();
1873 71 : for (sal_Int32 i = 0; i < nCount; i++)
1874 : {
1875 71 : aAny = xIndexAccess->getByIndex(i);
1876 71 : uno::Sequence<beans::PropertyValue> aProps;
1877 71 : if( aAny >>= aProps )
1878 : {
1879 71 : if( aProps.getLength() > 0 )
1880 : {
1881 71 : bAdd = true;
1882 71 : break;
1883 : }
1884 : }
1885 0 : }
1886 : }
1887 :
1888 677 : if( bAdd )
1889 : {
1890 71 : sal_Int32 nOldLength(rProps.getLength());
1891 71 : rProps.realloc(nOldLength + 1);
1892 71 : beans::PropertyValue aProp;
1893 71 : aProp.Name = "Views";
1894 71 : aProp.Value <<= xIndexAccess;
1895 71 : rProps[nOldLength] = aProp;
1896 677 : }
1897 773 : }
1898 773 : }
1899 :
1900 0 : void SvXMLExport::GetViewSettings(uno::Sequence<beans::PropertyValue>&)
1901 : {
1902 0 : }
1903 :
1904 0 : void SvXMLExport::GetConfigurationSettings(uno::Sequence<beans::PropertyValue>&)
1905 : {
1906 0 : }
1907 :
1908 773 : sal_Int32 SvXMLExport::GetDocumentSpecificSettings( ::std::list< SettingsGroup >& _out_rSettings )
1909 : {
1910 : (void)_out_rSettings;
1911 773 : return 0;
1912 : }
1913 :
1914 3802 : void SvXMLExport::addDataStyle(const sal_Int32 nNumberFormat, bool /*bTimeFormat*/ )
1915 : {
1916 3802 : if(mpNumExport)
1917 3802 : mpNumExport->SetUsed(nNumberFormat);
1918 3802 : }
1919 :
1920 125 : void SvXMLExport::exportDataStyles()
1921 : {
1922 125 : if(mpNumExport)
1923 125 : mpNumExport->Export(false);
1924 125 : }
1925 :
1926 442 : void SvXMLExport::exportAutoDataStyles()
1927 : {
1928 442 : if(mpNumExport)
1929 442 : mpNumExport->Export(true);
1930 :
1931 442 : if (mxFormExport.is())
1932 75 : mxFormExport->exportAutoControlNumberStyles();
1933 442 : }
1934 :
1935 1394 : OUString SvXMLExport::getDataStyleName(const sal_Int32 nNumberFormat, bool /*bTimeFormat*/ ) const
1936 : {
1937 1394 : OUString sTemp;
1938 1394 : if(mpNumExport)
1939 1394 : sTemp = mpNumExport->GetStyleName(nNumberFormat);
1940 1394 : return sTemp;
1941 : }
1942 :
1943 0 : void SvXMLExport::exportAnnotationMeta(const uno::Reference<drawing::XShape>&)
1944 : {
1945 0 : }
1946 :
1947 115 : sal_Int32 SvXMLExport::dataStyleForceSystemLanguage(sal_Int32 nFormat) const
1948 : {
1949 115 : return ( mpNumExport != NULL )
1950 115 : ? mpNumExport->ForceSystemLanguage( nFormat ) : nFormat;
1951 : }
1952 :
1953 35 : OUString SvXMLExport::AddEmbeddedGraphicObject( const OUString& rGraphicObjectURL )
1954 : {
1955 35 : OUString sRet( rGraphicObjectURL );
1956 65 : if( rGraphicObjectURL.startsWith( msGraphicObjectProtocol ) &&
1957 30 : mxGraphicResolver.is() )
1958 : {
1959 30 : if( !(getExportFlags() & SvXMLExportFlags::EMBEDDED) )
1960 30 : sRet = mxGraphicResolver->resolveGraphicObjectURL( rGraphicObjectURL );
1961 : else
1962 0 : sRet.clear();
1963 : }
1964 : else
1965 5 : sRet = GetRelativeReference( sRet );
1966 :
1967 35 : return sRet;
1968 : }
1969 :
1970 34 : bool SvXMLExport::AddEmbeddedGraphicObjectAsBase64( const OUString& rGraphicObjectURL )
1971 : {
1972 34 : bool bRet = false;
1973 :
1974 68 : if( (getExportFlags() & SvXMLExportFlags::EMBEDDED) &&
1975 68 : rGraphicObjectURL.startsWith( msGraphicObjectProtocol ) &&
1976 0 : mxGraphicResolver.is() )
1977 : {
1978 0 : Reference< XBinaryStreamResolver > xStmResolver( mxGraphicResolver, UNO_QUERY );
1979 :
1980 0 : if( xStmResolver.is() )
1981 : {
1982 0 : Reference< XInputStream > xIn( xStmResolver->getInputStream( rGraphicObjectURL ) );
1983 :
1984 0 : if( xIn.is() )
1985 : {
1986 0 : XMLBase64Export aBase64Exp( *this );
1987 0 : bRet = aBase64Exp.exportOfficeBinaryDataElement( xIn );
1988 0 : }
1989 0 : }
1990 : }
1991 :
1992 34 : return bRet;
1993 : }
1994 :
1995 26 : OUString SvXMLExport::AddEmbeddedObject( const OUString& rEmbeddedObjectURL )
1996 : {
1997 26 : OUString sRet;
1998 65 : if( (rEmbeddedObjectURL.startsWith( msEmbeddedObjectProtocol ) ||
1999 52 : rEmbeddedObjectURL.startsWith( msGraphicObjectProtocol ) ) &&
2000 26 : mxEmbeddedResolver.is() )
2001 : {
2002 52 : sRet =
2003 52 : mxEmbeddedResolver->resolveEmbeddedObjectURL( rEmbeddedObjectURL );
2004 : }
2005 : else
2006 0 : sRet = GetRelativeReference( rEmbeddedObjectURL );
2007 :
2008 26 : return sRet;
2009 : }
2010 :
2011 0 : bool SvXMLExport::AddEmbeddedObjectAsBase64( const OUString& rEmbeddedObjectURL )
2012 : {
2013 0 : bool bRet = false;
2014 0 : if( (rEmbeddedObjectURL.startsWith( msEmbeddedObjectProtocol ) ||
2015 0 : rEmbeddedObjectURL.startsWith( msGraphicObjectProtocol ) ) &&
2016 0 : mxEmbeddedResolver.is() )
2017 : {
2018 0 : Reference < XNameAccess > xNA( mxEmbeddedResolver, UNO_QUERY );
2019 0 : if( xNA.is() )
2020 : {
2021 0 : Any aAny = xNA->getByName( rEmbeddedObjectURL );
2022 0 : Reference < XInputStream > xIn;
2023 0 : aAny >>= xIn;
2024 0 : if( xIn.is() )
2025 : {
2026 0 : XMLBase64Export aBase64Exp( *this );
2027 0 : bRet = aBase64Exp.exportOfficeBinaryDataElement( xIn );
2028 0 : }
2029 0 : }
2030 : }
2031 :
2032 0 : return bRet;
2033 : }
2034 :
2035 6529 : OUString SvXMLExport::EncodeStyleName(
2036 : const OUString& rName,
2037 : bool *pEncoded ) const
2038 : {
2039 6529 : return GetMM100UnitConverter().encodeStyleName( rName, pEncoded );
2040 : }
2041 :
2042 2888 : ProgressBarHelper* SvXMLExport::GetProgressBarHelper()
2043 : {
2044 2888 : if (!mpProgressBarHelper)
2045 : {
2046 358 : mpProgressBarHelper = new ProgressBarHelper(mxStatusIndicator, true);
2047 :
2048 358 : if (mxExportInfo.is())
2049 : {
2050 350 : uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxExportInfo->getPropertySetInfo();
2051 350 : if (xPropertySetInfo.is())
2052 : {
2053 350 : OUString sProgressRange(XML_PROGRESSRANGE);
2054 700 : OUString sProgressMax(XML_PROGRESSMAX);
2055 700 : OUString sProgressCurrent(XML_PROGRESSCURRENT);
2056 700 : OUString sRepeat(XML_PROGRESSREPEAT);
2057 1048 : if (xPropertySetInfo->hasPropertyByName(sProgressMax) &&
2058 698 : xPropertySetInfo->hasPropertyByName(sProgressCurrent) &&
2059 348 : xPropertySetInfo->hasPropertyByName(sProgressRange))
2060 : {
2061 348 : uno::Any aAny;
2062 348 : sal_Int32 nProgressMax(0);
2063 348 : sal_Int32 nProgressCurrent(0);
2064 348 : sal_Int32 nProgressRange(0);
2065 348 : aAny = mxExportInfo->getPropertyValue(sProgressRange);
2066 348 : if (aAny >>= nProgressRange)
2067 307 : mpProgressBarHelper->SetRange(nProgressRange);
2068 348 : aAny = mxExportInfo->getPropertyValue(sProgressMax);
2069 348 : if (aAny >>= nProgressMax)
2070 306 : mpProgressBarHelper->SetReference(nProgressMax);
2071 348 : aAny = mxExportInfo->getPropertyValue(sProgressCurrent);
2072 348 : if (aAny >>= nProgressCurrent)
2073 235 : mpProgressBarHelper->SetValue(nProgressCurrent);
2074 : }
2075 350 : if (xPropertySetInfo->hasPropertyByName(sRepeat))
2076 : {
2077 0 : uno::Any aAny = mxExportInfo->getPropertyValue(sRepeat);
2078 0 : if (aAny.getValueType() == cppu::UnoType<bool>::get())
2079 0 : mpProgressBarHelper->SetRepeat(::cppu::any2bool(aAny));
2080 : else {
2081 : SAL_WARN("xmloff.core", "why is it no boolean?" );
2082 0 : }
2083 350 : }
2084 350 : }
2085 : }
2086 : }
2087 2888 : return mpProgressBarHelper;
2088 : }
2089 :
2090 1928 : XMLEventExport& SvXMLExport::GetEventExport()
2091 : {
2092 1928 : if( NULL == mpEventExport)
2093 : {
2094 : // create EventExport on demand
2095 325 : mpEventExport = new XMLEventExport(*this, NULL);
2096 :
2097 : // and register standard handlers + names
2098 325 : OUString sStarBasic("StarBasic");
2099 325 : mpEventExport->AddHandler(sStarBasic, new XMLStarBasicExportHandler());
2100 650 : OUString sScript("Script");
2101 325 : mpEventExport->AddHandler(sScript, new XMLScriptExportHandler());
2102 650 : mpEventExport->AddTranslationTable(aStandardEventTable);
2103 : }
2104 :
2105 1928 : return *mpEventExport;
2106 : }
2107 :
2108 87 : XMLImageMapExport& SvXMLExport::GetImageMapExport()
2109 : {
2110 : // image map export, create on-demand
2111 87 : if( NULL == mpImageMapExport )
2112 : {
2113 23 : mpImageMapExport = new XMLImageMapExport(*this);
2114 : }
2115 :
2116 87 : return *mpImageMapExport;
2117 : }
2118 :
2119 : namespace
2120 : {
2121 : class theSvXMLExportUnoTunnelId : public rtl::Static< UnoTunnelIdInit, theSvXMLExportUnoTunnelId> {};
2122 : }
2123 :
2124 : // XUnoTunnel & co
2125 184 : const uno::Sequence< sal_Int8 > & SvXMLExport::getUnoTunnelId() throw()
2126 : {
2127 184 : return theSvXMLExportUnoTunnelId::get().getSeq();
2128 : }
2129 :
2130 92 : SvXMLExport* SvXMLExport::getImplementation( uno::Reference< uno::XInterface > xInt ) throw()
2131 : {
2132 92 : uno::Reference< lang::XUnoTunnel > xUT( xInt, uno::UNO_QUERY );
2133 92 : if( xUT.is() )
2134 : {
2135 : return
2136 : reinterpret_cast<SvXMLExport*>(
2137 : sal::static_int_cast<sal_IntPtr>(
2138 92 : xUT->getSomething( SvXMLExport::getUnoTunnelId())));
2139 : }
2140 : else
2141 0 : return NULL;
2142 : }
2143 :
2144 : // XUnoTunnel
2145 92 : sal_Int64 SAL_CALL SvXMLExport::getSomething( const uno::Sequence< sal_Int8 >& rId )
2146 : throw( uno::RuntimeException, std::exception )
2147 : {
2148 276 : if( rId.getLength() == 16 && 0 == memcmp( getUnoTunnelId().getConstArray(),
2149 184 : rId.getConstArray(), 16 ) )
2150 : {
2151 92 : return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this));
2152 : }
2153 0 : return 0;
2154 : }
2155 :
2156 0 : bool SvXMLExport::ExportEmbeddedOwnObject( Reference< XComponent >& rComp )
2157 : {
2158 0 : OUString sFilterService;
2159 :
2160 0 : Reference < lang::XServiceInfo > xServiceInfo( rComp, UNO_QUERY );
2161 0 : if( xServiceInfo.is() )
2162 : {
2163 0 : const XMLServiceMapEntry_Impl *pEntry = aServiceMap;
2164 0 : while( pEntry->sModelService )
2165 : {
2166 : OUString sModelService( pEntry->sModelService,
2167 : pEntry->nModelServiceLen,
2168 0 : RTL_TEXTENCODING_ASCII_US );
2169 0 : if( xServiceInfo->supportsService( sModelService ) )
2170 : {
2171 0 : sFilterService = OUString( pEntry->sFilterService,
2172 : pEntry->nFilterServiceLen,
2173 0 : RTL_TEXTENCODING_ASCII_US );
2174 0 : break;
2175 : }
2176 0 : pEntry++;
2177 0 : }
2178 : }
2179 :
2180 : SAL_WARN_IF( !sFilterService.getLength(), "xmloff.core", "no export filter for own object" );
2181 :
2182 0 : if( sFilterService.isEmpty() )
2183 0 : return false;
2184 :
2185 : Reference < XDocumentHandler > xHdl =
2186 0 : new XMLEmbeddedObjectExportFilter( mxHandler );
2187 :
2188 0 : Sequence < Any > aArgs( 1 );
2189 0 : aArgs[0] <<= xHdl;
2190 :
2191 : Reference< document::XExporter > xExporter(
2192 0 : m_xContext->getServiceManager()->createInstanceWithArgumentsAndContext(sFilterService, aArgs, m_xContext),
2193 0 : UNO_QUERY);
2194 : SAL_WARN_IF( !xExporter.is(), "xmloff.core", "can't instantiate export filter component for own object" );
2195 0 : if( !xExporter.is() )
2196 0 : return false;
2197 :
2198 0 : xExporter->setSourceDocument( rComp );
2199 :
2200 0 : Reference<XFilter> xFilter( xExporter, UNO_QUERY );
2201 :
2202 0 : Sequence < PropertyValue > aMediaDesc( 0 );
2203 0 : return xFilter->filter( aMediaDesc );
2204 : }
2205 :
2206 129 : OUString SvXMLExport::GetRelativeReference(const OUString& rValue)
2207 : {
2208 129 : OUString sValue( rValue );
2209 : // #i65474# handling of fragment URLs ("#....") is undefined
2210 : // they are stored 'as is'
2211 258 : uno::Reference< uri::XUriReference > xUriRef;
2212 129 : if(!sValue.isEmpty() && sValue[0] != '#')
2213 : {
2214 : try
2215 : {
2216 96 : xUriRef = mpImpl->mxUriReferenceFactory->parse( rValue );
2217 96 : if( xUriRef.is() && !xUriRef->isAbsolute() )
2218 : {
2219 : //#i61943# relative URLs need special handling
2220 0 : INetURLObject aTemp( mpImpl->msPackageURI );
2221 0 : bool bWasAbsolute = false;
2222 0 : sValue = aTemp.smartRel2Abs(sValue, bWasAbsolute ).GetMainURL(INetURLObject::DECODE_TO_IURI);
2223 : }
2224 : }
2225 0 : catch(const uno::Exception&)
2226 : {
2227 : }
2228 : }
2229 129 : if( xUriRef.is() )//no conversion for empty values or for fragments
2230 : {
2231 : //conversion for matching schemes only
2232 96 : if( xUriRef->getScheme() == mpImpl->msPackageURIScheme )
2233 : {
2234 186 : sValue = INetURLObject::GetRelURL( msOrigFileName, sValue,
2235 93 : INetURLObject::WAS_ENCODED, INetURLObject::DECODE_TO_IURI, RTL_TEXTENCODING_UTF8, INetURLObject::FSYS_DETECT);
2236 : }
2237 : }
2238 258 : return sValue;
2239 : }
2240 :
2241 62 : void SvXMLExport::StartElement(sal_uInt16 nPrefix,
2242 : enum ::xmloff::token::XMLTokenEnum eName,
2243 : bool bIgnWSOutside )
2244 : {
2245 62 : StartElement(_GetNamespaceMap().GetQNameByKey( nPrefix,
2246 124 : GetXMLToken(eName) ), bIgnWSOutside);
2247 62 : }
2248 :
2249 124109 : void SvXMLExport::StartElement(const OUString& rName,
2250 : bool bIgnWSOutside )
2251 : {
2252 124109 : if ((mnErrorFlags & SvXMLErrorFlags::DO_NOTHING) != SvXMLErrorFlags::DO_NOTHING)
2253 : {
2254 : try
2255 : {
2256 123909 : if( bIgnWSOutside && ((mnExportFlags & SvXMLExportFlags::PRETTY) == SvXMLExportFlags::PRETTY))
2257 0 : mxHandler->ignorableWhitespace( msWS );
2258 123909 : mxHandler->startElement( rName, GetXAttrList() );
2259 : }
2260 0 : catch (const SAXInvalidCharacterException& e)
2261 : {
2262 0 : Sequence<OUString> aPars(1);
2263 0 : aPars[0] = rName;
2264 0 : SetError( XMLERROR_SAX|XMLERROR_FLAG_WARNING, aPars, e.Message, NULL );
2265 : }
2266 0 : catch (const SAXException& e)
2267 : {
2268 0 : Sequence<OUString> aPars(1);
2269 0 : aPars[0] = rName;
2270 : SetError( XMLERROR_SAX|XMLERROR_FLAG_ERROR|XMLERROR_FLAG_SEVERE,
2271 0 : aPars, e.Message, NULL );
2272 : }
2273 : }
2274 124109 : ClearAttrList();
2275 124109 : ++mpImpl->mDepth; // increment nesting depth counter
2276 124109 : }
2277 :
2278 5317 : void SvXMLExport::Characters(const OUString& rChars)
2279 : {
2280 5317 : if ((mnErrorFlags & SvXMLErrorFlags::DO_NOTHING) != SvXMLErrorFlags::DO_NOTHING)
2281 : {
2282 : try
2283 : {
2284 5315 : mxHandler->characters(rChars);
2285 : }
2286 0 : catch (const SAXInvalidCharacterException& e)
2287 : {
2288 0 : Sequence<OUString> aPars(1);
2289 0 : aPars[0] = rChars;
2290 0 : SetError( XMLERROR_SAX|XMLERROR_FLAG_WARNING, aPars, e.Message, NULL );
2291 : }
2292 0 : catch (const SAXException& e)
2293 : {
2294 0 : Sequence<OUString> aPars(1);
2295 0 : aPars[0] = rChars;
2296 : SetError( XMLERROR_SAX|XMLERROR_FLAG_ERROR|XMLERROR_FLAG_SEVERE,
2297 0 : aPars, e.Message, NULL );
2298 : }
2299 : }
2300 5317 : }
2301 :
2302 62 : void SvXMLExport::EndElement(sal_uInt16 nPrefix,
2303 : enum ::xmloff::token::XMLTokenEnum eName,
2304 : bool bIgnWSInside )
2305 : {
2306 124 : EndElement(_GetNamespaceMap().GetQNameByKey( nPrefix, GetXMLToken(eName) ),
2307 186 : bIgnWSInside);
2308 62 : }
2309 :
2310 124109 : void SvXMLExport::EndElement(const OUString& rName,
2311 : bool bIgnWSInside )
2312 : {
2313 : // decrement nesting depth counter & (maybe) restore namespace map
2314 124109 : --mpImpl->mDepth;
2315 124126 : if (!mpImpl->mNamespaceMaps.empty() &&
2316 17 : (mpImpl->mNamespaceMaps.top().second == mpImpl->mDepth))
2317 : {
2318 17 : delete mpNamespaceMap;
2319 17 : mpNamespaceMap = mpImpl->mNamespaceMaps.top().first;
2320 17 : mpImpl->mNamespaceMaps.pop();
2321 : }
2322 : SAL_WARN_IF(!mpImpl->mNamespaceMaps.empty() &&
2323 : (mpImpl->mNamespaceMaps.top().second >= mpImpl->mDepth), "xmloff.core", "SvXMLExport: NamespaceMaps corrupted");
2324 :
2325 124109 : if ((mnErrorFlags & SvXMLErrorFlags::DO_NOTHING) != SvXMLErrorFlags::DO_NOTHING)
2326 : {
2327 : try
2328 : {
2329 123909 : if( bIgnWSInside && ((mnExportFlags & SvXMLExportFlags::PRETTY) == SvXMLExportFlags::PRETTY))
2330 0 : mxHandler->ignorableWhitespace( msWS );
2331 123909 : mxHandler->endElement( rName );
2332 : }
2333 0 : catch (const SAXException& e)
2334 : {
2335 0 : Sequence<OUString> aPars(1);
2336 0 : aPars[0] = rName;
2337 : SetError( XMLERROR_SAX|XMLERROR_FLAG_ERROR|XMLERROR_FLAG_SEVERE,
2338 0 : aPars, e.Message, NULL );
2339 : }
2340 : }
2341 124109 : }
2342 :
2343 1992 : void SvXMLExport::IgnorableWhitespace()
2344 : {
2345 1992 : if ((mnExportFlags & SvXMLExportFlags::PRETTY) != SvXMLExportFlags::PRETTY)
2346 3984 : return;
2347 :
2348 0 : if ((mnErrorFlags & SvXMLErrorFlags::DO_NOTHING) != SvXMLErrorFlags::DO_NOTHING)
2349 : {
2350 : try
2351 : {
2352 0 : mxHandler->ignorableWhitespace( msWS );
2353 : }
2354 0 : catch (const SAXException& e)
2355 : {
2356 0 : Sequence<OUString> aPars(0);
2357 : SetError( XMLERROR_SAX|XMLERROR_FLAG_ERROR|XMLERROR_FLAG_SEVERE,
2358 0 : aPars, e.Message, NULL );
2359 : }
2360 : }
2361 : }
2362 :
2363 1 : void SvXMLExport::SetError(
2364 : sal_Int32 nId,
2365 : const Sequence<OUString>& rMsgParams,
2366 : const OUString& rExceptionMessage,
2367 : const Reference<XLocator>& rLocator )
2368 : {
2369 : // allow multi-threaded access to the cancel() method
2370 1 : static osl::Mutex aMutex;
2371 1 : osl::MutexGuard aGuard(aMutex);
2372 :
2373 : // maintain error flags
2374 1 : if ( ( nId & XMLERROR_FLAG_ERROR ) != 0 )
2375 0 : mnErrorFlags |= SvXMLErrorFlags::ERROR_OCCURRED;
2376 1 : if ( ( nId & XMLERROR_FLAG_WARNING ) != 0 )
2377 0 : mnErrorFlags |= SvXMLErrorFlags::WARNING_OCCURRED;
2378 1 : if ( ( nId & XMLERROR_FLAG_SEVERE ) != 0 )
2379 1 : mnErrorFlags |= SvXMLErrorFlags::DO_NOTHING;
2380 :
2381 : // create error lsit on demand
2382 1 : if ( mpXMLErrors == NULL )
2383 1 : mpXMLErrors = new XMLErrors();
2384 :
2385 : // save error information
2386 1 : mpXMLErrors->AddRecord( nId, rMsgParams, rExceptionMessage, rLocator );
2387 1 : }
2388 :
2389 1 : void SvXMLExport::SetError(
2390 : sal_Int32 nId,
2391 : const Sequence<OUString>& rMsgParams)
2392 : {
2393 1 : OUString sEmpty;
2394 1 : SetError( nId, rMsgParams, sEmpty, NULL );
2395 1 : }
2396 :
2397 26 : void SvXMLExport::DisposingModel()
2398 : {
2399 26 : mxModel.clear();
2400 : // Shapes in Writer cannot be named via context menu (#i51726#)
2401 26 : meModelType = SvtModuleOptions::EFactory::UNKNOWN_FACTORY;
2402 26 : mxEventListener.clear();
2403 26 : }
2404 :
2405 :
2406 1429 : ::comphelper::UnoInterfaceToUniqueIdentifierMapper& SvXMLExport::getInterfaceToIdentifierMapper()
2407 : {
2408 1429 : return mpImpl->maInterfaceToIdentifierMapper;
2409 : }
2410 :
2411 : // Written OpenDocument file format doesn't fit to the created text document (#i69627#)
2412 1359 : bool SvXMLExport::writeOutlineStyleAsNormalListStyle() const
2413 : {
2414 1359 : return mpImpl->mbOutlineStyleAsNormalListStyle;
2415 : }
2416 :
2417 19 : uno::Reference< embed::XStorage > SvXMLExport::GetTargetStorage()
2418 : {
2419 19 : return mpImpl->mxTargetStorage;
2420 : }
2421 :
2422 : /// returns the currently configured default version for ODF export
2423 18403 : SvtSaveOptions::ODFDefaultVersion SvXMLExport::getDefaultVersion() const
2424 : {
2425 18403 : if( mpImpl )
2426 18403 : return mpImpl->maSaveOptions.GetODFDefaultVersion();
2427 :
2428 : // fatal error, use current version as default
2429 0 : return SvtSaveOptions::ODFVER_012;
2430 : }
2431 :
2432 5 : SvtSaveOptions::ODFSaneDefaultVersion SvXMLExport::getSaneDefaultVersion() const
2433 : {
2434 5 : if( mpImpl )
2435 5 : return mpImpl->maSaveOptions.GetODFSaneDefaultVersion();
2436 :
2437 : // fatal error, use current version as default
2438 0 : return SvtSaveOptions::ODFSVER_012;
2439 : }
2440 :
2441 56 : OUString SvXMLExport::GetStreamName() const
2442 : {
2443 56 : return mpImpl->mStreamName;
2444 : }
2445 :
2446 : void
2447 2 : SvXMLExport::AddAttributeIdLegacy(
2448 : sal_uInt16 const nLegacyPrefix, OUString const& rValue)
2449 : {
2450 2 : switch (getDefaultVersion()) {
2451 : case SvtSaveOptions::ODFVER_011: // fall through
2452 0 : case SvtSaveOptions::ODFVER_010: break;
2453 : default: // ODF 1.2: xml:id
2454 2 : AddAttribute(XML_NAMESPACE_XML, XML_ID, rValue);
2455 : }
2456 : // in ODF 1.1 this was form:id, anim:id, draw:id, or text:id
2457 : // backward compatibility: in ODF 1.2 write _both_ id attrs
2458 2 : AddAttribute(nLegacyPrefix, XML_ID, rValue);
2459 : // FIXME: this function simply assumes that rValue is unique
2460 2 : }
2461 :
2462 : void
2463 2263 : SvXMLExport::AddAttributeXmlId(uno::Reference<uno::XInterface> const & i_xIfc)
2464 : {
2465 : // check version >= 1.2
2466 2263 : switch (getDefaultVersion()) {
2467 : case SvtSaveOptions::ODFVER_011: // fall through
2468 2263 : case SvtSaveOptions::ODFVER_010: return;
2469 2263 : default: break;
2470 : }
2471 : const uno::Reference<rdf::XMetadatable> xMeta(i_xIfc,
2472 2263 : uno::UNO_QUERY);
2473 : //FIXME not yet...
2474 2263 : if ( xMeta.is() )
2475 : {
2476 2007 : const beans::StringPair mdref( xMeta->getMetadataReference() );
2477 2007 : if ( !mdref.Second.isEmpty() )
2478 : {
2479 56 : const OUString streamName( GetStreamName() );
2480 56 : if ( !streamName.isEmpty() )
2481 : {
2482 56 : if ( streamName.equals(mdref.First) )
2483 : {
2484 56 : AddAttribute( XML_NAMESPACE_XML, XML_ID, mdref.Second );
2485 : }
2486 : else
2487 : {
2488 : SAL_WARN("xmloff.core","SvXMLExport::AddAttributeXmlId: invalid stream name");
2489 : }
2490 : }
2491 : else
2492 : {
2493 : // FIXME: this is ugly
2494 : // there is no stream name (e.g. XSLT, flat-xml format)!
2495 : // but how do we ensure uniqueness in this case?
2496 : // a) just omit styles.xml ids -- they are unlikely anyway...
2497 : // b) somehow find out whether we are currently exporting styles
2498 : // or content, and prefix "s" or "c" => unique
2499 0 : if ( mdref.First == "content.xml" )
2500 : {
2501 0 : AddAttribute( XML_NAMESPACE_XML, XML_ID, mdref.Second );
2502 : }
2503 : else
2504 : {
2505 : SAL_INFO("xmloff.core", "SvXMLExport::AddAttributeXmlId: no stream name given: dropping styles.xml xml:id");
2506 : }
2507 56 : }
2508 2007 : }
2509 2263 : }
2510 : }
2511 :
2512 : void
2513 2215 : SvXMLExport::AddAttributesRDFa(
2514 : uno::Reference<text::XTextContent> const & i_xTextContent)
2515 : {
2516 : // check version >= 1.2
2517 2215 : switch (getDefaultVersion()) {
2518 : case SvtSaveOptions::ODFVER_011: // fall through
2519 2185 : case SvtSaveOptions::ODFVER_010: return;
2520 2215 : default: break;
2521 : }
2522 :
2523 : const uno::Reference<rdf::XMetadatable> xMeta(
2524 2215 : i_xTextContent, uno::UNO_QUERY);
2525 2215 : if (!xMeta.is() || xMeta->getMetadataReference().Second.isEmpty())
2526 : {
2527 2185 : return; // no xml:id => no RDFa
2528 : }
2529 :
2530 30 : if (!mpImpl->mpRDFaHelper.get())
2531 : {
2532 4 : mpImpl->mpRDFaHelper.reset( new ::xmloff::RDFaExportHelper(*this) );
2533 : }
2534 30 : mpImpl->mpRDFaHelper->AddRDFa(xMeta);
2535 : }
2536 :
2537 1367 : bool SvXMLExport::exportTextNumberElement() const
2538 : {
2539 1367 : return mpImpl->mbExportTextNumberElement;
2540 : }
2541 :
2542 0 : bool SvXMLExport::SetNullDateOnUnitConverter()
2543 : {
2544 : // if the null date has already been set, don't set it again (performance)
2545 0 : if (!mpImpl->mbNullDateInitialized)
2546 0 : mpImpl->mbNullDateInitialized = GetMM100UnitConverter().setNullDate(GetModel());
2547 :
2548 0 : return mpImpl->mbNullDateInitialized;
2549 : }
2550 :
2551 :
2552 :
2553 76267 : void SvXMLElementExport::StartElement(
2554 : const sal_uInt16 nPrefixKey,
2555 : const OUString& rLName,
2556 : const bool bIgnoreWhitespaceOutside )
2557 : {
2558 76267 : maElementName = mrExport.GetNamespaceMap().GetQNameByKey(nPrefixKey, rLName);
2559 76267 : mrExport.StartElement(maElementName, bIgnoreWhitespaceOutside);
2560 76267 : }
2561 :
2562 4 : SvXMLElementExport::SvXMLElementExport(
2563 : SvXMLExport& rExp,
2564 : sal_uInt16 nPrefixKey,
2565 : const sal_Char *pLName,
2566 : bool bIWSOutside,
2567 : bool bIWSInside )
2568 : : mrExport( rExp )
2569 : , maElementName()
2570 : , mbIgnoreWhitespaceInside( bIWSInside )
2571 4 : , mbDoSomething( true )
2572 : {
2573 4 : const OUString sLName( OUString::createFromAscii( pLName ) );
2574 4 : StartElement( nPrefixKey, sLName, bIWSOutside );
2575 4 : }
2576 :
2577 11049 : SvXMLElementExport::SvXMLElementExport(
2578 : SvXMLExport& rExp,
2579 : sal_uInt16 nPrefixKey,
2580 : const OUString& rLName,
2581 : bool bIWSOutside,
2582 : bool bIWSInside )
2583 : : mrExport( rExp )
2584 : , maElementName()
2585 : , mbIgnoreWhitespaceInside( bIWSInside )
2586 11049 : , mbDoSomething( true )
2587 : {
2588 11049 : StartElement( nPrefixKey, rLName, bIWSOutside );
2589 11049 : }
2590 :
2591 63744 : SvXMLElementExport::SvXMLElementExport(
2592 : SvXMLExport& rExp,
2593 : sal_uInt16 nPrefixKey,
2594 : enum XMLTokenEnum eLName,
2595 : bool bIWSOutside,
2596 : bool bIWSInside )
2597 : : mrExport( rExp )
2598 : , maElementName()
2599 : , mbIgnoreWhitespaceInside( bIWSInside )
2600 63744 : , mbDoSomething( true )
2601 : {
2602 63744 : StartElement( nPrefixKey, GetXMLToken(eLName), bIWSOutside );
2603 63744 : }
2604 :
2605 8797 : SvXMLElementExport::SvXMLElementExport(
2606 : SvXMLExport& rExp,
2607 : bool bDoSth,
2608 : sal_uInt16 nPrefixKey,
2609 : enum XMLTokenEnum eLName,
2610 : bool bIWSOutside,
2611 : bool bIWSInside )
2612 : : mrExport( rExp )
2613 : , maElementName()
2614 : , mbIgnoreWhitespaceInside( bIWSInside )
2615 8797 : , mbDoSomething( bDoSth )
2616 : {
2617 8797 : if ( mbDoSomething )
2618 1470 : StartElement( nPrefixKey, GetXMLToken( eLName ), bIWSOutside );
2619 8797 : }
2620 :
2621 1166 : SvXMLElementExport::SvXMLElementExport(
2622 : SvXMLExport& rExp,
2623 : const OUString& rQName,
2624 : bool bIWSOutside,
2625 : bool bIWSInside )
2626 : : mrExport( rExp )
2627 : , maElementName()
2628 : , mbIgnoreWhitespaceInside( bIWSInside )
2629 1166 : , mbDoSomething( true )
2630 : {
2631 1166 : maElementName = rQName;
2632 1166 : rExp.StartElement( rQName, bIWSOutside );
2633 1166 : }
2634 :
2635 169520 : SvXMLElementExport::~SvXMLElementExport()
2636 : {
2637 84760 : if ( mbDoSomething )
2638 : {
2639 77433 : mrExport.EndElement( maElementName, mbIgnoreWhitespaceInside );
2640 : }
2641 84760 : }
2642 :
2643 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
