mirror of https://github.com/lianthony/NT4.0
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
772 lines
20 KiB
772 lines
20 KiB
// This is a part of the Microsoft Foundation Classes C++ library.
|
|
// Copyright (C) 1992-1995 Microsoft Corporation
|
|
// All rights reserved.
|
|
//
|
|
// This source code is only intended as a supplement to the
|
|
// Microsoft Foundation Classes Reference and related
|
|
// electronic documentation provided with the library.
|
|
// See these sources for detailed information regarding the
|
|
// Microsoft Foundation Classes product.
|
|
|
|
#include "stdafx.h"
|
|
#include <stdarg.h>
|
|
|
|
#ifdef AFX_INIT_SEG
|
|
#pragma code_seg(AFX_INIT_SEG)
|
|
#endif
|
|
|
|
#ifdef _DEBUG
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
|
|
#ifndef _AFXDLL
|
|
#error file must be compiled with _AFXDLL
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// _AFXDLL support
|
|
|
|
static AFX_EXTENSION_MODULE coreDLL;
|
|
#ifdef _AFX_OLE_IMPL
|
|
AFX_MODULE_STATE* AFXAPI _AfxGetOleModuleState();
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CDynLinkLibrary class
|
|
|
|
IMPLEMENT_DYNAMIC(CDynLinkLibrary, CCmdTarget)
|
|
|
|
// Constructor - will wire into the current application's list
|
|
CDynLinkLibrary::CDynLinkLibrary(AFX_EXTENSION_MODULE& state, BOOL bSystem)
|
|
{
|
|
#ifndef _AFX_NO_OLE_SUPPORT
|
|
m_factoryList.Construct(offsetof(COleObjectFactory, m_pNextFactory));
|
|
#endif
|
|
m_classList.Construct(offsetof(CRuntimeClass, m_pNextClass));
|
|
|
|
// copy info from AFX_EXTENSION_MODULE struct
|
|
ASSERT(state.hModule != NULL);
|
|
m_hModule = state.hModule;
|
|
m_hResource = state.hResource;
|
|
m_classList.m_pHead = state.pFirstSharedClass;
|
|
#ifndef _AFX_NO_OLE_SUPPORT
|
|
m_factoryList.m_pHead = state.pFirstSharedFactory;
|
|
#endif
|
|
m_bSystem = bSystem;
|
|
|
|
// insert at the head of the list (extensions will go in front of core DLL)
|
|
DEBUG_ONLY(m_pNextDLL = NULL);
|
|
AfxLockGlobals(CRIT_DYNLINKLIST);
|
|
m_pModuleState->m_libraryList.AddHead(this);
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
}
|
|
|
|
#ifdef AFX_TERM_SEG
|
|
#pragma code_seg(AFX_TERM_SEG)
|
|
#endif
|
|
|
|
CDynLinkLibrary::~CDynLinkLibrary()
|
|
{
|
|
// remove this frame window from the list of frame windows
|
|
AfxLockGlobals(CRIT_DYNLINKLIST);
|
|
m_pModuleState->m_libraryList.Remove(this);
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CDynLinkLibrary diagnostics
|
|
|
|
#ifdef _DEBUG
|
|
void CDynLinkLibrary::AssertValid() const
|
|
{
|
|
ASSERT(m_hModule != NULL);
|
|
}
|
|
|
|
void CDynLinkLibrary::Dump(CDumpContext& dc) const
|
|
{
|
|
CCmdTarget::Dump(dc);
|
|
|
|
dc << "m_hModule = " << (UINT)m_hModule;
|
|
dc << "\nm_hResource = " << (UINT)m_hResource;
|
|
|
|
if (m_hModule != NULL)
|
|
{
|
|
TCHAR szName[_MAX_PATH];
|
|
GetModuleFileName(m_hModule, szName, _countof(szName));
|
|
dc << "\nmodule name = " << szName;
|
|
}
|
|
else
|
|
dc << "\nmodule name is unknown";
|
|
|
|
dc << "\n";
|
|
}
|
|
#endif //_DEBUG
|
|
|
|
#ifdef AFX_INIT_SEG
|
|
#pragma code_seg(AFX_INIT_SEG)
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// special initialization and helper functions
|
|
|
|
// This is called in an extension DLL's DllMain
|
|
// It makes a copy of the DLL's HMODULE, as well as a copy of the
|
|
// runtime class objects that have been initialized by this
|
|
// extension DLL as part of normal static object construction
|
|
// executed before DllMain is entered.
|
|
|
|
BOOL AFXAPI AfxInitExtensionModule(AFX_EXTENSION_MODULE& state, HMODULE hModule)
|
|
{
|
|
// only initialize once
|
|
if (state.bInitialized)
|
|
{
|
|
AfxInitLocalData(hModule);
|
|
return TRUE;
|
|
}
|
|
state.bInitialized = TRUE;
|
|
|
|
// save the current HMODULE information for resource loading
|
|
ASSERT(hModule != NULL);
|
|
state.hModule = hModule;
|
|
state.hResource = hModule;
|
|
|
|
// save the start of the runtime class list
|
|
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
|
|
state.pFirstSharedClass = pModuleState->m_classList.GetHead();
|
|
pModuleState->m_classList.m_pHead = pModuleState->m_pClassInit;
|
|
|
|
#ifndef _AFX_NO_OLE_SUPPORT
|
|
// save the start of the class factory list
|
|
state.pFirstSharedFactory = pModuleState->m_factoryList.GetHead();
|
|
pModuleState->m_factoryList.m_pHead = pModuleState->m_pFactoryInit;
|
|
#endif
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
#ifdef AFX_TERM_SEG
|
|
#pragma code_seg(AFX_TERM_SEG)
|
|
#endif
|
|
|
|
void AFXAPI AfxTermExtensionModule(AFX_EXTENSION_MODULE& state, BOOL bAll)
|
|
{
|
|
// make sure initialized
|
|
if (!state.bInitialized)
|
|
return;
|
|
|
|
// search for CDynLinkLibrary matching state.hModule and delete it
|
|
ASSERT(state.hModule != NULL);
|
|
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
|
|
AfxLockGlobals(CRIT_DYNLINKLIST);
|
|
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL; )
|
|
{
|
|
CDynLinkLibrary* pNextDLL = pDLL->m_pNextDLL;
|
|
if (bAll || pDLL->m_hModule == state.hModule)
|
|
delete pDLL; // will unwire itself
|
|
pDLL = pNextDLL;
|
|
}
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
|
|
// delete any local storage attached to this module
|
|
AfxTermLocalData(state.hModule, TRUE);
|
|
|
|
// remove any entries from the CWnd message map cache
|
|
AfxResetMsgCache();
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// special LoadLibrary and FreeLibrary for loading MFC extension DLLs
|
|
|
|
HINSTANCE AFXAPI AfxLoadLibrary(LPCTSTR lpszModuleName)
|
|
{
|
|
ASSERT(lpszModuleName != NULL);
|
|
AfxLockGlobals(CRIT_LOCKSHARED);
|
|
HINSTANCE hInstLib = LoadLibrary(lpszModuleName);
|
|
AfxUnlockGlobals(CRIT_LOCKSHARED);
|
|
return hInstLib;
|
|
}
|
|
|
|
BOOL AFXAPI AfxFreeLibrary(HINSTANCE hInstLib)
|
|
{
|
|
AfxLockGlobals(CRIT_LOCKSHARED);
|
|
BOOL bResult = FreeLibrary(hInstLib);
|
|
AfxUnlockGlobals(CRIT_LOCKSHARED);
|
|
return bResult;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Resource helpers
|
|
|
|
#ifdef AFX_CORE2_SEG
|
|
#pragma code_seg(AFX_CORE2_SEG)
|
|
#endif
|
|
|
|
HINSTANCE AFXAPI AfxFindResourceHandle(LPCTSTR lpszName, LPCTSTR lpszType)
|
|
{
|
|
ASSERT(lpszName != NULL);
|
|
ASSERT(lpszType != NULL);
|
|
|
|
HINSTANCE hInst;
|
|
|
|
// first check the main module state
|
|
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
|
|
if (!pModuleState->m_bSystem)
|
|
{
|
|
hInst = AfxGetResourceHandle();
|
|
if (::FindResource(hInst, lpszName, lpszType) != NULL)
|
|
return hInst;
|
|
}
|
|
|
|
// check for non-system DLLs in proper order
|
|
AfxLockGlobals(CRIT_DYNLINKLIST);
|
|
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
|
|
pDLL = pDLL->m_pNextDLL)
|
|
{
|
|
if (!pDLL->m_bSystem && pDLL->m_hResource != NULL &&
|
|
::FindResource(pDLL->m_hResource, lpszName, lpszType) != NULL)
|
|
{
|
|
// found it in a DLL
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
return pDLL->m_hResource;
|
|
}
|
|
}
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
|
|
// check language specific resource next
|
|
hInst = pModuleState->m_appLangDLL;
|
|
if (hInst != NULL && ::FindResource(hInst, lpszName, lpszType) != NULL)
|
|
return hInst;
|
|
|
|
// check the main system module state
|
|
if (pModuleState->m_bSystem)
|
|
{
|
|
hInst = AfxGetResourceHandle();
|
|
if (::FindResource(hInst, lpszName, lpszType) != NULL)
|
|
return hInst;
|
|
}
|
|
|
|
// check for system DLLs in proper order
|
|
AfxLockGlobals(CRIT_DYNLINKLIST);
|
|
for (pDLL = pModuleState->m_libraryList; pDLL != NULL; pDLL = pDLL->m_pNextDLL)
|
|
{
|
|
if (pDLL->m_bSystem && pDLL->m_hResource != NULL &&
|
|
::FindResource(pDLL->m_hResource, lpszName, lpszType) != NULL)
|
|
{
|
|
// found it in a DLL
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
return pDLL->m_hResource;
|
|
}
|
|
}
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
|
|
// if failed to find resource, return application resource
|
|
return AfxGetResourceHandle();
|
|
}
|
|
|
|
// AfxLoadString must not only check for the appropriate string segment
|
|
// in the resource file, but also that the string is non-zero
|
|
int AFXAPI AfxLoadString(UINT nID, LPTSTR lpszBuf, UINT nMaxBuf)
|
|
{
|
|
ASSERT(AfxIsValidAddress(lpszBuf, nMaxBuf*sizeof(TCHAR)));
|
|
|
|
LPCTSTR lpszName = MAKEINTRESOURCE((nID>>4)+1);
|
|
HINSTANCE hInst;
|
|
int nLen;
|
|
|
|
// first check the main module state
|
|
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
|
|
if (!pModuleState->m_bSystem)
|
|
{
|
|
hInst = AfxGetResourceHandle();
|
|
if (::FindResource(hInst, lpszName, RT_STRING) != NULL &&
|
|
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
|
|
{
|
|
// found a non-zero string in app
|
|
return nLen;
|
|
}
|
|
}
|
|
|
|
// check non-system DLLs in proper order
|
|
AfxLockGlobals(CRIT_DYNLINKLIST);
|
|
for (CDynLinkLibrary* pDLL = pModuleState->m_libraryList; pDLL != NULL;
|
|
pDLL = pDLL->m_pNextDLL)
|
|
{
|
|
if (!pDLL->m_bSystem && (hInst = pDLL->m_hResource) != NULL &&
|
|
::FindResource(hInst, lpszName, RT_STRING) != NULL &&
|
|
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
|
|
{
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
return nLen;
|
|
}
|
|
}
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
|
|
// check language specific DLL next
|
|
hInst = pModuleState->m_appLangDLL;
|
|
if (hInst != NULL && ::FindResource(hInst, lpszName, RT_STRING) != NULL &&
|
|
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
|
|
{
|
|
// found a non-zero string in language DLL
|
|
return nLen;
|
|
}
|
|
|
|
// check the system module state
|
|
if (pModuleState->m_bSystem)
|
|
{
|
|
hInst = AfxGetResourceHandle();
|
|
if (::FindResource(hInst, lpszName, RT_STRING) != NULL &&
|
|
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
|
|
{
|
|
// found a non-zero string in app
|
|
return nLen;
|
|
}
|
|
}
|
|
|
|
// check system DLLs in proper order
|
|
AfxLockGlobals(CRIT_DYNLINKLIST);
|
|
for (pDLL = pModuleState->m_libraryList; pDLL != NULL; pDLL = pDLL->m_pNextDLL)
|
|
{
|
|
if (pDLL->m_bSystem && (hInst = pDLL->m_hResource) != NULL &&
|
|
::FindResource(hInst, lpszName, RT_STRING) != NULL &&
|
|
(nLen = ::LoadString(hInst, nID, lpszBuf, nMaxBuf)) != 0)
|
|
{
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
return nLen;
|
|
}
|
|
}
|
|
AfxUnlockGlobals(CRIT_DYNLINKLIST);
|
|
|
|
// did not find it
|
|
lpszBuf[0] = '\0';
|
|
return 0;
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Library initialization and cleanup
|
|
|
|
#ifdef _DEBUG
|
|
#define MSVCRT_DLL "MSVCRTD.DLL"
|
|
#else
|
|
#define MSVCRT_DLL "MSVCRT.DLL"
|
|
#endif
|
|
|
|
#ifdef AFX_INIT_SEG
|
|
#pragma code_seg(AFX_INIT_SEG)
|
|
#endif
|
|
|
|
extern "C" BOOL WINAPI RawDllMain(HINSTANCE, DWORD dwReason, LPVOID);
|
|
extern "C" BOOL (WINAPI* _pRawDllMain)(HINSTANCE, DWORD, LPVOID) = &RawDllMain;
|
|
|
|
extern "C"
|
|
BOOL WINAPI RawDllMain(HINSTANCE /*hInstance*/, DWORD dwReason, LPVOID)
|
|
{
|
|
if (dwReason == DLL_PROCESS_ATTACH)
|
|
{
|
|
#ifndef _MAC
|
|
// Prevent the C runtime DLL from being unloaded prematurely
|
|
LoadLibraryA(MSVCRT_DLL);
|
|
#endif
|
|
|
|
#ifdef _UNICODE
|
|
// give error message and exit if running Unicode on non-Unicode system
|
|
if (GetVersion() & 0x80000000)
|
|
{
|
|
// Note: this message is for programmers who can read english
|
|
::MessageBoxA(NULL,
|
|
"This application or DLL can not be loaded "
|
|
"on Windows 95 or on Windows 3.1. It takes advantage "
|
|
"of Unicode features only available on Windows NT.",
|
|
"MFC Runtime Module", MB_ICONSTOP|MB_OK);
|
|
return FALSE; // and fail
|
|
}
|
|
#endif
|
|
|
|
SetErrorMode(SetErrorMode(0) |
|
|
SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX);
|
|
|
|
// add a reference to thread local storage data
|
|
AfxTlsAddRef();
|
|
|
|
// make sure we have enough memory to attempt to start (8kb)
|
|
void* pMinHeap = LocalAlloc(NONZEROLPTR, 0x2000);
|
|
if (pMinHeap == NULL)
|
|
return FALSE; // fail if memory alloc fails
|
|
LocalFree(pMinHeap);
|
|
|
|
// cause early initialization of _afxCriticalSection
|
|
if (!AfxCriticalInit())
|
|
return FALSE;
|
|
|
|
#ifdef _AFX_OLE_IMPL
|
|
// set module state before initialization
|
|
AFX_MODULE_STATE* pModuleState = _AfxGetOleModuleState();
|
|
_AFX_THREAD_STATE* pState = AfxGetThreadState();
|
|
pState->m_pPrevModuleState = AfxSetModuleState(pModuleState);
|
|
#endif
|
|
}
|
|
else if (dwReason == DLL_PROCESS_DETACH)
|
|
{
|
|
#ifdef _AFX_OLE_IMPL
|
|
_AFX_THREAD_STATE* pThreadState = _afxThreadState.GetDataNA();
|
|
if (pThreadState != NULL)
|
|
{
|
|
// restore previously-saved module state
|
|
VERIFY(AfxSetModuleState(pThreadState->m_pPrevModuleState) ==
|
|
_AfxGetOleModuleState());
|
|
DEBUG_ONLY(pThreadState->m_pPrevModuleState = NULL);
|
|
}
|
|
#endif
|
|
|
|
// free up the _afxCriticalSection
|
|
AfxCriticalTerm();
|
|
|
|
#ifndef _MAC
|
|
// Now it's OK for C runtime DLL to be unloaded (see LoadLibrary above)
|
|
FreeLibrary(GetModuleHandleA(MSVCRT_DLL));
|
|
#endif
|
|
|
|
// remove reference from thread local data
|
|
AfxTlsRelease();
|
|
}
|
|
|
|
return TRUE; // ok
|
|
}
|
|
|
|
extern "C"
|
|
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID)
|
|
{
|
|
if (dwReason == DLL_PROCESS_ATTACH)
|
|
{
|
|
#ifdef _AFX_OLE_IMPL
|
|
BOOL bRegister = !coreDLL.bInitialized;
|
|
|
|
// shared initialization
|
|
AFX_MODULE_STATE* pModuleState = _AfxGetOleModuleState();
|
|
pModuleState->m_hCurrentInstanceHandle = hInstance;
|
|
pModuleState->m_hCurrentResourceHandle = hInstance;
|
|
pModuleState->m_pClassInit = pModuleState->m_classList.GetHead();
|
|
pModuleState->m_pFactoryInit = pModuleState->m_factoryList.GetHead();
|
|
#endif
|
|
|
|
// initialize this DLL's extension module
|
|
VERIFY(AfxInitExtensionModule(coreDLL, hInstance));
|
|
|
|
#ifdef _AFX_OLE_IMPL
|
|
AfxWinInit(hInstance, NULL, &afxChNil, 0);
|
|
|
|
// Register class factories in context of private module state
|
|
if (bRegister)
|
|
COleObjectFactory::RegisterAll();
|
|
#endif
|
|
|
|
#ifdef _AFX_OLE_IMPL
|
|
// restore previously-saved module state
|
|
VERIFY(AfxSetModuleState(AfxGetThreadState()->m_pPrevModuleState) ==
|
|
_AfxGetOleModuleState());
|
|
DEBUG_ONLY(AfxGetThreadState()->m_pPrevModuleState = NULL);
|
|
#endif
|
|
|
|
// wire up this DLL into the resource chain
|
|
CDynLinkLibrary* pDLL = new CDynLinkLibrary(coreDLL, TRUE);
|
|
ASSERT(pDLL != NULL);
|
|
pDLL->m_factoryList.m_pHead = NULL;
|
|
|
|
// load language specific DLL
|
|
// the DLL must be in the "system directory"
|
|
static const char szPrefix[] = "\\MFC42";
|
|
static const char szLOC[] = "LOC";
|
|
static const char szDLL[] = ".DLL";
|
|
char szLangDLL[_MAX_PATH+14]; // Note: 8.3 name
|
|
GetSystemDirectoryA(szLangDLL, _countof(szLangDLL));
|
|
lstrcatA(szLangDLL, szPrefix);
|
|
|
|
// try MFC42LOC.DLL
|
|
lstrcatA(szLangDLL, szLOC);
|
|
lstrcatA(szLangDLL, szDLL);
|
|
HINSTANCE hLangDLL = LoadLibraryA(szLangDLL);
|
|
AFX_MODULE_STATE* pState = AfxGetModuleState();
|
|
pState->m_appLangDLL = hLangDLL;
|
|
|
|
#ifdef _AFX_OLE_IMPL
|
|
// copy it to the private OLE state too
|
|
pModuleState->m_appLangDLL = hLangDLL;
|
|
#endif
|
|
}
|
|
else if (dwReason == DLL_PROCESS_DETACH)
|
|
{
|
|
// free language specific DLL
|
|
AFX_MODULE_STATE* pState = AfxGetModuleState();
|
|
if (pState->m_appLangDLL != NULL)
|
|
{
|
|
::FreeLibrary(pState->m_appLangDLL);
|
|
pState->m_appLangDLL = NULL;
|
|
}
|
|
|
|
// free the DLL info blocks
|
|
CDynLinkLibrary* pDLL;
|
|
while ((pDLL = pState->m_libraryList) != NULL)
|
|
delete pDLL;
|
|
ASSERT(pState->m_libraryList.IsEmpty());
|
|
|
|
// cleanup module state for this process
|
|
AfxTermExtensionModule(coreDLL);
|
|
|
|
#ifdef _AFX_OLE_IMPL
|
|
// set module state for cleanup
|
|
ASSERT(AfxGetThreadState()->m_pPrevModuleState == NULL);
|
|
AfxGetThreadState()->m_pPrevModuleState =
|
|
AfxSetModuleState(_AfxGetOleModuleState());
|
|
#endif
|
|
|
|
// cleanup module state in OLE private module state
|
|
AfxTermExtensionModule(coreDLL, TRUE);
|
|
|
|
// free any local data for this process/thread
|
|
AfxTermLocalData(NULL, TRUE);
|
|
}
|
|
else if (dwReason == DLL_THREAD_DETACH)
|
|
{
|
|
AfxTermThread();
|
|
}
|
|
|
|
return TRUE; // ok
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Special initialization entry point for controls
|
|
|
|
void AFXAPI AfxCoreInitModule()
|
|
{
|
|
ASSERT(AfxGetModuleState() != AfxGetAppModuleState());
|
|
|
|
// construct new dynlink library in this context for core resources
|
|
CDynLinkLibrary* pDLL = new CDynLinkLibrary(coreDLL, TRUE);
|
|
ASSERT(pDLL != NULL);
|
|
pDLL->m_factoryList.m_pHead = NULL;
|
|
|
|
// borrow resources from language specific DLL if loaded
|
|
AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
|
|
AFX_MODULE_STATE* pAppState = AfxGetAppModuleState();
|
|
if (pModuleState->m_appLangDLL == NULL)
|
|
pModuleState->m_appLangDLL = pAppState->m_appLangDLL;
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// COM entry points
|
|
|
|
#ifdef _AFX_OLE_IMPL
|
|
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
|
|
{
|
|
AFX_MANAGE_STATE(_AfxGetOleModuleState());
|
|
return AfxDllGetClassObject(rclsid, riid, ppv);
|
|
}
|
|
|
|
STDAPI DllCanUnloadNow(void)
|
|
{
|
|
AFX_MANAGE_STATE(_AfxGetOleModuleState());
|
|
return AfxDllCanUnloadNow();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Server registration
|
|
|
|
STDAPI DllRegisterServer(void)
|
|
{
|
|
AFX_MANAGE_STATE(_AfxGetOleModuleState());
|
|
|
|
if (!COleObjectFactoryEx::UpdateRegistryAll(TRUE))
|
|
return SELFREG_E_CLASS;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDAPI DllUnregisterServer(void)
|
|
{
|
|
AFX_MANAGE_STATE(_AfxGetOleModuleState());
|
|
|
|
if (!COleObjectFactoryEx::UpdateRegistryAll(FALSE))
|
|
return SELFREG_E_CLASS;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// This CWinApp is required so this module state has a CWinApp object!
|
|
CWinApp _afxOleWinApp;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// static-linked version of AfxWndProc for use by this module
|
|
|
|
#undef AfxWndProc
|
|
|
|
LRESULT CALLBACK
|
|
AfxWndProcDllOle(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
AFX_MANAGE_STATE(_AfxGetOleModuleState());
|
|
return AfxWndProc(hWnd, nMsg, wParam, lParam);
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
// force initialization early
|
|
#pragma warning(disable: 4074)
|
|
#pragma init_seg(lib)
|
|
|
|
static AFX_MODULE_STATE _afxOleModuleState(TRUE, &AfxWndProcDllOle,
|
|
_MFC_VER, TRUE);
|
|
|
|
AFX_MODULE_STATE* AFXAPI _AfxGetOleModuleState()
|
|
{
|
|
return &_afxOleModuleState;
|
|
}
|
|
#endif
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Special code to wire up vector deleting destructors
|
|
|
|
#ifdef AFX_VDEL_SEG
|
|
#pragma code_seg(AFX_VDEL_SEG)
|
|
#endif
|
|
static void _AfxForceVectorDelete()
|
|
{
|
|
ASSERT(FALSE); // never called
|
|
|
|
new CBitmap[2];
|
|
new CBitmapButton[2];
|
|
new CBrush[2];
|
|
new CButton[2];
|
|
new CByteArray[2];
|
|
new CCmdTarget[2];
|
|
new CComboBox[2];
|
|
new CDC[2];
|
|
new CDWordArray[2];
|
|
new CDialog[2];
|
|
new CDialogBar[2];
|
|
new CEdit[2];
|
|
new CFile[2];
|
|
new CFont[2];
|
|
new CFrameWnd[2];
|
|
new CGdiObject[2];
|
|
new CListBox[2];
|
|
new CCheckListBox[2];
|
|
new CMapPtrToPtr[2];
|
|
new CMapPtrToWord[2];
|
|
new CMapStringToOb[2];
|
|
new CMapStringToPtr[2];
|
|
new CMapStringToString[2];
|
|
new CMapWordToOb[2];
|
|
new CMapWordToPtr[2];
|
|
new CMemFile[2];
|
|
new CMenu[2];
|
|
new CMetaFileDC[2];
|
|
new CObArray[2];
|
|
new CObList[2];
|
|
new CPalette[2];
|
|
new CPen[2];
|
|
new CPtrArray[2];
|
|
new CPtrList[2];
|
|
new CRectTracker[2];
|
|
new CRgn[2];
|
|
new CScrollBar[2];
|
|
new CSharedFile[2];
|
|
new CSplitterWnd[2];
|
|
new CStatic[2];
|
|
new CStatusBar[2];
|
|
new CStdioFile[2];
|
|
new CString[2];
|
|
new CStringArray[2];
|
|
new CStringList[2];
|
|
new CThreadSlotData[2];
|
|
new CTime[2];
|
|
new CTimeSpan[2];
|
|
new CToolBar[2];
|
|
new CUIntArray[2];
|
|
new CWnd[2];
|
|
new CWordArray[2];
|
|
|
|
#ifndef _MAC
|
|
new CFileFind[2];
|
|
new CInternetSession[2];
|
|
#endif
|
|
|
|
new CDragListBox[2];
|
|
new CStatusBarCtrl[2];
|
|
new CListCtrl[2];
|
|
new CTreeCtrl[2];
|
|
new CSpinButtonCtrl[2];
|
|
new CSliderCtrl[2];
|
|
new CProgressCtrl[2];
|
|
new CHeaderCtrl[2];
|
|
new CHotKeyCtrl[2];
|
|
new CToolTipCtrl[2];
|
|
new CTabCtrl[2];
|
|
new CAnimateCtrl[2];
|
|
new CImageList[2];
|
|
new CToolBarCtrl[2];
|
|
new CRichEditCtrl[2];
|
|
|
|
new CMirrorFile[2];
|
|
new CDockState[2];
|
|
|
|
new CListView[2];
|
|
new CTreeView[2];
|
|
new CCommandLineInfo[2];
|
|
new CDocManager[2];
|
|
|
|
#ifndef _MAC
|
|
new CPageSetupDialog[2];
|
|
|
|
new CSemaphore[2];
|
|
new CMutex[2];
|
|
new CEvent[2];
|
|
new CCriticalSection[2];
|
|
#endif
|
|
|
|
#ifdef _AFX_OLE_IMPL
|
|
new COleDataSource[2];
|
|
new COleDispatchDriver[2];
|
|
new COleDropSource[2];
|
|
new CMonikerFile[2];
|
|
#ifndef _MAC
|
|
new COleResizeBar[2];
|
|
new CAsyncMonikerFile[2];
|
|
new CCachedDataPathProperty[2];
|
|
new CDataPathProperty[2];
|
|
#endif
|
|
new COleStreamFile[2];
|
|
new COleTemplateServer[2];
|
|
new COleDataObject[2];
|
|
new COleDropTarget[2];
|
|
new COleIPFrameWnd[2];
|
|
|
|
#ifndef _MAC
|
|
new COleDocIPFrameWnd[2];
|
|
#endif
|
|
|
|
new COleVariant[2];
|
|
new CRichEditView[2];
|
|
new CRichEditCntrItem[2];
|
|
#endif
|
|
|
|
#ifdef _AFX_DB_IMPL
|
|
new CDatabase[2];
|
|
new CLongBinary[2];
|
|
|
|
new CDaoWorkspace[2];
|
|
new CDaoException[2];
|
|
new CDaoDatabase[2];
|
|
new CDaoRecordset[2];
|
|
#endif
|
|
|
|
// Net
|
|
#ifdef _AFX_NET_IMPL
|
|
#ifndef _MAC
|
|
new CAsyncSocket[2];
|
|
new CSocket[2];
|
|
#endif
|
|
#endif
|
|
|
|
}
|
|
void (*_afxForceVectorDelete_mfc)() = &_AfxForceVectorDelete;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|