xmloff/source/core/xmlimp.cxx

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