embedserv/source/embed/ed_ipersiststr.cxx

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