188 lines
3.6 KiB
C++
188 lines
3.6 KiB
C++
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
|
|
|
|
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
|
|
|
|
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
|
|
|
|
// PARTICULAR PURPOSE.
|
|
|
|
//
|
|
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
|
|
#include "precomp.h"
|
|
#include "shvuicf.h"
|
|
#include "registration.h"
|
|
|
|
long g_serverLock = 0; //lock count on server
|
|
long g_cObjRefCount = 0;
|
|
extern SHVUIClassFactoryData* g_FactoryData;
|
|
|
|
///////////////////////////////////////////////////////////
|
|
//
|
|
// Static variables
|
|
//
|
|
LONG ShvUIClassFactory::s_cServerLocks = 0 ; // Count of locks
|
|
HMODULE ShvUIClassFactory::s_hModule = NULL ; // DLL module handle
|
|
|
|
ShvUIClassFactory::ShvUIClassFactory()
|
|
:m_cRef(1)
|
|
{
|
|
InterlockedIncrement(&g_cObjRefCount);
|
|
}
|
|
|
|
ShvUIClassFactory::~ShvUIClassFactory()
|
|
{
|
|
InterlockedDecrement(&g_cObjRefCount);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) ShvUIClassFactory::AddRef(void)
|
|
{
|
|
return InterlockedIncrement((PLONG)&m_cRef);
|
|
}
|
|
|
|
STDMETHODIMP_(ULONG) ShvUIClassFactory::Release(void)
|
|
{
|
|
ULONG res = InterlockedDecrement((PLONG)&m_cRef);
|
|
if (res == 0)
|
|
{
|
|
delete this;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
STDMETHODIMP ShvUIClassFactory::QueryInterface(REFIID riid, void** ppvObject)
|
|
{
|
|
if (IID_IUnknown == riid || IID_IClassFactory == riid)
|
|
{
|
|
*ppvObject = static_cast<IClassFactory*>(this);
|
|
}
|
|
else
|
|
{
|
|
*ppvObject = NULL;
|
|
return E_NOINTERFACE;
|
|
}
|
|
|
|
reinterpret_cast<IUnknown *>(*ppvObject)->AddRef();
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
STDMETHODIMP
|
|
ShvUIClassFactory::CreateInstance(
|
|
IUnknown *pUnkOuter,
|
|
REFIID riid,
|
|
void **ppvObject)
|
|
{
|
|
HRESULT hr =S_OK;
|
|
// aggregation not supported
|
|
if (pUnkOuter != NULL)
|
|
{
|
|
return CLASS_E_NOAGGREGATION;
|
|
}
|
|
|
|
// create the CoClass and return the interface
|
|
ShvUI* pShvUI = NULL;
|
|
pShvUI = new ShvUI();
|
|
|
|
if (pShvUI == NULL)
|
|
{
|
|
return E_OUTOFMEMORY;
|
|
}
|
|
|
|
pShvUI->AddRef();
|
|
|
|
hr = pShvUI->QueryInterface(riid, ppvObject);
|
|
|
|
// if QI failed Release will remove the object
|
|
pShvUI->Release();
|
|
|
|
return hr;
|
|
|
|
}
|
|
|
|
STDMETHODIMP
|
|
ShvUIClassFactory::LockServer(
|
|
BOOL fLock)
|
|
{
|
|
if (fLock)
|
|
{
|
|
InterlockedIncrement(&g_serverLock);
|
|
}
|
|
else
|
|
{
|
|
InterlockedDecrement(&g_serverLock);
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
|
|
//Out of proc server support
|
|
|
|
//
|
|
// Start the factory
|
|
//
|
|
BOOL ShvUIClassFactory::StartFactory()
|
|
{
|
|
|
|
SHVUIClassFactoryData* pFactoryData = g_FactoryData;
|
|
|
|
// Create the class factory for this component.
|
|
IClassFactory* pIFactory = new ShvUIClassFactory() ;
|
|
|
|
|
|
// Register the class factory.
|
|
DWORD dwRegister ;
|
|
|
|
HRESULT hr = ::CoRegisterClassObject(
|
|
pFactoryData->m_pCLSID,
|
|
static_cast<IUnknown*>(pIFactory),
|
|
CLSCTX_LOCAL_SERVER,
|
|
REGCLS_MULTIPLEUSE,
|
|
&dwRegister) ;
|
|
if (FAILED(hr))
|
|
{
|
|
pIFactory->Release() ;
|
|
return FALSE ;
|
|
}
|
|
pFactoryData->m_pIClassFactory = pIFactory;
|
|
pFactoryData->m_dwRegister = dwRegister;
|
|
|
|
return TRUE ;
|
|
}
|
|
|
|
//
|
|
// Stop the factory
|
|
//
|
|
void ShvUIClassFactory::StopFactory()
|
|
{
|
|
SHVUIClassFactoryData* pFactoryData = g_FactoryData;
|
|
|
|
DWORD dwRegister = pFactoryData->m_dwRegister;
|
|
if (dwRegister != 0)
|
|
{
|
|
::CoRevokeClassObject(dwRegister);
|
|
}
|
|
IClassFactory* pIFactory = pFactoryData->m_pIClassFactory;
|
|
|
|
if (pIFactory != NULL)
|
|
{
|
|
pIFactory->Release();
|
|
}
|
|
}
|
|
|
|
HRESULT ShvUIClassFactory::Register()
|
|
{
|
|
ShvUIRegisterServer() ;
|
|
return S_OK ;
|
|
}
|
|
|
|
HRESULT ShvUIClassFactory::Unregister()
|
|
{
|
|
ShvUIUnRegisterServer() ;
|
|
return S_OK ;
|
|
}
|