embedserv/source/embed/ed_ioleobject.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
  20 #include "embeddoc.hxx"
  21 #include <osl/diagnose.h>
  22 #include <com/sun/star/frame/XController.hpp>
  23 #include <com/sun/star/beans/PropertyValue.hpp>
  24
  25
  26 using namespace ::com::sun::star;
  27
  28
  29 extern OUString  getFilterNameFromGUID_Impl( GUID* );
  30
  31
  32 // IOleObject
  33
  34
  35 STDMETHODIMP EmbedDocument_Impl::SetClientSite( IOleClientSite* pSite )
  36 {
  37     m_pClientSite = pSite;
  38     return S_OK;
  39 }
  40
  41 STDMETHODIMP EmbedDocument_Impl::GetClientSite( IOleClientSite** pSite )
  42 {
  43     *pSite = m_pClientSite;
  44     return S_OK;
  45 }
  46
  47 STDMETHODIMP EmbedDocument_Impl::SetHostNames( LPCOLESTR szContainerApp, LPCOLESTR szContainerObj )
  48 {
  49     // the code should be ignored for links
  50     if ( !m_aFileName.getLength() )
  51     {
  52         m_pDocHolder->setTitle(
  53             OUString(
  54                 (sal_Unicode*)szContainerObj));
  55         m_pDocHolder->setContainerName(
  56             OUString(
  57                 (sal_Unicode*)szContainerApp));
  58     }
  59
  60     return S_OK;
  61 }
  62
  63 STDMETHODIMP EmbedDocument_Impl::Close( DWORD dwSaveOption )
  64 {
  65     HRESULT hr = S_OK;
  66
  67     if ( m_pDocHolder->HasFrame() )
  68     {
  69         if ( dwSaveOption == 2 && m_aFileName.getLength() )
  70         {
  71             // ask the user about saving
  72             if ( m_pDocHolder->ExecuteSuspendCloseFrame() )
  73             {
  74                 m_pDocHolder->CloseDocument();
  75                 return S_OK;
  76             }
  77             else
  78                 return OLE_E_PROMPTSAVECANCELLED;
  79         }
  80
  81         if ( dwSaveOption != 1 )
  82             hr = SaveObject(); // ADVF_DATAONSTOP);
  83
  84         m_pDocHolder->CloseFrame();
  85         OLENotifyDeactivation();
  86     }
  87
  88     m_pDocHolder->FreeOffice();
  89     m_pDocHolder->CloseDocument();
  90
  91     OLENotifyClosing();
  92
  93     return hr;
  94 }
  95
  96
  97 HRESULT EmbedDocument_Impl::OLENotifyClosing()
  98 {
  99     HRESULT hr = S_OK;
 100
 101     AdviseSinkHashMap aAHM(m_aAdviseHashMap);
 102
 103     for ( AdviseSinkHashMapIterator iAdvise = aAHM.begin();
 104           iAdvise != aAHM.end(); iAdvise++ )
 105     {
 106         if ( iAdvise->second )
 107             iAdvise->second->OnClose();
 108     }
 109
 110     return hr;
 111
 112 }
 113
 114 STDMETHODIMP EmbedDocument_Impl::SetMoniker( DWORD /*dwWhichMoniker*/, IMoniker * /*pmk*/ )
 115 {
 116     return E_NOTIMPL;
 117 }
 118
 119 STDMETHODIMP EmbedDocument_Impl::GetMoniker( DWORD /*dwAssign*/, DWORD /*dwWhichMoniker*/, IMoniker ** /*ppmk*/ )
 120 {
 121     return E_NOTIMPL;
 122 }
 123
 124 STDMETHODIMP EmbedDocument_Impl::InitFromData( IDataObject * /*pDataObject*/, BOOL /*fCreation*/, DWORD /*dwReserved*/ )
 125 {
 126     return E_NOTIMPL;
 127 }
 128
 129 STDMETHODIMP EmbedDocument_Impl::GetClipboardData( DWORD /*dwReserved*/, IDataObject ** /*ppDataObject*/ )
 130 {
 131     return E_NOTIMPL;
 132 }
 133
 134 /**
 135  *  Well, this is a not so very inefficient way to deliver
 136  *
 137  */
 138
 139 STDMETHODIMP EmbedDocument_Impl::DoVerb(
 140     LONG iVerb,
 141     LPMSG,
 142     IOleClientSite *pActiveSite,
 143     LONG,
 144     HWND,
 145     LPCRECT )
 146 {
 147     // no locking is used since the OLE must use the same thread always
 148     if ( m_bIsInVerbHandling )
 149         return OLEOBJ_S_CANNOT_DOVERB_NOW;
 150
 151     // an object can not handle any Verbs in Hands off mode
 152     if ( m_pMasterStorage == NULL || m_pOwnStream == NULL )
 153         return OLE_E_CANT_BINDTOSOURCE;
 154
 155
 156     BooleanGuard_Impl aGuard( m_bIsInVerbHandling );
 157
 158     if ( iVerb == OLEIVERB_PRIMARY )
 159     {
 160         if ( m_aFileName.getLength() )
 161         {
 162             // that should be a link
 163             iVerb = OLEIVERB_OPEN;
 164         }
 165         else
 166             iVerb = OLEIVERB_SHOW;
 167     }
 168
 169     try
 170     {
 171         switch(iVerb) {
 172             case OLEIVERB_DISCARDUNDOSTATE:
 173                 // free any undostate?
 174                 break;
 175             case OLEIVERB_INPLACEACTIVATE:
 176                 OSL_ENSURE(m_pDocHolder,"no document for inplace activation");
 177
 178                 return m_pDocHolder->InPlaceActivate(pActiveSite,FALSE);
 179             case OLEIVERB_UIACTIVATE:
 180                 OSL_ENSURE(m_pDocHolder,"no document for     inplace activation");
 181
 182                 return m_pDocHolder->InPlaceActivate(pActiveSite,TRUE);
 183             case OLEIVERB_PRIMARY:
 184             case OLEIVERB_SHOW:
 185                 OSL_ENSURE(m_pDocHolder,"no document for inplace activation");
 186
 187                 if(m_pDocHolder->isActive())
 188                     return NOERROR; //Already active
 189
 190                 if(SUCCEEDED(
 191                     m_pDocHolder->InPlaceActivate(
 192                         pActiveSite,TRUE)))
 193                     return NOERROR;
 194
 195                 SAL_FALLTHROUGH;
 196             case OLEIVERB_OPEN:
 197                 OSL_ENSURE(m_pDocHolder,"no document to open");
 198
 199                 // the commented code could be useful in case
 200                 // outer window would be resized depending from inner one
 201                 // RECTL aEmbArea;
 202                 // m_pDocHolder->GetVisArea( &aEmbArea );
 203                 // m_pDocHolder->show();
 204                 // m_pDocHolder->SetVisArea( &aEmbArea );
 205
 206                 if(m_pDocHolder->isActive())
 207                 {
 208                     m_pDocHolder->InPlaceDeactivate();
 209                     m_pDocHolder->DisableInplaceActivation(true);
 210                 }
 211
 212                 SIZEL aEmbSize;
 213                 m_pDocHolder->GetExtent( &aEmbSize );
 214                 m_pDocHolder->show();
 215                 m_pDocHolder->resizeWin( aEmbSize );
 216
 217                 if ( m_pClientSite )
 218                     m_pClientSite->OnShowWindow( TRUE );
 219
 220                 notify();
 221                 break;
 222             case OLEIVERB_HIDE:
 223                 OSL_ENSURE(m_pDocHolder,"no document to hide");
 224
 225                 if(m_pDocHolder->isActive())
 226                     m_pDocHolder->InPlaceDeactivate();
 227                 else {
 228                     m_pDocHolder->hide();
 229
 230                     if( m_pClientSite )
 231                         m_pClientSite->OnShowWindow(FALSE);
 232                 }
 233                 break;
 234             default:
 235                 break;
 236         }
 237     }
 238     catch( const uno::Exception& )
 239     {
 240         return OLEOBJ_S_CANNOT_DOVERB_NOW;
 241     }
 242
 243     return NOERROR;
 244 }
 245
 246
 247 STDMETHODIMP EmbedDocument_Impl::EnumVerbs( IEnumOLEVERB ** /*ppEnumOleVerb*/ )
 248 {
 249     return OLE_S_USEREG;
 250 }
 251
 252 STDMETHODIMP EmbedDocument_Impl::Update()
 253 {
 254     return S_OK;
 255 //    HRESULT hr = CACHE_E_NOCACHE_UPDATED;
 256 //    return hr;
 257 }
 258
 259 STDMETHODIMP EmbedDocument_Impl::IsUpToDate()
 260 {
 261     return S_OK;
 262 }
 263
 264 STDMETHODIMP EmbedDocument_Impl::GetUserClassID( CLSID *pClsid )
 265 {
 266     return GetClassID( pClsid );
 267 }
 268
 269 STDMETHODIMP EmbedDocument_Impl::GetUserType( DWORD /*dwFormOfTypeUe*/, LPOLESTR * /*pszUserType*/ )
 270 {
 271     return OLE_S_USEREG;
 272 }
 273
 274 STDMETHODIMP EmbedDocument_Impl::SetExtent( DWORD /*dwDrawAspect*/, SIZEL *psizel )
 275 {
 276     if ( !psizel )
 277         return E_FAIL;
 278
 279     m_pDocHolder->SetExtent( psizel );
 280
 281     return S_OK;
 282 }
 283
 284 STDMETHODIMP EmbedDocument_Impl::GetExtent( DWORD /*dwDrawAspect*/, SIZEL * psizel )
 285 {
 286     if ( !psizel )
 287         return E_INVALIDARG;
 288
 289     if ( FAILED( m_pDocHolder->GetExtent( psizel ) ) )
 290     {
 291         // return default values
 292         psizel->cx = 500;
 293         psizel->cy = 500;
 294     }
 295
 296     return S_OK;
 297 }
 298
 299 STDMETHODIMP EmbedDocument_Impl::Advise( IAdviseSink *pAdvSink, DWORD *pdwConnection )
 300 {
 301     if ( m_nAdviseNum == 0xFFFFFFFF )
 302         return E_OUTOFMEMORY;
 303
 304     pAdvSink->AddRef();
 305     m_aAdviseHashMap.insert( ::std::pair< DWORD, IAdviseSink* >( m_nAdviseNum, pAdvSink ) );
 306     *pdwConnection = m_nAdviseNum++;
 307
 308     return S_OK;
 309 }
 310
 311 STDMETHODIMP EmbedDocument_Impl::Unadvise( DWORD dwConnection )
 312 {
 313     AdviseSinkHashMapIterator iAdvise = m_aAdviseHashMap.find( dwConnection );
 314     if ( iAdvise != m_aAdviseHashMap.end() )
 315     {
 316         iAdvise->second->Release();
 317         m_aAdviseHashMap.erase( iAdvise );
 318     }
 319     else
 320         return OLE_E_NOCONNECTION;
 321
 322     return S_OK;
 323 }
 324
 325 STDMETHODIMP EmbedDocument_Impl::EnumAdvise( IEnumSTATDATA ** /*ppenumAdvise*/ )
 326 {
 327     return E_NOTIMPL;
 328 }
 329
 330 STDMETHODIMP EmbedDocument_Impl::GetMiscStatus( DWORD /*dwAspect*/, DWORD * /*pdwStatus*/ )
 331 {
 332     return OLE_S_USEREG;
 333 }
 334
 335 STDMETHODIMP EmbedDocument_Impl::SetColorScheme( LOGPALETTE * /*pLogpal*/ )
 336 {
 337     return E_NOTIMPL;
 338 }
 339
 340
 341 // IDispatch
 342
 343 STDMETHODIMP EmbedDocument_Impl::GetTypeInfoCount( unsigned int FAR*  pctinfo )
 344 {
 345     if ( m_pDocHolder->GetIDispatch() )
 346         return m_pDocHolder->GetIDispatch()->GetTypeInfoCount( pctinfo );
 347
 348     return E_NOTIMPL;
 349 }
 350
 351 STDMETHODIMP EmbedDocument_Impl::GetTypeInfo( unsigned int iTInfo, LCID lcid, ITypeInfo FAR* FAR* ppTInfo )
 352 {
 353     if ( m_pDocHolder->GetIDispatch() )
 354         return m_pDocHolder->GetIDispatch()->GetTypeInfo( iTInfo, lcid, ppTInfo );
 355
 356     return DISP_E_BADINDEX; // the only error that can be returned
 357 }
 358
 359 STDMETHODIMP EmbedDocument_Impl::GetIDsOfNames( REFIID riid,
 360                                                 OLECHAR FAR* FAR* rgszNames,
 361                                                 unsigned int cNames,
 362                                                 LCID lcid,
 363                                                 DISPID FAR* rgDispId )
 364 {
 365     if ( m_pDocHolder->GetIDispatch() )
 366         return m_pDocHolder->GetIDispatch()->GetIDsOfNames( riid, rgszNames, cNames, lcid, rgDispId );
 367
 368     for ( unsigned int ind = 0; ind < cNames; ind++ )
 369         rgDispId[ind] = DISPID_UNKNOWN;
 370
 371     return DISP_E_UNKNOWNNAME;
 372 }
 373
 374 STDMETHODIMP EmbedDocument_Impl::Invoke( DISPID dispIdMember,
 375                                          REFIID riid,
 376                                          LCID lcid,
 377                                          WORD wFlags,
 378                                          DISPPARAMS FAR* pDispParams,
 379                                          VARIANT FAR* pVarResult,
 380                                          EXCEPINFO FAR* pExcepInfo,
 381                                          unsigned int FAR* puArgErr )
 382 {
 383     if ( m_pDocHolder->GetIDispatch() )
 384         return m_pDocHolder->GetIDispatch()->Invoke( dispIdMember,
 385                                                      riid,
 386                                                      lcid,
 387                                                      wFlags,
 388                                                      pDispParams,
 389                                                      pVarResult,
 390                                                      pExcepInfo,
 391                                                      puArgErr );
 392
 393     return DISP_E_MEMBERNOTFOUND;
 394 }
 395
 396
 397 // IExternalConnection
 398
 399 DWORD STDMETHODCALLTYPE EmbedDocument_Impl::AddConnection( DWORD , DWORD )
 400 {
 401     return AddRef();
 402 }
 403
 404 DWORD STDMETHODCALLTYPE EmbedDocument_Impl::ReleaseConnection( DWORD , DWORD , BOOL )
 405 {
 406     return Release();
 407 }
 408
 409 // C++ - methods
 410
 411 HRESULT EmbedDocument_Impl::SaveObject()
 412 {
 413     HRESULT hr = S_OK;
 414
 415     if(m_pClientSite) {
 416         hr = m_pClientSite->SaveObject();
 417
 418         for ( AdviseSinkHashMapIterator iAdvise =
 419                   m_aAdviseHashMap.begin();
 420               iAdvise != m_aAdviseHashMap.end();
 421               iAdvise++ )
 422             if ( iAdvise->second )
 423                 iAdvise->second->OnSave( );
 424     }
 425     else if ( m_aFileName.getLength() && IsDirty() == S_OK )
 426     {
 427         OUString aPreservFileName = m_aFileName;
 428
 429         // in case of links the containers does not provide client site sometimes
 430         hr = Save( (LPCOLESTR)NULL, FALSE ); // triggers saving to the link location
 431         SaveCompleted( (LPCOLESTR)aPreservFileName.getStr() );
 432     }
 433
 434     notify( false );
 435
 436     return hr;
 437 }
 438
 439
 440 HRESULT EmbedDocument_Impl::ShowObject()
 441 {
 442     HRESULT hr = S_OK;
 443
 444     if(m_pClientSite)
 445         hr = m_pClientSite->ShowObject();
 446
 447     return hr;
 448 }
 449
 450
 451 void EmbedDocument_Impl::notify( bool bDataChanged )
 452 {
 453     for ( AdviseSinkHashMapIterator iAdvise =
 454               m_aAdviseHashMap.begin();
 455           iAdvise != m_aAdviseHashMap.end();
 456           iAdvise++ )
 457         if ( iAdvise->second )
 458             iAdvise->second->OnViewChange( DVASPECT_CONTENT, -1 );
 459
 460     if ( m_pDAdviseHolder && bDataChanged )
 461         m_pDAdviseHolder->SendOnDataChange( (IDataObject*)this, 0, 0 );
 462 }
 463
 464 void EmbedDocument_Impl::Deactivate()
 465 {
 466     HRESULT hr = S_OK;
 467
 468     if ( m_pDocHolder->HasFrame() )
 469     {
 470         hr = SaveObject();
 471         m_pDocHolder->CloseFrame();
 472         OLENotifyDeactivation();
 473     }
 474 }
 475
 476 HRESULT EmbedDocument_Impl::OLENotifyDeactivation()
 477 {
 478     HRESULT hr = S_OK;
 479
 480     if ( m_pClientSite )
 481         hr = m_pClientSite->OnShowWindow( FALSE );
 482
 483     return hr;
 484
 485 }
 486
 487 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */