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

Generated by: LCOV version 1.10