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