svx/source/xml/xmlgrhlp.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*************************************************************************
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * Copyright 2000, 2010 Oracle and/or its affiliates.
   7  *
   8  * OpenOffice.org - a multi-platform office productivity suite
   9  *
  10  * This file is part of OpenOffice.org.
  11  *
  12  * OpenOffice.org is free software: you can redistribute it and/or modify
  13  * it under the terms of the GNU Lesser General Public License version 3
  14  * only, as published by the Free Software Foundation.
  15  *
  16  * OpenOffice.org is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU Lesser General Public License version 3 for more details
  20  * (a copy is included in the LICENSE file that accompanied this code).
  21  *
  22  * You should have received a copy of the GNU Lesser General Public License
  23  * version 3 along with OpenOffice.org.  If not, see
  24  * <http://www.openoffice.org/license.html>
  25  * for a copy of the LGPLv3 License.
  26  *
  27  ************************************************************************/
  28
  29 #include <comphelper/string.hxx>
  30 #include <sal/macros.h>
  31 #include <rtl/oustringostreaminserter.hxx>
  32 #include <rtl/strbuf.hxx>
  33 #include <com/sun/star/embed/XTransactedObject.hpp>
  34 #include <com/sun/star/embed/ElementModes.hpp>
  35 #include <com/sun/star/beans/XPropertySet.hpp>
  36 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  37 #include <com/sun/star/lang/XServiceInfo.hpp>
  38 #include <com/sun/star/lang/XInitialization.hpp>
  39 #include <cppuhelper/compbase4.hxx>
  40
  41 #include <unotools/ucbstreamhelper.hxx>
  42 #include <unotools/streamwrap.hxx>
  43 #include <unotools/tempfile.hxx>
  44 #include <unotools/saveopt.hxx>
  45 #include <tools/debug.hxx>
  46 #include <vcl/cvtgrf.hxx>
  47 #include <vcl/gfxlink.hxx>
  48 #include <vcl/metaact.hxx>
  49 #include <tools/zcodec.hxx>
  50
  51 #include "svtools/filter.hxx"
  52 #include "svx/xmlgrhlp.hxx"
  53 #include "svx/xmleohlp.hxx"
  54
  55 #include <algorithm>
  56
  57 // -----------
  58 // - Defines -
  59 // -----------
  60
  61 using namespace com::sun::star;
  62 using namespace com::sun::star::uno;
  63 using namespace com::sun::star::io;
  64
  65 using ::com::sun::star::lang::XMultiServiceFactory;
  66
  67 #define XML_GRAPHICSTORAGE_NAME     "Pictures"
  68 #define XML_GRAPHICOBJECT_URL_BASE  "vnd.sun.star.GraphicObject:"
  69
  70 // ---------------------------
  71 // - SvXMLGraphicInputStream -
  72 // ---------------------------
  73
  74 const MetaCommentAction* ImplCheckForEPS( GDIMetaFile& rMtf )
  75 {
  76     const MetaCommentAction* pComment = NULL;
  77
  78     if ( ( rMtf.GetActionSize() >= 2 )
  79             && ( rMtf.FirstAction()->GetType() == META_EPS_ACTION )
  80             && ( ((const MetaAction*)rMtf.GetAction( 1 ))->GetType() == META_COMMENT_ACTION )
  81             && ( ((const MetaCommentAction*)rMtf.GetAction( 1 ))->GetComment().equalsL(RTL_CONSTASCII_STRINGPARAM("EPSReplacementGraphic")) ) )
  82         pComment = (const MetaCommentAction*)rMtf.GetAction( 1 );
  83
  84     return pComment;
  85 }
  86
  87 class SvXMLGraphicInputStream : public::cppu::WeakImplHelper1< XInputStream >
  88 {
  89 private:
  90
  91     virtual sal_Int32   SAL_CALL    readBytes( Sequence< sal_Int8 >& aData, sal_Int32 nBytesToRead) throw(NotConnectedException, BufferSizeExceededException, RuntimeException);
  92     virtual sal_Int32   SAL_CALL    readSomeBytes(Sequence< sal_Int8 >& aData, sal_Int32 nMaxBytesToRead) throw(NotConnectedException, BufferSizeExceededException, RuntimeException);
  93     virtual void        SAL_CALL    skipBytes(sal_Int32 nBytesToSkip) throw(NotConnectedException, BufferSizeExceededException, RuntimeException);
  94     virtual sal_Int32   SAL_CALL    available() throw(NotConnectedException, RuntimeException);
  95     virtual void        SAL_CALL    closeInput() throw(NotConnectedException, RuntimeException);
  96
  97 private:
  98
  99     ::utl::TempFile                 maTmp;
 100     Reference< XInputStream >       mxStmWrapper;
 101
 102                                     // not available
 103                                     SvXMLGraphicInputStream();
 104                                     SvXMLGraphicInputStream( const SvXMLGraphicInputStream& );
 105     SvXMLGraphicInputStream&        operator==( SvXMLGraphicInputStream& );
 106
 107 public:
 108
 109                                     SvXMLGraphicInputStream( const ::rtl::OUString& rGraphicId );
 110     virtual                         ~SvXMLGraphicInputStream();
 111
 112     sal_Bool                        Exists() const { return mxStmWrapper.is(); }
 113 };
 114
 115 // -----------------------------------------------------------------------------
 116
 117 SvXMLGraphicInputStream::SvXMLGraphicInputStream( const ::rtl::OUString& rGraphicId )
 118 {
 119     GraphicObject   aGrfObject( rtl::OUStringToOString(rGraphicId, RTL_TEXTENCODING_ASCII_US) );
 120
 121     maTmp.EnableKillingFile();
 122
 123     if( aGrfObject.GetType() != GRAPHIC_NONE )
 124     {
 125         SvStream* pStm = ::utl::UcbStreamHelper::CreateStream( maTmp.GetURL(), STREAM_WRITE | STREAM_TRUNC );
 126
 127         if( pStm )
 128         {
 129             Graphic         aGraphic( (Graphic&) aGrfObject.GetGraphic() );
 130             const GfxLink   aGfxLink( aGraphic.GetLink() );
 131             sal_Bool        bRet = sal_False;
 132
 133             if( aGfxLink.GetDataSize() && aGfxLink.GetData() )
 134             {
 135                 pStm->Write( aGfxLink.GetData(), aGfxLink.GetDataSize() );
 136                 bRet = ( pStm->GetError() == 0 );
 137             }
 138             else
 139             {
 140                 if( aGraphic.GetType() == GRAPHIC_BITMAP )
 141                 {
 142                     GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
 143                     String          aFormat;
 144
 145                     if( aGraphic.IsAnimated() )
 146                         aFormat = String(  "gif"  );
 147                     else
 148                         aFormat = String(  "png"  );
 149
 150                     bRet = ( rFilter.ExportGraphic( aGraphic, String(), *pStm, rFilter.GetExportFormatNumberForShortName( aFormat ) ) == 0 );
 151                 }
 152                 else if( aGraphic.GetType() == GRAPHIC_GDIMETAFILE )
 153                 {
 154                     pStm->SetVersion( SOFFICE_FILEFORMAT_8 );
 155                     pStm->SetCompressMode( COMPRESSMODE_ZBITMAP );
 156                     ( (GDIMetaFile&) aGraphic.GetGDIMetaFile() ).Write( *pStm, GDIMETAFILE_WRITE_REPLACEMENT_RENDERGRAPHIC );
 157                     bRet = ( pStm->GetError() == 0 );
 158                 }
 159             }
 160
 161             if( bRet )
 162             {
 163                 pStm->Seek( 0 );
 164                 mxStmWrapper = new ::utl::OInputStreamWrapper( pStm, sal_True );
 165             }
 166             else
 167                 delete pStm;
 168         }
 169     }
 170 }
 171
 172 // -----------------------------------------------------------------------------
 173
 174 SvXMLGraphicInputStream::~SvXMLGraphicInputStream()
 175 {
 176 }
 177
 178 // -----------------------------------------------------------------------------
 179
 180 sal_Int32 SAL_CALL SvXMLGraphicInputStream::readBytes( Sequence< sal_Int8 >& rData, sal_Int32 nBytesToRead )
 181     throw( NotConnectedException, BufferSizeExceededException, RuntimeException )
 182 {
 183     if( !mxStmWrapper.is() )
 184         throw NotConnectedException();
 185
 186     return mxStmWrapper->readBytes( rData, nBytesToRead );
 187 }
 188
 189 // -----------------------------------------------------------------------------
 190
 191 sal_Int32 SAL_CALL SvXMLGraphicInputStream::readSomeBytes( Sequence< sal_Int8 >& rData, sal_Int32 nMaxBytesToRead )
 192     throw( NotConnectedException, BufferSizeExceededException, RuntimeException )
 193 {
 194     if( !mxStmWrapper.is() )
 195         throw NotConnectedException() ;
 196
 197     return mxStmWrapper->readSomeBytes( rData, nMaxBytesToRead );
 198 }
 199
 200 // -----------------------------------------------------------------------------
 201
 202 void SAL_CALL SvXMLGraphicInputStream::skipBytes( sal_Int32 nBytesToSkip )
 203     throw( NotConnectedException, BufferSizeExceededException, RuntimeException )
 204 {
 205     if( !mxStmWrapper.is() )
 206         throw NotConnectedException() ;
 207
 208     mxStmWrapper->skipBytes( nBytesToSkip );
 209 }
 210
 211 // -----------------------------------------------------------------------------
 212
 213 sal_Int32 SAL_CALL SvXMLGraphicInputStream::available() throw( NotConnectedException, RuntimeException )
 214 {
 215     if( !mxStmWrapper.is() )
 216         throw NotConnectedException() ;
 217
 218     return mxStmWrapper->available();
 219 }
 220
 221 // -----------------------------------------------------------------------------
 222
 223 void SAL_CALL SvXMLGraphicInputStream::closeInput() throw( NotConnectedException, RuntimeException )
 224 {
 225     if( !mxStmWrapper.is() )
 226         throw NotConnectedException() ;
 227
 228     mxStmWrapper->closeInput();
 229 }
 230
 231 // ----------------------------
 232 // - SvXMLGraphicOutputStream -
 233 // ----------------------------
 234
 235 class SvXMLGraphicOutputStream : public::cppu::WeakImplHelper1< XOutputStream >
 236 {
 237 private:
 238
 239     // XOutputStream
 240     virtual void SAL_CALL           writeBytes( const Sequence< sal_Int8 >& rData ) throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException );
 241     virtual void SAL_CALL           flush() throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException );
 242     virtual void SAL_CALL           closeOutput() throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException );
 243
 244 private:
 245
 246     ::utl::TempFile*                mpTmp;
 247     SvStream*                       mpOStm;
 248     Reference< XOutputStream >      mxStmWrapper;
 249     GraphicObject                   maGrfObj;
 250     sal_Bool                        mbClosed;
 251
 252                                     // not available
 253                                     SvXMLGraphicOutputStream( const SvXMLGraphicOutputStream& );
 254     SvXMLGraphicOutputStream&       operator==( SvXMLGraphicOutputStream& );
 255
 256 public:
 257
 258                                     SvXMLGraphicOutputStream();
 259     virtual                         ~SvXMLGraphicOutputStream();
 260
 261     sal_Bool                        Exists() const { return mxStmWrapper.is(); }
 262     const GraphicObject&            GetGraphicObject();
 263 };
 264
 265 // -----------------------------------------------------------------------------
 266
 267 SvXMLGraphicOutputStream::SvXMLGraphicOutputStream() :
 268     mpTmp( new ::utl::TempFile ),
 269     mbClosed( sal_False )
 270 {
 271     mpTmp->EnableKillingFile();
 272
 273     mpOStm = ::utl::UcbStreamHelper::CreateStream( mpTmp->GetURL(), STREAM_WRITE | STREAM_TRUNC );
 274
 275     if( mpOStm )
 276         mxStmWrapper = new ::utl::OOutputStreamWrapper( *mpOStm );
 277 }
 278
 279 // -----------------------------------------------------------------------------
 280
 281 SvXMLGraphicOutputStream::~SvXMLGraphicOutputStream()
 282 {
 283     delete mpTmp;
 284     delete mpOStm;
 285 }
 286
 287 // -----------------------------------------------------------------------------
 288
 289 void SAL_CALL SvXMLGraphicOutputStream::writeBytes( const Sequence< sal_Int8 >& rData )
 290     throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException )
 291 {
 292     if( !mxStmWrapper.is() )
 293         throw NotConnectedException() ;
 294
 295     mxStmWrapper->writeBytes( rData );
 296 }
 297
 298 // -----------------------------------------------------------------------------
 299
 300 void SAL_CALL SvXMLGraphicOutputStream::flush()
 301     throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException )
 302 {
 303     if( !mxStmWrapper.is() )
 304         throw NotConnectedException() ;
 305
 306     mxStmWrapper->flush();
 307 }
 308
 309 // -----------------------------------------------------------------------------
 310
 311 void SAL_CALL SvXMLGraphicOutputStream::closeOutput()
 312     throw( NotConnectedException, BufferSizeExceededException, IOException, RuntimeException )
 313 {
 314     if( !mxStmWrapper.is() )
 315         throw NotConnectedException() ;
 316
 317     mxStmWrapper->closeOutput();
 318     mxStmWrapper = Reference< XOutputStream >();
 319
 320     mbClosed = sal_True;
 321 }
 322
 323 // ------------------------------------------------------------------------------
 324
 325 const GraphicObject& SvXMLGraphicOutputStream::GetGraphicObject()
 326 {
 327     if( mbClosed && ( maGrfObj.GetType() == GRAPHIC_NONE ) && mpOStm )
 328     {
 329         Graphic aGraphic;
 330
 331         mpOStm->Seek( 0 );
 332         sal_uInt16 nFormat = GRFILTER_FORMAT_DONTKNOW;
 333         sal_uInt16 pDeterminedFormat = GRFILTER_FORMAT_DONTKNOW;
 334         GraphicFilter::GetGraphicFilter().ImportGraphic( aGraphic, String(), *mpOStm ,nFormat,&pDeterminedFormat );
 335
 336         if (pDeterminedFormat == GRFILTER_FORMAT_DONTKNOW)
 337         {
 338             //Read the first two byte to check whether it is a gzipped stream, is so it may be in wmz or emz format
 339             //unzip them and try again
 340
 341             sal_uInt8    sFirstBytes[ 2 ];
 342
 343             mpOStm->Seek( STREAM_SEEK_TO_END );
 344             sal_uIntPtr nStreamLen = mpOStm->Tell();
 345             mpOStm->Seek( 0 );
 346
 347             if ( !nStreamLen )
 348             {
 349                 SvLockBytes* pLockBytes = mpOStm->GetLockBytes();
 350                 if ( pLockBytes  )
 351                     pLockBytes->SetSynchronMode( sal_True );
 352
 353                 mpOStm->Seek( STREAM_SEEK_TO_END );
 354                 nStreamLen = mpOStm->Tell();
 355                 mpOStm->Seek( 0 );
 356             }
 357             if( nStreamLen >= 2 )
 358             {
 359                 //read two byte
 360                 mpOStm->Read( sFirstBytes, 2 );
 361
 362                 if( sFirstBytes[0] == 0x1f && sFirstBytes[1] == 0x8b )
 363                 {
 364                     SvMemoryStream* pDest = new SvMemoryStream;
 365                     ZCodec aZCodec( 0x8000, 0x8000 );
 366                     aZCodec.BeginCompression(ZCODEC_GZ_LIB);
 367                     mpOStm->Seek( 0 );
 368                     aZCodec.Decompress( *mpOStm, *pDest );
 369
 370                     if (aZCodec.EndCompression() && pDest )
 371                     {
 372                         pDest->Seek( STREAM_SEEK_TO_END );
 373                         sal_uIntPtr nStreamLen_ = pDest->Tell();
 374                         if (nStreamLen_)
 375                         {
 376                             pDest->Seek(0L);
 377                             GraphicFilter::GetGraphicFilter().ImportGraphic( aGraphic, String(), *pDest ,nFormat,&pDeterminedFormat );
 378                         }
 379                     }
 380                     delete pDest;
 381                 }
 382             }
 383         }
 384
 385         maGrfObj = aGraphic;
 386         if( maGrfObj.GetType() != GRAPHIC_NONE )
 387         {
 388             delete mpOStm, mpOStm = NULL;
 389             delete mpTmp, mpTmp = NULL;
 390         }
 391     }
 392
 393     return maGrfObj;
 394 }
 395
 396 // ----------------------
 397 // - SvXMLGraphicHelper -
 398 // ----------------------
 399
 400 SvXMLGraphicHelper::SvXMLGraphicHelper( SvXMLGraphicHelperMode eCreateMode ) :
 401     ::cppu::WeakComponentImplHelper2< ::com::sun::star::document::XGraphicObjectResolver,
 402                                       ::com::sun::star::document::XBinaryStreamResolver >( maMutex )
 403 {
 404     Init( NULL, eCreateMode, sal_False );
 405 }
 406
 407 SvXMLGraphicHelper::SvXMLGraphicHelper() :
 408     ::cppu::WeakComponentImplHelper2< ::com::sun::star::document::XGraphicObjectResolver,
 409                                       ::com::sun::star::document::XBinaryStreamResolver >( maMutex )
 410 {
 411 }
 412
 413 // -----------------------------------------------------------------------------
 414
 415 SvXMLGraphicHelper::~SvXMLGraphicHelper()
 416 {
 417 }
 418
 419 // -----------------------------------------------------------------------------
 420
 421 void SAL_CALL SvXMLGraphicHelper::disposing()
 422 {
 423 }
 424
 425 // -----------------------------------------------------------------------------
 426
 427 sal_Bool SvXMLGraphicHelper::ImplGetStreamNames( const ::rtl::OUString& rURLStr,
 428                                                  ::rtl::OUString& rPictureStorageName,
 429                                                  ::rtl::OUString& rPictureStreamName )
 430 {
 431     String      aURLStr( rURLStr );
 432     sal_Bool    bRet = sal_False;
 433
 434     if( aURLStr.Len() )
 435     {
 436         aURLStr = aURLStr.GetToken( comphelper::string::getTokenCount(aURLStr, ':') - 1, ':' );
 437
 438         const sal_uInt32 nTokenCount = comphelper::string::getTokenCount(aURLStr, '/');
 439
 440         if( 1 == nTokenCount )
 441         {
 442             rPictureStorageName = String(  XML_GRAPHICSTORAGE_NAME  );
 443             rPictureStreamName = aURLStr;
 444         }
 445         else
 446             SvXMLEmbeddedObjectHelper::splitObjectURL(aURLStr, rPictureStorageName, rPictureStreamName);
 447
 448         bRet = !rPictureStreamName.isEmpty();
 449         SAL_WARN_IF(!bRet, "svx", "SvXMLGraphicHelper::ImplInsertGraphicURL: invalid scheme: " << rURLStr);
 450     }
 451
 452     return bRet;
 453 }
 454
 455 // -----------------------------------------------------------------------------
 456
 457 uno::Reference < embed::XStorage > SvXMLGraphicHelper::ImplGetGraphicStorage( const ::rtl::OUString& rStorageName )
 458 {
 459     uno::Reference < embed::XStorage > xRetStorage;
 460     if( mxRootStorage.is() )
 461     {
 462         try
 463         {
 464             xRetStorage = mxRootStorage->openStorageElement(
 465                 maCurStorageName = rStorageName,
 466                 ( GRAPHICHELPER_MODE_WRITE == meCreateMode )
 467                     ? embed::ElementModes::READWRITE
 468                     : embed::ElementModes::READ );
 469         }
 470         catch ( uno::Exception& )
 471         {
 472         }
 473         //#i43196# try again to open the storage element - this time readonly
 474         if(!xRetStorage.is())
 475         {
 476             try
 477             {
 478                 xRetStorage = mxRootStorage->openStorageElement( maCurStorageName = rStorageName, embed::ElementModes::READ );
 479             }
 480             catch ( uno::Exception& )
 481             {
 482             }
 483         }
 484     }
 485
 486     return xRetStorage;
 487 }
 488
 489 // -----------------------------------------------------------------------------
 490
 491 SvxGraphicHelperStream_Impl SvXMLGraphicHelper::ImplGetGraphicStream( const ::rtl::OUString& rPictureStorageName,
 492                                                               const ::rtl::OUString& rPictureStreamName,
 493                                                               sal_Bool bTruncate )
 494 {
 495     SvxGraphicHelperStream_Impl aRet;
 496     aRet.xStorage = ImplGetGraphicStorage( rPictureStorageName );
 497
 498     if( aRet.xStorage.is() )
 499     {
 500         sal_Int32 nMode = embed::ElementModes::READ;
 501         if ( GRAPHICHELPER_MODE_WRITE == meCreateMode )
 502         {
 503             nMode = embed::ElementModes::READWRITE;
 504             if ( bTruncate )
 505                 nMode |= embed::ElementModes::TRUNCATE;
 506         }
 507
 508         aRet.xStream = aRet.xStorage->openStreamElement( rPictureStreamName, nMode );
 509         if( aRet.xStream.is() && ( GRAPHICHELPER_MODE_WRITE == meCreateMode ) )
 510         {
 511             ::rtl::OUString aPropName( "UseCommonStoragePasswordEncryption" );
 512             uno::Reference < beans::XPropertySet > xProps( aRet.xStream, uno::UNO_QUERY );
 513             xProps->setPropertyValue( aPropName, uno::makeAny( sal_True) );
 514         }
 515     }
 516
 517     return aRet;
 518 }
 519
 520 // -----------------------------------------------------------------------------
 521
 522 String SvXMLGraphicHelper::ImplGetGraphicMimeType( const String& rFileName ) const
 523 {
 524     struct XMLGraphicMimeTypeMapper
 525     {
 526         const char* pExt;
 527         const char* pMimeType;
 528     };
 529
 530     static XMLGraphicMimeTypeMapper aMapper[] =
 531     {
 532         { "gif", "image/gif" },
 533         { "png", "image/png" },
 534         { "jpg", "image/jpeg" },
 535         { "tif", "image/tiff" },
 536         { "svg", "image/svg+xml" }
 537     };
 538
 539     String aMimeType;
 540
 541     if( ( rFileName.Len() >= 4 ) && ( rFileName.GetChar( rFileName.Len() - 4 ) == '.' ) )
 542     {
 543         const rtl::OString aExt(rtl::OUStringToOString(rFileName.Copy(rFileName.Len() - 3),
 544             RTL_TEXTENCODING_ASCII_US));
 545
 546         for( long i = 0, nCount = sizeof (aMapper) / sizeof (aMapper[0]); ( i < nCount ) && !aMimeType.Len(); i++ )
 547             if( aExt.getStr() == aMapper[ i ].pExt )
 548                 aMimeType = String( aMapper[ i ].pMimeType, RTL_TEXTENCODING_ASCII_US );
 549     }
 550
 551     return aMimeType;
 552 }
 553
 554 // -----------------------------------------------------------------------------
 555
 556 Graphic SvXMLGraphicHelper::ImplReadGraphic( const ::rtl::OUString& rPictureStorageName,
 557                                              const ::rtl::OUString& rPictureStreamName )
 558 {
 559     Graphic             aGraphic;
 560     SvxGraphicHelperStream_Impl aStream( ImplGetGraphicStream( rPictureStorageName, rPictureStreamName, sal_False ) );
 561     if( aStream.xStream.is() )
 562     {
 563         SvStream* pStream = utl::UcbStreamHelper::CreateStream( aStream.xStream );
 564         GraphicFilter::GetGraphicFilter().ImportGraphic( aGraphic, String(), *pStream );
 565         delete pStream;
 566     }
 567
 568     return aGraphic;
 569 }
 570
 571 // -----------------------------------------------------------------------------
 572
 573 sal_Bool SvXMLGraphicHelper::ImplWriteGraphic( const ::rtl::OUString& rPictureStorageName,
 574                                                const ::rtl::OUString& rPictureStreamName,
 575                                                const ::rtl::OUString& rGraphicId,
 576                                                bool bUseGfxLink )
 577 {
 578     GraphicObject   aGrfObject( rtl::OUStringToOString(rGraphicId, RTL_TEXTENCODING_ASCII_US) );
 579     sal_Bool        bRet = sal_False;
 580
 581     if( aGrfObject.GetType() != GRAPHIC_NONE )
 582     {
 583         SvxGraphicHelperStream_Impl aStream( ImplGetGraphicStream( rPictureStorageName, rPictureStreamName, sal_False ) );
 584         if( aStream.xStream.is() )
 585         {
 586             Graphic         aGraphic( (Graphic&) aGrfObject.GetGraphic() );
 587             const GfxLink   aGfxLink( aGraphic.GetLink() );
 588             const ::rtl::OUString  aMimeType( ImplGetGraphicMimeType( rPictureStreamName ) );
 589             uno::Any        aAny;
 590             uno::Reference < beans::XPropertySet > xProps( aStream.xStream, uno::UNO_QUERY );
 591
 592             // set stream properties (MediaType/Compression)
 593             if( !aMimeType.isEmpty() )
 594             {
 595                 aAny <<= aMimeType;
 596                 xProps->setPropertyValue( String(  "MediaType"  ), aAny );
 597             }
 598
 599             const sal_Bool bCompressed = aMimeType.isEmpty() || aMimeType == "image/tiff";
 600             aAny <<= bCompressed;
 601             xProps->setPropertyValue( String(  "Compressed"  ), aAny );
 602
 603             SvStream* pStream = utl::UcbStreamHelper::CreateStream( aStream.xStream );
 604             if( bUseGfxLink && aGfxLink.GetDataSize() && aGfxLink.GetData() )
 605                 pStream->Write( aGfxLink.GetData(), aGfxLink.GetDataSize() );
 606             else
 607             {
 608                 if( aGraphic.GetType() == GRAPHIC_BITMAP )
 609                 {
 610                     GraphicFilter &rFilter = GraphicFilter::GetGraphicFilter();
 611                     String          aFormat;
 612
 613                     if( aGraphic.IsAnimated() )
 614                         aFormat = String(  "gif"  );
 615                     else
 616                         aFormat = String(  "png"  );
 617
 618                     bRet = ( rFilter.ExportGraphic( aGraphic, String(), *pStream,
 619                                                      rFilter.GetExportFormatNumberForShortName( aFormat ) ) == 0 );
 620                 }
 621                 else if( aGraphic.GetType() == GRAPHIC_GDIMETAFILE )
 622                 {
 623                     pStream->SetVersion( SOFFICE_FILEFORMAT_8 );
 624                     pStream->SetCompressMode( COMPRESSMODE_ZBITMAP );
 625
 626                     // SJ: first check if this metafile is just a eps file, then we will store the eps instead of svm
 627                     GDIMetaFile& rMtf( (GDIMetaFile&)aGraphic.GetGDIMetaFile() );
 628                     const MetaCommentAction* pComment = ImplCheckForEPS( rMtf );
 629                     if ( pComment )
 630                     {
 631                         sal_uInt32  nSize = pComment->GetDataSize();
 632                         const sal_uInt8* pData = pComment->GetData();
 633                         if ( nSize && pData )
 634                             pStream->Write( pData, nSize );
 635
 636                         const MetaEPSAction* pAct = ( (const MetaEPSAction*)rMtf.FirstAction() );
 637                         const GfxLink&       rLink = pAct->GetLink();
 638
 639                         pStream->Write( rLink.GetData(), rLink.GetDataSize() );
 640                     }
 641                     else
 642                         rMtf.Write( *pStream, GDIMETAFILE_WRITE_REPLACEMENT_RENDERGRAPHIC );
 643
 644                     bRet = ( pStream->GetError() == 0 );
 645                 }
 646             }
 647             uno::Reference < embed::XTransactedObject > xStorage(
 648                                     aStream.xStorage, uno::UNO_QUERY);
 649             delete pStream;
 650             aStream.xStream->getOutputStream()->closeOutput();
 651             if( xStorage.is() )
 652                 xStorage->commit();
 653         }
 654     }
 655
 656     return bRet;
 657 }
 658
 659 // -----------------------------------------------------------------------------
 660
 661 void SvXMLGraphicHelper::ImplInsertGraphicURL( const ::rtl::OUString& rURLStr, sal_uInt32 nInsertPos, rtl::OUString& rRequestedFileName )
 662 {
 663     rtl::OUString aURLString( rURLStr );
 664     ::rtl::OUString aPictureStorageName, aPictureStreamName;
 665     if( ( maURLSet.find( aURLString ) != maURLSet.end() ) )
 666     {
 667         URLPairVector::iterator aIter( maGrfURLs.begin() ), aEnd( maGrfURLs.end() );
 668         while( aIter != aEnd )
 669         {
 670             if( aURLString == (*aIter).first )
 671             {
 672                 maGrfURLs[ nInsertPos ].second = (*aIter).second;
 673                 aIter = aEnd;
 674             }
 675             else
 676                 aIter++;
 677         }
 678     }
 679     else if( ImplGetStreamNames( aURLString, aPictureStorageName, aPictureStreamName ) )
 680     {
 681         URLPair& rURLPair = maGrfURLs[ nInsertPos ];
 682
 683         if( GRAPHICHELPER_MODE_READ == meCreateMode )
 684         {
 685             const GraphicObject aObj( ImplReadGraphic( aPictureStorageName, aPictureStreamName ) );
 686
 687             if( aObj.GetType() != GRAPHIC_NONE )
 688             {
 689                 maGrfObjs.push_back( aObj );
 690                 ::rtl::OUString aBaseURL(  XML_GRAPHICOBJECT_URL_BASE  );
 691
 692                 rURLPair.second = aBaseURL;
 693                 rURLPair.second += rtl::OStringToOUString(aObj.GetUniqueID(),
 694                     RTL_TEXTENCODING_ASCII_US);
 695             }
 696             else
 697                 rURLPair.second = String();
 698         }
 699         else
 700         {
 701             const String        aGraphicObjectId( aPictureStreamName );
 702             const rtl::OString aAsciiObjectID(rtl::OUStringToOString(aGraphicObjectId, RTL_TEXTENCODING_ASCII_US));
 703             const GraphicObject aGrfObject( aAsciiObjectID );
 704             if( aGrfObject.GetType() != GRAPHIC_NONE )
 705             {
 706                 String          aStreamName( aGraphicObjectId );
 707                 Graphic         aGraphic( (Graphic&) aGrfObject.GetGraphic() );
 708                 const GfxLink   aGfxLink( aGraphic.GetLink() );
 709                 String          aExtension;
 710                 bool            bUseGfxLink( true );
 711
 712                 if( aGfxLink.GetDataSize() )
 713                 {
 714                     switch( aGfxLink.GetType() )
 715                     {
 716                         case( GFX_LINK_TYPE_EPS_BUFFER ): aExtension = String(  ".eps"  ); break;
 717                         case( GFX_LINK_TYPE_NATIVE_GIF ): aExtension = String(  ".gif"  ); break;
 718                         case( GFX_LINK_TYPE_NATIVE_JPG ): aExtension = String(  ".jpg"  ); break;
 719                         case( GFX_LINK_TYPE_NATIVE_PNG ): aExtension = String(  ".png"  ); break;
 720                         case( GFX_LINK_TYPE_NATIVE_TIF ): aExtension = String(  ".tif"  ); break;
 721                         case( GFX_LINK_TYPE_NATIVE_WMF ): aExtension = String(  ".wmf"  ); break;
 722                         case( GFX_LINK_TYPE_NATIVE_MET ): aExtension = String(  ".met"  ); break;
 723                         case( GFX_LINK_TYPE_NATIVE_PCT ): aExtension = String(  ".pct"  ); break;
 724                         case( GFX_LINK_TYPE_NATIVE_SVG ):
 725                             // backward-compat kludge: since no released OOo
 726                             // version to date can handle svg properly, wrap it up
 727                             // into an svm. slight catch22 here, since strict ODF
 728                             // conformance _recommends_ svg - then again, most old
 729                             // ODF consumers are believed to be OOo
 730                             if( SvtSaveOptions().GetODFDefaultVersion() <= SvtSaveOptions::ODFVER_012 )
 731                             {
 732                                 bUseGfxLink = false;
 733                                 aExtension = String(  ".svm"  );
 734                             }
 735                             else
 736                                 aExtension = String(  ".svg"  );
 737                             break;
 738
 739                         default:
 740                             aExtension = String(  ".grf"  );
 741                         break;
 742                     }
 743                 }
 744                 else
 745                 {
 746                     if( aGrfObject.GetType() == GRAPHIC_BITMAP )
 747                     {
 748                         if( aGrfObject.IsAnimated() )
 749                             aExtension = String(  ".gif"  );
 750                         else
 751                             aExtension = String(  ".png"  );
 752                     }
 753                     else if( aGrfObject.GetType() == GRAPHIC_GDIMETAFILE )
 754                     {
 755                         // SJ: first check if this metafile is just a eps file, then we will store the eps instead of svm
 756                         GDIMetaFile& rMtf( (GDIMetaFile&)aGraphic.GetGDIMetaFile() );
 757                         if ( ImplCheckForEPS( rMtf ) )
 758                             aExtension = String(  ".eps"  );
 759                         else
 760                             aExtension = String(  ".svm"  );
 761                     }
 762                 }
 763
 764                 rtl::OUString aURLEntry;
 765                 const String sPictures(  "Pictures/"  );
 766
 767                 if ( !rRequestedFileName.isEmpty() )
 768                 {
 769                     aURLEntry = sPictures;
 770                     aURLEntry += rRequestedFileName;
 771                     aURLEntry += aExtension;
 772
 773                     URLPairVector::iterator aIter( maGrfURLs.begin() ), aEnd( maGrfURLs.end() );
 774                     while( aIter != aEnd )
 775                     {
 776                         if( aURLEntry == (*aIter).second )
 777                             break;
 778                         aIter++;
 779                     }
 780                     if ( aIter == aEnd )
 781                         aStreamName = rRequestedFileName;
 782                 }
 783
 784                 aStreamName += aExtension;
 785
 786                 if( mbDirect && aStreamName.Len() )
 787                     ImplWriteGraphic( aPictureStorageName, aStreamName, aGraphicObjectId, bUseGfxLink );
 788
 789                 rURLPair.second = sPictures;
 790                 rURLPair.second += aStreamName;
 791             }
 792 #if OSL_DEBUG_LEVEL > 0
 793             else
 794             {
 795                 rtl::OStringBuffer sMessage(
 796                     RTL_CONSTASCII_STRINGPARAM("graphic object with ID '"));
 797                 sMessage.append(aAsciiObjectID).
 798                     append(RTL_CONSTASCII_STRINGPARAM("' has an unknown type"));
 799                 OSL_ENSURE( false, sMessage.getStr() );
 800             }
 801 #endif
 802         }
 803
 804         maURLSet.insert( aURLString );
 805     }
 806 }
 807
 808 // -----------------------------------------------------------------------------
 809
 810 void SvXMLGraphicHelper::Init( const uno::Reference < embed::XStorage >& rXMLStorage,
 811                                SvXMLGraphicHelperMode eCreateMode,
 812                                sal_Bool bDirect )
 813 {
 814     mxRootStorage = rXMLStorage;
 815     meCreateMode = eCreateMode;
 816     mbDirect = ( ( GRAPHICHELPER_MODE_READ == meCreateMode ) ? bDirect : sal_True );
 817 }
 818
 819 // -----------------------------------------------------------------------------
 820
 821 SvXMLGraphicHelper* SvXMLGraphicHelper::Create( const uno::Reference < embed::XStorage >& rXMLStorage,
 822                                                 SvXMLGraphicHelperMode eCreateMode,
 823                                                 sal_Bool bDirect )
 824 {
 825     SvXMLGraphicHelper* pThis = new SvXMLGraphicHelper;
 826
 827     pThis->acquire();
 828     pThis->Init( rXMLStorage, eCreateMode, bDirect );
 829
 830     return pThis;
 831 }
 832
 833 // -----------------------------------------------------------------------------
 834
 835 SvXMLGraphicHelper* SvXMLGraphicHelper::Create( SvXMLGraphicHelperMode eCreateMode )
 836 {
 837     SvXMLGraphicHelper* pThis = new SvXMLGraphicHelper;
 838
 839     pThis->acquire();
 840     pThis->Init( NULL, eCreateMode, sal_False );
 841
 842     return pThis;
 843 }
 844
 845 // -----------------------------------------------------------------------------
 846
 847 void SvXMLGraphicHelper::Destroy( SvXMLGraphicHelper* pSvXMLGraphicHelper )
 848 {
 849     if( pSvXMLGraphicHelper )
 850     {
 851         pSvXMLGraphicHelper->dispose();
 852         pSvXMLGraphicHelper->release();
 853     }
 854 }
 855
 856 // -----------------------------------------------------------------------------
 857
 858 // XGraphicObjectResolver
 859 ::rtl::OUString SAL_CALL SvXMLGraphicHelper::resolveGraphicObjectURL( const ::rtl::OUString& rURL )
 860     throw(uno::RuntimeException)
 861 {
 862     ::osl::MutexGuard   aGuard( maMutex );
 863     const sal_Int32     nIndex = maGrfURLs.size();
 864
 865     rtl::OUString aURL( rURL );
 866     rtl::OUString aUserData;
 867     rtl::OUString aRequestedFileName;
 868
 869     sal_Int32 nUser = rURL.indexOf( '?', 0 );
 870     if ( nUser >= 0 )
 871     {
 872         aURL = rtl::OUString( rURL.copy( 0, nUser ) );
 873         nUser++;
 874         aUserData = rURL.copy( nUser, rURL.getLength() - nUser );
 875     }
 876     if ( !aUserData.isEmpty() )
 877     {
 878         sal_Int32 nIndex2 = 0;
 879         do
 880         {
 881             rtl::OUString aToken = aUserData.getToken( 0, ';', nIndex2 );
 882             sal_Int32 n = aToken.indexOf( '=' );
 883             if ( ( n > 0 ) && ( ( n + 1 ) < aToken.getLength() ) )
 884             {
 885                 rtl::OUString aParam( aToken.copy( 0, n ) );
 886                 rtl::OUString aValue( aToken.copy( n + 1, aToken.getLength() - ( n + 1 ) ) );
 887
 888                 const rtl::OUString sRequestedName( "requestedName" );
 889                 if ( aParam.match( sRequestedName ) )
 890                     aRequestedFileName = aValue;
 891             }
 892         }
 893         while ( nIndex2 >= 0 );
 894     }
 895
 896     maGrfURLs.push_back( ::std::make_pair( aURL, ::rtl::OUString() ) );
 897     ImplInsertGraphicURL( aURL, nIndex, aRequestedFileName );
 898
 899     return maGrfURLs[ nIndex ].second;
 900 }
 901
 902 // -----------------------------------------------------------------------------
 903
 904 // XBinaryStreamResolver
 905 Reference< XInputStream > SAL_CALL SvXMLGraphicHelper::getInputStream( const ::rtl::OUString& rURL )
 906     throw( RuntimeException )
 907 {
 908     Reference< XInputStream >   xRet;
 909     ::rtl::OUString                    aPictureStorageName, aGraphicId;
 910
 911
 912     if( ( GRAPHICHELPER_MODE_WRITE == meCreateMode ) &&
 913         ImplGetStreamNames( rURL, aPictureStorageName, aGraphicId ) )
 914     {
 915         SvXMLGraphicInputStream* pInputStream = new SvXMLGraphicInputStream( aGraphicId );
 916
 917         if( pInputStream->Exists() )
 918             xRet = pInputStream;
 919         else
 920             delete pInputStream;
 921     }
 922
 923     return xRet;
 924 }
 925
 926 // -----------------------------------------------------------------------------
 927
 928 Reference< XOutputStream > SAL_CALL SvXMLGraphicHelper::createOutputStream()
 929     throw( RuntimeException )
 930 {
 931     Reference< XOutputStream > xRet;
 932
 933     if( GRAPHICHELPER_MODE_READ == meCreateMode )
 934     {
 935         SvXMLGraphicOutputStream* pOutputStream = new SvXMLGraphicOutputStream;
 936
 937         if( pOutputStream->Exists() )
 938             maGrfStms.push_back( xRet = pOutputStream );
 939         else
 940             delete pOutputStream;
 941     }
 942
 943     return xRet;
 944 }
 945
 946 // -----------------------------------------------------------------------------
 947
 948 ::rtl::OUString SAL_CALL SvXMLGraphicHelper::resolveOutputStream( const Reference< XOutputStream >& rxBinaryStream )
 949     throw( RuntimeException )
 950 {
 951     ::rtl::OUString aRet;
 952
 953     if( ( GRAPHICHELPER_MODE_READ == meCreateMode ) && rxBinaryStream.is() )
 954     {
 955         if( ::std::find( maGrfStms.begin(), maGrfStms.end(), rxBinaryStream ) != maGrfStms.end() )
 956         {
 957             SvXMLGraphicOutputStream* pOStm = static_cast< SvXMLGraphicOutputStream* >( rxBinaryStream.get() );
 958
 959             if( pOStm )
 960             {
 961                 const GraphicObject& rGrfObj = pOStm->GetGraphicObject();
 962                 const ::rtl::OUString aId(::rtl::OStringToOUString(
 963                     rGrfObj.GetUniqueID(), RTL_TEXTENCODING_ASCII_US));
 964
 965                 if( !aId.isEmpty() )
 966                 {
 967                     aRet = ::rtl::OUString( XML_GRAPHICOBJECT_URL_BASE );
 968                     aRet += aId;
 969                 }
 970             }
 971         }
 972     }
 973
 974     return aRet;
 975 }
 976
 977
 978 // --------------------------------------------------------------------------------
 979
 980 // for instantiation via service manager
 981 namespace svx
 982 {
 983
 984 namespace impl
 985 {
 986 typedef ::cppu::WeakComponentImplHelper4<
 987         lang::XInitialization,
 988         document::XGraphicObjectResolver,
 989         document::XBinaryStreamResolver,
 990         lang::XServiceInfo >
 991     SvXMLGraphicImportExportHelper_Base;
 992 class MutexContainer
 993 {
 994 public:
 995     virtual ~MutexContainer();
 996
 997 protected:
 998     mutable ::osl::Mutex m_aMutex;
 999 };
1000 MutexContainer::~MutexContainer()
1001 {}
1002 } // namespace impl
1003
1004 class SvXMLGraphicImportExportHelper :
1005     public impl::MutexContainer,
1006     public impl::SvXMLGraphicImportExportHelper_Base
1007 {
1008 public:
1009     SvXMLGraphicImportExportHelper( SvXMLGraphicHelperMode eMode );
1010
1011 protected:
1012     // is called from WeakComponentImplHelper when XComponent::dispose() was
1013     // called from outside
1014     virtual void SAL_CALL disposing();
1015
1016     // ____ XInitialization ____
1017     // one argument is allowed, which is the XStorage
1018     virtual void SAL_CALL initialize( const Sequence< Any >& aArguments )
1019         throw (Exception,
1020                RuntimeException);
1021
1022     // ____ XGraphicObjectResolver ____
1023     virtual ::rtl::OUString SAL_CALL resolveGraphicObjectURL( const ::rtl::OUString& aURL )
1024         throw (RuntimeException);
1025
1026     // ____ XBinaryStreamResolver ____
1027     virtual Reference< io::XInputStream > SAL_CALL getInputStream( const ::rtl::OUString& aURL )
1028         throw (RuntimeException);
1029     virtual Reference< io::XOutputStream > SAL_CALL createOutputStream()
1030         throw (RuntimeException);
1031     virtual ::rtl::OUString SAL_CALL resolveOutputStream( const Reference< io::XOutputStream >& aBinaryStream )
1032         throw (RuntimeException);
1033
1034     // ____ XServiceInfo ____
1035     virtual ::rtl::OUString SAL_CALL getImplementationName()
1036         throw (RuntimeException);
1037     virtual ::sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName )
1038         throw (RuntimeException);
1039     virtual Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames()
1040         throw (RuntimeException);
1041
1042 private:
1043     SvXMLGraphicHelperMode              m_eGraphicHelperMode;
1044     Reference< XGraphicObjectResolver > m_xGraphicObjectResolver;
1045     Reference< XBinaryStreamResolver >  m_xBinaryStreamResolver;
1046 };
1047
1048 SvXMLGraphicImportExportHelper::SvXMLGraphicImportExportHelper( SvXMLGraphicHelperMode eMode ) :
1049         impl::SvXMLGraphicImportExportHelper_Base( m_aMutex ),
1050         m_eGraphicHelperMode( eMode )
1051 {}
1052
1053 void SAL_CALL SvXMLGraphicImportExportHelper::disposing()
1054 {
1055     Reference< XComponent > xComp( m_xGraphicObjectResolver, UNO_QUERY );
1056     OSL_ASSERT( xComp.is());
1057     if( xComp.is())
1058         xComp->dispose();
1059     // m_xBinaryStreamResolver is a reference to the same object => don't call
1060     // dispose() again
1061 }
1062
1063 // ____ XInitialization ____
1064 void SAL_CALL SvXMLGraphicImportExportHelper::initialize(
1065     const Sequence< Any >& aArguments )
1066     throw (Exception, RuntimeException)
1067 {
1068     Reference< embed::XStorage > xStorage;
1069     if( aArguments.getLength() > 0 )
1070         aArguments[0] >>= xStorage;
1071
1072     SvXMLGraphicHelper * pHelper( SvXMLGraphicHelper::Create( xStorage, m_eGraphicHelperMode ));
1073     m_xGraphicObjectResolver.set( pHelper );
1074     m_xBinaryStreamResolver.set( pHelper );
1075     // SvXMLGraphicHelper::Create calls acquire.  Since we have two references
1076     // now it is safe (and necessary) to undo this acquire
1077     pHelper->release();
1078 }
1079
1080 // ____ XGraphicObjectResolver ____
1081 ::rtl::OUString SAL_CALL SvXMLGraphicImportExportHelper::resolveGraphicObjectURL( const ::rtl::OUString& aURL )
1082     throw (uno::RuntimeException)
1083 {
1084     return m_xGraphicObjectResolver->resolveGraphicObjectURL( aURL );
1085 }
1086
1087
1088 // ____ XBinaryStreamResolver ____
1089 Reference< io::XInputStream > SAL_CALL SvXMLGraphicImportExportHelper::getInputStream( const ::rtl::OUString& aURL )
1090     throw (uno::RuntimeException)
1091 {
1092     return m_xBinaryStreamResolver->getInputStream( aURL );
1093 }
1094 Reference< io::XOutputStream > SAL_CALL SvXMLGraphicImportExportHelper::createOutputStream()
1095     throw (uno::RuntimeException)
1096 {
1097     return m_xBinaryStreamResolver->createOutputStream();
1098 }
1099 ::rtl::OUString SAL_CALL SvXMLGraphicImportExportHelper::resolveOutputStream( const Reference< io::XOutputStream >& aBinaryStream )
1100     throw (uno::RuntimeException)
1101 {
1102     return m_xBinaryStreamResolver->resolveOutputStream( aBinaryStream );
1103 }
1104
1105 // ____ XServiceInfo ____
1106 ::rtl::OUString SAL_CALL SvXMLGraphicImportExportHelper::getImplementationName()
1107     throw (uno::RuntimeException)
1108 {
1109     if( m_eGraphicHelperMode == GRAPHICHELPER_MODE_READ )
1110         return SvXMLGraphicImportHelper_getImplementationName();
1111     return SvXMLGraphicExportHelper_getImplementationName();
1112 }
1113 ::sal_Bool SAL_CALL SvXMLGraphicImportExportHelper::supportsService( const ::rtl::OUString& ServiceName )
1114     throw (uno::RuntimeException)
1115 {
1116     Sequence< ::rtl::OUString > aServiceNames( getSupportedServiceNames());
1117     const ::rtl::OUString * pBegin = aServiceNames.getConstArray();
1118     const ::rtl::OUString * pEnd = pBegin + aServiceNames.getLength();
1119     return (::std::find( pBegin, pEnd, ServiceName ) != pEnd);
1120 }
1121 Sequence< ::rtl::OUString > SAL_CALL SvXMLGraphicImportExportHelper::getSupportedServiceNames()
1122     throw (uno::RuntimeException)
1123 {
1124     if( m_eGraphicHelperMode == GRAPHICHELPER_MODE_READ )
1125         return SvXMLGraphicImportHelper_getSupportedServiceNames();
1126     return SvXMLGraphicExportHelper_getSupportedServiceNames();
1127 }
1128
1129 // import
1130 Reference< XInterface > SAL_CALL SvXMLGraphicImportHelper_createInstance(const Reference< XMultiServiceFactory > & /* rSMgr */ )
1131     throw( Exception )
1132 {
1133     return static_cast< XWeak* >( new SvXMLGraphicImportExportHelper( GRAPHICHELPER_MODE_READ ));
1134 }
1135 ::rtl::OUString SAL_CALL SvXMLGraphicImportHelper_getImplementationName()
1136     throw()
1137 {
1138     return ::rtl::OUString(  "com.sun.star.comp.Svx.GraphicImportHelper" );
1139 }
1140 Sequence< ::rtl::OUString > SAL_CALL SvXMLGraphicImportHelper_getSupportedServiceNames()
1141     throw()
1142 {
1143     // XGraphicObjectResolver and XBinaryStreamResolver are not part of any service
1144     Sequence< ::rtl::OUString > aSupportedServiceNames( 2 );
1145     aSupportedServiceNames[0] = ::rtl::OUString(  "com.sun.star.document.GraphicObjectResolver"  );
1146     aSupportedServiceNames[1] = ::rtl::OUString(  "com.sun.star.document.BinaryStreamResolver"  );
1147     return aSupportedServiceNames;
1148 }
1149
1150 // export
1151 Reference< XInterface > SAL_CALL SvXMLGraphicExportHelper_createInstance(const Reference< XMultiServiceFactory > & /* rSMgr */ )
1152     throw( Exception )
1153 {
1154     return static_cast< XWeak* >( new SvXMLGraphicImportExportHelper( GRAPHICHELPER_MODE_WRITE ));
1155 }
1156 ::rtl::OUString SAL_CALL SvXMLGraphicExportHelper_getImplementationName()
1157     throw()
1158 {
1159     return ::rtl::OUString(  "com.sun.star.comp.Svx.GraphicExportHelper" );
1160 }
1161 Sequence< ::rtl::OUString > SAL_CALL SvXMLGraphicExportHelper_getSupportedServiceNames()
1162     throw()
1163 {
1164     // XGraphicObjectResolver and XBinaryStreamResolver are not part of any service
1165     Sequence< ::rtl::OUString > aSupportedServiceNames( 2 );
1166     aSupportedServiceNames[0] = ::rtl::OUString(  "com.sun.star.document.GraphicObjectResolver"  );
1167     aSupportedServiceNames[1] = ::rtl::OUString(  "com.sun.star.document.BinaryStreamResolver"  );
1168     return aSupportedServiceNames;
1169 }
1170
1171 } // namespace svx
1172
1173 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */