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