BEEPER.CPP
/*
* BEEPER.CPP
* Simple Automation Object #5 Chapter 14
*
* Implementation of the CBeeper class demonstrating the use of
* CreateStdDispatch instead of DispInvoke, DispGetIDOfNames, and
* a custom IDispatch implementation. In this case we don't have
* our own IDispatch at all, which CreateStdDispatch provides for
* us, but at the loss of multiple language support and the ability
* to define exception.
*
* Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
*
* Kraig Brockschmidt, Microsoft
* Internet : kraigb@microsoft.com
* Compuserve: >INTERNET:kraigb@microsoft.com
*/
#include "beeper.h"
/*
* CBeeper::CBeeper
* CBeeper::~CBeeper
*
* Parameters (Constructor):
* pUnkOuter LPUNKNOWN of a controlling unknown.
* pfnDestroy PFNDESTROYED to call when an object
* is destroyed.
*/
CBeeper::CBeeper(LPUNKNOWN pUnkOuter, PFNDESTROYED pfnDestroy)
{
m_cRef=0;
m_pUnkOuter=pUnkOuter;
m_pfnDestroy=pfnDestroy;
m_lSound=0;
m_pITINeutral=NULL;
m_pIUnkStdDisp=NULL;
return;
}
CBeeper::~CBeeper(void)
{
ReleaseInterface(m_pIUnkStdDisp);
ReleaseInterface(m_pITINeutral);
return;
}
/*
* CBeeper::Init
*
* Purpose:
* Performs any intiailization of a CBeeper that's prone to failure
* that we also use internally before exposing the object outside.
*
* Parameters:
* None
*
* Return Value:
* BOOL TRUE if the function is successful,
* FALSE otherwise.
*/
BOOL CBeeper::Init(void)
{
LPUNKNOWN pIUnknown=this;
ITypeLib *pITypeLib;
HRESULT hr;
if (NULL!=m_pUnkOuter)
pIUnknown=m_pUnkOuter;
/*
* Load our type library. Since this sample uses
* CreateStdDispatch we can only support one locale,
* which is neutral (English) in this case.
*/
if (FAILED(LoadRegTypeLib(LIBID_BeeperTypeLibrary, 1, 0
, LANG_NEUTRAL, &pITypeLib)))
{
/*
* If LoadRegTypeLib fails, try loading directly with
* LoadTypeLib, which will register the library for us.
*
* NOTE: You should prepend your DIR registry key to the
* .TLB name so you don't depend on it being it the PATH.
* This sample will be updated later to reflect this.
*/
if (FAILED(LoadTypeLib(OLETEXT("BEEP0000.TLB"), &pITypeLib)))
return FALSE;
}
//Get the type information out of the type library.
hr=pITypeLib->GetTypeInfoOfGuid(DIID_DIBeeper, &m_pITINeutral);
if (FAILED(hr))
{
pITypeLib->Release();
return FALSE;
}
m_pImpIProvideCI=new CImpIProvideClassInfo(this, pITypeLib);
pITypeLib->Release();
if (FAILED(hr))
return FALSE;
/*
* CreateStdDispatch always returns an IUnknown pointer
* because such is required in aggregation, which is
* involved here. In other words, the Beeper is aggregating
* on the OLE-provided "StdDispatch" object in order to
* directly expose IDispatch from that object. See the
* implementation of QueryInterface.
*/
hr=CreateStdDispatch(pIUnknown, (IBeeper *)this, m_pITINeutral
, &m_pIUnkStdDisp);
if (FAILED(hr))
return FALSE;
return TRUE;
}
/*
* CBeeper::QueryInterface
* CBeeper::AddRef
* CBeeper::Release
*
* Purpose:
* IUnknown members for CBeeper object.
*/
STDMETHODIMP CBeeper::QueryInterface(REFIID riid, PPVOID ppv)
{
*ppv=NULL;
/*
* The only calls for IUnknown are either in a nonaggregated
* case or when created in an aggregation, so in either case
* always return our IUnknown for IID_IUnknown.
*/
if (IID_IUnknown==riid || IID_IBeeper==riid)
*ppv=this;
/*
* We specifically have to ask the object returned from
* CreateStdDispatch for our dispinterface. Note that
* it only understands IID_IDispatch and not DIID_DIBeeper,
* so we convert requests for DIID_DIBeeper into IID_IDispatch
* which amounts to exactly the same thing.
*/
if (IID_IDispatch==riid || DIID_DIBeeper==riid)
return m_pIUnkStdDisp->QueryInterface(IID_IDispatch, ppv);
//AddRef any interface we'll return.
if (NULL!=*ppv)
{
((LPUNKNOWN)*ppv)->AddRef();
return NOERROR;
}
return ResultFromScode(E_NOINTERFACE);
}
STDMETHODIMP_(ULONG) CBeeper::AddRef(void)
{
return ++m_cRef;
}
STDMETHODIMP_(ULONG) CBeeper::Release(void)
{
if (0L!=--m_cRef)
return m_cRef;
//Inform the server about destruction so it can handle shutdown
if (NULL!=m_pfnDestroy)
(*m_pfnDestroy)();
delete this;
return 0L;
}
//IBeeper interface functions
/*
* CBeeper::get_Sound
* CBeeper::put_Sound
*
* Purpose:
* Functions called from DispInvoke to handle the Sound property.
*
* Parameters (Set only):
* lSound long, new sound to save after validation.
*
* Return Value: (Get only):
* ULONG Current sound.
*/
STDMETHODIMP_(long) CBeeper::get_Sound(void)
{
return m_lSound;
}
STDMETHODIMP_(void) CBeeper::put_Sound(long lSound)
{
if (MB_OK!=lSound && MB_ICONEXCLAMATION!=lSound
&& MB_ICONQUESTION!=lSound && MB_ICONHAND!=lSound
&& MB_ICONASTERISK!=lSound)
{
/*
* We cannot return error information to the StdDispatch
* given the way we've defined the return value of this
* methods, so we can't raise an exception.
*/
return;
}
m_lSound=lSound;
return;
}
/*
* CBeeper::Beep
*
* Purpose:
* Function called from DispInvoke to invoke the Beep method.
*
* Return Value:
* long The sound played.
*/
STDMETHODIMP_(long) CBeeper::Beep(void)
{
MessageBeep((UINT)m_lSound);
return m_lSound;
}
/*
* Since CreateStdDispatch provides an IDispatch implementation
* for us, there's no specific code for that interface needed here.
*
* So to not get rid of too much code, we'll add an
* IProvideClassInfo
*/
/*
* CImpIProvideClassInfo::CImpIProvideClassInfo
* CImpIProvideClassInfo::~CImpIProvideClassInfo
*
* Parameters (Constructor):
* pUnkOuter LPUNKNOWN of a controlling unknown.
* pITypeLib ITypeLib * to return from this interface.
*/
CImpIProvideClassInfo::CImpIProvideClassInfo(LPUNKNOWN pUnkOuter
, ITypeLib *pITypeLib)
{
m_cRef=0;
m_pUnkOuter=pUnkOuter;
/*
* Get the coclass type info. If this fails then we'll
* just fail GetClassInfo below.
*/
m_pITI=NULL;
pITypeLib->GetTypeInfoOfGuid(CLSID_Beeper, &m_pITI);
return;
}
CImpIProvideClassInfo::~CImpIProvideClassInfo(void)
{
ReleaseInterface(m_pITI);
return;
}
/*
* CImpIProvideClassInfo::QueryInterface
* CImpIProvideClassInfo::AddRef
* CImpIProvideClassInfo::Release
*
* Purpose:
* IUnknown members for CImpIProvideClassInfo object.
*/
STDMETHODIMP CImpIProvideClassInfo::QueryInterface(REFIID riid, PPVOID ppv)
{
return m_pUnkOuter->QueryInterface(riid, ppv);
}
STDMETHODIMP_(ULONG) CImpIProvideClassInfo::AddRef(void)
{
return m_pUnkOuter->AddRef();
}
STDMETHODIMP_(ULONG) CImpIProvideClassInfo::Release(void)
{
return m_pUnkOuter->Release();
}
/*
* CImpIProvideClassInfo::GetClassInfo
*
* Purpose:
* Returns the type information for this coclass.
*
* Parameters:
* ppITI ITypeInfo ** in which to store the ITypeInfo
* for this coclass.
*
* Return Value:
* HRESULT NOERROR on success, error otherwise.
*/
STDMETHODIMP CImpIProvideClassInfo::GetClassInfo(ITypeInfo **ppITI)
{
if (NULL==ppITI)
return ResultFromScode(E_POINTER);
*ppITI=m_pITI;
if (NULL!=m_pITI)
{
m_pITI->AddRef();
return NOERROR;
}
return ResultFromScode(E_FAIL);
}