LCOV - code coverage report
Current view: top level - xmloff/source/core - xmlimp.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 758 895 84.7 %
Date: 2015-06-13 12:38:46 Functions: 87 111 78.4 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.11