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 23 24 // MARKER(update_precomp.py): autogen include statement, do not remove 25 #include "precompiled_xmloff.hxx" 26 #include <com/sun/star/beans/XPropertySetInfo.hpp> 27 #include <tools/debug.hxx> 28 #include <tools/urlobj.hxx> 29 #include <osl/mutex.hxx> 30 #include <rtl/uuid.h> 31 #include <rtl/memory.h> 32 #include <svl/svarray.hxx> 33 #include "unointerfacetouniqueidentifiermapper.hxx" 34 #include <xmloff/nmspmap.hxx> 35 #include <xmloff/xmluconv.hxx> 36 #include "xmloff/xmlnmspe.hxx" 37 #include <xmloff/xmltoken.hxx> 38 #include <xmloff/XMLFontStylesContext.hxx> 39 #include <xmloff/xmlictxt.hxx> 40 #include <xmloff/xmlimp.hxx> 41 #include <xmloff/xmlnumfi.hxx> 42 #include "XMLEventImportHelper.hxx" 43 #include "XMLStarBasicContextFactory.hxx" 44 #include "XMLScriptContextFactory.hxx" 45 #include "StyleMap.hxx" 46 #include <xmloff/ProgressBarHelper.hxx> 47 #include <xmloff/xmltoken.hxx> 48 #include "xmloff/xmlerror.hxx" 49 #include <com/sun/star/lang/XMultiServiceFactory.hpp> 50 #include <com/sun/star/lang/ServiceNotRegisteredException.hpp> 51 #include <com/sun/star/io/XOutputStream.hpp> 52 #include <com/sun/star/document/XBinaryStreamResolver.hpp> 53 #include <com/sun/star/document/XStorageBasedDocument.hpp> 54 #include <com/sun/star/xml/sax/XLocator.hpp> 55 #include <com/sun/star/packages/zip/ZipIOException.hpp> 56 #include <comphelper/namecontainer.hxx> 57 #include <rtl/logfile.hxx> 58 #include <tools/string.hxx> // used in StartElement for logging 59 #include <cppuhelper/implbase1.hxx> 60 #include <comphelper/extract.hxx> 61 #include <comphelper/processfactory.hxx> 62 #include <comphelper/documentconstants.hxx> 63 #include <comphelper/storagehelper.hxx> 64 #include <unotools/fontcvt.hxx> 65 66 #include <com/sun/star/rdf/XMetadatable.hpp> 67 #include <com/sun/star/rdf/XRepositorySupplier.hpp> 68 #include "RDFaImportHelper.hxx" 69 70 #define LOGFILE_AUTHOR "unknown" 71 72 using ::com::sun::star::beans::XPropertySetInfo; 73 74 using ::rtl::OUString; 75 using ::rtl::OUStringBuffer; 76 77 using namespace ::osl; 78 using namespace ::com::sun::star; 79 using namespace ::com::sun::star::frame; 80 using namespace ::com::sun::star::uno; 81 using namespace ::com::sun::star::util; 82 using namespace ::com::sun::star::io; 83 using namespace ::com::sun::star::container; 84 using namespace ::com::sun::star::document; 85 using namespace ::xmloff::token; 86 87 sal_Char __READONLY_DATA sXML_np__office[] = "_office"; 88 sal_Char __READONLY_DATA sXML_np__office_ext[] = "_office_ooo"; 89 sal_Char __READONLY_DATA sXML_np__ooo[] = "_ooo"; 90 sal_Char __READONLY_DATA sXML_np__ooow[] = "_ooow"; 91 sal_Char __READONLY_DATA sXML_np__oooc[] = "_oooc"; 92 sal_Char __READONLY_DATA sXML_np__of[] = "_of"; 93 sal_Char __READONLY_DATA sXML_np__style[] = "_style"; 94 sal_Char __READONLY_DATA sXML_np__text[] = "_text"; 95 sal_Char __READONLY_DATA sXML_np__text_ext[] = "_text_ooo"; 96 sal_Char __READONLY_DATA sXML_np__table[] = "_table"; 97 sal_Char __READONLY_DATA sXML_np__table_ext[] = "_table_ooo"; 98 sal_Char __READONLY_DATA sXML_np__draw[] = "_draw"; 99 sal_Char __READONLY_DATA sXML_np__draw_ext[] = "_draw_ooo"; 100 sal_Char __READONLY_DATA sXML_np__dr3d[] = "_dr3d"; 101 sal_Char __READONLY_DATA sXML_np__fo[] = "_fo"; 102 sal_Char __READONLY_DATA sXML_np__xlink[] = "_xlink"; 103 sal_Char __READONLY_DATA sXML_np__dc[] = "_dc"; 104 sal_Char __READONLY_DATA sXML_np__dom[] = "_dom"; 105 sal_Char __READONLY_DATA sXML_np__meta[] = "_meta"; 106 sal_Char __READONLY_DATA sXML_np__number[] = "_number"; 107 sal_Char __READONLY_DATA sXML_np__svg[] = "_svg"; 108 sal_Char __READONLY_DATA sXML_np__chart[] = "_chart"; 109 sal_Char __READONLY_DATA sXML_np__math[] = "_math"; 110 sal_Char __READONLY_DATA sXML_np__form[] = "_form"; 111 sal_Char __READONLY_DATA sXML_np__script[] = "_script"; 112 sal_Char __READONLY_DATA sXML_np__config[] = "_config"; 113 sal_Char __READONLY_DATA sXML_np__db[] = "_db"; 114 sal_Char __READONLY_DATA sXML_np__xforms[] = "_xforms"; 115 sal_Char __READONLY_DATA sXML_np__xsd[] = "_xsd"; 116 sal_Char __READONLY_DATA sXML_np__xsi[] = "_xsi"; 117 sal_Char __READONLY_DATA sXML_np__field[] = "_field"; 118 sal_Char __READONLY_DATA sXML_np__xhtml[] = "_xhtml"; 119 120 sal_Char __READONLY_DATA sXML_np__fo_old[] = "__fo"; 121 sal_Char __READONLY_DATA sXML_np__xlink_old[] = "__xlink"; 122 sal_Char __READONLY_DATA sXML_np__office_old[] = "__office"; 123 sal_Char __READONLY_DATA sXML_np__style_old[] = "__style"; 124 sal_Char __READONLY_DATA sXML_np__text_old[] = "__text"; 125 sal_Char __READONLY_DATA sXML_np__table_old[] = "__table"; 126 sal_Char __READONLY_DATA sXML_np__meta_old[] = "__meta"; 127 128 129 130 class SvXMLImportEventListener : public cppu::WeakImplHelper1< 131 com::sun::star::lang::XEventListener > 132 { 133 private: 134 SvXMLImport* pImport; 135 136 public: 137 SvXMLImportEventListener(SvXMLImport* pImport); 138 virtual ~SvXMLImportEventListener(); 139 140 // XEventListener 141 virtual void SAL_CALL disposing(const lang::EventObject& rEventObject) throw(::com::sun::star::uno::RuntimeException); 142 }; 143 144 SvXMLImportEventListener::SvXMLImportEventListener(SvXMLImport* pTempImport) 145 : pImport(pTempImport) 146 { 147 } 148 149 SvXMLImportEventListener::~SvXMLImportEventListener() 150 { 151 } 152 153 // XEventListener 154 void SAL_CALL SvXMLImportEventListener::disposing( const lang::EventObject& ) 155 throw(uno::RuntimeException) 156 { 157 if (pImport) 158 { 159 pImport->DisposingModel(); 160 pImport = NULL; 161 } 162 } 163 164 //============================================================================== 165 // --> ORW 166 namespace 167 { 168 class DocumentInfo 169 { 170 private: 171 sal_uInt16 mnGeneratorVersion; 172 173 public: 174 DocumentInfo( const SvXMLImport& rImport ) 175 : mnGeneratorVersion( SvXMLImport::ProductVersionUnknown ) 176 { 177 sal_Int32 nUPD, nBuild; 178 if ( rImport.getBuildIds( nUPD, nBuild ) ) 179 { 180 if ( nUPD >= 640 && nUPD <= 645 ) 181 { 182 mnGeneratorVersion = SvXMLImport::OOo_1x; 183 } 184 else if ( nUPD == 680 ) 185 { 186 mnGeneratorVersion = SvXMLImport::OOo_2x; 187 } 188 else if ( nUPD == 300 && nBuild <= 9379 ) 189 { 190 mnGeneratorVersion = SvXMLImport::OOo_30x; 191 } 192 else if ( nUPD == 310 ) 193 { 194 mnGeneratorVersion = SvXMLImport::OOo_31x; 195 } 196 else if ( nUPD == 320 ) 197 { 198 mnGeneratorVersion = SvXMLImport::OOo_32x; 199 } 200 else if ( nUPD == 330 ) 201 { 202 mnGeneratorVersion = SvXMLImport::OOo_33x; 203 } 204 else if ( nUPD == 340 ) 205 { 206 mnGeneratorVersion = SvXMLImport::OOo_34x; 207 } 208 } 209 } 210 211 ~DocumentInfo() 212 {} 213 214 sal_uInt16 getGeneratorVersion() const 215 { 216 return mnGeneratorVersion; 217 } 218 }; 219 } 220 // <-- 221 222 class SvXMLImport_Impl 223 { 224 public: 225 FontToSubsFontConverter hBatsFontConv; 226 FontToSubsFontConverter hMathFontConv; 227 228 bool mbOwnGraphicResolver; 229 bool mbOwnEmbeddedResolver; 230 INetURLObject aBaseURL; 231 INetURLObject aDocBase; 232 233 /// name of stream in package, e.g., "content.xml" 234 ::rtl::OUString mStreamName; 235 236 ::rtl::OUString aODFVersion; 237 238 // --> OD 2004-08-10 #i28749# - boolean, indicating that position attributes 239 // of shapes are given in horizontal left-to-right layout. This is the case 240 // for the OpenOffice.org file format. 241 sal_Bool mbShapePositionInHoriL2R; 242 // <-- 243 // --> OD 2007-12-19 #152540# 244 sal_Bool mbTextDocInOOoFileFormat; 245 // <-- 246 247 const uno::Reference< uno::XComponentContext > mxComponentContext; 248 249 std::auto_ptr< xmloff::RDFaImportHelper > mpRDFaHelper; 250 251 // --> ORW 252 std::auto_ptr< DocumentInfo > mpDocumentInfo; 253 // <-- 254 255 SvXMLImport_Impl() 256 : hBatsFontConv( 0 ) 257 , hMathFontConv( 0 ) 258 , mbOwnGraphicResolver( false ) 259 , mbOwnEmbeddedResolver( false ) 260 , mStreamName() 261 , mbShapePositionInHoriL2R( sal_False ) 262 , mbTextDocInOOoFileFormat( sal_False ) 263 , mxComponentContext( ::comphelper::getProcessComponentContext() ) 264 , mpRDFaHelper() // lazy 265 // --> ORW 266 , mpDocumentInfo() // lazy 267 // <-- 268 { 269 OSL_ENSURE(mxComponentContext.is(), "SvXMLImport: no ComponentContext"); 270 if (!mxComponentContext.is()) throw uno::RuntimeException(); 271 } 272 273 ~SvXMLImport_Impl() 274 { 275 if( hBatsFontConv ) 276 DestroyFontToSubsFontConverter( hBatsFontConv ); 277 if( hMathFontConv ) 278 DestroyFontToSubsFontConverter( hMathFontConv ); 279 } 280 281 // --> ORW 282 sal_uInt16 getGeneratorVersion( const SvXMLImport& rImport ) 283 { 284 if ( !mpDocumentInfo.get() ) 285 { 286 mpDocumentInfo.reset( new DocumentInfo( rImport ) ); 287 } 288 289 return mpDocumentInfo->getGeneratorVersion(); 290 } 291 // <-- 292 293 ::comphelper::UnoInterfaceToUniqueIdentifierMapper maInterfaceToIdentifierMapper; 294 }; 295 296 typedef SvXMLImportContext *SvXMLImportContextPtr; 297 SV_DECL_PTRARR( SvXMLImportContexts_Impl, SvXMLImportContextPtr, 20, 5 ) 298 SV_IMPL_PTRARR( SvXMLImportContexts_Impl, SvXMLImportContextPtr ) 299 300 SvXMLImportContext *SvXMLImport::CreateContext( sal_uInt16 nPrefix, 301 const OUString& rLocalName, 302 const uno::Reference< xml::sax::XAttributeList >& ) 303 { 304 return new SvXMLImportContext( *this, nPrefix, rLocalName ); 305 } 306 307 void SvXMLImport::_InitCtor() 308 { 309 if( mnImportFlags != 0 ) 310 { 311 // implicit "xml" namespace prefix 312 mpNamespaceMap->Add( GetXMLToken(XML_XML), GetXMLToken(XML_N_XML), XML_NAMESPACE_XML ); 313 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__office ) ), 314 GetXMLToken(XML_N_OFFICE), 315 XML_NAMESPACE_OFFICE ); 316 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__office_ext ) ), 317 GetXMLToken(XML_N_OFFICE_EXT), 318 XML_NAMESPACE_OFFICE_EXT ); 319 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__ooo ) ), GetXMLToken(XML_N_OOO), XML_NAMESPACE_OOO ); 320 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__style) ), 321 GetXMLToken(XML_N_STYLE), 322 XML_NAMESPACE_STYLE ); 323 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__text) ), 324 GetXMLToken(XML_N_TEXT), 325 XML_NAMESPACE_TEXT ); 326 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__text_ext ) ), 327 GetXMLToken(XML_N_TEXT_EXT), 328 XML_NAMESPACE_TEXT_EXT ); 329 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__table ) ), 330 GetXMLToken(XML_N_TABLE), 331 XML_NAMESPACE_TABLE ); 332 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__table_ext ) ), 333 GetXMLToken(XML_N_TABLE_EXT), 334 XML_NAMESPACE_TABLE_EXT ); 335 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__draw ) ), 336 GetXMLToken(XML_N_DRAW), 337 XML_NAMESPACE_DRAW ); 338 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__draw_ext ) ), 339 GetXMLToken(XML_N_DRAW_EXT), 340 XML_NAMESPACE_DRAW_EXT ); 341 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM (sXML_np__dr3d ) ), 342 GetXMLToken(XML_N_DR3D), 343 XML_NAMESPACE_DR3D ); 344 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__fo) ), 345 GetXMLToken(XML_N_FO_COMPAT), 346 XML_NAMESPACE_FO ); 347 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xlink) ), 348 GetXMLToken(XML_N_XLINK), 349 XML_NAMESPACE_XLINK ); 350 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__dc) ), 351 GetXMLToken(XML_N_DC), 352 XML_NAMESPACE_DC ); 353 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__dom ) ), 354 GetXMLToken(XML_N_DOM), 355 XML_NAMESPACE_DOM ); 356 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__meta) ), 357 GetXMLToken(XML_N_META), 358 XML_NAMESPACE_META ); 359 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__number) ), 360 GetXMLToken(XML_N_NUMBER), 361 XML_NAMESPACE_NUMBER ); 362 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__svg) ), 363 GetXMLToken(XML_N_SVG_COMPAT), 364 XML_NAMESPACE_SVG ); 365 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__chart) ), 366 GetXMLToken(XML_N_CHART), 367 XML_NAMESPACE_CHART ); 368 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__math) ), 369 GetXMLToken(XML_N_MATH), 370 XML_NAMESPACE_MATH ); 371 mpNamespaceMap->Add(OUString(RTL_CONSTASCII_USTRINGPARAM( sXML_np__form )), 372 GetXMLToken(XML_N_FORM), 373 XML_NAMESPACE_FORM ); 374 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__script) ), 375 GetXMLToken(XML_N_SCRIPT), 376 XML_NAMESPACE_SCRIPT ); 377 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__config) ), 378 GetXMLToken(XML_N_CONFIG), 379 XML_NAMESPACE_CONFIG ); 380 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xforms) ), 381 GetXMLToken(XML_N_XFORMS_1_0), 382 XML_NAMESPACE_XFORMS ); 383 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xsd) ), 384 GetXMLToken(XML_N_XSD), 385 XML_NAMESPACE_XSD ); 386 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xsi) ), 387 GetXMLToken(XML_N_XSI), 388 XML_NAMESPACE_XFORMS ); 389 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__ooow ) ), GetXMLToken(XML_N_OOOW), XML_NAMESPACE_OOOW ); 390 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__oooc ) ), GetXMLToken(XML_N_OOOC), XML_NAMESPACE_OOOC ); 391 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__field ) ), GetXMLToken(XML_N_FIELD), XML_NAMESPACE_FIELD ); 392 mpNamespaceMap->Add( OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__of ) ), 393 GetXMLToken(XML_N_OF), XML_NAMESPACE_OF ); 394 mpNamespaceMap->Add( 395 OUString( RTL_CONSTASCII_USTRINGPARAM ( sXML_np__xhtml ) ), 396 GetXMLToken(XML_N_XHTML), XML_NAMESPACE_XHTML ); 397 } 398 399 msPackageProtocol = OUString( RTL_CONSTASCII_USTRINGPARAM( "vnd.sun.star.Package:" ) ); 400 401 if (mxNumberFormatsSupplier.is()) 402 mpNumImport = new SvXMLNumFmtHelper(mxNumberFormatsSupplier, getServiceFactory()); 403 404 if (mxModel.is() && !mxEventListener.is()) 405 { 406 mxEventListener.set(new SvXMLImportEventListener(this)); 407 mxModel->addEventListener(mxEventListener); 408 } 409 410 ::comphelper::UnoInterfaceToUniqueIdentifierMapper maInterfaceToIdentifierMapper; 411 412 } 413 414 // #110680# 415 SvXMLImport::SvXMLImport( 416 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory, 417 sal_uInt16 nImportFlags ) throw () 418 : mpImpl( new SvXMLImport_Impl() ), 419 mpNamespaceMap( new SvXMLNamespaceMap ), 420 421 // #110680# 422 // pUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM ) ), 423 mpUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM, xServiceFactory ) ), 424 425 mpContexts( new SvXMLImportContexts_Impl ), 426 mpNumImport( NULL ), 427 mpProgressBarHelper( NULL ), 428 mpEventImportHelper( NULL ), 429 mpXMLErrors( NULL ), 430 mpStyleMap(0), 431 mnImportFlags( nImportFlags ), 432 mnErrorFlags(0), 433 // #110680# 434 mxServiceFactory(xServiceFactory), 435 mbIsFormsSupported( sal_True ), 436 mbIsTableShapeSupported( false ), 437 mbIsGraphicLoadOnDemandSupported( true ) 438 { 439 DBG_ASSERT( mxServiceFactory.is(), "got no service manager" ); 440 _InitCtor(); 441 } 442 443 // #110680# 444 SvXMLImport::SvXMLImport( 445 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory, 446 const Reference< XModel > & rModel ) throw () 447 : mxModel( rModel ), 448 mxNumberFormatsSupplier (rModel, uno::UNO_QUERY), 449 mpImpl( new SvXMLImport_Impl() ), 450 mpNamespaceMap( new SvXMLNamespaceMap ), 451 // #110680# 452 // pUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM ) ), 453 mpUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM, xServiceFactory ) ), 454 mpContexts( new SvXMLImportContexts_Impl ), 455 mpNumImport( NULL ), 456 mpProgressBarHelper( NULL ), 457 mpEventImportHelper( NULL ), 458 mpXMLErrors( NULL ), 459 mpStyleMap(0), 460 mnImportFlags( IMPORT_ALL ), 461 mnErrorFlags(0), 462 // #110680# 463 mxServiceFactory(xServiceFactory), 464 mbIsFormsSupported( sal_True ), 465 mbIsTableShapeSupported( false ), 466 mbIsGraphicLoadOnDemandSupported( true ) 467 { 468 DBG_ASSERT( mxServiceFactory.is(), "got no service manager" ); 469 _InitCtor(); 470 } 471 472 // #110680# 473 SvXMLImport::SvXMLImport( 474 const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory >& xServiceFactory, 475 const Reference< XModel > & rModel, 476 const ::com::sun::star::uno::Reference< ::com::sun::star::document::XGraphicObjectResolver > & rGraphicObjects ) throw () 477 : mxModel( rModel ), 478 mxNumberFormatsSupplier (rModel, uno::UNO_QUERY), 479 mxGraphicResolver( rGraphicObjects ), 480 mpImpl( new SvXMLImport_Impl() ), 481 mpNamespaceMap( new SvXMLNamespaceMap ), 482 // #110680# 483 // pUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM ) ), 484 mpUnitConv( new SvXMLUnitConverter( MAP_100TH_MM, MAP_100TH_MM, xServiceFactory ) ), 485 mpContexts( new SvXMLImportContexts_Impl ), 486 mpNumImport( NULL ), 487 mpProgressBarHelper( NULL ), 488 mpEventImportHelper( NULL ), 489 mpXMLErrors( NULL ), 490 mpStyleMap(0), 491 mnImportFlags( IMPORT_ALL ), 492 mnErrorFlags(0), 493 // #110680# 494 mxServiceFactory(xServiceFactory), 495 mbIsFormsSupported( sal_True ), 496 mbIsGraphicLoadOnDemandSupported( true ) 497 { 498 DBG_ASSERT( mxServiceFactory.is(), "got no service manager" ); 499 _InitCtor(); 500 } 501 502 SvXMLImport::~SvXMLImport() throw () 503 { 504 delete mpXMLErrors; 505 delete mpNamespaceMap; 506 delete mpUnitConv; 507 delete mpEventImportHelper; 508 if( mpContexts ) 509 { 510 while( mpContexts->Count() ) 511 { 512 sal_uInt16 n = mpContexts->Count() - 1; 513 SvXMLImportContext *pContext = (*mpContexts)[n]; 514 mpContexts->Remove( n, 1 ); 515 if( pContext ) 516 pContext->ReleaseRef(); 517 } 518 delete mpContexts; 519 } 520 521 // delete pImageMapImportHelper; 522 523 // #i9518# the import component might not be deleted until after the document has been closed, 524 // so the stuff that accesses the document has been moved to endDocument. 525 526 // pNumImport is allocated in the ctor, so it must also be deleted here in case the component 527 // is created and deleted without actually importing. 528 delete mpNumImport; 529 delete mpProgressBarHelper; 530 531 xmloff::token::ResetTokens(); 532 533 if( mpImpl ) 534 delete mpImpl; 535 536 if (mxEventListener.is() && mxModel.is()) 537 mxModel->removeEventListener(mxEventListener); 538 } 539 540 // XUnoTunnel & co 541 const uno::Sequence< sal_Int8 > & SvXMLImport::getUnoTunnelId() throw() 542 { 543 static uno::Sequence< sal_Int8 > * pSeq = 0; 544 if( !pSeq ) 545 { 546 Guard< Mutex > aGuard( Mutex::getGlobalMutex() ); 547 if( !pSeq ) 548 { 549 static uno::Sequence< sal_Int8 > aSeq( 16 ); 550 rtl_createUuid( (sal_uInt8*)aSeq.getArray(), 0, sal_True ); 551 pSeq = &aSeq; 552 } 553 } 554 return *pSeq; 555 } 556 557 SvXMLImport* SvXMLImport::getImplementation( uno::Reference< uno::XInterface > xInt ) throw() 558 { 559 uno::Reference< lang::XUnoTunnel > xUT( xInt, uno::UNO_QUERY ); 560 if( xUT.is() ) 561 { 562 return 563 reinterpret_cast<SvXMLImport*>( 564 sal::static_int_cast<sal_IntPtr>( 565 xUT->getSomething( SvXMLImport::getUnoTunnelId()))); 566 } 567 else 568 return NULL; 569 } 570 571 // XUnoTunnel 572 sal_Int64 SAL_CALL SvXMLImport::getSomething( const uno::Sequence< sal_Int8 >& rId ) 573 throw( uno::RuntimeException ) 574 { 575 if( rId.getLength() == 16 && 0 == rtl_compareMemory( getUnoTunnelId().getConstArray(), 576 rId.getConstArray(), 16 ) ) 577 { 578 return sal::static_int_cast<sal_Int64>(reinterpret_cast<sal_uIntPtr>(this)); 579 } 580 return 0; 581 } 582 583 void SAL_CALL SvXMLImport::startDocument( void ) 584 throw( xml::sax::SAXException, uno::RuntimeException ) 585 { 586 RTL_LOGFILE_TRACE_AUTHOR( "xmloff", LOGFILE_AUTHOR, "{ SvXMLImport::startDocument" ); 587 588 if( !mxGraphicResolver.is() || !mxEmbeddedResolver.is() ) 589 { 590 Reference< lang::XMultiServiceFactory > xFactory( mxModel, UNO_QUERY ); 591 if( xFactory.is() ) 592 { 593 try 594 { 595 if( !mxGraphicResolver.is() ) 596 { 597 mxGraphicResolver = Reference< XGraphicObjectResolver >::query( 598 xFactory->createInstance( 599 OUString(RTL_CONSTASCII_USTRINGPARAM( 600 // #99870# Import... instead of Export... 601 "com.sun.star.document.ImportGraphicObjectResolver")))); 602 mpImpl->mbOwnGraphicResolver = mxGraphicResolver.is(); 603 } 604 605 if( !mxEmbeddedResolver.is() ) 606 { 607 mxEmbeddedResolver = Reference< XEmbeddedObjectResolver >::query( 608 xFactory->createInstance( 609 OUString(RTL_CONSTASCII_USTRINGPARAM( 610 // #99870# Import... instead of Export... 611 "com.sun.star.document.ImportEmbeddedObjectResolver")))); 612 mpImpl->mbOwnEmbeddedResolver = mxEmbeddedResolver.is(); 613 } 614 } 615 catch( com::sun::star::uno::Exception& ) 616 { 617 } 618 } 619 } 620 } 621 622 void SAL_CALL SvXMLImport::endDocument( void ) 623 throw( xml::sax::SAXException, uno::RuntimeException) 624 { 625 RTL_LOGFILE_TRACE_AUTHOR( "xmloff", LOGFILE_AUTHOR, "} SvXMLImport::startDocument" ); 626 627 // #i9518# All the stuff that accesses the document has to be done here, not in the dtor, 628 // because the SvXMLImport dtor might not be called until after the document has been closed. 629 630 if (mpImpl->mpRDFaHelper.get()) 631 { 632 const uno::Reference<rdf::XRepositorySupplier> xRS(mxModel, 633 uno::UNO_QUERY); 634 if (xRS.is()) 635 { 636 mpImpl->mpRDFaHelper->InsertRDFa( xRS ); 637 } 638 } 639 640 if (mpNumImport) 641 { 642 delete mpNumImport; 643 mpNumImport = NULL; 644 } 645 if (mxImportInfo.is()) 646 { 647 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo(); 648 if (xPropertySetInfo.is()) 649 { 650 if (mpProgressBarHelper) 651 { 652 OUString sProgressMax(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSMAX)); 653 OUString sProgressCurrent(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSCURRENT)); 654 OUString sRepeat(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSREPEAT)); 655 if (xPropertySetInfo->hasPropertyByName(sProgressMax) && 656 xPropertySetInfo->hasPropertyByName(sProgressCurrent)) 657 { 658 sal_Int32 nProgressMax(mpProgressBarHelper->GetReference()); 659 sal_Int32 nProgressCurrent(mpProgressBarHelper->GetValue()); 660 uno::Any aAny; 661 aAny <<= nProgressMax; 662 mxImportInfo->setPropertyValue(sProgressMax, aAny); 663 aAny <<= nProgressCurrent; 664 mxImportInfo->setPropertyValue(sProgressCurrent, aAny); 665 } 666 if (xPropertySetInfo->hasPropertyByName(sRepeat)) 667 mxImportInfo->setPropertyValue(sRepeat, cppu::bool2any(mpProgressBarHelper->GetRepeat())); 668 // pProgressBarHelper is deleted in dtor 669 } 670 OUString sNumberStyles(RTL_CONSTASCII_USTRINGPARAM(XML_NUMBERSTYLES)); 671 if (mxNumberStyles.is() && xPropertySetInfo->hasPropertyByName(sNumberStyles)) 672 { 673 uno::Any aAny; 674 aAny <<= mxNumberStyles; 675 mxImportInfo->setPropertyValue(sNumberStyles, aAny); 676 } 677 } 678 } 679 680 if( mxFontDecls.Is() ) 681 ((SvXMLStylesContext *)&mxFontDecls)->Clear(); 682 if( mxStyles.Is() ) 683 ((SvXMLStylesContext *)&mxStyles)->Clear(); 684 if( mxAutoStyles.Is() ) 685 ((SvXMLStylesContext *)&mxAutoStyles)->Clear(); 686 if( mxMasterStyles.Is() ) 687 ((SvXMLStylesContext *)&mxMasterStyles)->Clear(); 688 689 // possible form-layer related knittings which can only be done when 690 // the whole document exists 691 if ( mxFormImport.is() ) 692 mxFormImport->documentDone(); 693 694 // The shape import helper does the z-order sorting in the dtor, 695 // so it must be deleted here, too. 696 mxShapeImport = NULL; 697 698 if( mpImpl->mbOwnGraphicResolver ) 699 { 700 Reference< lang::XComponent > xComp( mxGraphicResolver, UNO_QUERY ); 701 xComp->dispose(); 702 } 703 704 if( mpImpl->mbOwnEmbeddedResolver ) 705 { 706 Reference< lang::XComponent > xComp( mxEmbeddedResolver, UNO_QUERY ); 707 xComp->dispose(); 708 } 709 if( mpStyleMap ) 710 { 711 mpStyleMap->release(); 712 mpStyleMap = 0; 713 } 714 715 if ( mpXMLErrors != NULL ) 716 { 717 mpXMLErrors->ThrowErrorAsSAXException( XMLERROR_FLAG_SEVERE ); 718 } 719 } 720 721 void SAL_CALL SvXMLImport::startElement( const OUString& rName, 722 const uno::Reference< xml::sax::XAttributeList >& xAttrList ) 723 throw(xml::sax::SAXException, uno::RuntimeException) 724 { 725 SvXMLNamespaceMap *pRewindMap = 0; 726 727 // Process namespace attributes. This must happen before creating the 728 // context, because namespace decaration apply to the element name itself. 729 sal_Int16 nAttrCount = xAttrList.is() ? xAttrList->getLength() : 0; 730 for( sal_Int16 i=0; i < nAttrCount; i++ ) 731 { 732 const OUString& rAttrName = xAttrList->getNameByIndex( i ); 733 if ( rAttrName.equalsAscii("office:version") ) 734 { 735 mpImpl->aODFVersion = xAttrList->getValueByIndex( i ); 736 737 // the ODF version in content.xml and manifest.xml must be the same starting from ODF1.2 738 if ( mpImpl->mStreamName.equals( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "content.xml" ) ) ) 739 && !IsODFVersionConsistent( mpImpl->aODFVersion ) ) 740 { 741 throw xml::sax::SAXException( 742 ::rtl::OUString( 743 RTL_CONSTASCII_USTRINGPARAM( "Inconsistent ODF versions in content.xml and manifest.xml!" ) ), 744 uno::Reference< uno::XInterface >(), 745 uno::makeAny( 746 packages::zip::ZipIOException( 747 ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( 748 "Inconsistent ODF versions in content.xml and manifest.xml!" ) ), 749 Reference< XInterface >() ) ) ); 750 } 751 } 752 else if( ( rAttrName.getLength() >= 5 ) && 753 ( rAttrName.compareTo( GetXMLToken(XML_XMLNS), 5 ) == 0 ) && 754 ( rAttrName.getLength() == 5 || ':' == rAttrName[5] ) ) 755 { 756 if( !pRewindMap ) 757 { 758 pRewindMap = mpNamespaceMap; 759 mpNamespaceMap = new SvXMLNamespaceMap( *mpNamespaceMap ); 760 } 761 const OUString& rAttrValue = xAttrList->getValueByIndex( i ); 762 763 OUString aPrefix( ( rAttrName.getLength() == 5 ) 764 ? OUString() 765 : rAttrName.copy( 6 ) ); 766 // Add namespace, but only if it is known. 767 sal_uInt16 nKey = mpNamespaceMap->AddIfKnown( aPrefix, rAttrValue ); 768 // If namespace is unknwon, try to match a name with similar 769 // TC Id an version 770 if( XML_NAMESPACE_UNKNOWN == nKey ) 771 { 772 OUString aTestName( rAttrValue ); 773 if( SvXMLNamespaceMap::NormalizeURI( aTestName ) ) 774 nKey = mpNamespaceMap->AddIfKnown( aPrefix, aTestName ); 775 } 776 // If that namespace is not known, too, add it as unknown 777 if( XML_NAMESPACE_UNKNOWN == nKey ) 778 mpNamespaceMap->Add( aPrefix, rAttrValue ); 779 780 } 781 } 782 783 // Get element's namespace and local name. 784 OUString aLocalName; 785 sal_uInt16 nPrefix = 786 mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName ); 787 788 // If there are contexts already, call a CreateChildContext at the topmost 789 // context. Otherwise, create a default context. 790 SvXMLImportContext *pContext; 791 sal_uInt16 nCount = mpContexts->Count(); 792 if( nCount > 0 ) 793 { 794 pContext = (*mpContexts)[nCount - 1]->CreateChildContext( nPrefix, 795 aLocalName, 796 xAttrList ); 797 DBG_ASSERT( pContext && pContext->GetPrefix() == nPrefix, 798 "SvXMLImport::startElement: created context has wrong prefix" ); 799 } 800 else 801 { 802 #ifdef TIMELOG 803 // If we do profiling, we want a trace message for the first element 804 // in order to identify the stream. 805 ByteString aString( (String)rName, RTL_TEXTENCODING_ASCII_US ); 806 RTL_LOGFILE_TRACE_AUTHOR1( "xmloff", LOGFILE_AUTHOR, 807 "SvXMLImport::StartElement( \"%s\", ... )", 808 aString.GetBuffer() ); 809 #endif 810 811 pContext = CreateContext( nPrefix, aLocalName, xAttrList ); 812 if( (nPrefix & XML_NAMESPACE_UNKNOWN_FLAG) != 0 && 813 IS_TYPE( SvXMLImportContext, pContext ) ) 814 { 815 OUString aMsg( RTL_CONSTASCII_USTRINGPARAM( "Root element unknown" ) ); 816 Reference<xml::sax::XLocator> xDummyLocator; 817 Sequence < OUString > aParams(1); 818 aParams.getArray()[0] = rName; 819 820 SetError( XMLERROR_FLAG_SEVERE|XMLERROR_UNKNWON_ROOT, 821 aParams, aMsg, xDummyLocator ); 822 } 823 } 824 825 DBG_ASSERT( pContext, "SvXMLImport::startElement: missing context" ); 826 if( !pContext ) 827 pContext = new SvXMLImportContext( *this, nPrefix, aLocalName ); 828 829 pContext->AddRef(); 830 831 // Remeber old namespace map. 832 if( pRewindMap ) 833 pContext->SetRewindMap( pRewindMap ); 834 835 // Call a startElement at the new context. 836 pContext->StartElement( xAttrList ); 837 838 // Push context on stack. 839 mpContexts->Insert( pContext, nCount ); 840 } 841 842 void SAL_CALL SvXMLImport::endElement( const OUString& 843 #ifdef DBG_UTIL 844 rName 845 #endif 846 ) 847 throw(xml::sax::SAXException, uno::RuntimeException) 848 { 849 sal_uInt16 nCount = mpContexts->Count(); 850 DBG_ASSERT( nCount, "SvXMLImport::endElement: no context left" ); 851 if( nCount > 0 ) 852 { 853 // Get topmost context and remove it from the stack. 854 SvXMLImportContext *pContext = (*mpContexts)[nCount-1]; 855 mpContexts->Remove( nCount-1, 1 ); 856 857 #ifdef DBG_UTIL 858 // Non product only: check if endElement call matches startELement call. 859 OUString aLocalName; 860 sal_uInt16 nPrefix = 861 mpNamespaceMap->GetKeyByAttrName( rName, &aLocalName ); 862 DBG_ASSERT( pContext->GetPrefix() == nPrefix, 863 "SvXMLImport::endElement: popped context has wrong prefix" ); 864 DBG_ASSERT( pContext->GetLocalName() == aLocalName, 865 "SvXMLImport::endElement: popped context has wrong lname" ); 866 #endif 867 868 // Call a EndElement at the current context. 869 pContext->EndElement(); 870 871 // Get a namespace map to rewind. 872 SvXMLNamespaceMap *pRewindMap = pContext->GetRewindMap(); 873 874 // Delete the current context. 875 pContext->ReleaseRef(); 876 pContext = 0; 877 878 // Rewind a namespace map. 879 if( pRewindMap ) 880 { 881 delete mpNamespaceMap; 882 mpNamespaceMap = pRewindMap; 883 } 884 } 885 } 886 887 void SAL_CALL SvXMLImport::characters( const OUString& rChars ) 888 throw(xml::sax::SAXException, uno::RuntimeException) 889 { 890 sal_uInt16 nCount = mpContexts->Count(); 891 if( nCount > 0 ) 892 { 893 (*mpContexts)[nCount - 1]->Characters( rChars ); 894 } 895 } 896 897 void SAL_CALL SvXMLImport::ignorableWhitespace( const OUString& ) 898 throw(xml::sax::SAXException, uno::RuntimeException) 899 { 900 } 901 902 void SAL_CALL SvXMLImport::processingInstruction( const OUString&, 903 const OUString& ) 904 throw(xml::sax::SAXException, uno::RuntimeException) 905 { 906 } 907 908 void SAL_CALL SvXMLImport::setDocumentLocator( const uno::Reference< xml::sax::XLocator >& rLocator ) 909 throw(xml::sax::SAXException, uno::RuntimeException) 910 { 911 mxLocator = rLocator; 912 } 913 914 // XExtendedDocumentHandler 915 void SAL_CALL SvXMLImport::startCDATA( void ) throw(xml::sax::SAXException, uno::RuntimeException) 916 { 917 } 918 919 void SAL_CALL SvXMLImport::endCDATA( void ) throw(uno::RuntimeException) 920 { 921 } 922 923 void SAL_CALL SvXMLImport::comment( const OUString& ) 924 throw(xml::sax::SAXException, uno::RuntimeException) 925 { 926 } 927 928 void SAL_CALL SvXMLImport::allowLineBreak( void ) 929 throw(xml::sax::SAXException, uno::RuntimeException) 930 { 931 } 932 933 void SAL_CALL SvXMLImport::unknown( const OUString& ) 934 throw(xml::sax::SAXException, uno::RuntimeException) 935 { 936 } 937 938 void SvXMLImport::SetStatistics(const uno::Sequence< beans::NamedValue> &) 939 { 940 GetProgressBarHelper()->SetRepeat(sal_False); 941 GetProgressBarHelper()->SetReference(0); 942 } 943 944 /////////////////////////////////////////////////////////////////////// 945 946 // XImporter 947 void SAL_CALL SvXMLImport::setTargetDocument( const uno::Reference< lang::XComponent >& xDoc ) 948 throw(lang::IllegalArgumentException, uno::RuntimeException) 949 { 950 mxModel = uno::Reference< frame::XModel >::query( xDoc ); 951 if( !mxModel.is() ) 952 throw lang::IllegalArgumentException(); 953 if (mxModel.is() && !mxEventListener.is()) 954 { 955 mxEventListener.set(new SvXMLImportEventListener(this)); 956 mxModel->addEventListener(mxEventListener); 957 } 958 959 DBG_ASSERT( !mpNumImport, "number format import already exists." ); 960 if( mpNumImport ) 961 { 962 delete mpNumImport; 963 mpNumImport = 0; 964 } 965 } 966 967 // XFilter 968 sal_Bool SAL_CALL SvXMLImport::filter( const uno::Sequence< beans::PropertyValue >& ) 969 throw (uno::RuntimeException) 970 { 971 return sal_False; 972 } 973 974 void SAL_CALL SvXMLImport::cancel( ) 975 throw (uno::RuntimeException) 976 { 977 } 978 979 // XInitialize 980 void SAL_CALL SvXMLImport::initialize( const uno::Sequence< uno::Any >& aArguments ) 981 throw(::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException) 982 { 983 const sal_Int32 nAnyCount = aArguments.getLength(); 984 const uno::Any* pAny = aArguments.getConstArray(); 985 986 for( sal_Int32 nIndex = 0; nIndex < nAnyCount; nIndex++, pAny++ ) 987 { 988 Reference<XInterface> xValue; 989 *pAny >>= xValue; 990 991 uno::Reference<task::XStatusIndicator> xTmpStatusIndicator( 992 xValue, UNO_QUERY ); 993 if( xTmpStatusIndicator.is() ) 994 mxStatusIndicator = xTmpStatusIndicator; 995 996 uno::Reference<document::XGraphicObjectResolver> xTmpGraphicResolver( 997 xValue, UNO_QUERY ); 998 if( xTmpGraphicResolver.is() ) 999 mxGraphicResolver = xTmpGraphicResolver; 1000 1001 uno::Reference<document::XEmbeddedObjectResolver> xTmpObjectResolver( 1002 xValue, UNO_QUERY ); 1003 if( xTmpObjectResolver.is() ) 1004 mxEmbeddedResolver = xTmpObjectResolver; 1005 1006 uno::Reference<beans::XPropertySet> xTmpPropSet( xValue, UNO_QUERY ); 1007 if( xTmpPropSet.is() ) 1008 { 1009 mxImportInfo = xTmpPropSet; 1010 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo(); 1011 if (xPropertySetInfo.is()) 1012 { 1013 OUString sPropName(RTL_CONSTASCII_USTRINGPARAM(XML_NUMBERSTYLES)); 1014 if (xPropertySetInfo->hasPropertyByName(sPropName)) 1015 { 1016 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName); 1017 aAny >>= mxNumberStyles; 1018 } 1019 1020 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("PrivateData" ) ); 1021 if (xPropertySetInfo->hasPropertyByName(sPropName)) 1022 { 1023 Reference < XInterface > xIfc; 1024 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName); 1025 aAny >>= xIfc; 1026 1027 StyleMap *pSMap = StyleMap::getImplementation( xIfc ); 1028 if( pSMap ) 1029 { 1030 mpStyleMap = pSMap; 1031 mpStyleMap->acquire(); 1032 } 1033 } 1034 OUString sBaseURI; 1035 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("BaseURI" ) ); 1036 if (xPropertySetInfo->hasPropertyByName(sPropName)) 1037 { 1038 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName); 1039 aAny >>= sBaseURI; 1040 mpImpl->aBaseURL.SetURL( sBaseURI ); 1041 mpImpl->aDocBase.SetURL( sBaseURI ); 1042 } 1043 OUString sRelPath; 1044 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("StreamRelPath" ) ); 1045 if( xPropertySetInfo->hasPropertyByName(sPropName) ) 1046 { 1047 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName); 1048 aAny >>= sRelPath; 1049 } 1050 OUString sName; 1051 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("StreamName" ) ); 1052 if( xPropertySetInfo->hasPropertyByName(sPropName) ) 1053 { 1054 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName); 1055 aAny >>= sName; 1056 } 1057 if( sBaseURI.getLength() && sName.getLength() ) 1058 { 1059 if( sRelPath.getLength() ) 1060 mpImpl->aBaseURL.insertName( sRelPath ); 1061 mpImpl->aBaseURL.insertName( sName ); 1062 } 1063 mpImpl->mStreamName = sName; // Note: may be empty (XSLT) 1064 // --> OD 2004-08-10 #i28749# - retrieve property <ShapePositionInHoriL2R> 1065 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("ShapePositionInHoriL2R" ) ); 1066 if( xPropertySetInfo->hasPropertyByName(sPropName) ) 1067 { 1068 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName); 1069 aAny >>= (mpImpl->mbShapePositionInHoriL2R); 1070 } 1071 // <-- 1072 // --> OD 2007-12-19 #152540# 1073 sPropName = OUString( RTL_CONSTASCII_USTRINGPARAM("TextDocInOOoFileFormat" ) ); 1074 if( xPropertySetInfo->hasPropertyByName(sPropName) ) 1075 { 1076 uno::Any aAny = mxImportInfo->getPropertyValue(sPropName); 1077 aAny >>= (mpImpl->mbTextDocInOOoFileFormat); 1078 } 1079 // <-- 1080 } 1081 } 1082 } 1083 } 1084 1085 // XServiceInfo 1086 OUString SAL_CALL SvXMLImport::getImplementationName() 1087 throw(uno::RuntimeException) 1088 { 1089 OUString aStr; 1090 return aStr; 1091 } 1092 1093 sal_Bool SAL_CALL SvXMLImport::supportsService( const OUString& rServiceName ) 1094 throw(::com::sun::star::uno::RuntimeException) 1095 { 1096 return 1097 rServiceName.equalsAsciiL( 1098 "com.sun.star.document.ImportFilter", 1099 sizeof("com.sun.star.document.ImportFilter")-1 ) || 1100 rServiceName.equalsAsciiL( 1101 "com.sun.star.xml.XMLImportFilter", 1102 sizeof("com.sun.star.xml.XMLImportFilter")-1); 1103 } 1104 1105 uno::Sequence< OUString > SAL_CALL SvXMLImport::getSupportedServiceNames( ) 1106 throw(uno::RuntimeException) 1107 { 1108 uno::Sequence<OUString> aSeq(2); 1109 aSeq[0] = OUString( 1110 RTL_CONSTASCII_USTRINGPARAM("com.sun.star.document.ImportFilter")); 1111 aSeq[1] = OUString( 1112 RTL_CONSTASCII_USTRINGPARAM("com.sun.star.xml.XMLImportFilter")); 1113 return aSeq; 1114 } 1115 1116 /////////////////////////////////////////////////////////////////////// 1117 1118 XMLTextImportHelper* SvXMLImport::CreateTextImport() 1119 { 1120 return new XMLTextImportHelper( mxModel, *this ); 1121 } 1122 1123 XMLShapeImportHelper* SvXMLImport::CreateShapeImport() 1124 { 1125 return new XMLShapeImportHelper( *this, mxModel ); 1126 } 1127 1128 #ifndef SVX_LIGHT 1129 SchXMLImportHelper* SvXMLImport::CreateChartImport() 1130 { 1131 return new SchXMLImportHelper(); 1132 } 1133 #endif 1134 1135 #ifndef SVX_LIGHT 1136 ::xmloff::OFormLayerXMLImport* SvXMLImport::CreateFormImport() 1137 { 1138 return new ::xmloff::OFormLayerXMLImport(*this); 1139 } 1140 #endif // #ifndef SVX_LIGHT 1141 1142 1143 /////////////////////////////////////////////////////////////////////////////// 1144 // 1145 // Get or create fill/line/lineend-style-helper 1146 // 1147 1148 const Reference< container::XNameContainer > & SvXMLImport::GetGradientHelper() 1149 { 1150 if( !mxGradientHelper.is() ) 1151 { 1152 if( mxModel.is() ) 1153 { 1154 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY); 1155 if( xServiceFact.is() ) 1156 { 1157 try 1158 { 1159 mxGradientHelper = Reference< container::XNameContainer >( xServiceFact->createInstance( 1160 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.GradientTable" ) ) ), UNO_QUERY); 1161 } 1162 catch( lang::ServiceNotRegisteredException& ) 1163 {} 1164 } 1165 } 1166 } 1167 1168 return mxGradientHelper; 1169 } 1170 1171 const Reference< container::XNameContainer > & SvXMLImport::GetHatchHelper() 1172 { 1173 if( !mxHatchHelper.is() ) 1174 { 1175 if( mxModel.is() ) 1176 { 1177 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY); 1178 if( xServiceFact.is() ) 1179 { 1180 try 1181 { 1182 mxHatchHelper = Reference< container::XNameContainer >( xServiceFact->createInstance( 1183 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.HatchTable" ) ) ), UNO_QUERY); 1184 } 1185 catch( lang::ServiceNotRegisteredException& ) 1186 {} 1187 } 1188 } 1189 } 1190 1191 return mxHatchHelper; 1192 } 1193 1194 const Reference< container::XNameContainer > & SvXMLImport::GetBitmapHelper() 1195 { 1196 if( !mxBitmapHelper.is() ) 1197 { 1198 if( mxModel.is() ) 1199 { 1200 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY); 1201 if( xServiceFact.is() ) 1202 { 1203 try 1204 { 1205 mxBitmapHelper = Reference< container::XNameContainer >( xServiceFact->createInstance( 1206 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.BitmapTable" ) ) ), UNO_QUERY); 1207 } 1208 catch( lang::ServiceNotRegisteredException& ) 1209 {} 1210 } 1211 } 1212 } 1213 1214 return mxBitmapHelper; 1215 } 1216 1217 const Reference< container::XNameContainer > & SvXMLImport::GetTransGradientHelper() 1218 { 1219 if( !mxTransGradientHelper.is() ) 1220 { 1221 if( mxModel.is() ) 1222 { 1223 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY); 1224 if( xServiceFact.is() ) 1225 { 1226 try 1227 { 1228 mxTransGradientHelper = Reference< container::XNameContainer >( xServiceFact->createInstance( 1229 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.TransparencyGradientTable" ) ) ), UNO_QUERY); 1230 } 1231 catch( lang::ServiceNotRegisteredException& ) 1232 {} 1233 } 1234 } 1235 } 1236 1237 return mxTransGradientHelper; 1238 } 1239 1240 const Reference< container::XNameContainer > & SvXMLImport::GetMarkerHelper() 1241 { 1242 if( !mxMarkerHelper.is() ) 1243 { 1244 if( mxModel.is() ) 1245 { 1246 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY); 1247 if( xServiceFact.is() ) 1248 { 1249 try 1250 { 1251 mxMarkerHelper = Reference< container::XNameContainer >( xServiceFact->createInstance( 1252 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.MarkerTable" ) ) ), UNO_QUERY); 1253 } 1254 catch( lang::ServiceNotRegisteredException& ) 1255 {} 1256 } 1257 } 1258 } 1259 1260 return mxMarkerHelper; 1261 } 1262 1263 const Reference< container::XNameContainer > & SvXMLImport::GetDashHelper() 1264 { 1265 if( !mxDashHelper.is() ) 1266 { 1267 if( mxModel.is() ) 1268 { 1269 Reference< lang::XMultiServiceFactory > xServiceFact( mxModel, UNO_QUERY); 1270 if( xServiceFact.is() ) 1271 { 1272 try 1273 { 1274 mxDashHelper = Reference< container::XNameContainer >( xServiceFact->createInstance( 1275 OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.DashTable" ) ) ), UNO_QUERY); 1276 } 1277 catch( lang::ServiceNotRegisteredException& ) 1278 {} 1279 } 1280 } 1281 } 1282 1283 return mxDashHelper; 1284 } 1285 1286 sal_Bool SvXMLImport::IsPackageURL( const ::rtl::OUString& rURL ) const 1287 { 1288 1289 // if, and only if, only parts are imported, then we're in a package 1290 const sal_uInt32 nTest = IMPORT_META|IMPORT_STYLES|IMPORT_CONTENT|IMPORT_SETTINGS; 1291 if( (mnImportFlags & nTest) == nTest ) 1292 return sal_False; 1293 1294 // Some quick tests: Some may rely on the package structure! 1295 sal_Int32 nLen = rURL.getLength(); 1296 if( (nLen > 0 && '/' == rURL[0]) ) 1297 // RFC2396 net_path or abs_path 1298 return sal_False; 1299 else if( nLen > 1 && '.' == rURL[0] ) 1300 { 1301 if( '.' == rURL[1] ) 1302 // ../: We are never going up one level, so we know 1303 // it's not an external URI 1304 return sal_False; 1305 else if( '/' == rURL[1] ) 1306 // we are remaining on a level, so it's an package URI 1307 return sal_True; 1308 } 1309 1310 // Now check for a RFC2396 schema 1311 sal_Int32 nPos = 1; 1312 while( nPos < nLen ) 1313 { 1314 switch( rURL[nPos] ) 1315 { 1316 case '/': 1317 // a relative path segement 1318 return sal_True; 1319 case ':': 1320 // a schema 1321 return sal_False; 1322 default: 1323 break; 1324 // we don't care about any other characters 1325 } 1326 ++nPos; 1327 } 1328 1329 return sal_True; 1330 } 1331 1332 ::rtl::OUString SvXMLImport::ResolveGraphicObjectURL( const ::rtl::OUString& rURL, 1333 sal_Bool bLoadOnDemand ) 1334 { 1335 ::rtl::OUString sRet; 1336 1337 if( IsPackageURL( rURL ) ) 1338 { 1339 if( !bLoadOnDemand && mxGraphicResolver.is() ) 1340 { 1341 ::rtl::OUString aTmp( msPackageProtocol ); 1342 aTmp += rURL; 1343 sRet = mxGraphicResolver->resolveGraphicObjectURL( aTmp ); 1344 } 1345 1346 if( !sRet.getLength() ) 1347 { 1348 sRet = msPackageProtocol; 1349 sRet += rURL; 1350 } 1351 } 1352 1353 if( !sRet.getLength() ) 1354 sRet = GetAbsoluteReference( rURL ); 1355 1356 return sRet; 1357 } 1358 1359 Reference< XOutputStream > SvXMLImport::GetStreamForGraphicObjectURLFromBase64() 1360 { 1361 Reference< XOutputStream > xOStm; 1362 Reference< document::XBinaryStreamResolver > xStmResolver( mxGraphicResolver, UNO_QUERY ); 1363 1364 if( xStmResolver.is() ) 1365 xOStm = xStmResolver->createOutputStream(); 1366 1367 return xOStm; 1368 } 1369 1370 ::rtl::OUString SvXMLImport::ResolveGraphicObjectURLFromBase64( 1371 const Reference < XOutputStream >& rOut ) 1372 { 1373 OUString sURL; 1374 Reference< document::XBinaryStreamResolver > xStmResolver( mxGraphicResolver, UNO_QUERY ); 1375 if( xStmResolver.is() ) 1376 sURL = xStmResolver->resolveOutputStream( rOut ); 1377 1378 return sURL; 1379 } 1380 1381 ::rtl::OUString SvXMLImport::ResolveEmbeddedObjectURL( 1382 const ::rtl::OUString& rURL, 1383 const ::rtl::OUString& rClassId ) 1384 { 1385 ::rtl::OUString sRet; 1386 1387 if( IsPackageURL( rURL ) ) 1388 { 1389 if ( mxEmbeddedResolver.is() ) 1390 { 1391 OUString sURL( rURL ); 1392 if( rClassId.getLength() ) 1393 { 1394 sURL += OUString( sal_Unicode('!') ); 1395 sURL += rClassId; 1396 } 1397 sRet = mxEmbeddedResolver->resolveEmbeddedObjectURL( sURL ); 1398 } 1399 } 1400 else 1401 sRet = GetAbsoluteReference( rURL ); 1402 1403 return sRet; 1404 } 1405 1406 Reference < XOutputStream > 1407 SvXMLImport::GetStreamForEmbeddedObjectURLFromBase64() 1408 { 1409 Reference < XOutputStream > xOLEStream; 1410 1411 if( mxEmbeddedResolver.is() ) 1412 { 1413 Reference< XNameAccess > xNA( mxEmbeddedResolver, UNO_QUERY ); 1414 if( xNA.is() ) 1415 { 1416 OUString aURL( RTL_CONSTASCII_USTRINGPARAM( "Obj12345678" ) ); 1417 Any aAny = xNA->getByName( aURL ); 1418 aAny >>= xOLEStream; 1419 } 1420 } 1421 1422 return xOLEStream; 1423 } 1424 1425 ::rtl::OUString SvXMLImport::ResolveEmbeddedObjectURLFromBase64() 1426 { 1427 ::rtl::OUString sRet; 1428 1429 if( mxEmbeddedResolver.is() ) 1430 { 1431 OUString aURL( RTL_CONSTASCII_USTRINGPARAM( "Obj12345678" ) ); 1432 sRet = mxEmbeddedResolver->resolveEmbeddedObjectURL( aURL ); 1433 } 1434 1435 return sRet; 1436 } 1437 1438 void SvXMLImport::AddStyleDisplayName( sal_uInt16 nFamily, 1439 const OUString& rName, 1440 const OUString& rDisplayName ) 1441 { 1442 if( !mpStyleMap ) 1443 { 1444 mpStyleMap = new StyleMap; 1445 mpStyleMap->acquire(); 1446 if( mxImportInfo.is() ) 1447 { 1448 OUString sPrivateData( 1449 RTL_CONSTASCII_USTRINGPARAM("PrivateData" ) ); 1450 Reference< beans::XPropertySetInfo > xPropertySetInfo = 1451 mxImportInfo->getPropertySetInfo(); 1452 if( xPropertySetInfo.is() && 1453 xPropertySetInfo->hasPropertyByName(sPrivateData) ) 1454 { 1455 Reference < XInterface > xIfc( 1456 static_cast< XUnoTunnel *>( mpStyleMap ) ); 1457 Any aAny; 1458 aAny <<= xIfc; 1459 mxImportInfo->setPropertyValue( sPrivateData, aAny ); 1460 } 1461 } 1462 } 1463 1464 StyleMap::key_type aKey( nFamily, rName ); 1465 StyleMap::value_type aValue( aKey, rDisplayName ); 1466 ::std::pair<StyleMap::iterator,bool> aRes( mpStyleMap->insert( aValue ) ); 1467 OSL_ENSURE( aRes.second, "duplicate style name" ); 1468 1469 } 1470 1471 OUString SvXMLImport::GetStyleDisplayName( sal_uInt16 nFamily, 1472 const OUString& rName ) const 1473 { 1474 OUString sName( rName ); 1475 if( mpStyleMap && rName.getLength() ) 1476 { 1477 StyleMap::key_type aKey( nFamily, rName ); 1478 StyleMap::const_iterator aIter = mpStyleMap->find( aKey ); 1479 if( aIter != mpStyleMap->end() ) 1480 sName = (*aIter).second; 1481 } 1482 return sName; 1483 } 1484 1485 void SvXMLImport::SetViewSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue>&) 1486 { 1487 } 1488 1489 void SvXMLImport::SetConfigurationSettings(const com::sun::star::uno::Sequence<com::sun::star::beans::PropertyValue>&) 1490 { 1491 } 1492 1493 void SvXMLImport::SetDocumentSpecificSettings(const ::rtl::OUString& _rSettingsGroupName, const uno::Sequence<beans::PropertyValue>& _rSettings) 1494 { 1495 (void)_rSettingsGroupName; 1496 (void)_rSettings; 1497 } 1498 1499 ProgressBarHelper* SvXMLImport::GetProgressBarHelper() 1500 { 1501 if (!mpProgressBarHelper) 1502 { 1503 mpProgressBarHelper = new ProgressBarHelper(mxStatusIndicator, sal_False); 1504 1505 if (mxImportInfo.is()) 1506 { 1507 uno::Reference< beans::XPropertySetInfo > xPropertySetInfo = mxImportInfo->getPropertySetInfo(); 1508 if (xPropertySetInfo.is()) 1509 { 1510 OUString sProgressRange(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSRANGE)); 1511 OUString sProgressMax(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSMAX)); 1512 OUString sProgressCurrent(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSCURRENT)); 1513 OUString sRepeat(RTL_CONSTASCII_USTRINGPARAM(XML_PROGRESSREPEAT)); 1514 if (xPropertySetInfo->hasPropertyByName(sProgressMax) && 1515 xPropertySetInfo->hasPropertyByName(sProgressCurrent) && 1516 xPropertySetInfo->hasPropertyByName(sProgressRange)) 1517 { 1518 uno::Any aAny; 1519 sal_Int32 nProgressMax(0); 1520 sal_Int32 nProgressCurrent(0); 1521 sal_Int32 nProgressRange(0); 1522 aAny = mxImportInfo->getPropertyValue(sProgressRange); 1523 if (aAny >>= nProgressRange) 1524 mpProgressBarHelper->SetRange(nProgressRange); 1525 aAny = mxImportInfo->getPropertyValue(sProgressMax); 1526 if (aAny >>= nProgressMax) 1527 mpProgressBarHelper->SetReference(nProgressMax); 1528 aAny = mxImportInfo->getPropertyValue(sProgressCurrent); 1529 if (aAny >>= nProgressCurrent) 1530 mpProgressBarHelper->SetValue(nProgressCurrent); 1531 } 1532 if (xPropertySetInfo->hasPropertyByName(sRepeat)) 1533 { 1534 uno::Any aAny = mxImportInfo->getPropertyValue(sRepeat); 1535 if (aAny.getValueType() == getBooleanCppuType()) 1536 mpProgressBarHelper->SetRepeat(::cppu::any2bool(aAny)); 1537 else { 1538 DBG_ERRORFILE("why is it no boolean?"); 1539 } 1540 } 1541 } 1542 } 1543 } 1544 return mpProgressBarHelper; 1545 } 1546 1547 void SvXMLImport::AddNumberStyle(sal_Int32 nKey, const OUString& rName) 1548 { 1549 if (!mxNumberStyles.is()) 1550 mxNumberStyles = uno::Reference< container::XNameContainer >( comphelper::NameContainer_createInstance( ::getCppuType((const sal_Int32*)0)) ); 1551 if (mxNumberStyles.is()) 1552 { 1553 uno::Any aAny; 1554 aAny <<= nKey; 1555 try 1556 { 1557 mxNumberStyles->insertByName(rName, aAny); 1558 } 1559 catch ( uno::Exception& ) 1560 { 1561 DBG_ERROR("Numberformat could not be inserted"); 1562 } 1563 } 1564 else { 1565 DBG_ERROR("not possible to create NameContainer"); 1566 } 1567 } 1568 1569 XMLEventImportHelper& SvXMLImport::GetEventImport() 1570 { 1571 #ifndef SVX_LIGHT 1572 if (!mpEventImportHelper) 1573 { 1574 // construct event helper and register StarBasic handler and standard 1575 // event tables 1576 mpEventImportHelper = new XMLEventImportHelper(); 1577 OUString sStarBasic(GetXMLToken(XML_STARBASIC)); 1578 mpEventImportHelper->RegisterFactory(sStarBasic, 1579 new XMLStarBasicContextFactory()); 1580 OUString sScript(GetXMLToken(XML_SCRIPT)); 1581 mpEventImportHelper->RegisterFactory(sScript, 1582 new XMLScriptContextFactory()); 1583 mpEventImportHelper->AddTranslationTable(aStandardEventTable); 1584 1585 // register StarBasic event handler with capitalized spelling 1586 OUString sStarBasicCap(RTL_CONSTASCII_USTRINGPARAM("StarBasic")); 1587 mpEventImportHelper->RegisterFactory(sStarBasicCap, 1588 new XMLStarBasicContextFactory()); 1589 } 1590 #endif 1591 1592 return *mpEventImportHelper; 1593 } 1594 1595 void SvXMLImport::SetFontDecls( XMLFontStylesContext *pFontDecls ) 1596 { 1597 mxFontDecls = pFontDecls; 1598 GetTextImport()->SetFontDecls( pFontDecls ); 1599 } 1600 1601 void SvXMLImport::SetStyles( SvXMLStylesContext *pStyles ) 1602 { 1603 mxStyles = pStyles; 1604 } 1605 1606 void SvXMLImport::SetAutoStyles( SvXMLStylesContext *pAutoStyles ) 1607 { 1608 if (pAutoStyles && mxNumberStyles.is() && (mnImportFlags & IMPORT_CONTENT) ) 1609 { 1610 uno::Reference<xml::sax::XAttributeList> xAttrList; 1611 uno::Sequence< ::rtl::OUString > aNames = mxNumberStyles->getElementNames(); 1612 sal_uInt32 nCount(aNames.getLength()); 1613 if (nCount) 1614 { 1615 const OUString* pNames = aNames.getConstArray(); 1616 if ( pNames ) 1617 { 1618 SvXMLStyleContext* pContext; 1619 uno::Any aAny; 1620 sal_Int32 nKey(0); 1621 for (sal_uInt32 i = 0; i < nCount; i++, pNames++) 1622 { 1623 aAny = mxNumberStyles->getByName(*pNames); 1624 if (aAny >>= nKey) 1625 { 1626 pContext = new SvXMLNumFormatContext( *this, XML_NAMESPACE_NUMBER, 1627 *pNames, xAttrList, nKey, *pAutoStyles ); 1628 pAutoStyles->AddStyle(*pContext); 1629 } 1630 } 1631 } 1632 } 1633 } 1634 mxAutoStyles = pAutoStyles; 1635 GetTextImport()->SetAutoStyles( pAutoStyles ); 1636 GetShapeImport()->SetAutoStylesContext( pAutoStyles ); 1637 #ifndef SVX_LIGHT 1638 GetChartImport()->SetAutoStylesContext( pAutoStyles ); 1639 GetFormImport()->setAutoStyleContext( pAutoStyles ); 1640 #endif 1641 } 1642 1643 void SvXMLImport::SetMasterStyles( SvXMLStylesContext *pMasterStyles ) 1644 { 1645 mxMasterStyles = pMasterStyles; 1646 } 1647 1648 XMLFontStylesContext *SvXMLImport::GetFontDecls() 1649 { 1650 return (XMLFontStylesContext *)&mxFontDecls; 1651 } 1652 1653 SvXMLStylesContext *SvXMLImport::GetStyles() 1654 { 1655 return (SvXMLStylesContext *)&mxStyles; 1656 } 1657 1658 SvXMLStylesContext *SvXMLImport::GetAutoStyles() 1659 { 1660 return (SvXMLStylesContext *)&mxAutoStyles; 1661 } 1662 1663 SvXMLStylesContext *SvXMLImport::GetMasterStyles() 1664 { 1665 return (SvXMLStylesContext *)&mxMasterStyles; 1666 } 1667 1668 const XMLFontStylesContext *SvXMLImport::GetFontDecls() const 1669 { 1670 return (const XMLFontStylesContext *)&mxFontDecls; 1671 } 1672 1673 const SvXMLStylesContext *SvXMLImport::GetStyles() const 1674 { 1675 return (const SvXMLStylesContext *)&mxStyles; 1676 } 1677 1678 const SvXMLStylesContext *SvXMLImport::GetAutoStyles() const 1679 { 1680 return (const SvXMLStylesContext *)&mxAutoStyles; 1681 } 1682 1683 const SvXMLStylesContext *SvXMLImport::GetMasterStyles() const 1684 { 1685 return (const SvXMLStylesContext *)&mxMasterStyles; 1686 } 1687 1688 OUString SvXMLImport::GetAbsoluteReference(const OUString& rValue) const 1689 { 1690 if( rValue.getLength() == 0 || rValue[0] == '#' ) 1691 return rValue; 1692 1693 INetURLObject aAbsURL; 1694 if( mpImpl->aBaseURL.GetNewAbsURL( rValue, &aAbsURL ) ) 1695 return aAbsURL.GetMainURL( INetURLObject::DECODE_TO_IURI ); 1696 else 1697 return rValue; 1698 } 1699 1700 sal_Bool SvXMLImport::IsODFVersionConsistent( const ::rtl::OUString& aODFVersion ) 1701 { 1702 // the check returns sal_False only if the storage version could be retrieved 1703 sal_Bool bResult = sal_True; 1704 1705 if ( aODFVersion.getLength() && aODFVersion.compareTo( ODFVER_012_TEXT ) >= 0 ) 1706 { 1707 // check the consistency only for the ODF1.2 and later ( according to content.xml ) 1708 // manifest.xml might have no version, it should be checked here and the correct version should be set 1709 try 1710 { 1711 uno::Reference< document::XStorageBasedDocument > xDoc( mxModel, uno::UNO_QUERY_THROW ); 1712 uno::Reference< embed::XStorage > xStor = xDoc->getDocumentStorage(); 1713 uno::Reference< beans::XPropertySet > xStorProps( xStor, uno::UNO_QUERY_THROW ); 1714 1715 // the check should be done only for OASIS format 1716 ::rtl::OUString aMediaType; 1717 xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "MediaType" ) ) ) >>= aMediaType; 1718 if ( ::comphelper::OStorageHelper::GetXStorageFormat( xStor ) >= SOFFICE_FILEFORMAT_8 ) 1719 { 1720 sal_Bool bRepairPackage = sal_False; 1721 try 1722 { 1723 xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "RepairPackage" ) ) ) 1724 >>= bRepairPackage; 1725 } catch ( uno::Exception& ) 1726 {} 1727 1728 // check only if not in Repair mode 1729 if ( !bRepairPackage ) 1730 { 1731 ::rtl::OUString aStorVersion; 1732 xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ) ) 1733 >>= aStorVersion; 1734 1735 // if the storage version is set in manifest.xml, it must be the same as in content.xml 1736 // if not, set it explicitly to be used further ( it will work even for readonly storage ) 1737 // This workaround is not nice, but I see no other way to handle it, since there are 1738 // ODF1.2 documents without version in manifest.xml 1739 if ( aStorVersion.getLength() ) 1740 bResult = aODFVersion.equals( aStorVersion ); 1741 else 1742 xStorProps->setPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Version" ) ), 1743 uno::makeAny( aODFVersion ) ); 1744 1745 if ( bResult ) 1746 { 1747 sal_Bool bInconsistent = sal_False; 1748 xStorProps->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "IsInconsistent" ) ) ) 1749 >>= bInconsistent; 1750 bResult = !bInconsistent; 1751 } 1752 } 1753 } 1754 } 1755 catch( uno::Exception& ) 1756 {} 1757 } 1758 1759 return bResult; 1760 } 1761 1762 void SvXMLImport::_CreateNumberFormatsSupplier() 1763 { 1764 DBG_ASSERT( !mxNumberFormatsSupplier.is(), 1765 "number formats supplier already exists!" ); 1766 if(mxModel.is()) 1767 mxNumberFormatsSupplier = 1768 uno::Reference< util::XNumberFormatsSupplier> (mxModel, uno::UNO_QUERY); 1769 } 1770 1771 1772 void SvXMLImport::_CreateDataStylesImport() 1773 { 1774 DBG_ASSERT( mpNumImport == NULL, "data styles import already exists!" ); 1775 uno::Reference<util::XNumberFormatsSupplier> xNum = 1776 GetNumberFormatsSupplier(); 1777 if ( xNum.is() ) 1778 mpNumImport = new SvXMLNumFmtHelper(xNum, getServiceFactory()); 1779 } 1780 1781 1782 sal_Unicode SvXMLImport::ConvStarBatsCharToStarSymbol( sal_Unicode c ) 1783 { 1784 sal_Unicode cNew = c; 1785 if( !mpImpl->hBatsFontConv ) 1786 { 1787 OUString sStarBats( RTL_CONSTASCII_USTRINGPARAM( "StarBats" ) ); 1788 mpImpl->hBatsFontConv = CreateFontToSubsFontConverter( sStarBats, 1789 FONTTOSUBSFONT_IMPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS ); 1790 OSL_ENSURE( mpImpl->hBatsFontConv, "Got no symbol font converter" ); 1791 } 1792 if( mpImpl->hBatsFontConv ) 1793 { 1794 cNew = ConvertFontToSubsFontChar( mpImpl->hBatsFontConv, c ); 1795 } 1796 1797 return cNew; 1798 } 1799 1800 sal_Unicode SvXMLImport::ConvStarMathCharToStarSymbol( sal_Unicode c ) 1801 { 1802 sal_Unicode cNew = c; 1803 if( !mpImpl->hMathFontConv ) 1804 { 1805 OUString sStarMath( RTL_CONSTASCII_USTRINGPARAM( "StarMath" ) ); 1806 mpImpl->hMathFontConv = CreateFontToSubsFontConverter( sStarMath, 1807 FONTTOSUBSFONT_IMPORT|FONTTOSUBSFONT_ONLYOLDSOSYMBOLFONTS ); 1808 OSL_ENSURE( mpImpl->hMathFontConv, "Got no symbol font converter" ); 1809 } 1810 if( mpImpl->hMathFontConv ) 1811 { 1812 cNew = ConvertFontToSubsFontChar( mpImpl->hMathFontConv, c ); 1813 } 1814 1815 return cNew; 1816 } 1817 1818 1819 1820 void SvXMLImport::SetError( 1821 sal_Int32 nId, 1822 const Sequence<OUString>& rMsgParams, 1823 const OUString& rExceptionMessage, 1824 const Reference<xml::sax::XLocator>& rLocator ) 1825 { 1826 // maintain error flags 1827 if ( ( nId & XMLERROR_FLAG_ERROR ) != 0 ) 1828 mnErrorFlags |= ERROR_ERROR_OCCURED; 1829 if ( ( nId & XMLERROR_FLAG_WARNING ) != 0 ) 1830 mnErrorFlags |= ERROR_WARNING_OCCURED; 1831 if ( ( nId & XMLERROR_FLAG_SEVERE ) != 0 ) 1832 mnErrorFlags |= ERROR_DO_NOTHING; 1833 1834 // create error list on demand 1835 if ( mpXMLErrors == NULL ) 1836 mpXMLErrors = new XMLErrors(); 1837 1838 // save error information 1839 // use document locator (if none supplied) 1840 mpXMLErrors->AddRecord( nId, rMsgParams, rExceptionMessage, 1841 rLocator.is() ? rLocator : mxLocator ); 1842 } 1843 1844 void SvXMLImport::SetError( 1845 sal_Int32 nId, 1846 const Sequence<OUString>& rMsgParams) 1847 { 1848 OUString sEmpty; 1849 SetError( nId, rMsgParams, sEmpty, NULL ); 1850 } 1851 1852 void SvXMLImport::SetError( 1853 sal_Int32 nId) 1854 { 1855 Sequence<OUString> aSeq(0); 1856 SetError( nId, aSeq ); 1857 } 1858 1859 void SvXMLImport::SetError( 1860 sal_Int32 nId, 1861 const OUString& rMsg1) 1862 { 1863 Sequence<OUString> aSeq(1); 1864 OUString* pSeq = aSeq.getArray(); 1865 pSeq[0] = rMsg1; 1866 SetError( nId, aSeq ); 1867 } 1868 1869 void SvXMLImport::SetError( 1870 sal_Int32 nId, 1871 const OUString& rMsg1, 1872 const OUString& rMsg2) 1873 { 1874 Sequence<OUString> aSeq(2); 1875 OUString* pSeq = aSeq.getArray(); 1876 pSeq[0] = rMsg1; 1877 pSeq[1] = rMsg2; 1878 SetError( nId, aSeq ); 1879 } 1880 1881 void SvXMLImport::SetError( 1882 sal_Int32 nId, 1883 const OUString& rMsg1, 1884 const OUString& rMsg2, 1885 const OUString& rMsg3) 1886 { 1887 Sequence<OUString> aSeq(3); 1888 OUString* pSeq = aSeq.getArray(); 1889 pSeq[0] = rMsg1; 1890 pSeq[1] = rMsg2; 1891 pSeq[2] = rMsg3; 1892 SetError( nId, aSeq ); 1893 } 1894 1895 void SvXMLImport::SetError( 1896 sal_Int32 nId, 1897 const OUString& rMsg1, 1898 const OUString& rMsg2, 1899 const OUString& rMsg3, 1900 const OUString& rMsg4) 1901 { 1902 Sequence<OUString> aSeq(4); 1903 OUString* pSeq = aSeq.getArray(); 1904 pSeq[0] = rMsg1; 1905 pSeq[1] = rMsg2; 1906 pSeq[2] = rMsg3; 1907 pSeq[3] = rMsg4; 1908 SetError( nId, aSeq ); 1909 } 1910 1911 XMLErrors* SvXMLImport::GetErrors() 1912 { 1913 return mpXMLErrors; 1914 } 1915 1916 void SvXMLImport::DisposingModel() 1917 { 1918 if( mxFontDecls.Is() ) 1919 ((SvXMLStylesContext *)&mxFontDecls)->Clear(); 1920 if( mxStyles.Is() ) 1921 ((SvXMLStylesContext *)&mxStyles)->Clear(); 1922 if( mxAutoStyles.Is() ) 1923 ((SvXMLStylesContext *)&mxAutoStyles)->Clear(); 1924 if( mxMasterStyles.Is() ) 1925 ((SvXMLStylesContext *)&mxMasterStyles)->Clear(); 1926 1927 mxModel.set(0); 1928 mxEventListener.set(NULL); 1929 } 1930 1931 ::comphelper::UnoInterfaceToUniqueIdentifierMapper& SvXMLImport::getInterfaceToIdentifierMapper() 1932 { 1933 return mpImpl->maInterfaceToIdentifierMapper; 1934 } 1935 1936 ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > SvXMLImport::getServiceFactory() 1937 { 1938 // #110680# 1939 return mxServiceFactory; 1940 } 1941 1942 uno::Reference< uno::XComponentContext > 1943 SvXMLImport::GetComponentContext() const 1944 { 1945 return mpImpl->mxComponentContext; 1946 } 1947 1948 String SvXMLImport::GetBaseURL() const 1949 { 1950 return mpImpl->aBaseURL.GetMainURL( INetURLObject::NO_DECODE ); 1951 } 1952 1953 String SvXMLImport::GetDocumentBase() const 1954 { 1955 return mpImpl->aDocBase.GetMainURL( INetURLObject::NO_DECODE ); 1956 } 1957 1958 ::rtl::OUString SvXMLImport::GetStreamName() const 1959 { 1960 return mpImpl->mStreamName; 1961 } 1962 1963 // --> OD 2004-08-10 #i28749# 1964 sal_Bool SvXMLImport::IsShapePositionInHoriL2R() const 1965 { 1966 return mpImpl->mbShapePositionInHoriL2R; 1967 } 1968 // <-- 1969 1970 // --> OD 2007-12-19 #152540# 1971 sal_Bool SvXMLImport::IsTextDocInOOoFileFormat() const 1972 { 1973 return mpImpl->mbTextDocInOOoFileFormat; 1974 } 1975 1976 // <-- 1977 1978 void SvXMLImport::initXForms() 1979 { 1980 // dummy method; to be implemented by derived classes supporting XForms 1981 } 1982 1983 bool SvXMLImport::getBuildIds( sal_Int32& rUPD, sal_Int32& rBuild ) const 1984 { 1985 bool bRet = false; 1986 if( mxImportInfo.is() ) try 1987 { 1988 const OUString aPropName(RTL_CONSTASCII_USTRINGPARAM("BuildId")); 1989 Reference< XPropertySetInfo > xSetInfo( mxImportInfo->getPropertySetInfo() ); 1990 if( xSetInfo.is() && xSetInfo->hasPropertyByName( aPropName ) ) 1991 { 1992 OUString aBuildId; 1993 mxImportInfo->getPropertyValue( aPropName ) >>= aBuildId; 1994 if( aBuildId.getLength() ) 1995 { 1996 sal_Int32 nIndex = aBuildId.indexOf('$'); 1997 if( nIndex != -1 ) 1998 { 1999 rUPD = aBuildId.copy( 0, nIndex ).toInt32(); 2000 rBuild = aBuildId.copy( nIndex+1 ).toInt32(); 2001 bRet = true; 2002 } 2003 } 2004 } 2005 } 2006 catch( Exception& ) 2007 { 2008 } 2009 return bRet; 2010 } 2011 2012 sal_uInt16 SvXMLImport::getGeneratorVersion() const 2013 { 2014 // --> ORW 2015 return mpImpl->getGeneratorVersion( *this ); 2016 // <-- 2017 } 2018 2019 bool SvXMLImport::isGraphicLoadOnDemandSupported() const 2020 { 2021 return mbIsGraphicLoadOnDemandSupported; 2022 } 2023 2024 ::rtl::OUString SvXMLImport::GetODFVersion() const 2025 { 2026 return mpImpl->aODFVersion; 2027 } 2028 2029 // xml:id for RDF metadata 2030 void SvXMLImport::SetXmlId(uno::Reference<uno::XInterface> const & i_xIfc, 2031 ::rtl::OUString const & i_rXmlId) 2032 { 2033 if (i_rXmlId.getLength() > 0) { 2034 try { 2035 const uno::Reference<rdf::XMetadatable> xMeta(i_xIfc, 2036 uno::UNO_QUERY); 2037 //FIXME: not yet 2038 // OSL_ENSURE(xMeta.is(), "xml:id: not XMetadatable"); 2039 if (xMeta.is()) { 2040 const beans::StringPair mdref( GetStreamName(), i_rXmlId ); 2041 try { 2042 xMeta->setMetadataReference(mdref); 2043 } catch (lang::IllegalArgumentException &) { 2044 // probably duplicate; ignore 2045 OSL_TRACE("SvXMLImport::SetXmlId: cannot set xml:id"); 2046 } 2047 } 2048 } catch (uno::Exception &) { 2049 OSL_ENSURE(false, "SvXMLImport::SetXmlId: exception?"); 2050 } 2051 } 2052 } 2053 2054 SAL_DLLPRIVATE ::xmloff::RDFaImportHelper & 2055 SvXMLImport::GetRDFaImportHelper() 2056 { 2057 if (!mpImpl->mpRDFaHelper.get()) 2058 { 2059 mpImpl->mpRDFaHelper.reset( new ::xmloff::RDFaImportHelper(*this) ); 2060 } 2061 return *mpImpl->mpRDFaHelper; 2062 } 2063 2064 void 2065 SvXMLImport::AddRDFa(uno::Reference<rdf::XMetadatable> i_xObject, 2066 ::rtl::OUString const & i_rAbout, 2067 ::rtl::OUString const & i_rProperty, 2068 ::rtl::OUString const & i_rContent, 2069 ::rtl::OUString const & i_rDatatype) 2070 { 2071 // N.B.: we only get called if i_xObject had xhtml:about attribute 2072 // (an empty attribute value is valid) 2073 ::xmloff::RDFaImportHelper & rRDFaHelper( GetRDFaImportHelper() ); 2074 rRDFaHelper.ParseAndAddRDFa(i_xObject, 2075 i_rAbout, i_rProperty, i_rContent, i_rDatatype); 2076 } 2077 2078