Category

Development Platform
Home > SourceCode/Document > Windows Develop > Windows Kernel > View Code
clslock.cpp
Package: shell.rar　[view]
Upload User: xhy777
Upload Date: 2007-02-14
Package Size: 24088k
Code Size: 4k
Category:

Windows Kernel

Development Platform:

Visual C++

clslock.cpp：Code Content
  1. #include "priv.h"
  2. #include "dochost.h"
  4. #define DM_CACHEOLESERVER   DM_TRACE
  6. #define HACK_CACHE_OBJECT_TOO
  7. // #define HACK_LOCKRUNNING_TOO
  9. class CClassHolder : IUnknown
  10. {
  11. protected:
  12.     // *** IUnknown methods ***
  13.     virtual STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj);
  14.     virtual STDMETHODIMP_(ULONG) AddRef(void) ;
  15.     virtual STDMETHODIMP_(ULONG) Release(void);
  17.     friend IUnknown* ClassHolder_Create(const CLSID* pclsid);
  19.     CClassHolder(const CLSID* pclsid);
  20.     ~CClassHolder();
  22.     UINT _cRef;
  23.     IClassFactory* _pcf;
  24.     DWORD _dwAppHack;
  26. #ifdef HACK_CACHE_OBJECT_TOO
  27.     IUnknown* _punk;
  28. #ifdef HACK_LOCKRUNNING_TOO
  29.     IRunnableObject* _pro;
  30. #endif
  31. #endif // HACK_CACHE_OBJECT_TOO
  32. };
  34. HRESULT CClassHolder::QueryInterface(REFIID riid, LPVOID * ppvObj)
  35. {
  36.     static const QITAB qit[] = {
  37.         QITABENTMULTI(CClassHolder, IDiscardableBrowserProperty, IUnknown),
  38.         { 0 },
  39.     };
  41.     return QISearch(this, qit, riid, ppvObj);
  42. }
  44. ULONG CClassHolder::AddRef()
  45. {
  46.     _cRef++;
  47.     return _cRef;
  48. }
  50. ULONG CClassHolder::Release()
  51. {
  52.     _cRef--;
  53.     if (_cRef > 0)
  54.         return _cRef;
  56.     delete this;
  57.     return 0;
  58. }
  60. CClassHolder::CClassHolder(const CLSID* pclsid) : _cRef(1)
  61. {
  62.     HRESULT hres;
  63.     hres = CoGetClassObject(*pclsid, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER,
  64.                     0, IID_IClassFactory, (LPVOID*)&_pcf);
  66.     TraceMsg(DM_CACHEOLESERVER, "CCH::CCH Just called CoGetClassObject %x", hres);
  68.     if (SUCCEEDED(hres)) {
  69.         ::GetAppHackFlags(NULL, pclsid, &_dwAppHack);
  71.         _pcf->LockServer(TRUE);
  73. #ifdef HACK_CACHE_OBJECT_TOO
  74.         hres = _pcf->CreateInstance(NULL, IID_IUnknown, (LPVOID*)&_punk);
  76.         if ((_dwAppHack & BROWSERFLAG_INITNEWTOKEEP) && SUCCEEDED(hres)) {
  78.             TraceMsg(TF_SHDAPPHACK, "CCH::CCH hack for Excel. Call InitNew to keep it running");
  80.             //
  81.             // This InitNew keeps Excel running
  82.             //
  83.             IPersistStorage* pps;
  84.             HRESULT hresT;
  85.             hresT = _punk->QueryInterface(IID_IPersistStorage, (LPVOID*)&pps);
  86.             if (SUCCEEDED(hresT)) {
  87.                 IStorage* pstg;
  88.                 hresT = StgCreateDocfile(NULL,
  89.                     STGM_DIRECT | STGM_CREATE | STGM_READWRITE
  90.                     | STGM_SHARE_EXCLUSIVE | STGM_DELETEONRELEASE,
  91.                     0, &pstg);
  92.                 if (SUCCEEDED(hresT)) {
  93.                     TraceMsg(DM_TRACE, "CCLH::ctor calling InitNew()");
  94.                     pps->InitNew(pstg);
  95.                     pstg->Release();
  96.                 } else {
  97.                     TraceMsg(DM_TRACE, "CCLH::ctor StgCreateDocfile failed %x", hresT);
  98.                 }
  99.                 pps->Release();
  100.             } else {
  101.                 TraceMsg(DM_TRACE, "CCLH::ctor QI to IPersistStorage failed %x", hresT);
  102.             }
  103. #ifdef HACK_LOCKRUNNING_TOO
  104.             hres = _punk->QueryInterface(IID_IRunnableObject, (LPVOID*)&_pro);
  105.             if (SUCCEEDED(hres)) {
  106.                 TraceMsg(DM_CACHEOLESERVER, "CCH::CCH This is runnable. Keep it running %x", _pro);
  107.                 OleRun(_pro);
  108.                 OleLockRunning(_pro, TRUE, TRUE);
  109.             }
  110. #endif
  111.         }
  112. #endif
  113.     }
  114. }
  116. CClassHolder::~CClassHolder()
  117. {
  118.     if (_pcf) {
  119. #ifdef HACK_CACHE_OBJECT_TOO
  120.         if (_punk) {
  121. #ifdef HACK_LOCKRUNNING_TOO
  122.             if (_pro) {
  123.                 OleLockRunning(_pro, FALSE, TRUE);
  124.                 _pro->Release();
  125.             }
  126. #endif
  127.             _punk->Release();
  128.         }
  129. #endif
  130.         _pcf->LockServer(FALSE);
  131.         ATOMICRELEASE(_pcf);
  132.     }
  133. }
  135. IUnknown* ClassHolder_Create(const CLSID* pclsid)
  136. {
  137.     return new CClassHolder(pclsid);
  138. }