/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** ** 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 #include #include #include #ifndef _UNICODE #include // needed for _alloca #include #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_indexnNumPages;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