embedserv/source/embed/ed_ipersiststr.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: ed_ipersiststr.cxx,v $
  10  * $Revision: 1.27.10.1 $
  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 #if defined(_MSC_VER) && (_MSC_VER > 1310)
  31 #pragma warning(disable : 4917 4555)
  32 #endif
  33
  34 #include "embeddoc.hxx"
  35 #include <com/sun/star/uno/Any.h>
  36 #include <com/sun/star/uno/Exception.hpp>
  37 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  38 #include <com/sun/star/lang/XComponent.hpp>
  39 #include <com/sun/star/io/XInputStream.hpp>
  40 #include <com/sun/star/io/XOutputStream.hpp>
  41 #include <com/sun/star/io/XSeekable.hpp>
  42 #include <com/sun/star/frame/XModel.hpp>
  43 #include <com/sun/star/frame/XLoadable.hpp>
  44 #include <com/sun/star/util/XModifiable.hpp>
  45 #include <com/sun/star/frame/XStorable.hpp>
  46 #include <com/sun/star/frame/XComponentLoader.hpp>
  47 #include <com/sun/star/util/XUrlTransformer.hpp>
  48
  49
  50 #include <osl/mutex.hxx>
  51 #include <osl/diagnose.h>
  52
  53 #include <string.h>
  54
  55 #define EXT_STREAM_LENGTH 16
  56
  57 using namespace ::com::sun::star;
  58
  59 extern ::rtl::OUString  getStorageTypeFromGUID_Impl( GUID* guid );
  60 extern ::rtl::OUString  getServiceNameFromGUID_Impl( GUID* );
  61 extern ::rtl::OUString  getFilterNameFromGUID_Impl( GUID* );
  62 // extern CLIPFORMAT            getClipFormatFromGUID_Impl( GUID* );
  63 ::rtl::OUString getTestFileURLFromGUID_Impl( GUID* guid );
  64
  65 const ::rtl::OUString aOfficeEmbedStreamName( RTL_CONSTASCII_USTRINGPARAM ( "package_stream" ) );
  66 const ::rtl::OUString aExtentStreamName( RTL_CONSTASCII_USTRINGPARAM ( "properties_stream" ) );
  67
  68 uno::Reference< io::XInputStream > createTempXInStreamFromIStream(
  69                                         uno::Reference< lang::XMultiServiceFactory > xFactory,
  70                                         IStream *pStream )
  71 {
  72     uno::Reference< io::XInputStream > xResult;
  73
  74     if ( !pStream )
  75         return xResult;
  76
  77     const ::rtl::OUString aServiceName ( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.io.TempFile" ) );
  78     uno::Reference < io::XOutputStream > xTempOut = uno::Reference < io::XOutputStream > (
  79                                                             xFactory->createInstance ( aServiceName ),
  80                                                             uno::UNO_QUERY );
  81     if ( xTempOut.is() )
  82     {
  83         ULARGE_INTEGER nNewPos;
  84         LARGE_INTEGER aZero = { 0L, 0L };
  85         HRESULT hr = pStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos );
  86         if ( FAILED( hr ) ) return xResult;
  87
  88         STATSTG aStat;
  89         hr = pStream->Stat( &aStat, STATFLAG_NONAME );
  90         if ( FAILED( hr ) ) return xResult;
  91
  92         sal_uInt32 nSize = (sal_uInt32)aStat.cbSize.QuadPart;
  93         sal_uInt32 nCopied = 0;
  94         uno::Sequence< sal_Int8 > aBuffer( nConstBufferSize );
  95         try
  96         {
  97             sal_uInt32 nRead = 0;
  98             do
  99             {
 100                 pStream->Read( (void*)aBuffer.getArray(), nConstBufferSize, &nRead );
 101
 102                 if ( nRead < nConstBufferSize )
 103                     aBuffer.realloc( nRead );
 104
 105                 xTempOut->writeBytes( aBuffer );
 106                 nCopied += nRead;
 107             } while( nRead == nConstBufferSize );
 108
 109             if ( nCopied == nSize )
 110             {
 111                 uno::Reference < io::XSeekable > xTempSeek ( xTempOut, uno::UNO_QUERY );
 112                 if ( xTempSeek.is() )
 113                 {
 114                     xTempSeek->seek ( 0 );
 115                     xResult = uno::Reference< io::XInputStream >( xTempOut, uno::UNO_QUERY );
 116                 }
 117             }
 118         }
 119         catch( uno::Exception& )
 120         {
 121         }
 122     }
 123
 124     return xResult;
 125 }
 126
 127 HRESULT copyXTempOutToIStream( uno::Reference< io::XOutputStream > xTempOut, IStream* pStream )
 128 {
 129     if ( !xTempOut.is() || !pStream )
 130         return E_FAIL;
 131
 132     uno::Reference < io::XSeekable > xTempSeek ( xTempOut, uno::UNO_QUERY );
 133     if ( !xTempSeek.is() )
 134         return E_FAIL;
 135
 136     xTempSeek->seek ( 0 );
 137
 138     uno::Reference< io::XInputStream > xTempIn ( xTempOut, uno::UNO_QUERY );
 139     if ( !xTempSeek.is() )
 140         return E_FAIL;
 141
 142     // Seek to zero and truncate the stream
 143     ULARGE_INTEGER nNewPos;
 144     LARGE_INTEGER aZero = { 0L, 0L };
 145     HRESULT hr = pStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos );
 146     if ( FAILED( hr ) ) return E_FAIL;
 147     ULARGE_INTEGER aUZero = { 0L, 0L };
 148     hr = pStream->SetSize( aUZero );
 149     if ( FAILED( hr ) ) return E_FAIL;
 150
 151     uno::Sequence< sal_Int8 > aBuffer( nConstBufferSize );
 152     sal_uInt32 nReadBytes = 0;
 153
 154     do
 155     {
 156         try {
 157             nReadBytes = xTempIn->readBytes( aBuffer, nConstBufferSize );
 158         }
 159         catch( uno::Exception& )
 160         {
 161             return E_FAIL;
 162         }
 163
 164         sal_uInt32 nWritten = 0;
 165         HRESULT hr = pStream->Write( (void*)aBuffer.getArray(), nReadBytes, &nWritten );
 166         if ( !SUCCEEDED( hr ) || nWritten != nReadBytes )
 167             return E_FAIL;
 168
 169     } while( nReadBytes == nConstBufferSize );
 170
 171     return S_OK;
 172 }
 173
 174
 175 //===============================================================================
 176 // EmbedDocument_Impl
 177 //===============================================================================
 178
 179 EmbedDocument_Impl::EmbedDocument_Impl( const uno::Reference< lang::XMultiServiceFactory >& xFactory, const GUID* guid )
 180 : m_refCount( 0L )
 181 , m_xFactory( xFactory )
 182 , m_guid( *guid )
 183 , m_bIsDirty( sal_False )
 184 , m_nAdviseNum( 0 )
 185 , m_bIsInVerbHandling( sal_False )
 186 //, m_bLoadedFromFile( sal_False )
 187 {
 188     m_xOwnAccess = new EmbeddedDocumentInstanceAccess_Impl( this );
 189     m_pDocHolder = new DocumentHolder( xFactory, m_xOwnAccess );
 190     m_pDocHolder->acquire();
 191 }
 192
 193 EmbedDocument_Impl::~EmbedDocument_Impl()
 194 {
 195     m_pDocHolder->FreeOffice();
 196
 197     if ( m_pDocHolder->HasFrame() && m_pDocHolder->IsLink() )
 198     {
 199         // a link with frame should be only disconnected, not closed
 200         m_pDocHolder->DisconnectFrameDocument( sal_True );
 201     }
 202     else
 203     {
 204         m_pDocHolder->CloseDocument();
 205         m_pDocHolder->CloseFrame();
 206     }
 207
 208     m_pDocHolder->release();
 209 }
 210
 211 uno::Sequence< beans::PropertyValue > EmbedDocument_Impl::fillArgsForLoading_Impl( uno::Reference< io::XInputStream > xStream, DWORD /*nStreamMode*/, LPCOLESTR pFilePath )
 212 {
 213     uno::Sequence< beans::PropertyValue > aArgs( 3 );
 214
 215     sal_Int32 nInd = 0; // must not be bigger than the preset size
 216     aArgs[nInd].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "FilterName" ) );
 217     aArgs[nInd++].Value <<= getFilterNameFromGUID_Impl( &m_guid );
 218
 219     if ( xStream.is() )
 220     {
 221         aArgs[nInd].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "InputStream" ) );
 222         aArgs[nInd++].Value <<= xStream;
 223         aArgs[nInd].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "URL" ) );
 224         aArgs[nInd++].Value <<= ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "private:stream" ) );
 225     }
 226     else
 227     {
 228         aArgs[nInd].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "URL" ) );
 229
 230         rtl::OUString sDocUrl;
 231         if ( pFilePath )
 232         {
 233             ::rtl::OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.util.URLTransformer" ) );
 234             uno::Reference< util::XURLTransformer > aTransformer( m_xFactory->createInstance( aServiceName ),
 235                                                                     uno::UNO_QUERY );
 236             if ( aTransformer.is() )
 237             {
 238                 util::URL aURL;
 239
 240                 aURL.Complete = ::rtl::OUString( reinterpret_cast<const sal_Unicode*>(pFilePath) );
 241
 242                 if ( aTransformer->parseSmart( aURL, ::rtl::OUString() ) )
 243                     sDocUrl = aURL.Complete;
 244             }
 245         }
 246
 247         aArgs[nInd++].Value <<= sDocUrl;
 248     }
 249
 250     aArgs.realloc( nInd );
 251
 252     // aArgs[].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "ReadOnly" ) );
 253     // aArgs[].Value <<= sal_False; //( ( nStreamMode & ( STGM_READWRITE | STGM_WRITE ) ) ? sal_True : sal_False );
 254
 255     return aArgs;
 256 }
 257
 258 uno::Sequence< beans::PropertyValue > EmbedDocument_Impl::fillArgsForStoring_Impl( uno::Reference< io::XOutputStream > xStream)
 259 {
 260     uno::Sequence< beans::PropertyValue > aArgs( xStream.is() ? 2 : 1 );
 261
 262     aArgs[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "FilterName" ) );
 263     aArgs[0].Value <<= getFilterNameFromGUID_Impl( &m_guid );
 264
 265     if ( xStream.is() )
 266     {
 267         aArgs[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "OutputStream" ) );
 268         aArgs[1].Value <<= xStream;
 269     }
 270
 271     return aArgs;
 272 }
 273
 274 HRESULT EmbedDocument_Impl::SaveTo_Impl( IStorage* pStg )
 275 {
 276     if ( !pStg || pStg == m_pMasterStorage )
 277         return E_FAIL;
 278
 279     // for saveto operation the master storage
 280     // should not enter NoScribble mode
 281     CComPtr< IStream > pOrigOwn = m_pOwnStream;
 282     CComPtr< IStream > pOrigExt = m_pExtStream;
 283     HRESULT hr = Save( pStg, sal_False );
 284     pStg->Commit( STGC_ONLYIFCURRENT );
 285     m_pOwnStream = pOrigOwn;
 286     m_pExtStream = pOrigExt;
 287
 288     return hr;
 289 }
 290
 291 //-------------------------------------------------------------------------------
 292 // IUnknown
 293
 294 STDMETHODIMP EmbedDocument_Impl::QueryInterface( REFIID riid, void FAR* FAR* ppv )
 295 {
 296     if(IsEqualIID(riid, IID_IUnknown))
 297     {
 298         AddRef();
 299         *ppv = (IUnknown*) (IPersistStorage*) this;
 300         return S_OK;
 301     }
 302     else if (IsEqualIID(riid, IID_IPersist))
 303     {
 304         AddRef();
 305         *ppv = (IPersist*) (IPersistStorage*) this;
 306         return S_OK;
 307     }
 308     else if (IsEqualIID(riid, IID_IExternalConnection))
 309     {
 310         AddRef();
 311         *ppv = (IExternalConnection*) this;
 312         return S_OK;
 313     }
 314     else if (IsEqualIID(riid, IID_IPersistStorage))
 315     {
 316         AddRef();
 317         *ppv = (IPersistStorage*) this;
 318         return S_OK;
 319     }
 320     else if (IsEqualIID(riid, IID_IDataObject))
 321     {
 322         AddRef();
 323         *ppv = (IDataObject*) this;
 324         return S_OK;
 325     }
 326     else if (IsEqualIID(riid, IID_IOleObject))
 327     {
 328         AddRef();
 329         *ppv = (IOleObject*) this;
 330         return S_OK;
 331     }
 332     else if (IsEqualIID(riid, IID_IOleWindow))
 333     {
 334         AddRef();
 335         *ppv = (IOleWindow*) this;
 336         return S_OK;
 337     }
 338     else if (IsEqualIID(riid, IID_IOleInPlaceObject))
 339     {
 340         AddRef();
 341         *ppv = (IOleInPlaceObject*) this;
 342         return S_OK;
 343     }
 344     else if (IsEqualIID(riid, IID_IPersistFile))
 345     {
 346         AddRef();
 347         *ppv = (IPersistFile*) this;
 348         return S_OK;
 349     }
 350     else if (IsEqualIID(riid, IID_IDispatch))
 351     {
 352         AddRef();
 353         *ppv = (IDispatch*) this;
 354         return S_OK;
 355     }
 356
 357     *ppv = NULL;
 358     return ResultFromScode(E_NOINTERFACE);
 359 }
 360
 361 STDMETHODIMP_(ULONG) EmbedDocument_Impl::AddRef()
 362 {
 363     return osl_incrementInterlockedCount( &m_refCount);
 364 }
 365
 366 STDMETHODIMP_(ULONG) EmbedDocument_Impl::Release()
 367 {
 368     // if there is a time when the last reference is destructed, that means that only internal pointers are alive
 369     // after the following call either the refcount is increased or the pointers are empty
 370     if ( m_refCount == 1 )
 371         m_xOwnAccess->ClearEmbedDocument();
 372
 373     sal_Int32 nCount = osl_decrementInterlockedCount( &m_refCount );
 374     if ( nCount == 0 )
 375         delete this;
 376     return nCount;
 377 }
 378
 379 //-------------------------------------------------------------------------------
 380 // IPersist
 381
 382 STDMETHODIMP EmbedDocument_Impl::GetClassID( CLSID* pClassId )
 383 {
 384     *pClassId = *&m_guid;
 385     return S_OK;
 386 }
 387
 388 //-------------------------------------------------------------------------------
 389 // IPersistStorage
 390
 391 STDMETHODIMP EmbedDocument_Impl::IsDirty()
 392 {
 393     // the link modified state is controlled by the document
 394     if ( m_bIsDirty && !m_aFileName.getLength() )
 395         return S_OK;
 396
 397     uno::Reference< util::XModifiable > xMod( m_pDocHolder->GetDocument(), uno::UNO_QUERY );
 398     if ( xMod.is() )
 399         return xMod->isModified() ? S_OK : S_FALSE;
 400     return S_FALSE;
 401 }
 402
 403 STDMETHODIMP EmbedDocument_Impl::InitNew( IStorage *pStg )
 404 {
 405     HRESULT hr = CO_E_ALREADYINITIALIZED;
 406
 407     if ( !m_pDocHolder->GetDocument().is() )
 408     {
 409
 410         STATSTG aStat;
 411         hr = pStg->Stat( &aStat, STATFLAG_NONAME );
 412         if ( FAILED( hr ) ) return E_FAIL;
 413
 414         DWORD nStreamMode = aStat.grfMode;
 415
 416         hr = E_FAIL;
 417         if ( m_xFactory.is() && pStg )
 418         {
 419             uno::Reference< frame::XModel > aDocument(
 420                             m_xFactory->createInstance( getServiceNameFromGUID_Impl( &m_guid ) ),
 421                             uno::UNO_QUERY );
 422             if ( aDocument.is() )
 423             {
 424                 m_pDocHolder->SetDocument( aDocument );
 425
 426                 uno::Reference< frame::XLoadable > xLoadable( m_pDocHolder->GetDocument(), uno::UNO_QUERY );
 427                 if( xLoadable.is() )
 428                 {
 429                     try
 430                     {
 431                         xLoadable->initNew();
 432                         // xLoadable->load( fillArgsForLoading_Impl( uno::Reference< io::XInputStream >(), nStreamMode ) );
 433                         hr = S_OK;
 434                     }
 435                     catch( uno::Exception& )
 436                     {
 437                     }
 438                 }
 439
 440                 if ( hr == S_OK )
 441                 {
 442                     ::rtl::OUString aCurType = getStorageTypeFromGUID_Impl( &m_guid ); // ???
 443                     CLIPFORMAT cf = (CLIPFORMAT)RegisterClipboardFormatA( "Embedded Object" );
 444                     hr = WriteFmtUserTypeStg( pStg,
 445                                             cf,                                                 // ???
 446                                             reinterpret_cast<LPWSTR>(( sal_Unicode* )aCurType.getStr()) );
 447
 448                     if ( hr == S_OK )
 449                     {
 450                         hr = pStg->CreateStream( reinterpret_cast<LPCWSTR>(aOfficeEmbedStreamName.getStr()),
 451                                                  STGM_CREATE | ( nStreamMode & 0x73 ),
 452                                                  0,
 453                                                  0,
 454                                                  &m_pOwnStream );
 455
 456                         if ( hr == S_OK && m_pOwnStream )
 457                         {
 458                             hr = pStg->CreateStream( reinterpret_cast<LPCWSTR>(aExtentStreamName.getStr()),
 459                                                      STGM_CREATE | ( nStreamMode & 0x73 ),
 460                                                      0,
 461                                                      0,
 462                                                      &m_pExtStream );
 463
 464                             if ( hr == S_OK && m_pExtStream )
 465                             {
 466
 467                                 m_pMasterStorage = pStg;
 468                                 m_bIsDirty = sal_True;
 469                             }
 470                             else
 471                                 hr = E_FAIL;
 472                         }
 473                         else
 474                             hr = E_FAIL;
 475                     }
 476                     else
 477                         hr = E_FAIL;
 478                 }
 479
 480                 if ( hr != S_OK )
 481                     m_pDocHolder->CloseDocument();
 482             }
 483         }
 484     }
 485
 486     return hr;
 487 }
 488
 489 STDMETHODIMP EmbedDocument_Impl::Load( IStorage *pStg )
 490 {
 491     if ( m_pDocHolder->GetDocument().is() )
 492         return CO_E_ALREADYINITIALIZED;
 493
 494     if ( !m_xFactory.is() || !pStg )
 495         return E_FAIL;
 496
 497     HRESULT hr = E_FAIL;
 498
 499     STATSTG aStat;
 500     hr = pStg->Stat( &aStat, STATFLAG_NONAME );
 501     if ( FAILED( hr ) ) return E_FAIL;
 502
 503     DWORD nStreamMode = aStat.grfMode;
 504     hr = pStg->OpenStream( reinterpret_cast<LPCWSTR>(aOfficeEmbedStreamName.getStr()),
 505                             0,
 506                             nStreamMode & 0x73,
 507                             0,
 508                             &m_pOwnStream );
 509     if ( !m_pOwnStream ) hr = E_FAIL;
 510
 511     if ( SUCCEEDED( hr ) )
 512     {
 513         hr = pStg->OpenStream( reinterpret_cast<LPCWSTR>(aExtentStreamName.getStr()),
 514                                 0,
 515                                 nStreamMode & 0x73,
 516                                 0,
 517                                 &m_pExtStream );
 518         if ( !m_pExtStream ) hr = E_FAIL;
 519     }
 520
 521     // RECTL aRectToSet;
 522     SIZEL aSizeToSet;
 523     if ( SUCCEEDED( hr ) )
 524     {
 525         ULARGE_INTEGER nNewPos;
 526         LARGE_INTEGER aZero = { 0L, 0L };
 527         hr = m_pExtStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos );
 528         if ( SUCCEEDED( hr ) )
 529         {
 530             sal_uInt32 nRead;
 531             sal_Int8 aInf[EXT_STREAM_LENGTH];
 532             hr = m_pExtStream->Read( (void*)aInf, EXT_STREAM_LENGTH, &nRead );
 533             if ( nRead != EXT_STREAM_LENGTH ) hr = E_FAIL;
 534
 535             if ( SUCCEEDED( hr ) )
 536             {
 537                 // aRectToSet.left = *((sal_Int32*)aInf);
 538                 // aRectToSet.top = *((sal_Int32*)&aInf[4]);
 539                 // aRectToSet.right = *((sal_Int32*)&aInf[8]);
 540                 // aRectToSet.bottom = *((sal_Int32*)&aInf[12]);
 541                 aSizeToSet.cx = *((sal_Int32*)&aInf[8]) - *((sal_Int32*)aInf);
 542                 aSizeToSet.cy = *((sal_Int32*)&aInf[12]) - *((sal_Int32*)&aInf[4]);
 543             }
 544         }
 545     }
 546
 547     if ( SUCCEEDED( hr ) )
 548     {
 549         hr = E_FAIL;
 550
 551         uno::Reference < io::XInputStream > xTempIn = createTempXInStreamFromIStream( m_xFactory, m_pOwnStream );
 552         if ( xTempIn.is() )
 553         {
 554             uno::Reference< frame::XModel > aDocument(
 555                                                 m_xFactory->createInstance( getServiceNameFromGUID_Impl( &m_guid ) ),
 556                                                 uno::UNO_QUERY );
 557             if ( aDocument.is() )
 558             {
 559                 m_pDocHolder->SetDocument( aDocument );
 560
 561                 uno::Reference< frame::XLoadable > xLoadable( m_pDocHolder->GetDocument(), uno::UNO_QUERY );
 562                 if( xLoadable.is() )
 563                 {
 564                     try
 565                     {
 566                         xLoadable->load( fillArgsForLoading_Impl( xTempIn, nStreamMode ) );
 567                         m_pMasterStorage = pStg;
 568                         hr = m_pDocHolder->SetExtent( &aSizeToSet );
 569                         // hr = m_pDocHolder->SetVisArea( &aRectToSet );
 570                     }
 571                     catch( uno::Exception& )
 572                     {
 573                     }
 574                 }
 575
 576                 if ( FAILED( hr ) )
 577                     m_pDocHolder->CloseDocument();
 578             }
 579         }
 580     }
 581
 582     if ( FAILED( hr ) )
 583     {
 584         m_pOwnStream = CComPtr< IStream >();
 585         m_pExtStream = CComPtr< IStream >();
 586         hr = pStg->DestroyElement( reinterpret_cast<LPCWSTR>(aOfficeEmbedStreamName.getStr()) );
 587         hr = pStg->DestroyElement( reinterpret_cast<LPCWSTR>(aExtentStreamName.getStr()) );
 588
 589         OSL_ENSURE( SUCCEEDED( hr ), "Can not destroy created stream!\n" );
 590         if ( FAILED( hr ) )
 591             hr = E_FAIL;
 592     }
 593
 594        return hr;
 595 }
 596
 597 STDMETHODIMP EmbedDocument_Impl::Save( IStorage *pStgSave, BOOL fSameAsLoad )
 598 {
 599     if ( !m_pDocHolder->GetDocument().is() || !m_xFactory.is() || !pStgSave || !m_pOwnStream || !m_pExtStream )
 600         return E_FAIL;
 601
 602     CComPtr< IStream > pTargetStream;
 603     CComPtr< IStream > pNewExtStream;
 604
 605     if ( !fSameAsLoad && pStgSave != m_pMasterStorage )
 606     {
 607         OSL_ENSURE( m_pMasterStorage, "How could the document be initialized without storage!??\n" );
 608         HRESULT hr = m_pMasterStorage->CopyTo( NULL, NULL, NULL, pStgSave );
 609         if ( FAILED( hr ) ) return E_FAIL;
 610
 611         STATSTG aStat;
 612         hr = pStgSave->Stat( &aStat, STATFLAG_NONAME );
 613         if ( FAILED( hr ) ) return E_FAIL;
 614
 615         DWORD nStreamMode = aStat.grfMode;
 616         hr = pStgSave->CreateStream( reinterpret_cast<LPCWSTR>(aOfficeEmbedStreamName.getStr()),
 617                                  STGM_CREATE | ( nStreamMode & 0x73 ),
 618                                 0,
 619                                  0,
 620                                  &pTargetStream );
 621         if ( FAILED( hr ) || !pTargetStream ) return E_FAIL;
 622
 623         hr = pStgSave->CreateStream( reinterpret_cast<LPCWSTR>(aExtentStreamName.getStr()),
 624                                  STGM_CREATE | ( nStreamMode & 0x73 ),
 625                                 0,
 626                                  0,
 627                                  &pNewExtStream );
 628         if ( FAILED( hr ) || !pNewExtStream ) return E_FAIL;
 629     }
 630     else
 631     {
 632         pTargetStream = m_pOwnStream;
 633         pNewExtStream = m_pExtStream;
 634     }
 635
 636     HRESULT hr = E_FAIL;
 637
 638     const ::rtl::OUString aServiceName ( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.io.TempFile" ) );
 639     uno::Reference < io::XOutputStream > xTempOut = uno::Reference < io::XOutputStream > (
 640                                                             m_xFactory->createInstance ( aServiceName ),
 641                                                             uno::UNO_QUERY );
 642
 643     if ( xTempOut.is() )
 644     {
 645         uno::Reference< frame::XStorable > xStorable( m_pDocHolder->GetDocument(), uno::UNO_QUERY );
 646         if( xStorable.is() )
 647         {
 648             try
 649             {
 650                 xStorable->storeToURL( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM ( "private:stream" ) ),
 651                                             fillArgsForStoring_Impl( xTempOut ) );
 652                 hr = copyXTempOutToIStream( xTempOut, pTargetStream );
 653                 if ( SUCCEEDED( hr ) )
 654                 {
 655                     // no need to truncate the stream, the size of the stream is always the same
 656                     ULARGE_INTEGER nNewPos;
 657                     LARGE_INTEGER aZero = { 0L, 0L };
 658                     hr = pNewExtStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos );
 659                     if ( SUCCEEDED( hr ) )
 660                     {
 661                         SIZEL aSize;
 662                         hr = m_pDocHolder->GetExtent( &aSize );
 663
 664                         if ( SUCCEEDED( hr ) )
 665                         {
 666                             sal_uInt32 nWritten;
 667                             sal_Int8 aInf[EXT_STREAM_LENGTH];
 668                             *((sal_Int32*)aInf) = 0;
 669                             *((sal_Int32*)&aInf[4]) = 0;
 670                             *((sal_Int32*)&aInf[8]) = aSize.cx;
 671                             *((sal_Int32*)&aInf[12]) = aSize.cy;
 672
 673                             hr = pNewExtStream->Write( (void*)aInf, EXT_STREAM_LENGTH, &nWritten );
 674                             if ( nWritten != EXT_STREAM_LENGTH ) hr = E_FAIL;
 675
 676                             if ( SUCCEEDED( hr ) )
 677                             {
 678                                 m_pOwnStream = CComPtr< IStream >();
 679                                 m_pExtStream = CComPtr< IStream >();
 680                                 if ( fSameAsLoad || pStgSave == m_pMasterStorage )
 681                                 {
 682                                     uno::Reference< util::XModifiable > xMod( m_pDocHolder->GetDocument(), uno::UNO_QUERY );
 683                                     if ( xMod.is() )
 684                                         xMod->setModified( sal_False );
 685                                     m_bIsDirty = sal_False;
 686                                 }
 687                             }
 688                         }
 689                     }
 690                 }
 691             }
 692             catch( uno::Exception& )
 693             {
 694             }
 695         }
 696     }
 697
 698     return hr;
 699 }
 700
 701 STDMETHODIMP EmbedDocument_Impl::SaveCompleted( IStorage *pStgNew )
 702 {
 703     // m_pOwnStream == NULL && m_pMasterStorage != NULL means the object is in NoScribble mode
 704     // m_pOwnStream == NULL && m_pMasterStorage == NULL means the object is in HandsOff mode
 705
 706     if ( m_pOwnStream || m_pExtStream )
 707         return E_UNEXPECTED;
 708
 709     if ( !m_pMasterStorage && !pStgNew )
 710         return E_INVALIDARG;
 711
 712     if ( pStgNew )
 713         m_pMasterStorage = pStgNew;
 714
 715     STATSTG aStat;
 716     HRESULT hr = m_pMasterStorage->Stat( &aStat, STATFLAG_NONAME );
 717     if ( FAILED( hr ) ) return E_OUTOFMEMORY;
 718
 719     DWORD nStreamMode = aStat.grfMode;
 720     hr = m_pMasterStorage->OpenStream( reinterpret_cast<LPCWSTR>(aOfficeEmbedStreamName.getStr()),
 721                                         0,
 722                                         nStreamMode & 0x73,
 723                                         0,
 724                                         &m_pOwnStream );
 725     if ( FAILED( hr ) || !m_pOwnStream ) return E_OUTOFMEMORY;
 726
 727     hr = m_pMasterStorage->OpenStream( reinterpret_cast<LPCWSTR>(aExtentStreamName.getStr()),
 728                                         0,
 729                                         nStreamMode & 0x73,
 730                                         0,
 731                                         &m_pExtStream );
 732     if ( FAILED( hr ) || !m_pExtStream ) return E_OUTOFMEMORY;
 733
 734     sal_Bool bModified = sal_False;
 735     uno::Reference< util::XModifiable > xMod( m_pDocHolder->GetDocument(), uno::UNO_QUERY );
 736     if ( xMod.is() )
 737         bModified = xMod->isModified();
 738
 739     for ( AdviseSinkHashMapIterator iAdvise = m_aAdviseHashMap.begin(); iAdvise != m_aAdviseHashMap.end(); iAdvise++ )
 740     {
 741         if ( iAdvise->second )
 742             iAdvise->second->OnSave();
 743     }
 744
 745     if ( xMod.is() )
 746         bModified = xMod->isModified();
 747
 748     return S_OK;
 749 }
 750
 751 STDMETHODIMP EmbedDocument_Impl::HandsOffStorage()
 752 {
 753     m_pMasterStorage = CComPtr< IStorage >();
 754     m_pOwnStream = CComPtr< IStream >();
 755     m_pExtStream = CComPtr< IStream >();
 756
 757     return S_OK;
 758 }
 759
 760 //-------------------------------------------------------------------------------
 761 // IPersistFile
 762
 763 STDMETHODIMP EmbedDocument_Impl::Load( LPCOLESTR pszFileName, DWORD /*dwMode*/ )
 764 {
 765     if ( m_pDocHolder->GetDocument().is() )
 766         return CO_E_ALREADYINITIALIZED;
 767
 768     if ( !m_xFactory.is() )
 769         return E_FAIL;
 770
 771     DWORD nStreamMode = STGM_CREATE | STGM_READWRITE | STGM_DELETEONRELEASE | STGM_SHARE_EXCLUSIVE;
 772     HRESULT hr = StgCreateDocfile( NULL,
 773                                      nStreamMode ,
 774                                      0,
 775                                      &m_pMasterStorage );
 776
 777     if ( FAILED( hr ) || !m_pMasterStorage ) return E_FAIL;
 778
 779     ::rtl::OUString aCurType = getServiceNameFromGUID_Impl( &m_guid ); // ???
 780     CLIPFORMAT cf = (CLIPFORMAT)RegisterClipboardFormatA( "Embedded Object" );
 781     hr = WriteFmtUserTypeStg( m_pMasterStorage,
 782                             cf,                                                 // ???
 783                             reinterpret_cast<LPWSTR>(( sal_Unicode* )aCurType.getStr()) );
 784     if ( FAILED( hr ) ) return E_FAIL;
 785
 786     hr = m_pMasterStorage->SetClass( m_guid );
 787     if ( FAILED( hr ) ) return E_FAIL;
 788
 789     hr = m_pMasterStorage->CreateStream( reinterpret_cast<LPCWSTR>(aOfficeEmbedStreamName.getStr()),
 790                             STGM_CREATE | ( nStreamMode & 0x73 ),
 791                             0,
 792                             0,
 793                             &m_pOwnStream );
 794     if ( FAILED( hr ) || !m_pOwnStream ) return E_FAIL;
 795
 796     hr = m_pMasterStorage->CreateStream( reinterpret_cast<LPCWSTR>(aExtentStreamName.getStr()),
 797                             STGM_CREATE | ( nStreamMode & 0x73 ),
 798                             0,
 799                             0,
 800                             &m_pExtStream );
 801     if ( FAILED( hr ) || !m_pExtStream ) return E_FAIL;
 802
 803
 804     uno::Reference< frame::XModel > aDocument(
 805                     m_xFactory->createInstance( getServiceNameFromGUID_Impl( &m_guid ) ),
 806                     uno::UNO_QUERY );
 807     if ( aDocument.is() )
 808     {
 809         m_pDocHolder->SetDocument( aDocument, sal_True );
 810
 811         uno::Reference< frame::XLoadable > xLoadable( m_pDocHolder->GetDocument(), uno::UNO_QUERY );
 812         if( xLoadable.is() )
 813         {
 814             try
 815             {
 816                 xLoadable->load( fillArgsForLoading_Impl( uno::Reference< io::XInputStream >(),
 817                                                             STGM_READWRITE,
 818                                                             pszFileName ) );
 819                 hr = S_OK;
 820
 821                 m_aFileName = ::rtl::OUString( reinterpret_cast<const sal_Unicode*>(pszFileName) );
 822             }
 823             catch( uno::Exception& )
 824             {
 825             }
 826         }
 827
 828         if ( hr == S_OK )
 829         {
 830             ::rtl::OUString aCurType = getServiceNameFromGUID_Impl( &m_guid ); // ???
 831             CLIPFORMAT cf = (CLIPFORMAT)RegisterClipboardFormatA( "Embedded Object" );
 832             hr = WriteFmtUserTypeStg( m_pMasterStorage,
 833                                     cf,                                                 // ???
 834                                     reinterpret_cast<LPWSTR>(( sal_Unicode* )aCurType.getStr()) );
 835
 836             if ( SUCCEEDED( hr ) )
 837             {
 838                 // no need to truncate the stream, the size of the stream is always the same
 839                 ULARGE_INTEGER nNewPos;
 840                 LARGE_INTEGER aZero = { 0L, 0L };
 841                 hr = m_pExtStream->Seek( aZero, STREAM_SEEK_SET, &nNewPos );
 842                 if ( SUCCEEDED( hr ) )
 843                 {
 844                     SIZEL aSize;
 845                     hr = m_pDocHolder->GetExtent( &aSize );
 846
 847                     if ( SUCCEEDED( hr ) )
 848                     {
 849                         sal_uInt32 nWritten;
 850                         sal_Int8 aInf[EXT_STREAM_LENGTH];
 851                         *((sal_Int32*)aInf) = 0;
 852                         *((sal_Int32*)&aInf[4]) = 0;
 853                         *((sal_Int32*)&aInf[8]) = aSize.cx;
 854                         *((sal_Int32*)&aInf[12]) = aSize.cy;
 855
 856                         hr = m_pExtStream->Write( (void*)aInf, EXT_STREAM_LENGTH, &nWritten );
 857                         if ( nWritten != EXT_STREAM_LENGTH ) hr = E_FAIL;
 858                     }
 859                 }
 860             }
 861
 862             if ( SUCCEEDED( hr ) )
 863                 m_bIsDirty = sal_True;
 864             else
 865                 hr = E_FAIL;
 866         }
 867
 868         if ( FAILED( hr ) )
 869         {
 870             m_pDocHolder->CloseDocument();
 871             m_pOwnStream = NULL;
 872             m_pExtStream = NULL;
 873             m_pMasterStorage = NULL;
 874         }
 875     }
 876
 877     return hr;
 878 }
 879
 880 STDMETHODIMP EmbedDocument_Impl::Save( LPCOLESTR pszFileName, BOOL fRemember )
 881 {
 882     if ( !m_pDocHolder->GetDocument().is() || !m_xFactory.is() )
 883         return E_FAIL;
 884
 885     HRESULT hr = E_FAIL;
 886
 887     // TODO/LATER: currently there is no hands off state implemented
 888     try
 889     {
 890         uno::Reference< frame::XStorable > xStorable( m_pDocHolder->GetDocument(), uno::UNO_QUERY_THROW );
 891
 892         if ( !pszFileName )
 893             xStorable->store();
 894         else
 895         {
 896             util::URL aURL;
 897             aURL.Complete = ::rtl::OUString( reinterpret_cast<const sal_Unicode*>( pszFileName ) );
 898
 899             ::rtl::OUString aServiceName( RTL_CONSTASCII_USTRINGPARAM ( "com.sun.star.util.URLTransformer" ) );
 900             uno::Reference< util::XURLTransformer > aTransformer( m_xFactory->createInstance( aServiceName ),
 901                                                                   uno::UNO_QUERY_THROW );
 902
 903             if ( aTransformer->parseSmart( aURL, ::rtl::OUString() ) && aURL.Complete.getLength() )
 904             {
 905                 if ( fRemember )
 906                 {
 907                     xStorable->storeAsURL( aURL.Complete, fillArgsForStoring_Impl( uno::Reference< io::XOutputStream >() ) );
 908                     m_aFileName = aURL.Complete;
 909                 }
 910                 else
 911                     xStorable->storeToURL( aURL.Complete, fillArgsForStoring_Impl( uno::Reference< io::XOutputStream >() ) );
 912             }
 913         }
 914
 915         hr = S_OK;
 916     }
 917     catch( uno::Exception& )
 918     {
 919     }
 920
 921     return hr;
 922 }
 923
 924 STDMETHODIMP EmbedDocument_Impl::SaveCompleted( LPCOLESTR pszFileName )
 925 {
 926     // the different file name would mean error here
 927     m_aFileName = ::rtl::OUString( reinterpret_cast<const sal_Unicode*>(pszFileName) );
 928     return S_OK;
 929 }
 930
 931 STDMETHODIMP EmbedDocument_Impl::GetCurFile( LPOLESTR *ppszFileName )
 932 {
 933     CComPtr<IMalloc> pMalloc;
 934
 935     HRESULT hr = CoGetMalloc( 1, &pMalloc );
 936     if ( FAILED( hr ) || !pMalloc ) return E_FAIL;
 937
 938     *ppszFileName = (LPOLESTR)( pMalloc->Alloc( sizeof( sal_Unicode ) * ( m_aFileName.getLength() + 1 ) ) );
 939     wcsncpy( *ppszFileName, reinterpret_cast<LPCWSTR>(m_aFileName.getStr()), m_aFileName.getLength() + 1 );
 940
 941     return m_aFileName.getLength() ? S_OK : S_FALSE;
 942 }
 943
 944 // ===============================================
 945
 946 LockedEmbedDocument_Impl EmbeddedDocumentInstanceAccess_Impl::GetEmbedDocument()
 947 {
 948     ::osl::MutexGuard aGuard( m_aMutex );
 949     return LockedEmbedDocument_Impl( m_pEmbedDocument );
 950 }
 951
 952 void EmbeddedDocumentInstanceAccess_Impl::ClearEmbedDocument()
 953 {
 954     ::osl::MutexGuard aGuard( m_aMutex );
 955     m_pEmbedDocument = NULL;
 956 }
 957
 958 // ===============================================
 959
 960 LockedEmbedDocument_Impl::LockedEmbedDocument_Impl()
 961 : m_pEmbedDocument( NULL )
 962 {}
 963
 964 LockedEmbedDocument_Impl::LockedEmbedDocument_Impl( EmbedDocument_Impl* pEmbedDocument )
 965 : m_pEmbedDocument( pEmbedDocument )
 966 {
 967     if ( m_pEmbedDocument )
 968         m_pEmbedDocument->AddRef();
 969 }
 970
 971 LockedEmbedDocument_Impl::LockedEmbedDocument_Impl( const LockedEmbedDocument_Impl& aDocLock )
 972 : m_pEmbedDocument( aDocLock.m_pEmbedDocument )
 973 {
 974     if ( m_pEmbedDocument )
 975         m_pEmbedDocument->AddRef();
 976 }
 977
 978 LockedEmbedDocument_Impl& LockedEmbedDocument_Impl::operator=( const LockedEmbedDocument_Impl& aDocLock )
 979 {
 980     if ( m_pEmbedDocument )
 981         m_pEmbedDocument->Release();
 982
 983     m_pEmbedDocument = aDocLock.m_pEmbedDocument;
 984     if ( m_pEmbedDocument )
 985         m_pEmbedDocument->AddRef();
 986
 987     return *this;
 988 }
 989
 990 LockedEmbedDocument_Impl::~LockedEmbedDocument_Impl()
 991 {
 992     if ( m_pEmbedDocument )
 993         m_pEmbedDocument->Release();
 994 }
 995
 996 void LockedEmbedDocument_Impl::ExecuteMethod( sal_Int16 nId )
 997 {
 998     if ( m_pEmbedDocument )
 999     {
1000         if ( nId == OLESERV_SAVEOBJECT )
1001             m_pEmbedDocument->SaveObject();
1002         else if ( nId == OLESERV_CLOSE )
1003             m_pEmbedDocument->Close( 0 );
1004         else if ( nId == OLESERV_NOTIFY )
1005             m_pEmbedDocument->notify();
1006         else if ( nId == OLESERV_NOTIFYCLOSING )
1007             m_pEmbedDocument->OLENotifyClosing();
1008         else if ( nId == OLESERV_SHOWOBJECT )
1009             m_pEmbedDocument->ShowObject();
1010         else if ( nId == OLESERV_DEACTIVATE )
1011             m_pEmbedDocument->Deactivate();
1012     }
1013 }
1014
1015 // Fix strange warnings about some
1016 // ATL::CAxHostWindow::QueryInterface|AddRef|Releae functions.
1017 // warning C4505: 'xxx' : unreferenced local function has been removed
1018 #if defined(_MSC_VER)
1019 #pragma warning(disable: 4505)
1020 #endif
1021