sd/source/filter/xml/sdxmlwrp.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: sdxmlwrp.cxx,v $
  10  * $Revision: 1.70 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_sd.hxx"
  33 #include <rtl/logfile.hxx>
  34 #include <com/sun/star/container/XChild.hpp>
  35 #include <com/sun/star/beans/XPropertySetInfo.hpp>
  36 #include <com/sun/star/embed/ElementModes.hpp>
  37 #include <com/sun/star/xml/sax/SAXParseException.hdl>
  38 #include <comphelper/processfactory.hxx>
  39 #include <sfx2/docfile.hxx>
  40 #include <sfx2/docfilt.hxx>
  41 #include <tools/urlobj.hxx>
  42 #include "drawdoc.hxx"
  43 #include <unotools/streamwrap.hxx>
  44 #include <svx/xmlgrhlp.hxx>
  45
  46 #include "../../ui/inc/DrawDocShell.hxx"
  47
  48 #include "sdxmlwrp.hxx"
  49 #include "strmname.h"
  50 #include <svx/xmleohlp.hxx>
  51 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
  52 #include <com/sun/star/document/XFilter.hpp>
  53 #include <com/sun/star/document/XImporter.hpp>
  54 #include <com/sun/star/document/XExporter.hpp>
  55 #include <com/sun/star/lang/XServiceInfo.hpp>
  56 #include <com/sun/star/document/XGraphicObjectResolver.hpp>
  57 #include <com/sun/star/beans/PropertyAttribute.hpp>
  58 #include <com/sun/star/container/XNameAccess.hpp>
  59 #include <com/sun/star/packages/zip/ZipIOException.hpp>
  60
  61 #include <com/sun/star/xml/sax/XErrorHandler.hpp>
  62 #include <com/sun/star/xml/sax/XEntityResolver.hpp>
  63 #include <com/sun/star/xml/sax/InputSource.hpp>
  64 #include <com/sun/star/xml/sax/XDTDHandler.hpp>
  65 #include <com/sun/star/xml/sax/XParser.hpp>
  66 #include <com/sun/star/io/XActiveDataSource.hpp>
  67 #include <com/sun/star/io/XActiveDataControl.hpp>
  68 #include <comphelper/genericpropertyset.hxx>
  69 #include <comphelper/propertysetinfo.hxx>
  70 #include <svtools/saveopt.hxx>
  71
  72 // #80365# include necessary for XML progress bar at load time
  73 #include <svtools/itemset.hxx>
  74 #include <svtools/stritem.hxx>
  75 #include <svtools/sfxecode.hxx>
  76
  77 #include "sderror.hxx"
  78 #include "sdresid.hxx"
  79 #include "glob.hrc"
  80
  81 #include <sfx2/frame.hxx>
  82
  83 using rtl::OUString;
  84 using namespace com::sun::star;
  85 using namespace com::sun::star::uno;
  86 using namespace com::sun::star::lang;
  87 using namespace com::sun::star::document;
  88 using namespace comphelper;
  89
  90 #define SD_XML_READERROR 1234
  91
  92 extern void TransformOOo2xDocument( SdDrawDocument* pDocument );
  93
  94 //////////////////////////////////////////////////////////////////////////////
  95
  96 #ifndef SEQTYPE
  97  #if defined(__SUNPRO_CC) && (__SUNPRO_CC == 0x500)
  98   #define SEQTYPE(x) (new ::com::sun::star::uno::Type( x ))
  99  #else
 100   #define SEQTYPE(x) &(x)
 101  #endif
 102 #endif
 103
 104 #define MAP_LEN(x) x, sizeof(x) - 1
 105
 106 #define XML_STRING(i, x) sal_Char __READONLY_DATA i[sizeof(x)] = x
 107
 108 XML_STRING( sXML_metaStreamName, "meta.xml");
 109 XML_STRING( sXML_styleStreamName, "styles.xml" );
 110 XML_STRING( sXML_contentStreamName, "content.xml" );
 111 XML_STRING( sXML_oldContentStreamName, "Content.xml" );
 112 XML_STRING( sXML_settingsStreamName, "settings.xml" );
 113
 114 XML_STRING( sXML_export_impress_oasis_service, "com.sun.star.comp.Impress.XMLOasisExporter" );
 115 XML_STRING( sXML_export_impress_meta_oasis_service, "com.sun.star.comp.Impress.XMLOasisMetaExporter" );
 116 XML_STRING( sXML_export_impress_styles_oasis_service, "com.sun.star.comp.Impress.XMLOasisStylesExporter" );
 117 XML_STRING( sXML_export_impress_content_oasis_service, "com.sun.star.comp.Impress.XMLOasisContentExporter" );
 118 XML_STRING( sXML_export_impress_settings_oasis_service, "com.sun.star.comp.Impress.XMLOasisSettingsExporter" );
 119
 120 XML_STRING( sXML_export_draw_oasis_service, "com.sun.star.comp.Draw.XMLOasisExporter" );
 121 XML_STRING( sXML_export_draw_meta_oasis_service, "com.sun.star.comp.Draw.XMLOasisMetaExporter" );
 122 XML_STRING( sXML_export_draw_styles_oasis_service, "com.sun.star.comp.Draw.XMLOasisStylesExporter" );
 123 XML_STRING( sXML_export_draw_content_oasis_service, "com.sun.star.comp.Draw.XMLOasisContentExporter" );
 124 XML_STRING( sXML_export_draw_settings_oasis_service, "com.sun.star.comp.Draw.XMLOasisSettingsExporter" );
 125
 126 XML_STRING( sXML_import_impress_oasis_service, "com.sun.star.comp.Impress.XMLOasisImporter" );
 127 XML_STRING( sXML_import_impress_meta_oasis_service, "com.sun.star.comp.Impress.XMLOasisMetaImporter" );
 128 XML_STRING( sXML_import_impress_styles_oasis_service, "com.sun.star.comp.Impress.XMLOasisStylesImporter" );
 129 XML_STRING( sXML_import_impress_content_oasis_service, "com.sun.star.comp.Impress.XMLOasisContentImporter" );
 130 XML_STRING( sXML_import_impress_settings_oasis_service, "com.sun.star.comp.Impress.XMLOasisSettingsImporter" );
 131
 132 XML_STRING( sXML_import_draw_oasis_service, "com.sun.star.comp.Draw.XMLOasisImporter" );
 133 XML_STRING( sXML_import_draw_meta_oasis_service, "com.sun.star.comp.Draw.XMLOasisMetaImporter" );
 134 XML_STRING( sXML_import_draw_styles_oasis_service, "com.sun.star.comp.Draw.XMLOasisStylesImporter" );
 135 XML_STRING( sXML_import_draw_content_oasis_service, "com.sun.star.comp.Draw.XMLOasisContentImporter" );
 136 XML_STRING( sXML_import_draw_settings_oasis_service, "com.sun.star.comp.Draw.XMLOasisSettingsImporter" );
 137
 138 // OOo
 139 XML_STRING( sXML_export_impress_ooo_service, "com.sun.star.comp.Impress.XMLExporter" );
 140 XML_STRING( sXML_export_impress_meta_ooo_service, "com.sun.star.comp.Impress.XMLMetaExporter" );
 141 XML_STRING( sXML_export_impress_styles_ooo_service, "com.sun.star.comp.Impress.XMLStylesExporter" );
 142 XML_STRING( sXML_export_impress_content_ooo_service, "com.sun.star.comp.Impress.XMLContentExporter" );
 143 XML_STRING( sXML_export_impress_settings_ooo_service, "com.sun.star.comp.Impress.XMLSettingsExporter" );
 144
 145 XML_STRING( sXML_export_draw_ooo_service, "com.sun.star.comp.Draw.XMLExporter" );
 146 XML_STRING( sXML_export_draw_meta_ooo_service, "com.sun.star.comp.Draw.XMLMetaExporter" );
 147 XML_STRING( sXML_export_draw_styles_ooo_service, "com.sun.star.comp.Draw.XMLStylesExporter" );
 148 XML_STRING( sXML_export_draw_content_ooo_service, "com.sun.star.comp.Draw.XMLContentExporter" );
 149 XML_STRING( sXML_export_draw_settings_ooo_service, "com.sun.star.comp.Draw.XMLSettingsExporter" );
 150
 151 XML_STRING( sXML_import_impress_ooo_service, "com.sun.star.comp.Impress.XMLImporter" );
 152 XML_STRING( sXML_import_impress_meta_ooo_service, "com.sun.star.comp.Impress.XMLMetaImporter" );
 153 XML_STRING( sXML_import_impress_styles_ooo_service, "com.sun.star.comp.Impress.XMLStylesImporter" );
 154 XML_STRING( sXML_import_impress_content_ooo_service, "com.sun.star.comp.Impress.XMLContentImporter" );
 155 XML_STRING( sXML_import_impress_settings_ooo_service, "com.sun.star.comp.Impress.XMLSettingsImporter" );
 156
 157 XML_STRING( sXML_import_draw_ooo_service, "com.sun.star.comp.Draw.XMLImporter" );
 158 XML_STRING( sXML_import_draw_meta_ooo_service, "com.sun.star.comp.Draw.XMLMetaImporter" );
 159 XML_STRING( sXML_import_draw_styles_ooo_service, "com.sun.star.comp.Draw.XMLStylesImporter" );
 160 XML_STRING( sXML_import_draw_content_ooo_service, "com.sun.star.comp.Draw.XMLContentImporter" );
 161 XML_STRING( sXML_import_draw_settings_ooo_service, "com.sun.star.comp.Draw.XMLSettingsImporter" );
 162
 163 struct XML_SERVICEMAP
 164 {
 165     const sal_Char* mpService;
 166     const sal_Char* mpStream;
 167     sal_Bool mbPlain;
 168 };
 169
 170 struct XML_SERVICES
 171 {
 172     const sal_Char* mpAll;
 173     const sal_Char* mpMeta;
 174     const sal_Char* mpStyles;
 175     const sal_Char* mpContent;
 176     const sal_Char* mpSettings;
 177 };
 178
 179 XML_SERVICES* getServices( bool bImport, bool bDraw, ULONG nStoreVer )
 180 {
 181     static XML_SERVICES gServices[] =
 182     {
 183         { sXML_export_impress_oasis_service, sXML_export_impress_meta_oasis_service, sXML_export_impress_styles_oasis_service, sXML_export_impress_content_oasis_service, sXML_export_impress_settings_oasis_service },
 184         { sXML_export_draw_oasis_service, sXML_export_draw_meta_oasis_service, sXML_export_draw_styles_oasis_service, sXML_export_draw_content_oasis_service, sXML_export_draw_settings_oasis_service },
 185         { sXML_import_impress_oasis_service, sXML_import_impress_meta_oasis_service, sXML_import_impress_styles_oasis_service, sXML_import_impress_content_oasis_service, sXML_import_impress_settings_oasis_service },
 186         { sXML_import_draw_oasis_service, sXML_import_draw_meta_oasis_service, sXML_import_draw_styles_oasis_service, sXML_import_draw_content_oasis_service, sXML_import_draw_settings_oasis_service },
 187
 188         { sXML_export_impress_ooo_service, sXML_export_impress_meta_ooo_service, sXML_export_impress_styles_ooo_service, sXML_export_impress_content_ooo_service, sXML_export_impress_settings_ooo_service },
 189         { sXML_export_draw_ooo_service, sXML_export_draw_meta_ooo_service, sXML_export_draw_styles_ooo_service, sXML_export_draw_content_ooo_service, sXML_export_draw_settings_ooo_service },
 190         { sXML_import_impress_ooo_service, sXML_import_impress_meta_ooo_service, sXML_import_impress_styles_ooo_service, sXML_import_impress_content_ooo_service, sXML_import_impress_settings_ooo_service },
 191         { sXML_import_draw_ooo_service, sXML_import_draw_meta_ooo_service, sXML_import_draw_styles_ooo_service, sXML_import_draw_content_ooo_service, sXML_import_draw_settings_ooo_service },
 192     };
 193
 194     return &gServices[ (bImport ? 2 : 0) + ((nStoreVer == SOFFICE_FILEFORMAT_60) ? 4 : 0) + (bDraw ? 1 : 0 ) ];
 195 }
 196
 197
 198 // ----------------
 199 // - SdXMLWrapper -
 200 // ----------------
 201
 202 SdXMLFilter::SdXMLFilter( SfxMedium& rMedium, ::sd::DrawDocShell& rDocShell, sal_Bool bShowProgress, SdXMLFilterMode eFilterMode, ULONG nStoreVer ) :
 203     SdFilter( rMedium, rDocShell, bShowProgress ), meFilterMode( eFilterMode ), mnStoreVer( nStoreVer )
 204 {
 205 }
 206
 207 SdXMLFilter::~SdXMLFilter(void)
 208 {
 209 }
 210
 211 sal_Int32 ReadThroughComponent(
 212     Reference<io::XInputStream> xInputStream,
 213     Reference<XComponent> xModelComponent,
 214     const String& rStreamName,
 215     Reference<lang::XMultiServiceFactory> & rFactory,
 216     const sal_Char* pFilterName,
 217     Sequence<Any> rFilterArguments,
 218     const OUString& rName,
 219     sal_Bool bMustBeSuccessfull,
 220     sal_Bool bEncrypted )
 221 {
 222     DBG_ASSERT(xInputStream.is(), "input stream missing");
 223     DBG_ASSERT(xModelComponent.is(), "document missing");
 224     DBG_ASSERT(rFactory.is(), "factory missing");
 225     DBG_ASSERT(NULL != pFilterName,"I need a service name for the component!");
 226
 227     RTL_LOGFILE_CONTEXT( aLog, "ReadThroughComponent" );
 228
 229     // prepare ParserInputSrouce
 230     xml::sax::InputSource aParserInput;
 231     aParserInput.sSystemId = rName;
 232     aParserInput.aInputStream = xInputStream;
 233
 234     // get parser
 235     Reference< xml::sax::XParser > xParser(
 236         rFactory->createInstance(
 237             OUString::createFromAscii("com.sun.star.xml.sax.Parser") ),
 238         UNO_QUERY );
 239     DBG_ASSERT( xParser.is(), "Can't create parser" );
 240     if( !xParser.is() )
 241         return SD_XML_READERROR;
 242     RTL_LOGFILE_CONTEXT_TRACE( aLog, "parser created" );
 243
 244     // get filter
 245     Reference< xml::sax::XDocumentHandler > xFilter(
 246         rFactory->createInstanceWithArguments(
 247             OUString::createFromAscii(pFilterName), rFilterArguments),
 248         UNO_QUERY );
 249     DBG_ASSERT( xFilter.is(), "Can't instantiate filter component." );
 250     if( !xFilter.is() )
 251         return SD_XML_READERROR;
 252     RTL_LOGFILE_CONTEXT_TRACE1( aLog, "%s created", pFilterName );
 253
 254     // connect parser and filter
 255     xParser->setDocumentHandler( xFilter );
 256
 257     // connect model and filter
 258     Reference < XImporter > xImporter( xFilter, UNO_QUERY );
 259     xImporter->setTargetDocument( xModelComponent );
 260     // finally, parser the stream
 261     RTL_LOGFILE_CONTEXT_TRACE( aLog, "parsing stream" );
 262     try
 263     {
 264         xParser->parseStream( aParserInput );
 265     }
 266     catch( xml::sax::SAXParseException& r )
 267     {
 268         // sax parser sends wrapped exceptions,
 269         // try to find the original one
 270         xml::sax::SAXException aSaxEx = *(xml::sax::SAXException*)(&r);
 271         sal_Bool bTryChild = sal_True;
 272
 273         while( bTryChild )
 274         {
 275             xml::sax::SAXException aTmp;
 276             if ( aSaxEx.WrappedException >>= aTmp )
 277                 aSaxEx = aTmp;
 278             else
 279                 bTryChild = sal_False;
 280         }
 281
 282         packages::zip::ZipIOException aBrokenPackage;
 283         if ( aSaxEx.WrappedException >>= aBrokenPackage )
 284             return ERRCODE_IO_BROKENPACKAGE;
 285
 286         if( bEncrypted )
 287             return ERRCODE_SFX_WRONGPASSWORD;
 288
 289 #if OSL_DEBUG_LEVEL > 1
 290         ByteString aError( "SAX parse exception catched while importing:\n" );
 291         aError += ByteString( String( r.Message), RTL_TEXTENCODING_ASCII_US );
 292         DBG_ERROR( aError.GetBuffer() );
 293 #endif
 294
 295         String sErr( String::CreateFromInt32( r.LineNumber ));
 296         sErr += ',';
 297         sErr += String::CreateFromInt32( r.ColumnNumber );
 298
 299         if( rStreamName.Len() )
 300         {
 301             return *new TwoStringErrorInfo(
 302                             (bMustBeSuccessfull ? ERR_FORMAT_FILE_ROWCOL
 303                                                     : WARN_FORMAT_FILE_ROWCOL),
 304                             rStreamName, sErr,
 305                             ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR );
 306         }
 307         else
 308         {
 309             DBG_ASSERT( bMustBeSuccessfull, "Warnings are not supported" );
 310             return *new StringErrorInfo( ERR_FORMAT_ROWCOL, sErr,
 311                              ERRCODE_BUTTON_OK | ERRCODE_MSG_ERROR );
 312         }
 313     }
 314     catch( xml::sax::SAXException& r )
 315     {
 316         packages::zip::ZipIOException aBrokenPackage;
 317         if ( r.WrappedException >>= aBrokenPackage )
 318             return ERRCODE_IO_BROKENPACKAGE;
 319
 320         if( bEncrypted )
 321             return ERRCODE_SFX_WRONGPASSWORD;
 322
 323 #if OSL_DEBUG_LEVEL > 1
 324         ByteString aError( "SAX exception catched while importing:\n" );
 325         aError += ByteString( String( r.Message), RTL_TEXTENCODING_ASCII_US );
 326         DBG_ERROR( aError.GetBuffer() );
 327 #endif
 328         return SD_XML_READERROR;
 329     }
 330     catch( packages::zip::ZipIOException& r )
 331     {
 332         (void)r;
 333 #if OSL_DEBUG_LEVEL > 1
 334         ByteString aError( "Zip exception catched while importing:\n" );
 335         aError += ByteString( String( r.Message), RTL_TEXTENCODING_ASCII_US );
 336         DBG_ERROR( aError.GetBuffer() );
 337 #endif
 338         return ERRCODE_IO_BROKENPACKAGE;
 339     }
 340     catch( io::IOException& r )
 341     {
 342         (void)r;
 343 #if OSL_DEBUG_LEVEL > 1
 344         ByteString aError( "IO exception catched while importing:\n" );
 345         aError += ByteString( String( r.Message), RTL_TEXTENCODING_ASCII_US );
 346         DBG_ERROR( aError.GetBuffer() );
 347 #endif
 348         return SD_XML_READERROR;
 349     }
 350     catch( uno::Exception& r )
 351     {
 352         (void)r;
 353 #if OSL_DEBUG_LEVEL > 1
 354         ByteString aError( "uno exception catched while importing:\n" );
 355         aError += ByteString( String( r.Message), RTL_TEXTENCODING_ASCII_US );
 356         DBG_ERROR( aError.GetBuffer() );
 357 #endif
 358         return SD_XML_READERROR;
 359     }
 360
 361     // success!
 362     return 0;
 363 }
 364
 365 sal_Int32 ReadThroughComponent(
 366     const uno::Reference < embed::XStorage >& xStorage,
 367     Reference<XComponent> xModelComponent,
 368     const sal_Char* pStreamName,
 369     const sal_Char* pCompatibilityStreamName,
 370     Reference<lang::XMultiServiceFactory> & rFactory,
 371     const sal_Char* pFilterName,
 372     Sequence<Any> rFilterArguments,
 373     const OUString& rName,
 374     sal_Bool bMustBeSuccessfull )
 375 {
 376     DBG_ASSERT(xStorage.is(), "Need storage!");
 377     DBG_ASSERT(NULL != pStreamName, "Please, please, give me a name!");
 378
 379     // open stream (and set parser input)
 380     OUString sStreamName = OUString::createFromAscii(pStreamName);
 381     sal_Bool bContainsStream = sal_False;
 382     try
 383     {
 384         bContainsStream = xStorage->isStreamElement(sStreamName);
 385     }
 386     catch( container::NoSuchElementException& )
 387     {
 388     }
 389
 390     if (!bContainsStream )
 391     {
 392         // stream name not found! Then try the compatibility name.
 393         // if no stream can be opened, return immediatly with OK signal
 394
 395         // do we even have an alternative name?
 396         if ( NULL == pCompatibilityStreamName )
 397             return 0;
 398
 399         // if so, does the stream exist?
 400         sStreamName = OUString::createFromAscii(pCompatibilityStreamName);
 401         try
 402         {
 403             bContainsStream = xStorage->isStreamElement(sStreamName);
 404         }
 405         catch( container::NoSuchElementException& )
 406         {
 407         }
 408
 409         if (! bContainsStream )
 410             return 0;
 411     }
 412
 413     // set Base URL
 414     uno::Reference< beans::XPropertySet > xInfoSet;
 415     if( rFilterArguments.getLength() > 0 )
 416         rFilterArguments.getConstArray()[0] >>= xInfoSet;
 417     DBG_ASSERT( xInfoSet.is(), "missing property set" );
 418     if( xInfoSet.is() )
 419     {
 420         OUString sPropName( RTL_CONSTASCII_USTRINGPARAM("StreamName") );
 421         xInfoSet->setPropertyValue( sPropName, makeAny( sStreamName ) );
 422     }
 423
 424     try
 425     {
 426         // get input stream
 427         Reference <io::XStream> xStream =
 428                 xStorage->openStreamElement( sStreamName, embed::ElementModes::READ );
 429         Reference <beans::XPropertySet > xProps( xStream, uno::UNO_QUERY );
 430         if ( !xStream.is() || ! xProps.is() )
 431             return SD_XML_READERROR;
 432
 433         Any aAny = xProps->getPropertyValue(
 434                 OUString( RTL_CONSTASCII_USTRINGPARAM("Encrypted") ) );
 435
 436         sal_Bool bEncrypted = aAny.getValueType() == ::getBooleanCppuType() &&
 437                 *(sal_Bool *)aAny.getValue();
 438
 439         Reference <io::XInputStream> xInputStream = xStream->getInputStream();
 440
 441         // read from the stream
 442         return ReadThroughComponent(
 443             xInputStream, xModelComponent, sStreamName, rFactory,
 444             pFilterName, rFilterArguments,
 445             rName, bMustBeSuccessfull, bEncrypted );
 446     }
 447     catch ( packages::WrongPasswordException& )
 448     {
 449         return ERRCODE_SFX_WRONGPASSWORD;
 450     }
 451     catch( packages::zip::ZipIOException& )
 452     {
 453         return ERRCODE_IO_BROKENPACKAGE;
 454     }
 455     catch ( uno::Exception& )
 456     {}
 457
 458     return SD_XML_READERROR;
 459 }
 460
 461 // -----------------------------------------------------------------------------
 462
 463 sal_Bool SdXMLFilter::Import( ErrCode& nError )
 464 {
 465     RTL_LOGFILE_CONTEXT_AUTHOR ( aLog, "sd", "cl93746", "SdXMLFilter::Import" );
 466 #ifdef TIMELOG
 467     ByteString aFile( mrMedium.GetName(), RTL_TEXTENCODING_ASCII_US );
 468     RTL_LOGFILE_CONTEXT_TRACE1( aLog, "importing %s", aFile.GetBuffer() );
 469 #endif
 470
 471     sal_uInt32  nRet = 0;
 472
 473     // Get service factory
 474     Reference< lang::XMultiServiceFactory > xServiceFactory =
 475             comphelper::getProcessServiceFactory();
 476     DBG_ASSERT( xServiceFactory.is(),
 477             "XMLReader::Read: got no service manager" );
 478     if( !xServiceFactory.is() )
 479         return sal_False;
 480
 481     // -------------------------------------
 482
 483     SdDrawDocument* pDoc = mrDocShell.GetDoc();
 484     pDoc->EnableUndo(false);
 485     pDoc->NewOrLoadCompleted( NEW_DOC );
 486     pDoc->CreateFirstPages();
 487     pDoc->StopWorkStartupDelay();
 488
 489     // -------------------------------------
 490
 491     mxModel->lockControllers();
 492
 493     // -------------------------------------
 494
 495     /** property map for export info set */
 496     PropertyMapEntry aImportInfoMap[] =
 497     {
 498         // #80365# necessary properties for XML progress bar at load time
 499         { MAP_LEN( "ProgressRange" ),   0, &::getCppuType((const sal_Int32*)0), ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 500         { MAP_LEN( "ProgressMax" ),             0, &::getCppuType((const sal_Int32*)0), ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 501         { MAP_LEN( "ProgressCurrent" ), 0, &::getCppuType((const sal_Int32*)0), ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 502         { MAP_LEN( "Preview" ),                 0, &::getCppuType((const sal_Bool*)0),  ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 503         { MAP_LEN( "PageLayouts" ), 0, SEQTYPE(::getCppuType((const uno::Reference< container::XNameAccess >*)0)),      ::com::sun::star::beans::PropertyAttribute::MAYBEVOID,     0},
 504         { MAP_LEN( "PrivateData" ), 0,
 505               &::getCppuType( (Reference<XInterface> *)0 ),
 506               ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 507         { MAP_LEN( "BaseURI" ), 0,
 508               &::getCppuType( (OUString *)0 ),
 509               ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 510         { MAP_LEN( "StreamRelPath" ), 0,
 511               &::getCppuType( (OUString *)0 ),
 512               ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 513         { MAP_LEN( "StreamName" ), 0,
 514               &::getCppuType( (OUString *)0 ),
 515               ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 516         { MAP_LEN( "BuildId" ), 0,
 517               &::getCppuType( (OUString *)0 ),
 518               ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 519         { NULL, 0, 0, NULL, 0, 0 }
 520     };
 521
 522     uno::Reference< beans::XPropertySet > xInfoSet( GenericPropertySet_CreateInstance( new PropertySetInfo( aImportInfoMap ) ) );
 523     xInfoSet->setPropertyValue( OUString::createFromAscii( "Preview" ), uno::makeAny( mrDocShell.GetDoc()->IsStarDrawPreviewMode() ) );
 524
 525     // ---- get BuildId from parent container if available
 526
 527     uno::Reference< container::XChild > xChild( mxModel, uno::UNO_QUERY );
 528     if( xChild.is() )
 529     {
 530         uno::Reference< beans::XPropertySet > xParentSet( xChild->getParent(), uno::UNO_QUERY );
 531         if( xParentSet.is() )
 532         {
 533             uno::Reference< beans::XPropertySetInfo > xPropSetInfo( xParentSet->getPropertySetInfo() );
 534             OUString sPropName( RTL_CONSTASCII_USTRINGPARAM("BuildId" ) );
 535             if( xPropSetInfo.is() && xPropSetInfo->hasPropertyByName(sPropName) )
 536             {
 537                 xInfoSet->setPropertyValue( sPropName, xParentSet->getPropertyValue(sPropName) );
 538             }
 539         }
 540     }
 541
 542     // -------------------------------------
 543
 544     Reference< io::XActiveDataSource > xSource;
 545     Reference< XInterface > xPipe;
 546     Reference< document::XGraphicObjectResolver > xGraphicResolver;
 547     SvXMLGraphicHelper *pGraphicHelper = 0;
 548     Reference< document::XEmbeddedObjectResolver > xObjectResolver;
 549     SvXMLEmbeddedObjectHelper *pObjectHelper = 0;
 550
 551     Reference< lang::XComponent > xModelComp( mxModel, uno::UNO_QUERY );
 552
 553     // -------------------------------------
 554
 555     // #80365# try to get an XStatusIndicator from the Medium
 556     if( mbShowProgress )
 557     {
 558         SfxItemSet* pSet = mrMedium.GetItemSet();
 559         if(pSet)
 560         {
 561             const SfxUnoAnyItem* pItem = static_cast<const SfxUnoAnyItem*>(
 562                 pSet->GetItem(SID_PROGRESS_STATUSBAR_CONTROL) );
 563             if (pItem)
 564             {
 565                 pItem->GetValue() >>= mxStatusIndicator;
 566             }
 567         }
 568
 569         if(mxStatusIndicator.is())
 570         {
 571             sal_Int32 nProgressRange(1000000);
 572             sal_Int32 nProgressCurrent(0);
 573             OUString aMsg = String( SdResId( STR_LOAD_DOC ) );
 574             mxStatusIndicator->start(aMsg, nProgressRange);
 575
 576             // set ProgressRange
 577             uno::Any aProgRange;
 578             aProgRange <<= nProgressRange;
 579             xInfoSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ProgressRange")), aProgRange);
 580
 581             // set ProgressCurrent
 582             uno::Any aProgCurrent;
 583             aProgCurrent <<= nProgressCurrent;
 584             xInfoSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ProgressCurrent")), aProgCurrent);
 585         }
 586     }
 587
 588     // -------------------------------------
 589     // get the input stream (storage or stream)
 590     // -------------------------------------
 591
 592     SvStorageStreamRef xDocStream;
 593     Reference<io::XInputStream> xInputStream;
 594     uno::Reference < embed::XStorage > xStorage = mrMedium.GetStorage();
 595
 596     if( !xStorage.is() )
 597         nRet = SD_XML_READERROR;
 598
 599     if( 0 == nRet )
 600     {
 601         pGraphicHelper = SvXMLGraphicHelper::Create( xStorage,
 602                                                      GRAPHICHELPER_MODE_READ,
 603                                                      sal_False );
 604         xGraphicResolver = pGraphicHelper;
 605         pObjectHelper = SvXMLEmbeddedObjectHelper::Create(
 606                                     xStorage, *pDoc->GetPersist(),
 607                                     EMBEDDEDOBJECTHELPER_MODE_READ,
 608                                     sal_False );
 609         xObjectResolver = pObjectHelper;
 610     }
 611
 612     // Set base URI
 613     const OUString sBaseURI( RTL_CONSTASCII_USTRINGPARAM("BaseURI") );
 614     xInfoSet->setPropertyValue( sBaseURI, makeAny( mrMedium.GetBaseURL() ) );
 615
 616     if( 0 == nRet && SFX_CREATE_MODE_EMBEDDED == mrDocShell.GetCreateMode() )
 617     {
 618         OUString aName;
 619         if ( mrMedium.GetItemSet() )
 620         {
 621             const SfxStringItem* pDocHierarchItem = static_cast<const SfxStringItem*>(
 622                 mrMedium.GetItemSet()->GetItem(SID_DOC_HIERARCHICALNAME) );
 623             if ( pDocHierarchItem )
 624                 aName = pDocHierarchItem->GetValue();
 625         }
 626         else
 627             aName = ::rtl::OUString::createFromAscii( "dummyObjectName" );
 628
 629         if( aName.getLength() )
 630         {
 631             const OUString sStreamRelPath(RTL_CONSTASCII_USTRINGPARAM("StreamRelPath"));
 632             xInfoSet->setPropertyValue( sStreamRelPath, Any( aName ) );
 633         }
 634     }
 635
 636     // -------------------------------------
 637
 638     if( 0 == nRet )
 639     {
 640
 641         // prepare filter arguments
 642         Sequence<Any> aFilterArgs( 4 );
 643         Any *pArgs = aFilterArgs.getArray();
 644         *pArgs++ <<= xInfoSet;
 645         *pArgs++ <<= xGraphicResolver;
 646         *pArgs++ <<= xObjectResolver;
 647         *pArgs++ <<= mxStatusIndicator;
 648
 649         Sequence<Any> aEmptyArgs( 2 );
 650         pArgs = aEmptyArgs.getArray();
 651         *pArgs++ <<= xInfoSet;
 652         *pArgs++ <<= mxStatusIndicator;
 653
 654         const OUString aName( mrMedium.GetName() );
 655
 656         XML_SERVICES* pServices = getServices( true, IsDraw(), mnStoreVer );
 657
 658         sal_uInt32 nWarn = 0;
 659         sal_uInt32 nWarn2 = 0;
 660         // read storage streams
 661         if( meFilterMode != SDXMLMODE_Organizer )
 662         {
 663             nWarn = ReadThroughComponent(
 664                 xStorage, xModelComp, "meta.xml", "Meta.xml", xServiceFactory,
 665                 pServices->mpMeta,
 666                 aEmptyArgs, aName, sal_False );
 667
 668             nWarn2 = ReadThroughComponent(
 669                 xStorage, xModelComp, "settings.xml", NULL, xServiceFactory,
 670                 pServices->mpSettings,
 671                 aFilterArgs, aName, sal_False );
 672         }
 673
 674         nRet = ReadThroughComponent(
 675             xStorage, xModelComp, "styles.xml", NULL, xServiceFactory,
 676             pServices->mpStyles,
 677             aFilterArgs, aName, sal_True );
 678
 679         if( !nRet && (meFilterMode != SDXMLMODE_Organizer) )
 680             nRet = ReadThroughComponent(
 681                xStorage, xModelComp, "content.xml", "Content.xml", xServiceFactory,
 682                pServices->mpContent,
 683                aFilterArgs, aName, sal_True );
 684
 685         if( !nRet )
 686         {
 687             if( nWarn )
 688                 nRet = nWarn;
 689             else if( nWarn2 )
 690                 nRet = nWarn2;
 691         }
 692     }
 693
 694     // -------------------------------------
 695     if( pGraphicHelper )
 696         SvXMLGraphicHelper::Destroy( pGraphicHelper );
 697     xGraphicResolver = 0;
 698     if( pObjectHelper )
 699         SvXMLEmbeddedObjectHelper::Destroy( pObjectHelper );
 700     xObjectResolver = 0;
 701
 702     if( mxStatusIndicator.is() )
 703         mxStatusIndicator->end();
 704
 705     if( mxModel.is() )
 706         mxModel->unlockControllers();
 707
 708     if( nRet == 0 )
 709         pDoc->UpdateAllLinks();
 710
 711     switch( nRet )
 712     {
 713     case 0: break;
 714     // case ERRCODE_SFX_WRONGPASSWORD: break;
 715     case SD_XML_READERROR: break;
 716     case ERRCODE_IO_BROKENPACKAGE:
 717         if( xStorage.is() )
 718         {
 719             nError = ERRCODE_IO_BROKENPACKAGE;
 720             break;
 721         }
 722         // fall through intented
 723     default:
 724         {
 725             // TODO/LATER: this is completely wrong! Filter code should never call ErrorHandler directly!
 726             ErrorHandler::HandleError( nRet );
 727             if( IsWarning( nRet ) )
 728                 nRet = 0;
 729         }
 730     }
 731
 732
 733     // clear unused named items from item pool
 734
 735     uno::Reference< lang::XMultiServiceFactory> xModelFactory( mxModel, uno::UNO_QUERY );
 736     if( xModelFactory.is() )
 737     {
 738         try
 739         {
 740             const OUString aName( RTL_CONSTASCII_USTRINGPARAM( "~clear~" ) );
 741             uno::Reference< container::XNameContainer > xGradient( xModelFactory->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.GradientTable") ) ), uno::UNO_QUERY );
 742             if( xGradient.is() )
 743                 xGradient->removeByName( aName );
 744
 745             uno::Reference< container::XNameContainer > xHatch( xModelFactory->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.HatchTable") ) ), uno::UNO_QUERY );
 746             if( xHatch.is() )
 747                 xHatch->removeByName( aName );
 748
 749             uno::Reference< container::XNameContainer > xBitmap( xModelFactory->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.BitmapTable") ) ), uno::UNO_QUERY );
 750             if( xBitmap.is() )
 751                 xBitmap->removeByName( aName );
 752
 753             uno::Reference< container::XNameContainer > xTransGradient( xModelFactory->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.TransparencyGradientTable") ) ), uno::UNO_QUERY );
 754             if( xTransGradient.is() )
 755                 xTransGradient->removeByName( aName );
 756
 757             uno::Reference< container::XNameContainer > xMarker( xModelFactory->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.MarkerTable") ) ), uno::UNO_QUERY );
 758             if( xMarker.is() )
 759                 xMarker->removeByName( aName );
 760
 761             uno::Reference< container::XNameContainer > xDashes( xModelFactory->createInstance( OUString(RTL_CONSTASCII_USTRINGPARAM("com.sun.star.drawing.DashTable") ) ), uno::UNO_QUERY );
 762             if( xDashes.is() )
 763                 xDashes->removeByName( aName );
 764         }
 765         catch( Exception& )
 766         {
 767             DBG_ERROR("sd::SdXMLFilter::Import(), exception during clearing of unused named items");
 768         }
 769     }
 770
 771     // set BuildId on XModel for later OLE object loading
 772     if( xInfoSet.is() )
 773     {
 774         uno::Reference< beans::XPropertySet > xModelSet( mxModel, uno::UNO_QUERY );
 775         if( xModelSet.is() )
 776         {
 777             uno::Reference< beans::XPropertySetInfo > xModelSetInfo( xModelSet->getPropertySetInfo() );
 778             const OUString sPropName( RTL_CONSTASCII_USTRINGPARAM("BuildId" ) );
 779
 780             OUString sBuildId;
 781             xInfoSet->getPropertyValue(sPropName) >>= sBuildId;
 782
 783             if( xModelSetInfo.is() && xModelSetInfo->hasPropertyByName(sPropName) )
 784             {
 785                 xModelSet->setPropertyValue( sPropName, Any( sBuildId ) );
 786             }
 787
 788             bool bTransform = false;
 789
 790             if( (nRet == 0) )
 791             {
 792                 if( sBuildId.getLength() )
 793                 {
 794                     sal_Int32 nIndex = sBuildId.indexOf('$');
 795                     if( nIndex != -1 )
 796                     {
 797                         sal_Int32 nUPD = sBuildId.copy( 0, nIndex ).toInt32();
 798
 799                         if( nUPD == 300 )
 800                         {
 801                             sal_Int32 nBuildId = sBuildId.copy( nIndex+1 ).toInt32();
 802                             if( (nBuildId > 0) && (nBuildId < 9316) )
 803                                 bTransform = true; // treat OOo 3.0 beta1 as OOo 2.x
 804                         }
 805                         else if( (nUPD == 680) || ( nUPD >= 640 && nUPD <= 645 ) )
 806                             bTransform = true;
 807                     }
 808                 }
 809                 else
 810                 {
 811                     // check for binary formats
 812                      const SfxFilter * pFilter = mrMedium.GetFilter();
 813                     if( pFilter )
 814                     {
 815                         const String& rTypeName = pFilter->GetRealTypeName();
 816
 817                         if( (rTypeName.CompareToAscii( RTL_CONSTASCII_STRINGPARAM("impress_StarImpress" ) ) == 0) ||
 818                             (rTypeName.CompareToAscii( RTL_CONSTASCII_STRINGPARAM("draw_StarDraw" ) ) == 0) )
 819                         {
 820                             bTransform = true;
 821                         }
 822                     }
 823                 }
 824             }
 825
 826             if( bTransform )
 827                 TransformOOo2xDocument( pDoc );
 828         }
 829     }
 830
 831     pDoc->EnableUndo(true);
 832     mrDocShell.ClearUndoBuffer();
 833     return nRet == 0;
 834 }
 835
 836 // -----------------------------------------------------------------------------
 837
 838 sal_Bool SdXMLFilter::Export()
 839 {
 840 #ifdef TIMELOG
 841     RTL_LOGFILE_CONTEXT_AUTHOR ( aLog, "sd", "cl93746", "SdXMLFilter::Export" );
 842     ByteString aFile( mrMedium.GetName(), RTL_TEXTENCODING_ASCII_US );
 843     RTL_LOGFILE_CONTEXT_TRACE1( aLog, "exporting %s", aFile.GetBuffer() );
 844 #endif
 845
 846     SvXMLEmbeddedObjectHelper*  pObjectHelper = NULL;
 847     SvXMLGraphicHelper*                 pGraphicHelper = NULL;
 848     sal_Bool                                    bDocRet = FALSE;
 849
 850     if( !mxModel.is() )
 851     {
 852         DBG_ERROR("Got NO Model in XMLExport");
 853         return FALSE;
 854     }
 855
 856     sal_Bool bLocked = mxModel->hasControllersLocked();
 857
 858     try
 859     {
 860         mxModel->lockControllers();
 861
 862         uno::Reference< lang::XServiceInfo > xServiceInfo( mxModel, uno::UNO_QUERY );
 863
 864         if( !xServiceInfo.is() || !xServiceInfo->supportsService( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.drawing.GenericDrawingDocument" ) ) ) )
 865         {
 866             DBG_ERROR( "Model is no DrawingDocument in XMLExport" );
 867             return FALSE;
 868         }
 869
 870         uno::Reference< lang::XMultiServiceFactory> xServiceFactory( ::comphelper::getProcessServiceFactory() );
 871
 872         if( !xServiceFactory.is() )
 873         {
 874             DBG_ERROR( "got no service manager" );
 875             return FALSE;
 876         }
 877
 878         uno::Reference< uno::XInterface > xWriter( xServiceFactory->createInstance( OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.xml.sax.Writer" ) ) ) );
 879
 880         if( !xWriter.is() )
 881         {
 882             DBG_ERROR( "com.sun.star.xml.sax.Writer service missing" );
 883             return FALSE;
 884         }
 885         uno::Reference<xml::sax::XDocumentHandler>      xHandler( xWriter, uno::UNO_QUERY );
 886
 887         /** property map for export info set */
 888         PropertyMapEntry aExportInfoMap[] =
 889         {
 890             // #82003#
 891             { MAP_LEN( "ProgressRange" ),       0, &::getCppuType((const sal_Int32*)0), ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 892             { MAP_LEN( "ProgressMax" ),         0, &::getCppuType((const sal_Int32*)0), ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 893             { MAP_LEN( "ProgressCurrent" ),     0, &::getCppuType((const sal_Int32*)0), ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 894             { MAP_LEN( "UsePrettyPrinting"),0, &::getBooleanCppuType(),                         ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 895                         { MAP_LEN( "GenerousListLevels"),0, &::getBooleanCppuType(),                    ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0},
 896
 897             { MAP_LEN( "PageLayoutNames" ), 0, SEQTYPE(::getCppuType((const OUString*)0)),      ::com::sun::star::beans::PropertyAttribute::MAYBEVOID,     0},
 898             { MAP_LEN( "BaseURI" ), 0,
 899                   &::getCppuType( (OUString *)0 ),
 900                   ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 901             { MAP_LEN( "StreamRelPath" ), 0,
 902                   &::getCppuType( (OUString *)0 ),
 903                   ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 904             { MAP_LEN( "StreamName" ), 0,
 905                   &::getCppuType( (OUString *)0 ),
 906                   ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 907             { MAP_LEN( "StyleNames" ), 0,
 908                   &::getCppuType( (Sequence<OUString>*)0 ),
 909                   ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 910             { MAP_LEN( "StyleFamilies" ), 0,
 911                   &::getCppuType( (Sequence<sal_Int32>*)0 ),
 912                   ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 913             { MAP_LEN( "TargetStorage" ), 0, &embed::XStorage::static_type(),
 914                   ::com::sun::star::beans::PropertyAttribute::MAYBEVOID, 0 },
 915
 916             { NULL, 0, 0, NULL, 0, 0 }
 917         };
 918
 919         uno::Reference< beans::XPropertySet > xInfoSet( GenericPropertySet_CreateInstance( new PropertySetInfo( aExportInfoMap ) ) );
 920
 921
 922         SvtSaveOptions aSaveOpt;
 923         OUString sUsePrettyPrinting(RTL_CONSTASCII_USTRINGPARAM("UsePrettyPrinting"));
 924         sal_Bool bUsePrettyPrinting( aSaveOpt.IsPrettyPrinting() );
 925         xInfoSet->setPropertyValue( sUsePrettyPrinting, makeAny( bUsePrettyPrinting ) );
 926
 927                 OUString sGenerousListLevels(RTL_CONSTASCII_USTRINGPARAM("GenerousListLevels"));
 928                 xInfoSet->setPropertyValue( sGenerousListLevels, makeAny( true ) );
 929
 930         const uno::Reference < embed::XStorage >& xStorage = mrMedium.GetOutputStorage();
 931
 932         // Set base URI
 933         OUString sPropName( RTL_CONSTASCII_USTRINGPARAM("BaseURI") );
 934         xInfoSet->setPropertyValue( sPropName, makeAny( mrMedium.GetBaseURL( true ) ) );
 935
 936         OUString sTargetStorage( RTL_CONSTASCII_USTRINGPARAM("TargetStorage") );
 937         xInfoSet->setPropertyValue( sTargetStorage, Any( xStorage ) );
 938
 939         if( SFX_CREATE_MODE_EMBEDDED == mrDocShell.GetCreateMode() )
 940         {
 941             OUString aName;
 942             if ( mrMedium.GetItemSet() )
 943             {
 944                 const SfxStringItem* pDocHierarchItem = static_cast<const SfxStringItem*>(
 945                     mrMedium.GetItemSet()->GetItem(SID_DOC_HIERARCHICALNAME) );
 946                 if ( pDocHierarchItem )
 947                     aName = pDocHierarchItem->GetValue();
 948             }
 949
 950             if( aName.getLength() )
 951             {
 952                 sPropName = OUString(RTL_CONSTASCII_USTRINGPARAM("StreamRelPath"));
 953                 xInfoSet->setPropertyValue( sPropName, makeAny( aName ) );
 954             }
 955         }
 956
 957         // initialize descriptor
 958         uno::Sequence< beans::PropertyValue > aDescriptor( 1 );
 959         beans::PropertyValue* pProps = aDescriptor.getArray();
 960
 961         pProps[0].Name = OUString( RTL_CONSTASCII_USTRINGPARAM( "FileName" ) );
 962         pProps[0].Value <<= OUString( mrMedium.GetName() );
 963
 964         {
 965             uno::Reference< document::XEmbeddedObjectResolver > xObjectResolver;
 966             uno::Reference< document::XGraphicObjectResolver >  xGrfResolver;
 967
 968             // create helper for graphic and ole export if we have a storage
 969             if( xStorage.is() )
 970             {
 971                 pObjectHelper = SvXMLEmbeddedObjectHelper::Create( xStorage, *mrDocShell.GetDoc()->GetPersist(), EMBEDDEDOBJECTHELPER_MODE_WRITE, sal_False );
 972                 xObjectResolver = pObjectHelper;
 973
 974                 pGraphicHelper = SvXMLGraphicHelper::Create( xStorage, GRAPHICHELPER_MODE_WRITE, FALSE );
 975                 xGrfResolver = pGraphicHelper;
 976             }
 977
 978             // #82003#
 979             if(mbShowProgress)
 980             {
 981                 CreateStatusIndicator();
 982                 if(mxStatusIndicator.is())
 983                 {
 984                     sal_Int32 nProgressRange(1000000);
 985                     sal_Int32 nProgressCurrent(0);
 986                     OUString aMsg = String( SdResId( STR_SAVE_DOC ) );
 987                     mxStatusIndicator->start(aMsg, nProgressRange);
 988
 989                     // set ProgressRange
 990                     uno::Any aProgRange;
 991                     aProgRange <<= nProgressRange;
 992                     xInfoSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ProgressRange")), aProgRange);
 993
 994                     // set ProgressCurrent
 995                     uno::Any aProgCurrent;
 996                     aProgCurrent <<= nProgressCurrent;
 997                     xInfoSet->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ProgressCurrent")), aProgCurrent);
 998                 }
 999             }
1000
1001             uno::Reference< lang::XComponent > xComponent( mxModel, uno::UNO_QUERY );
1002
1003             XML_SERVICES* pServiceNames = getServices( false, IsDraw(), mnStoreVer );
1004
1005             XML_SERVICEMAP aServices[5]; sal_uInt16 i = 0;
1006             aServices[i  ].mpService = pServiceNames->mpStyles;
1007             aServices[i  ].mpStream  = sXML_styleStreamName;
1008             aServices[i++].mbPlain = sal_False;
1009
1010             aServices[i  ].mpService = pServiceNames->mpContent;
1011             aServices[i  ].mpStream  = sXML_contentStreamName;
1012             aServices[i++].mbPlain = sal_False;
1013
1014             aServices[i  ].mpService = pServiceNames->mpSettings;
1015             aServices[i  ].mpStream  = sXML_settingsStreamName;
1016             aServices[i++].mbPlain = sal_False;
1017
1018             if( mrDocShell.GetCreateMode() != SFX_CREATE_MODE_EMBEDDED )
1019             {
1020                 aServices[i  ].mpService = pServiceNames->mpMeta;
1021                 aServices[i  ].mpStream  = sXML_metaStreamName;
1022                 aServices[i++].mbPlain = sal_True;
1023             };
1024
1025             aServices[i].mpService = NULL;
1026             aServices[i].mpStream  = NULL;
1027
1028             XML_SERVICEMAP* pServices = aServices;
1029
1030             // doc export
1031             do
1032             {
1033                 RTL_LOGFILE_CONTEXT_TRACE1( aLog, "exporting substream %s", pServices->mpStream );
1034
1035                 uno::Reference<io::XOutputStream> xDocOut;
1036                 if( xStorage.is() )
1037                 {
1038                     const OUString sDocName( OUString::createFromAscii( pServices->mpStream ) );
1039                     uno::Reference<io::XStream> xStream =
1040                             xStorage->openStreamElement( sDocName,
1041                             embed::ElementModes::READWRITE | embed::ElementModes::TRUNCATE );
1042
1043                     DBG_ASSERT(xStream.is(), "Can't create output stream in package!");
1044                     if( !xStream.is() )
1045                         return sal_False;
1046
1047                     xDocOut = xStream->getOutputStream();
1048                     Reference <beans::XPropertySet > xProps( xStream, uno::UNO_QUERY );
1049                     if( !xDocOut.is() || !xProps.is() )
1050                         return sal_False;
1051
1052                     uno::Any aAny; aAny <<= OUString( RTL_CONSTASCII_USTRINGPARAM("text/xml") );
1053                     xProps->setPropertyValue(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("MediaType")), aAny);
1054
1055                     OUString aUseCommonPassPropName( RTL_CONSTASCII_USTRINGPARAM("UseCommonStoragePasswordEncryption") );
1056                     if( pServices->mbPlain )
1057                         xProps->setPropertyValue( rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Compressed") ), uno::makeAny( (sal_Bool) sal_False ) );
1058                     // if the document is encrypted even the plain streams should be encrypted
1059                     xProps->setPropertyValue( aUseCommonPassPropName, uno::makeAny( (sal_Bool)sal_True ) );
1060
1061                     const OUString sStreamName( RTL_CONSTASCII_USTRINGPARAM("StreamName") );
1062                     xInfoSet->setPropertyValue( sStreamName, Any( sDocName ) );
1063                 }
1064
1065                 uno::Reference< io::XActiveDataSource > xDocSrc( xWriter, uno::UNO_QUERY );
1066                 xDocSrc->setOutputStream( xDocOut );
1067
1068                 uno::Sequence< uno::Any > aArgs( 2 + ( mxStatusIndicator.is() ? 1 : 0 ) + ( xGrfResolver.is() ? 1 : 0 ) + ( xObjectResolver.is() ? 1 : 0 ) );
1069                 uno::Any* pArgs = aArgs.getArray();
1070                 *pArgs++ <<= xInfoSet;
1071                 if( xGrfResolver.is() )                 *pArgs++ <<= xGrfResolver;
1072                 if( xObjectResolver.is() )              *pArgs++ <<= xObjectResolver;
1073                 if( mxStatusIndicator.is() )    *pArgs++ <<= mxStatusIndicator;
1074
1075                 *pArgs   <<= xHandler;
1076
1077                 uno::Reference< document::XFilter > xFilter( xServiceFactory->createInstanceWithArguments( OUString::createFromAscii( pServices->mpService ), aArgs ), uno::UNO_QUERY );
1078                 if( xFilter.is() )
1079                 {
1080                     uno::Reference< document::XExporter > xExporter( xFilter, uno::UNO_QUERY );
1081                     if( xExporter.is() )
1082                     {
1083                         xExporter->setSourceDocument( xComponent );
1084                         // outputstream will be closed by SAX parser
1085                         bDocRet = xFilter->filter( aDescriptor );
1086                     }
1087                 }
1088
1089                 pServices++;
1090             }
1091             while( bDocRet && pServices->mpService );
1092
1093             // #82003#
1094             if(mbShowProgress)
1095             {
1096                 if(mxStatusIndicator.is())
1097                     mxStatusIndicator->end();
1098             }
1099         }
1100     }
1101     catch(uno::Exception e)
1102     {
1103 #if OSL_DEBUG_LEVEL > 1
1104         ByteString aError( "uno Exception caught while exporting:\n" );
1105         aError += ByteString( String( e.Message), RTL_TEXTENCODING_ASCII_US );
1106         DBG_ERROR( aError.GetBuffer() );
1107 #endif
1108         bDocRet = sal_False;
1109     }
1110     if ( !bLocked )
1111         mxModel->unlockControllers();
1112
1113     if( pGraphicHelper )
1114         SvXMLGraphicHelper::Destroy( pGraphicHelper );
1115
1116     if( pObjectHelper )
1117         SvXMLEmbeddedObjectHelper::Destroy( pObjectHelper );
1118
1119     return bDocRet;
1120 }