|
|
//=--------------------------------------------------------------------------=
// IPServer.Cpp
//=--------------------------------------------------------------------------=
// Copyright 1995-1996 Microsoft Corporation. All Rights Reserved.
//
// 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.
//=--------------------------------------------------------------------------=
//
// implements all exported DLL functions for the program, as well as a few
// others that will be used by same
//
#include "IPServer.H"
#include "LocalSrv.H"
#include "AutoObj.H"
#include "ClassF.H"
#include "CtrlObj.H"
#include "Globals.H"
#include "Unknown.H"
#include "Util.H"
//=--------------------------------------------------------------------------=
// Private module level data
//
// for ASSERT and FAIL
//
SZTHISFILE
//=--------------------------------------------------------------------------=
// These are used for reflection in OLE Controls. Not that big of a hit that
// we mind defining them for all servers, including automation or generic
// COM.
//
char g_szReflectClassName [] = "CtlFrameWork_ReflectWindow";BYTE g_fRegisteredReflect = FALSE;
//=--------------------------------------------------------------------------=
// allow controls to register for DLL_THREAD_ATTACH and DLL_THREAD_DETACH
//
THRDNFYPROC g_pfnThreadProc = NULL;
extern "C" void SetLibraryThreadProc(THRDNFYPROC pfnThreadNotify){ if ((g_pfnThreadProc = pfnThreadNotify) == NULL) DisableThreadLibraryCalls((HMODULE)g_hInstance);}
// ref count for LockServer
//
LONG g_cLocks;
// private routines for this file.
//
int IndexOfOleObject(REFCLSID);HRESULT RegisterAllObjects(void);HRESULT UnregisterAllObjects(void);
//=--------------------------------------------------------------------------=
// DllMain
//=--------------------------------------------------------------------------=
// yon standard LibMain.
//
// Parameters and Output:
// - see SDK Docs on DllMain
//
// Notes:
//
BOOL WINAPI DllMain( HANDLE hInstance, DWORD dwReason, void *pvReserved){ int i;
switch (dwReason) { // set up some global variables, and get some OS/Version information
// set up.
//
case DLL_PROCESS_ATTACH: { DWORD dwVer = GetVersion(); DWORD dwWinVer;
// swap the two lowest bytes of dwVer so that the major and minor version
// numbers are in a usable order.
// for dwWinVer: high byte = major version, low byte = minor version
// OS Sys_WinVersion (as of 5/2/95)
// =-------------= =-------------=
// Win95 0x035F (3.95)
// WinNT ProgMan 0x0333 (3.51)
// WinNT Win95 UI 0x0400 (4.00)
//
dwWinVer = (UINT)(((dwVer & 0xFF) << 8) | ((dwVer >> 8) & 0xFF)); g_fSysWinNT = FALSE; g_fSysWin95 = FALSE; g_fSysWin95Shell = FALSE;
if (dwVer < 0x80000000) { g_fSysWinNT = TRUE; g_fSysWin95Shell = (dwWinVer >= 0x0334); } else { g_fSysWin95 = TRUE; g_fSysWin95Shell = TRUE; }
// initialize a critical seciton for our apartment threading support
//
InitializeCriticalSection(&g_CriticalSection);
// create an initial heap for everybody to use.
// currently, we're going to let the system make things thread-safe,
// which will make them a little slower, but hopefully not enough
// to notice
//
g_hHeap = GetProcessHeap(); if (!g_hHeap) { FAIL("Couldn't get Process Heap. Not good!"); return FALSE; }
g_hInstance = (HINSTANCE)hInstance;
// give the user a chance to initialize whatever
//
InitializeLibrary();
// if they didn't ask for thread notifications then optimize by turning
// them off for our DLL.
//
if (!g_pfnThreadProc) DisableThreadLibraryCalls((HMODULE)hInstance); } break;
case DLL_THREAD_ATTACH: case DLL_THREAD_DETACH: if (g_pfnThreadProc) g_pfnThreadProc(hInstance, dwReason, pvReserved); break;
// do a little cleaning up!
//
case DLL_PROCESS_DETACH:
// clean up our critical seciton
//
DeleteCriticalSection(&g_CriticalSection);
// unregister all the registered window classes.
//
i = 0;
while (!ISEMPTYOBJECT(i)) { if (g_ObjectInfo[i].usType == OI_CONTROL) { if (CTLWNDCLASSREGISTERED(i)) UnregisterClass(WNDCLASSNAMEOFCONTROL(i), g_hInstance); } i++; }
// clean up our parking window.
//
if (g_hwndParking) { DestroyWindow(g_hwndParking); UnregisterClass("CtlFrameWork_Parking", g_hInstance); --g_cLocks; }
// clean up after reflection, if appropriate.
//
if (g_fRegisteredReflect) UnregisterClass(g_szReflectClassName, g_hInstance);
// give the user a chance to do some cleaning up
//
UninitializeLibrary(); break; }
return TRUE;}
//=--------------------------------------------------------------------------=
// DllRegisterServer
//=--------------------------------------------------------------------------=
// registers the Automation server
//
// Output:
// HRESULT
//
// Notes:
//
STDAPI DllRegisterServer( void){ HRESULT hr;
hr = RegisterAllObjects(); RETURN_ON_FAILURE(hr);
// call user registration function.
//
return (RegisterData())? S_OK : E_FAIL;}
//=--------------------------------------------------------------------------=
// DllUnregisterServer
//=--------------------------------------------------------------------------=
// unregister's the Automation server
//
// Output:
// HRESULT
//
// Notes:
//
STDAPI DllUnregisterServer( void){ HRESULT hr;
hr = UnregisterAllObjects(); RETURN_ON_FAILURE(hr);
// call user unregistration function
//
return (UnregisterData()) ? S_OK : E_FAIL;}
//=--------------------------------------------------------------------------=
// DllCanUnloadNow
//=--------------------------------------------------------------------------=
// we are being asked whether or not it's okay to unload the DLL. just check
// the lock counts on remaining objects ...
//
// Output:
// HRESULT - S_OK, can unload now, S_FALSE, can't.
//
// Notes:
//
STDAPI DllCanUnloadNow( void){ // if there are any objects lying around, then we can't unload. The
// controlling CUnknownObject class that people should be inheriting from
// takes care of this
//
return (g_cLocks) ? S_FALSE : S_OK;}
//=--------------------------------------------------------------------------=
// DllGetClassObject
//=--------------------------------------------------------------------------=
// creates a ClassFactory object, and returns it.
//
// Parameters:
// REFCLSID - CLSID for the class object
// REFIID - interface we want class object to be.
// void ** - pointer to where we should ptr to new object.
//
// Output:
// HRESULT - S_OK, CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY,
// E_INVALIDARG, E_UNEXPECTED
//
// Notes:
//
STDAPI DllGetClassObject( REFCLSID rclsid, REFIID riid, void **ppvObjOut){ HRESULT hr; void *pv; int iIndex;
// arg checking
//
if (!ppvObjOut) return E_INVALIDARG;
// first of all, make sure they're asking for something we work with.
//
iIndex = IndexOfOleObject(rclsid); if (iIndex == -1) return CLASS_E_CLASSNOTAVAILABLE;
// create the blank object.
//
pv = (void *)new CClassFactory(iIndex); if (!pv) return E_OUTOFMEMORY;
// QI for whatever the user has asked for.
//
hr = ((IUnknown *)pv)->QueryInterface(riid, ppvObjOut); ((IUnknown *)pv)->Release();
return hr;}//=--------------------------------------------------------------------------=
// IndexOfOleObject
//=--------------------------------------------------------------------------=
// returns the index in our global table of objects of the given CLSID. if
// it's not a supported object, then we return -1
//
// Parameters:
// REFCLSID - [in] duh.
//
// Output:
// int - >= 0 is index into global table, -1 means not supported
//
// Notes:
//
int IndexOfOleObject( REFCLSID rclsid){ int x = 0;
// an object is creatable if it's CLSID is in the table of all allowable object
// types.
//
while (!ISEMPTYOBJECT(x)) { if (OBJECTISCREATABLE(x)) { if (rclsid == CLSIDOFOBJECT(x)) return x; } x++; }
return -1;}
//=--------------------------------------------------------------------------=
// RegisterAllObjects
//=--------------------------------------------------------------------------=
// registers all the objects for the given automation server.
//
// Parameters:
// none
//
// Output:
// HERSULT - S_OK, E_FAIL
//
// Notes:
//
HRESULT RegisterAllObjects( void){ ITypeLib *pTypeLib; HRESULT hr; DWORD dwPathLen; char szTmp[MAX_PATH]; int x = 0;
// loop through all of our creatable objects [those that have a clsid in
// our global table] and register them.
//
while (!ISEMPTYOBJECT(x)) { if (!OBJECTISCREATABLE(x)) { x++; continue; }
// depending on the object type, register different pieces of information
//
switch (g_ObjectInfo[x].usType) {
// for both simple co-creatable objects and proeprty pages, do the same
// thing
//
case OI_UNKNOWN: case OI_PROPERTYPAGE: RegisterUnknownObject(NAMEOFOBJECT(x), CLSIDOFOBJECT(x)); break;
case OI_AUTOMATION: RegisterAutomationObject(g_szLibName, NAMEOFOBJECT(x), VERSIONOFOBJECT(x), *g_pLibid, CLSIDOFOBJECT(x)); break;
case OI_CONTROL: RegisterControlObject(g_szLibName, NAMEOFOBJECT(x), VERSIONOFOBJECT(x), *g_pLibid, CLSIDOFOBJECT(x), OLEMISCFLAGSOFCONTROL(x), BITMAPIDOFCONTROL(x)); break;
} x++; }
// Load and register our type library.
//
if (g_fServerHasTypeLibrary) { dwPathLen = GetModuleFileName(g_hInstance, szTmp, MAX_PATH); MAKE_WIDEPTR_FROMANSI(pwsz, szTmp); hr = LoadTypeLib(pwsz, &pTypeLib); RETURN_ON_FAILURE(hr); hr = RegisterTypeLib(pTypeLib, pwsz, NULL); pTypeLib->Release(); RETURN_ON_FAILURE(hr); }
return S_OK;}
//=--------------------------------------------------------------------------=
// UnregisterAllObjects
//=--------------------------------------------------------------------------=
// un-registers all the objects for the given automation server.
//
// Parameters:
// none
//
// Output:
// HRESULT - S_OK
//
// Notes:
//
HRESULT UnregisterAllObjects( void){ int x = 0;
// loop through all of our creatable objects [those that have a clsid in
// our global table] and register them.
//
while (!ISEMPTYOBJECT(x)) { if (!OBJECTISCREATABLE(x)) { x++; continue; }
switch (g_ObjectInfo[x].usType) {
case OI_UNKNOWN: case OI_PROPERTYPAGE: UnregisterUnknownObject(CLSIDOFOBJECT(x)); break;
case OI_CONTROL: UnregisterControlObject(g_szLibName, NAMEOFOBJECT(x), VERSIONOFOBJECT(x), CLSIDOFOBJECT(x)); case OI_AUTOMATION: UnregisterAutomationObject(g_szLibName, NAMEOFOBJECT(x), VERSIONOFOBJECT(x), CLSIDOFOBJECT(x)); break;
} x++; }
// if we've got one, unregister our type library [this isn't an API function
// -- we've implemented this ourselves]
//
if (g_pLibid) UnregisterTypeLibrary(*g_pLibid);
return S_OK;}
|
