able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/multimedia/directx/gamectrl/handler/mainhand.cpp

940 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
**
** FILE: MAINHANDLER.CPP
** DATE: 01/29/97
** PROJ: ATLAS
** PROG: Guru Datta Venkatarama
** COMMENTS: Common interface to gaming devices in-proc servers
**
** DESCRIPTION:This is the generic handler that supports a standard
** protocol to support plug in servers to implement its
** property sheet and diagnostics interface
**
** NOTE:
**
** HISTORY:
** DATE WHO WHAT
** ---- --- ----
** 1/29/97 Guru CREATED
** 3/25/97 a-kirkh ADDED COMMENTS
**
**
**
** Copyright (C) Microsoft 1997. All Rights Reserved.
**
**~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
// %%% debug %%% check out the includes
#define INC_OLE2
#pragma pack (8)
#include "stdafx.h"
#include <objbase.h>
#include <initguid.h>
#include <shlobj.h>
#include <assert.h>
#ifndef _UNICODE
#include <malloc.h> // needed for _alloca
#include <afxconv.h>
#endif
#include "mainhand.h"
#include "plugsrvr.h"
// BEGINNING OF UNICODE CONVERSION UTILITY DEFINITIONS
#ifndef USES_CONVERSION
#ifndef _DEBUG
#define USES_CONVERSION int _convert; _convert
#else
#define USES_CONVERSION int _convert = 0;
#endif
#endif // USES_CONVERSION
#ifndef A2W
#define A2W(lpa) (((LPCSTR)lpa == NULL) ? NULL : (_convert = (lstrlenA(lpa)+1), AfxA2WHelper((LPWSTR) alloca(_convert*2), lpa, _convert)))
#endif // A2W
#ifndef W2A
#define W2A(lpw) (((LPCWSTR)lpw == NULL) ? NULL : ( _convert = (wcslen(lpw)+1)*2, AfxW2AHelper((LPSTR) alloca(_convert), lpw, _convert)))
#endif // W2A
// END OF UNICODE CONVERSION UTILITY DEFINITIONS
static USHORT g_cServerLocks;
static USHORT g_cComponents;
/*------------------------------------------------------------
** DllMain
*
* DESCRIPTION : Entry point into the Inprocess handler.
* Here is where it all begins !! This implementation
* is a single thread, in process handler.
*
* AUTHOR : Guru Datta Venkatarama 01/29/97 11:13:49 (PST)
* a-kirkh - Implemented reference counting
------------------------------------------------------------*/
int APIENTRY DllMain(
HINSTANCE hInstance,
DWORD dwReason,
LPVOID lpReserved)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
break;
case DLL_PROCESS_DETACH:
break;
}
return 1;
}
/*------------------------------------------------------------
* DllGetClassObject
*
* PARAMETERS : rclsid = Reference to class ID specifier
* riid = Reference to interface ID specifier
* ppv = Pointer to location to receive interface pointer
*
* DESCRIPTION : Here be the entry point of COM.
* DllGetClassObject is called by the Client socket to
* create a class factory object.
* This Class factory will support the generation of three different class
* Objects.
*
* RETURNS : HRESULT code signifying success or failure
*
* AUTHOR : Guru Datta Venkatarama 01/29/97 14:22:02 (PST)
*
------------------------------------------------------------*/
STDAPI DllGetClassObject(
REFCLSID rclsid,
REFIID riid,
PPVOID ppv)
{
*ppv = NULL;
if (!IsEqualIID (riid, IID_IClassFactory))
{
TRACE(TEXT("Mainhand.cpp: DllGetClassObject: Failed to find IID_IClassFactory!\n"));
return ResultFromScode (E_NOINTERFACE);
}
CHandlerClassFactory *pClassFactory = new CHandlerClassFactory();
ASSERT (pClassFactory);
if (pClassFactory == NULL)
{
return ResultFromScode (E_OUTOFMEMORY);
}
// Get the interface pointer from QueryInterface and copy it to *ppv.
// The required type of riid is automatically being passed in ....
HRESULT hr = pClassFactory->QueryInterface (riid, ppv);
if(SUCCEEDED(hr))
pClassFactory->m_CLSID_whoamI = rclsid;
return hr;
}
/*------------------------------------------------------------
** DllCanUnloadNow
*
* PARAMETERS : None
*
* DESCRIPTION : DllCanUnloadNow is called by the shell to find out if the DLL can be
* unloaded. The answer is yes if (and only if) the module reference count
* stored in g_cServerLocks and g_cComponents is 0.
* This Dll can be unloaded if and only if :
* a) All the in components that it "spawns" have been deleted and
* b) There are no locks on any of the class factory interfaces
* RETURNS : HRESULT code equal to S_OK if the DLL can be unloaded, S_FALSE if not
* AUTHOR : Guru Datta Venkatarama 01/30/97 08:24:21 (PST)
* a-kirkh - Implemented.
*
------------------------------------------------------------*/
STDAPI DllCanUnloadNow(void)
{
return ((!g_cComponents) && (!g_cServerLocks)) ? S_OK : S_FALSE;
}
/*------------------------------------------------------------
* CHandlerClassFactory Member Functions
*
* DESCRIPTION : This is the implementation of the standard member functions of the
* Handler's class factory.
*
* AUTHOR : Guru Datta Venkatarama 01/30/97 08:30:18 (PST)
*
------------------------------------------------------------*/
// constructor ..
CHandlerClassFactory::CHandlerClassFactory(void):m_ClassFactory_refcount(0){}
// -----------------------------------------------------------
// destructor ..
CHandlerClassFactory::~CHandlerClassFactory(void){/**/}
// -----------------------------------------------------------
STDMETHODIMP CHandlerClassFactory::QueryInterface(
REFIID riid,
PPVOID ppv)
{
if (IsEqualIID(riid, IID_IUnknown))
{
*ppv = (LPUNKNOWN) (LPCLASSFACTORY) this;
// add reference count every time a pointer is provided
AddRef();
return NOERROR;
}
else
{
if (IsEqualIID(riid, IID_IClassFactory))
{
*ppv = (LPCLASSFACTORY) this;
// add reference count every time a pointer is provided
AddRef();
return NOERROR;
}
else
{
// unsupported interface requested
*ppv = NULL;
TRACE(TEXT("Mainhand.cpp: QueryInterface: Failed to find IID_IClassFactory!\n"));
return ResultFromScode (E_NOINTERFACE);
}
}
}
// -----------------------------------------------------------
STDMETHODIMP_(ULONG)CHandlerClassFactory::AddRef(void)
{
// bump up the usage count
InterlockedIncrement((LPLONG)&m_ClassFactory_refcount);
return m_ClassFactory_refcount;
}
// -----------------------------------------------------------
STDMETHODIMP_(ULONG)CHandlerClassFactory::Release(void)
{
InterlockedDecrement((LPLONG)&m_ClassFactory_refcount);
if(m_ClassFactory_refcount > 0)
{
return (m_ClassFactory_refcount);
}
else
{
delete this;
return 0;
}
}
// -----------------------------------------------------------
/*------------------------------------------------------------
** CHandlerClassFactory::CreateInstance
*
* PARAMETERS : pUnkOuter = Pointer to controlling unknown
* riid = Reference to interface ID specifier
* ppvObj = Pointer to location to receive interface pointer
* DESCRIPTION : CreateInstance is the class factory implementation.
* It is called by the client to create the IServerCharacterstics interface
* It is called by the members of the IServerCharacteristics interface
* viz CreatePropertySheet and CreateDiagnostics to create the
* appropriate interfaces for each.
*
* RETURNS : HRESULT code signifying success or failure
*
* AUTHOR : Guru Datta Venkatarama 01/31/97 09:29:36 (PST)
*
------------------------------------------------------------*/
STDMETHODIMP CHandlerClassFactory::CreateInstance(
LPUNKNOWN pUnkOuter,
REFIID riid,
PPVOID ppvObj)
{
*ppvObj = NULL;
HRESULT hr=S_OK;
//Cannot aggregate here
if (pUnkOuter != NULL)
{
return ResultFromScode(CLASS_E_NOAGGREGATION);
}
CPluginHandler *pCPluginHandler = new CPluginHandler;
ASSERT (pCPluginHandler);
if (!pCPluginHandler) return E_OUTOFMEMORY;
hr = pCPluginHandler->QueryInterface(riid, ppvObj);
// Init the CLSID
if(SUCCEEDED(hr))
pCPluginHandler->m_CLSID_whoamI = m_CLSID_whoamI;
return hr;
}
/*------------------------------------------------------------
** LockServer
*
* PARAMETERS :
*
* DESCRIPTION : LockServer increments or decrements the DLL's lock count.
*
* RETURNS :
*
* AUTHOR : Guru Datta Venkatarama 01/31/97 18:40:17 (PST)
* a-kirkh - Implemented
*
------------------------------------------------------------*/
STDMETHODIMP CHandlerClassFactory::LockServer(BOOL fLock)
{
if(fLock)
InterlockedIncrement((LPLONG)&g_cServerLocks);
else
InterlockedDecrement((LPLONG)&g_cServerLocks);
return S_OK;
}
/*------------------------------------------------------------
** CPluginHandler Object member functions
*
* PARAMETERS :
*
* DESCRIPTION :
*
* RETURNS :
*
* AUTHOR : Guru Datta Venkatarama 02/03/97 10:55:34 (PST)
* a-kirkh - cleaned up the ref-counting
*
------------------------------------------------------------*/
CPluginHandler::CPluginHandler(void)
{
InterlockedIncrement((LPLONG)&g_cComponents);
m_pImpIServerProperty = NULL;
m_cPluginHandler_refcount = 0;
return;
}
// -----------------------------------------------------------
CPluginHandler::~CPluginHandler(void)
{
InterlockedDecrement((LPLONG)&g_cComponents);
return;
}
// -----------------------------------------------------------
STDMETHODIMP CPluginHandler::QueryInterface(
REFIID riid,
PPVOID ppv)
{
if (IsEqualIID(riid, IID_IUnknown) || IsEqualIID(riid, IID_IServerCharacteristics))
{
*ppv = this;
}
else
{
*ppv = NULL;
TRACE(TEXT("Mainhand.cpp: QueryInterface: riid is != IID_IUnknown || IID_IServerCharacteristics!\n"));
return ResultFromScode (E_NOINTERFACE);
}
AddRef();
return(S_OK);
}
// -----------------------------------------------------------CPluginHandler::AddRef
STDMETHODIMP_(ULONG)CPluginHandler::AddRef(void)
{
// bump up the usage count
InterlockedIncrement((LPLONG)&m_cPluginHandler_refcount);
return(m_cPluginHandler_refcount);
}
// -----------------------------------------------------------CPluginHandler::Release
STDMETHODIMP_(ULONG)CPluginHandler::Release(void)
{
InterlockedDecrement((LPLONG)&m_cPluginHandler_refcount);
if(m_cPluginHandler_refcount > 0)
{
return(m_cPluginHandler_refcount);
}
else
{
delete this;
return 0;
}
}
/*------------------------------------------------------------CPluginHandler::Launch
** CPluginHandler::Launch
*
* PARAMETERS : hWnd - Handle to window of the client (Control Panel)
* startpage - Page to start with
* nID - Joystick ID that the device associated with this page is on!
*
* DESCRIPTION : Restricts the building of property pages to our supported method.
*
* RETURNS : Error standard COM error codes or our errors from E_ERROR_START to E_ERROR_STOP (defined in sstructs.h)
*
* AUTHOR : Guru Datta Venkatarama
* 02/03/97 14:47:47 (PST)
*
------------------------------------------------------------*/
STDMETHODIMP CPluginHandler::Launch(HWND hWnd, USHORT startpage, USHORT nID)
{
LPDIGCPAGEINFO serverpage;
LPDIGCSHEETINFO serversheet;
LPPROPSHEETPAGE pspptr;
UINT loop_index;
LPCDIGAMECNTRLPROPSHEET propiface;
HRESULT hr=S_OK;
ASSERT (::IsWindow(hWnd));
if (startpage > MAX_PAGES)
return DIGCERR_STARTPAGETOOLARGE;
// check to make certain that the server has the required interface
// step A : do we have an interface to work with ?
//
if(!(propiface = GetServerPropIface()))
{
TRACE(TEXT("Mainhand.cpp: Launch: GetPropIface didn't find IID_IDIGameCntrlPropSheet!\n"));
return ResultFromScode (E_NOINTERFACE);
}
// Step B. Use the interface ...
// step 1 : get the property sheet info from the server
if (FAILED(propiface->GetSheetInfo(&serversheet)))
{
TRACE(TEXT("GCHAND.DLL: MAINHAND.CPP: Launch: GetSheetInfo Failed!\n"));
return E_FAIL;
}
if (serversheet->nNumPages > MAX_PAGES)
{
return DIGCERR_NUMPAGESTOOLARGE;
}
// step 2 : get the information for all the pages from the server
if (FAILED(propiface->GetPageInfo(&serverpage)))
{
TRACE(TEXT("GCHAND.DLL: MAINHAND.CPP: Launch: GetPageInfo Failed!\n"));
return E_FAIL;
}
/* BLJ: REMOVED 1/12/98
// return for testing of interface!!!
#ifdef _DEBUG
USES_CONVERSION;
// PAGE TRACE MESSAGES
for(loop_index=0; loop_index < serversheet->nNumPages; loop_index++)
{
TRACE(TEXT("GetPageInfo: Page %d dwSize is %d, expected %d\n"), loop_index, serverpage[loop_index].dwSize, sizeof(DIGCPAGEINFO));
#ifdef _UNICODE
TRACE(TEXT("GetPageInfo: Page %d lpwszPageTitle (AFTER ANSI CONVERSION) is %s\n"), loop_index, serverpage[loop_index].lpwszPageTitle);
#else
TRACE(TEXT("GetPageInfo: Page %d lpwszPageTitle (AFTER ANSI CONVERSION) is %s\n"), loop_index, W2A(serverpage[loop_index].lpwszPageTitle));
#endif
if (serverpage[loop_index].fpPageProc)
TRACE(TEXT("GetPageInfo: Page %d Has an assigned page proc!\n"), loop_index);
else
TRACE(TEXT("GetPageInfo: Page %d Has NO assigned page proc!\n"), loop_index);
if (serverpage[loop_index].fProcFlag)
{
TRACE(TEXT("GetPageInfo: Page %d Has a PrePostPage proc and %s\n"), loop_index,
(serverpage[loop_index].fpPrePostProc) ? "it is NOT NULL" : "it is NULL!");
}
else TRACE(TEXT("GetPageInfo: Page %d's PrePostPage proc flag is FALSE!\n"), loop_index);
if (serverpage[loop_index].fIconFlag)
{
TRACE(TEXT("GetPageInfo: Page %d's fIconFlag flag is TRUE!\n"), loop_index);
}
else
TRACE(TEXT("GetPageInfo: Page %d's fIconFlag flag is FALSE!\n"), loop_index);
TRACE(TEXT("GetPageInfo: Page %d's lParam is %d\n"), loop_index, serverpage[loop_index].lParam);
// TRACE(TEXT("GetPageInfo: Page %d's lpwszTemplate (AFTER ANSI CONVERSION) is %s\n"), loop_index, W2A(serverpage[loop_index].lpwszTemplate));
TRACE(TEXT("GetPageInfo: Page %d's hInstance is %x\n"), loop_index, serverpage[loop_index].hInstance);
}
// SHEET TRACE MESSAGES!!!
TRACE (TEXT("GetSheetInfo: dwSize %d, expected %d\n"), serversheet->dwSize, sizeof(DIGCSHEETINFO));
TRACE (TEXT("GetSheetInfo: nNumPages %d\n"), serversheet->nNumPages);
#ifdef _UNICODE
TRACE (TEXT("GetSheetInfo: lpwszSheetCaption (AFTER CONVERSION TO ANSI) is %s\n"), serversheet->lpwszSheetCaption);
#else
TRACE (TEXT("GetSheetInfo: lpwszSheetCaption (AFTER CONVERSION TO ANSI) is %s\n"), W2A(serversheet->lpwszSheetCaption));
#endif
if (serversheet->fSheetIconFlag)
{
TRACE (TEXT("GetSheetInfo: fSheetInfoFlag is set to TRUE!\n"));
// TRACE (TEXT("GetSheetInfo: lpwszSheetIcon (AFTER CONVERSION TO ANSI) is %s\n"), W2A(serversheet->lpwszSheetIcon));
}
else
TRACE (TEXT("GetSheetInfo: fSheetInfoFlag is set to FALSE!\n"));
#endif
*/
// here's where we are sending the property sheet an ID describing the location of the installed device!
hr = propiface->SetID(nID);
ASSERT (SUCCEEDED(hr));
// step 3 : construct the property pages structure
// 3.1 allocate an array of PROPERTYSHEETPAGE for the number of pages required
if(!(pspptr = (LPPROPSHEETPAGE) malloc(sizeof(PROPSHEETPAGE)*serversheet->nNumPages)))
{
return ResultFromScode (E_OUTOFMEMORY);
}
else
{
#ifndef _UNICODE
USES_CONVERSION;
#endif
// 3.2 Now proceed to fill up each page
for(loop_index=0;loop_index<serversheet->nNumPages;loop_index++)
{
// transfer data .. the size
pspptr[loop_index].dwSize = sizeof(PROPSHEETPAGE);
// transfer the lparam value
pspptr[loop_index].lParam = serverpage[loop_index].lParam;
// ---------- TITLING OF THE PAGE ----------------------------
// set the basic flags
pspptr[loop_index].dwFlags = 0;
if (serverpage[loop_index].lpwszPageTitle)
{
pspptr[loop_index].dwFlags |= PSP_USETITLE;
// Check to see if you are a String!!!
if (HIWORD((INT_PTR)serverpage[loop_index].lpwszPageTitle))
{
#ifdef _UNICODE
pspptr[loop_index].pszTitle = serverpage[loop_index].lpwszPageTitle;
#else
pspptr[loop_index].pszTitle = W2A(serverpage[loop_index].lpwszPageTitle);
#endif
}
else pspptr[loop_index].pszTitle = (LPTSTR)serverpage[loop_index].lpwszPageTitle;
}
else
{
pspptr[loop_index].pszTitle = NULL;
}
/*
if (!lstrlen(pspptr[loop_index].pszTitle))
{
return DIGCERR_NOTITLE;
}
*/
// if icon is required go ahead and add it.
if(serverpage[loop_index].fIconFlag)
{
pspptr[loop_index].dwFlags |= PSP_USEICONID;
// Check to see if you are an INT or a String!
if (HIWORD((INT_PTR)serverpage[loop_index].lpwszPageIcon))
{
// You're a string!!!
#ifdef _UNICODE
pspptr[loop_index].pszIcon = serverpage[loop_index].lpwszPageIcon;
#else
pspptr[loop_index].pszIcon = W2A(serverpage[loop_index].lpwszPageIcon);
#endif
}
else pspptr[loop_index].pszIcon = (LPCTSTR)(serverpage[loop_index].lpwszPageIcon);
}
// ---------- PROCEDURAL SUPPORT FOR THE PAGE ----------------
// if a pre - post processing call back proc is required go ahead and add it
if(serverpage[loop_index].fProcFlag)
{
if(serverpage[loop_index].fpPrePostProc)
{
pspptr[loop_index].dwFlags |= PSP_USECALLBACK;
pspptr[loop_index].pfnCallback = (LPFNPSPCALLBACK) serverpage[loop_index].fpPrePostProc;
}
else
{
return DIGCERR_NOPREPOSTPROC;
}
}
// and the essential "dialog" proc
if(serverpage[loop_index].fpPageProc)
{
pspptr[loop_index].pfnDlgProc = serverpage[loop_index].fpPageProc;
}
else
{
return DIGCERR_NODLGPROC;
}
// ---------- INSTANCE & PARENTHOOD --------------------------
pspptr[loop_index].hInstance = serverpage[loop_index].hInstance;
pspptr[loop_index].pcRefParent = 0;
// ---------- DIALOG TEMPLATE --------------------------------
if (HIWORD((INT_PTR)serverpage[loop_index].lpwszTemplate))
{
#ifdef _UNICODE
pspptr[loop_index].pszTemplate = serverpage[loop_index].lpwszTemplate;
#else
pspptr[loop_index].pszTemplate = W2A(serverpage[loop_index].lpwszTemplate);
#endif
}
else
{
pspptr[loop_index].pszTemplate = (LPTSTR)serverpage[loop_index].lpwszTemplate;
}
// test to see if template will fit on the screen!
}
}
// step 4 : construct the property sheet header
// %%% debug %%% - strange stuff - not there in include file ! PSH_MULTILINETABS |
LPPROPSHEETHEADER ppsh = new (PROPSHEETHEADER);
ASSERT (ppsh);
ZeroMemory(ppsh, sizeof(PROPSHEETHEADER));
ppsh->dwSize = sizeof(PROPSHEETHEADER);
ppsh->dwFlags = PSH_PROPSHEETPAGE;
ppsh->hwndParent = hWnd;
if (serversheet->fSheetIconFlag)
{
if (serversheet->lpwszSheetIcon)
{
// check to see if you are an INT or a WSTR
if (HIWORD((INT_PTR)serversheet->lpwszSheetIcon))
{
// You are a string!
#ifdef _UNICODE
ppsh->pszIcon = serversheet->lpwszSheetIcon;
#else
USES_CONVERSION;
ppsh->pszIcon = W2A(serversheet->lpwszSheetIcon);
#endif
}
else ppsh->pszIcon = (LPTSTR)serversheet->lpwszSheetIcon;
ppsh->dwFlags |= PSH_USEICONID;
}
else return DIGCERR_NOICON;
}
// do we have a sheet caption ?
if (serversheet->lpwszSheetCaption)
{
// is the sheet caption provided physically existant ?
if(wcslen(serversheet->lpwszSheetCaption))
{
#ifdef _UNICODE
ppsh->pszCaption = serversheet->lpwszSheetCaption;
#else
USES_CONVERSION;
ppsh->pszCaption = W2A(serversheet->lpwszSheetCaption);
#endif
ppsh->dwFlags |= PSH_PROPTITLE;
}
else
{
return DIGCERR_NOCAPTION;
}
}
// test for user error!
if (!serversheet->nNumPages)
return DIGCERR_NUMPAGESZERO;
// set the number of pages %%% debug %%% is this limit appropriate ?
ppsh->nPages = serversheet->nNumPages;
// ( and whilst at it ) : select the current page
if (serversheet->nNumPages > startpage)
ppsh->nStartPage = startpage;
else
return DIGCERR_STARTPAGETOOLARGE;
// set the property pages inofrmation into the header
ppsh->ppsp = (LPCPROPSHEETPAGE)pspptr;
// and set the standard call back function for the property sheet
ppsh->pfnCallback = NULL;
// step 5 : launch modal property sheet dialog
switch (PropertySheet(ppsh))
{
// In the event that the user wants to reboot...
case ID_PSREBOOTSYSTEM:
case ID_PSRESTARTWINDOWS:
#ifdef _DEBUG
TRACE(TEXT("GCHAND.DLL: PropertySheet returned a REBOOT request!\n"));
#endif
ExitWindowsEx(EWX_REBOOT, NULL);
break;
}
if (ppsh)
delete (ppsh);
if (pspptr)
free (pspptr);
// step 6 : release all elements of the Property interface on the server
propiface->Release();
// step 7 : return success / failure code back to the caller
return(hr);
}
/*------------------------------------------------------------CPluginHandler::GetReport
** CPluginHandler::GetReport
*
* PARAMETERS :
*
* DESCRIPTION : Provides the client with a report of the number of property pages that
* this server supports and their names
*
* RETURNS :
*
* AUTHOR : Guru Datta Venkatarama 02/11/97 15:26:56 (PST)
* a-kirkh - Added asserts
*
------------------------------------------------------------*/
STDMETHODIMP CPluginHandler::GetReport(LPDIGCSHEETINFO *pServerSheetData, LPDIGCPAGEINFO *pServerPageData)
{
// check out your parameters
ASSERT (pServerSheetData);
ASSERT (pServerPageData );
LPCDIGAMECNTRLPROPSHEET pPropIFace = GetServerPropIface();
ASSERT (pPropIFace);
if(!pPropIFace)
return ResultFromScode (E_NOINTERFACE);
// A little temp pointer for error trapping...
LPDIGCSHEETINFO pTmpSheet;
// get the property sheet info from the server
HRESULT hr = pPropIFace->GetSheetInfo(&pTmpSheet);
ASSERT (SUCCEEDED(hr));
#ifdef _DEBUG
// SHEET TRACE MESSAGES!!!
USES_CONVERSION;
TRACE (TEXT("GetSheetInfo: dwSize %d, expected %d\n"), pTmpSheet->dwSize, sizeof(DIGCSHEETINFO));
TRACE (TEXT("GetSheetInfo: nNumPages %d\n"), pTmpSheet->nNumPages);
#ifdef _UNICODE
TRACE (TEXT("GetSheetInfo: lpwszSheetCaption (AFTER CONVERSION TO ANSI) is %s\n"), pTmpSheet->lpwszSheetCaption);
#else
TRACE (TEXT("GetSheetInfo: lpwszSheetCaption (AFTER CONVERSION TO ANSI) is %s\n"), W2A(pTmpSheet->lpwszSheetCaption));
#endif
if (pTmpSheet->fSheetIconFlag)
{
TRACE (TEXT("GetSheetInfo: fSheetInfoFlag is set to TRUE!\n"));
// Check to see if you are a string!
if (HIWORD((INT_PTR)pTmpSheet->lpwszSheetIcon))
#ifdef _UNICODE
TRACE (TEXT("GetSheetInfo: lpwszSheetIcon (AFTER CONVERSION TO ANSI) is %s\n"), pTmpSheet->lpwszSheetIcon);
#else
TRACE (TEXT("GetSheetInfo: lpwszSheetIcon (AFTER CONVERSION TO ANSI) is %s\n"), W2A(pTmpSheet->lpwszSheetIcon));
#endif
else
TRACE (TEXT("GetSheetInfo: lpwszSheetIcon id is %d\n"), pTmpSheet->lpwszSheetIcon);
}
else
TRACE (TEXT("GetSheetInfo: fSheetInfoFlag is set to FALSE!\n"));
#endif
if (pTmpSheet->dwSize != sizeof(DIGCSHEETINFO))
{
TRACE (TEXT("MainHand: GetReport: Error - Call to GetSheetInfo returned an invalid dwSize parameter!\n"));
// Just in case someone's not checking their return values...
memset (pServerSheetData, 0, sizeof(DIGCSHEETINFO));
pPropIFace->Release();
return DIGCERR_INVALIDDWSIZE;
}
// A little temp pointer for error trapping...
LPDIGCPAGEINFO pTmpPage;
hr = pPropIFace->GetPageInfo (&pTmpPage);
ASSERT (SUCCEEDED(hr));
#ifdef _DEBUG
// PAGE TRACE MESSAGES!!!
for(BYTE loop_index=0; loop_index < pTmpSheet->nNumPages; loop_index++)
{
TRACE(TEXT("GetPageInfo: Page %d dwSize is %d, expected %d\n"), loop_index, pTmpPage[loop_index].dwSize, sizeof(DIGCPAGEINFO));
#ifdef _UNICODE
TRACE(TEXT("GetPageInfo: Page %d lpwszPageTitle (AFTER CONVERSION TO ANSI) is %s\n"), loop_index, pTmpPage[loop_index].lpwszPageTitle);
#else
TRACE(TEXT("GetPageInfo: Page %d lpwszPageTitle (AFTER CONVERSION TO ANSI) is %s\n"), loop_index, W2A(pTmpPage[loop_index].lpwszPageTitle));
#endif
if (pTmpPage[loop_index].fpPageProc)
TRACE(TEXT("GetPageInfo: Page %d Has an assigned page proc!\n"), loop_index);
else
TRACE(TEXT("GetPageInfo: Page %d Has NO assigned page proc!\n"), loop_index);
if (pTmpPage[loop_index].fProcFlag)
{
TRACE(TEXT("GetPageInfo: Page %d Has a PrePostPage proc and %s\n"), loop_index,
(pTmpPage[loop_index].fpPrePostProc) ? "it is NOT NULL" : "it is NULL!");
}
else TRACE(TEXT("GetPageInfo: Page %d's PrePostPage proc flag is FALSE!\n"), loop_index);
if (pTmpPage[loop_index].fIconFlag)
{
// Check to see if you are a string!
if (HIWORD((INT_PTR)pTmpPage[loop_index].lpwszPageIcon))
#ifdef _UNICODE
TRACE (TEXT("GetSheetInfo: lpwszPageIcon #%d (AFTER CONVERSION TO ANSI) is %s\n"), loop_index, pTmpPage[loop_index].lpwszPageIcon);
#else
TRACE (TEXT("GetSheetInfo: lpwszPageIcon #%d (AFTER CONVERSION TO ANSI) is %s\n"), loop_index, W2A(pTmpPage[loop_index].lpwszPageIcon));
#endif
else
TRACE (TEXT("GetSheetInfo: lpwszPageIcon #%d id is %d\n"), loop_index, pTmpSheet->lpwszSheetIcon);
}
else TRACE(TEXT("GetPageInfo: Page %d's fIconFlag flag is FALSE!\n"), loop_index);
TRACE(TEXT("GetPageInfo: Page %d's lParam is %d\n"), loop_index, pTmpPage->lParam);
// TRACE(TEXT("GetPageInfo: Page %d's lpwszTemplate (AFTER ANSI CONVERSION) is %s\n"), loop_index, W2A(pTmpPage[loop_index].lpwszTemplate));
TRACE(TEXT("GetPageInfo: Page %d's hInstance is %d\n"), loop_index, pTmpPage->hInstance);
}
#endif
for (BYTE nIndex = 0; nIndex < pTmpSheet->nNumPages; nIndex++)
{
if (pTmpPage[nIndex].dwSize != sizeof(DIGCPAGEINFO))
{
TRACE (TEXT("MainHand: GetReport: Error - Call to GetPageInfo returned an invalid dwSize parameter!\n"));
// Just in case someone's not checking their return values...
memset (pServerPageData, 0, sizeof(DIGCPAGEINFO));
pPropIFace->Release();
return DIGCERR_INVALIDDWSIZE;
}
}
// Assign and return...
*pServerSheetData = pTmpSheet;
*pServerPageData = pTmpPage;
pPropIFace->Release();
return S_OK;
}
/*------------------------------------------------------------PropSheetCallback
** PropSheetCallback
*
* PARAMETERS :
*
* DESCRIPTION :
*
* RETURNS :
*
* AUTHOR : Guru Datta Venkatarama
* 02/11/97 14:01:50 (PST)
*
------------------------------------------------------------*/
int CALLBACK PropSheetCallback(
HWND hDlg,
UINT uMsg,
LPARAM lParam)
{
switch (uMsg)
{
case PSCB_INITIALIZED:
break;
case PSCB_PRECREATE:
break;
}
return 0;
}
/*------------------------------------------------------------CPluginHandler::LoadServerInterface
************************************ PRIVATE TO THE CLASS ***************************************
** CPluginHandler::LoadServerInterface
*
* PARAMETERS :
*
* DESCRIPTION :
*
* RETURNS :
*
* AUTHOR : Guru Datta Venkatarama
* 02/10/97 10:54:25 (PST)
*
------------------------------------------------------------*/
BOOL CPluginHandler::LoadServerInterface(REFIID interfaceId,PPVOID ppv)
{
IClassFactory* ppv_classfactory;
if(SUCCEEDED(CoGetClassObject( m_CLSID_whoamI, CLSCTX_INPROC_SERVER, NULL, IID_IClassFactory, (void **)&ppv_classfactory)))
{
if(SUCCEEDED(ppv_classfactory->CreateInstance(NULL, interfaceId, ppv)))
{
ppv_classfactory->Release();
return TRUE;
}
else
{
TRACE(TEXT("Mainhand.cpp: CreateInstance Failed!\n"));
}
// make sure the pointer is nulled
*ppv = NULL;
ppv_classfactory->Release();
}
else
{
TRACE(TEXT("Mainhand.cpp: LoadServerInterface Failed!\n"));
}
// Its time for the swarming herd of turtles
return FALSE;
}
//*********************************************************************************************
// -------------------------------------------------------------------EOF
Reference in a new issue Copy permalink