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