KOALA.CPP
/*
* KOALA.CPP
* Koala Object with Custom Marshaling, Chapter 6
*
* Implementation of the CKoala object with a custom interface
* to demonstrate local/remote transparency.
*
* Copyright (c)1993-1995 Microsoft Corporation, All Rights Reserved
*
* Kraig Brockschmidt, Microsoft
* Internet : kraigb@microsoft.com
* Compuserve: >INTERNET:kraigb@microsoft.com
*/
#include "koala.h"
/*
* ObjectWndProc
*
* Purpose:
* Standard window class procedure for each object.
*/
LRESULT APIENTRY ObjectWndProc(HWND hWnd, UINT iMsg
, WPARAM wParam, LPARAM lParam)
{
PCKoala pKoala;
pKoala=(PCKoala)GetWindowLong(hWnd, OBJECTWL_STRUCTURE);
switch (iMsg)
{
case WM_NCCREATE:
pKoala=(PCKoala)(((LPCREATESTRUCT)lParam)->lpCreateParams);
SetWindowLong(hWnd, OBJECTWL_STRUCTURE, (LONG)pKoala);
return (DefWindowProc(hWnd, iMsg, wParam, lParam));
case WM_COMMAND:
//Dispatch the call to the right object
return pKoala->HandleCall(LOWORD(wParam), lParam);
default:
return (DefWindowProc(hWnd, iMsg, wParam, lParam));
}
return 0L;
}
/*
* CKoala::CKoala
* CKoala::~CKoala
*
* Parameters (Constructor):
* pfnDestroy PFNDESTROYED to call when an object
* is destroyed.
*/
CKoala::CKoala(PFNDESTROYED pfnDestroy)
{
m_cRef=0;
m_pfnDestroy=pfnDestroy;
m_fJustAte=FALSE;
m_cSleepAfterEat=0;
return;
}
CKoala::~CKoala(void)
{
if (NULL!=m_hWnd)
DestroyWindow(m_hWnd);
return;
}
/*
* CKoala::Init
*
* Purpose:
* Performs any intiailization of a CKoala that's prone to failure
* that we also use internally before exposing the object outside.
*
* Parameters:
* hInst HINSTANCE of the application.
* hWndParent HWND in which to create our window
*
* Return Value:
* BOOL TRUE if the function is successful,
* FALSE otherwise.
*/
BOOL CKoala::Init(HINSTANCE hInst, HWND hWndParent)
{
//Create our window that receives marshaling calls
m_hWnd=CreateWindow(TEXT("KoalaObject"), TEXT("KoalaObject")
, WS_CHILD, 35, 35, 35, 25, hWndParent, NULL
, hInst, this);
if (NULL==m_hWnd)
return FALSE;
return TRUE;
}
/*
* CKoala::HandleCall
*
* Purpose:
* Handles messages sent via custom marshaling from the client
* side proxy.
*
* Parameters:
* iMsg UINT identifying the call made.
* lParam LPARAM with extra information.
*
* Return Value:
* DWORD Value to return to the proxy which it uses
* in whatever way it must to return a value to
* the client.
*/
DWORD CKoala::HandleCall(UINT iMsg, LPARAM lParam)
{
DWORD dw;
short iRet=0;
/*
* You'll notice that all the important server-side
* implementation of the object exists here instead of
* separate interface implementations. Everything
* else is contained in the client-side proxy, who knows
* when there's no point at all in calling a function
* on the server side (such as with some of the IKoala
* functions that don't do anything.
*/
switch (iMsg)
{
case MSG_RELEASE: //Last IUnknown::Release
/*
* There is only one reference count from
* IClassFactory::CreateInstance, which the proxy
* will own. The proxy sends this message when
* it detects the last Release from the client.
* Otherwise it doesn't forward AddRef/Release calls.
*/
Release();
break;
case MSG_EAT:
m_fJustAte=TRUE;
break;
case MSG_SLEEP: //IAnimal::Sleep
//Client's in-parameter in LOWORD(lParam)
iRet=LOWORD(lParam)+m_cSleepAfterEat;
m_fJustAte=FALSE; //Probably want to eat again
break;
case MSG_PROCREATE: //IAnimal::Procreate
dw=GetTickCount()/100;
iRet=((dw/10)*10==dw) ? 1 : 0;
break;
case MSG_SLEEPAFTEREATING: //IKoala::SleepAfterEating
m_cSleepAfterEat=LOWORD(lParam);
break;
default:
break;
}
return iRet;
}
/*
* CKoala::QueryInterface
* CKoala::AddRef
* CKoala::Release
*
* Purpose:
* IUnknown members for CKoala object.
*/
STDMETHODIMP CKoala::QueryInterface(REFIID riid, PPVOID ppv)
{
*ppv=NULL;
if (IID_IUnknown==riid || IID_IMarshal==riid
|| IID_IAnimal==riid || IID_IKoala==riid)
*ppv=this;
if (NULL!=*ppv)
{
((LPUNKNOWN)*ppv)->AddRef();
return NOERROR;
}
return ResultFromScode(E_NOINTERFACE);
}
STDMETHODIMP_(ULONG) CKoala::AddRef(void)
{
return ++m_cRef;
}
STDMETHODIMP_(ULONG) CKoala::Release(void)
{
if (0L!=--m_cRef)
return m_cRef;
if (NULL!=m_pfnDestroy)
(*m_pfnDestroy)();
delete this;
return 0;
}
/*
* CKoala::GetUnmarshalClass
*
* Purpose:
* Determines the class of object to be used to create an
* uninitalized proxy in the unmarshaling process.
*
* Parameters:
* riid REFIID of the interface to be marshaled.
* pv LPVOID to the interface to be marshaled.
* dwCtx DWORD specifying the relation of the processes
* between which the marshaling is occuring, from the
* MSHCTX enumeration.
* pvCtx LPVOID Reserved for future MSHCTX values.
* dwFlags DWORD specifying why marshaling is taking place.
* pClsID LPCLSID in which to store the proxy CLSID.
*/
STDMETHODIMP CKoala::GetUnmarshalClass(REFIID riid
, LPVOID pv, DWORD dwCtx, LPVOID pvCtx, DWORD dwFlags
, LPCLSID pClsID)
{
#ifdef WIN32
/*
* If the context is on a different machine we cannot use
* our custom marshaling based on SendMessage.
*/
if (dwCtx & MSHCTX_DIFFERENTMACHINE)
return ResultFromScode(E_FAIL);
#endif
//Same proxy for all interfaces.
*pClsID=CLSID_KoalaProxy;
return NOERROR;
}
/*
* CKoala::GetMarshalSizeMax
*
* Purpose:
* Returns the upper memory bound needed to write data into a stream
* for IMarshal::MarshalInterface.
*
* Parameters:
* riid REFIID of the interface to be marshaled.
* pv LPVOID of the interface to be marshaled.
* dwDestCtx DWORD with the destination context from MSHCTX.
* pvDestCtx LPVOID reserved for future MSHCTX flags.
* dwFlags DWORD specifying why marshaling is taking place.
* pdwSize LPDWORD in which the size is returned.
*/
STDMETHODIMP CKoala::GetMarshalSizeMax(REFIID riid, LPVOID pv
, DWORD dwDestCtx, LPVOID pvDestCtx, DWORD dwFlags
, LPDWORD pdwSize)
{
#ifdef WIN32
if (dwDestCtx & MSHCTX_DIFFERENTMACHINE)
return ResultFromScode(E_FAIL);
#endif
*pdwSize=sizeof(KOALAMARSHAL);
return NOERROR;
}
/*
* CKoala::MarshalInterface
*
* Purpose:
* Stores a marshaling packet in a stream for use by a client-side
* proxy.
*
* Parameters:
* pStm LPSTREAM into which to marshal the interface.
* riid REFIID of the interface to be marshaled.
* pv LPVOID of the interface to be marshaled.
* dwDestCtx DWORD with the destination context from MSHCTX.
* pvDestCtx LPVOID reserved for future MSHCTX flags.
* dwFlags DWORD specifying why marshaling is taking place.
*/
STDMETHODIMP CKoala::MarshalInterface(LPSTREAM pstm
, REFIID riid, LPVOID pv, DWORD dwDestCtx, LPVOID pvDestCtx
, DWORD dwFlags)
{
KOALAMARSHAL km;
#ifdef WIN32
if (dwDestCtx & MSHCTX_DIFFERENTMACHINE)
return ResultFromScode(E_FAIL);
#endif
//Proxy only needs to know where to send messages
km.hWnd=m_hWnd;
//This is for the client who will call Release when needed
AddRef();
//Write the marshaling packet to the stream
return pstm->Write((void *)&km, sizeof(KOALAMARSHAL), NULL);
}
/*
* CKoala::UnmarshalInterface
*
* Purpose:
* Initializes a newly created proxy the marshaling packet in
* the stream created in the server-side implementation of
* MarshalInterface. This is the primary member of this interface
* used on the client side proxy.
*
* Parameters:
* pStm LPSTREAM to the stream containing marshal
* data.
* riid REFIID of the interface to be marshaled.
* pv LPVOID of the interface to be marshaled.
*/
STDMETHODIMP CKoala::UnmarshalInterface(LPSTREAM pstm
, REFIID riid, LPVOID *pv)
{
//No need to implement on server side
return ResultFromScode(E_NOTIMPL);
}
/*
* CKoala::ReleaseMarshalData
*
* Purpose:
* Destroy a marshaled data packet, client-side only.
*
* Parameters:
* pStm LPSTREAM containing the data to release.
*/
STDMETHODIMP CKoala::ReleaseMarshalData(LPSTREAM pstm)
{
//Client-side function
return ResultFromScode(E_NOTIMPL);
}
/*
* CKoala::Disconnect
*
* Purpose:
* Instructs an object with custom marshaling that it's being
* disconnected.
*
* Parameters:
* dwReserved DWORD reserved.
*/
STDMETHODIMP CKoala::DisconnectObject(DWORD dwReserved)
{
/*
* This is generated from within CoDisconnectObject, which
* our server doesn't call itself. This would give the object
* a chance to close its connection and cleanup before going
* away since the proxy will no longer be calling it.
* This should also be used to block any additional calls
* made after this point.
*/
return NOERROR;
}