home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / vc98 / mfc / src / dllole.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1998-06-16  |  7.6 KB  |  273 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12.  
  13. #ifdef AFX_INIT_SEG
  14. #pragma code_seg(AFX_INIT_SEG)
  15. #endif
  16.  
  17. #ifdef _DEBUG
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  21.  
  22. /////////////////////////////////////////////////////////////////////////////
  23. // Initialization of MFC extension DLL
  24.  
  25. static AFX_EXTENSION_MODULE extensionDLL;
  26. AFX_MODULE_STATE* AFXAPI _AfxGetOleModuleState();
  27.  
  28. /////////////////////////////////////////////////////////////////////////////
  29. // Library initialization and cleanup
  30.  
  31. extern "C" BOOL WINAPI RawDllMain(HINSTANCE, DWORD dwReason, LPVOID);
  32. extern "C" BOOL (WINAPI* _pRawDllMain)(HINSTANCE, DWORD, LPVOID) = &RawDllMain;
  33.  
  34. #ifdef _DEBUG
  35. #ifndef _UNICODE
  36. #define MFC42_DLL "MFC42D.DLL"
  37. #else
  38. #define MFC42_DLL "MFC42UD.DLL"
  39. #endif
  40. #else
  41. #ifndef _UNICODE
  42. #define MFC42_DLL "MFC42.DLL"
  43. #else
  44. #define MFC42_DLL "MFC42U.DLL"
  45. #endif
  46. #endif
  47.  
  48. extern "C"
  49. BOOL WINAPI RawDllMain(HINSTANCE, DWORD dwReason, LPVOID)
  50. {
  51.     if (dwReason == DLL_PROCESS_ATTACH)
  52.     {
  53.         // Prevent the MFC DLL from being unloaded prematurely
  54.         LoadLibraryA(MFC42_DLL);
  55.  
  56.         // make sure we have enough memory to attempt to start (8kb)
  57.         void* pMinHeap = LocalAlloc(NONZEROLPTR, 0x2000);
  58.         if (pMinHeap == NULL)
  59.             return FALSE;   // fail if memory alloc fails
  60.         LocalFree(pMinHeap);
  61.  
  62.         // save critical data pointers before running the constructors
  63.         AFX_MODULE_STATE* pModuleState = AfxGetModuleState();
  64.         pModuleState->m_pClassInit = pModuleState->m_classList;
  65.         pModuleState->m_pFactoryInit = pModuleState->m_factoryList;
  66.         pModuleState->m_classList.m_pHead = NULL;
  67.         pModuleState->m_factoryList.m_pHead = NULL;
  68.  
  69.         // set module state before initialization
  70.         pModuleState = _AfxGetOleModuleState();
  71.         _AFX_THREAD_STATE* pState = AfxGetThreadState();
  72.         pState->m_pPrevModuleState = AfxSetModuleState(pModuleState);
  73.     }
  74.     else if (dwReason == DLL_PROCESS_DETACH)
  75.     {
  76.         // restore previously-saved module state
  77.         VERIFY(AfxSetModuleState(AfxGetThreadState()->m_pPrevModuleState) ==
  78.             _AfxGetOleModuleState());
  79.         DEBUG_ONLY(AfxGetThreadState()->m_pPrevModuleState = NULL);
  80.  
  81.         // Now it's OK for the MFC  DLL to be unloaded (see LoadLibrary above)
  82.         FreeLibrary(GetModuleHandleA(MFC42_DLL));
  83.     }
  84.     return TRUE;    // ok
  85. }
  86.  
  87. extern "C"
  88. BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
  89. {
  90.     if (dwReason == DLL_PROCESS_ATTACH)
  91.     {
  92.         // shared initialization
  93.         BOOL bRegister = !extensionDLL.bInitialized;
  94.         AFX_MODULE_STATE* pModuleState = _AfxGetOleModuleState();
  95.         pModuleState->m_hCurrentInstanceHandle = hInstance;
  96.         pModuleState->m_hCurrentResourceHandle = hInstance;
  97.         pModuleState->m_pClassInit = pModuleState->m_classList.GetHead();
  98.         pModuleState->m_pFactoryInit = pModuleState->m_factoryList.GetHead();
  99.         VERIFY(AfxInitExtensionModule(extensionDLL, hInstance));
  100.  
  101.         // wire up base DLL class list into private module state
  102.         AfxCoreInitModule();
  103.  
  104.         AfxWinInit(hInstance, NULL, _T(""), 0);
  105.  
  106.         // Register class factories in context of private module state
  107.         if (bRegister)
  108.             COleObjectFactory::RegisterAll();
  109.  
  110.         // restore previously-saved module state
  111.         VERIFY(AfxSetModuleState(AfxGetThreadState()->m_pPrevModuleState) ==
  112.             _AfxGetOleModuleState());
  113.         DEBUG_ONLY(AfxGetThreadState()->m_pPrevModuleState = NULL);
  114.  
  115.         // wire up this DLL into the base module state resource chain
  116.         CDynLinkLibrary* pDLL = new CDynLinkLibrary(extensionDLL, TRUE);
  117.         ASSERT(pDLL != NULL);
  118.         pDLL->m_factoryList.m_pHead = NULL;
  119.     }
  120.     else if (dwReason == DLL_PROCESS_DETACH)
  121.     {
  122.         // cleanup module state in base module state
  123.         AfxTermExtensionModule(extensionDLL);
  124.  
  125.         // set module state for cleanup
  126.         ASSERT(AfxGetThreadState()->m_pPrevModuleState == NULL);
  127.         AfxGetThreadState()->m_pPrevModuleState =
  128.             AfxSetModuleState(_AfxGetOleModuleState());
  129.  
  130.         // cleanup module state in OLE private module state
  131.         AfxTermExtensionModule(extensionDLL, TRUE);
  132.     }
  133.     else if (dwReason == DLL_THREAD_DETACH)
  134.     {
  135.         AfxTermThread(hInstance);
  136.     }
  137.  
  138.     return TRUE;    // ok
  139. }
  140.  
  141. ////////////////////////////////////////////////////////////////////////////
  142. // Special initialization entry point for controls
  143.  
  144. void AFXAPI AfxOleInitModule()
  145. {
  146.     ASSERT(AfxGetModuleState() != AfxGetAppModuleState());
  147.  
  148.     CDynLinkLibrary* pDLL = new CDynLinkLibrary(extensionDLL, TRUE);
  149.     ASSERT(pDLL != NULL);
  150.     pDLL->m_factoryList.m_pHead = NULL;
  151. }
  152.  
  153. ////////////////////////////////////////////////////////////////////////////
  154. // COM entry points
  155.  
  156. STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
  157. {
  158.     AFX_MANAGE_STATE(_AfxGetOleModuleState());
  159.     return AfxDllGetClassObject(rclsid, riid, ppv);
  160. }
  161.  
  162. STDAPI DllCanUnloadNow(void)
  163. {
  164.     AFX_MANAGE_STATE(_AfxGetOleModuleState());
  165.     return AfxDllCanUnloadNow();
  166. }
  167.  
  168. ////////////////////////////////////////////////////////////////////////////
  169. // Server registration
  170.  
  171. STDAPI DllRegisterServer(void)
  172. {
  173.     AFX_MANAGE_STATE(_AfxGetOleModuleState());
  174.  
  175.     if (!COleObjectFactoryEx::UpdateRegistryAll(TRUE))
  176.         return SELFREG_E_CLASS;
  177.  
  178.     return S_OK;
  179. }
  180.  
  181. STDAPI DllUnregisterServer(void)
  182. {
  183.     AFX_MANAGE_STATE(_AfxGetOleModuleState());
  184.  
  185.     if (!COleObjectFactoryEx::UpdateRegistryAll(FALSE))
  186.         return SELFREG_E_CLASS;
  187.  
  188.     return S_OK;
  189. }
  190.  
  191. // This CWinApp is required so this module state has a CWinApp object!
  192. CWinApp _afxOleWinApp;
  193.  
  194. /////////////////////////////////////////////////////////////////////////////
  195. // static-linked version of AfxWndProc for use by this module
  196.  
  197. #undef AfxWndProc
  198.  
  199. LRESULT CALLBACK
  200. AfxWndProcDllOle(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
  201. {
  202.     AFX_MANAGE_STATE(_AfxGetOleModuleState());
  203.     return AfxWndProc(hWnd, nMsg, wParam, lParam);
  204. }
  205.  
  206. /////////////////////////////////////////////////////////////////////////////
  207. // initialize app state such that it points to this module's core state
  208.  
  209. #ifndef _AFX_NO_OCC_SUPPORT
  210. class _AFX_INIT_OLE_DLL_STATE
  211. {
  212. public:
  213.     ~_AFX_INIT_OLE_DLL_STATE();
  214. };
  215.  
  216. _AFX_INIT_OLE_DLL_STATE::~_AFX_INIT_OLE_DLL_STATE()
  217. {
  218.     // OLE dll is not loaded any more, so no OLE controls capability
  219.     afxOccManager = NULL;
  220. }
  221. #endif
  222.  
  223. /////////////////////////////////////////////////////////////////////////////
  224.  
  225. // force initialization early
  226. #pragma warning(disable: 4074)
  227. #pragma init_seg(lib)
  228.  
  229. static AFX_MODULE_STATE _afxOleModuleState(TRUE, &AfxWndProcDllOle,
  230.     _MFC_VER, TRUE);
  231. #ifndef _AFX_NO_OCC_SUPPORT
  232. _AFX_INIT_OLE_DLL_STATE _afxInitOleDllState;
  233. #endif
  234.  
  235. AFX_MODULE_STATE* AFXAPI _AfxGetOleModuleState()
  236. {
  237.     return &_afxOleModuleState;
  238. }
  239.  
  240. /////////////////////////////////////////////////////////////////////////////
  241.  
  242. #ifdef AFX_VDEL_SEG
  243. #pragma code_seg(AFX_VDEL_SEG)
  244. #endif
  245. static void _AfxForceVectorDelete()
  246. {
  247.     ASSERT(FALSE);  // never called
  248.  
  249.     new COleDataSource[2];
  250.     new COleDispatchDriver[2];
  251.     new COleDropSource[2];
  252.     new COleResizeBar[2];
  253.     new COleStreamFile[2];
  254.     new CMonikerFile[2];
  255.     new COleTemplateServer[2];
  256.     new COleDataObject[2];
  257.     new COleDropTarget[2];
  258.     new COleIPFrameWnd[2];
  259.  
  260.     new COleDocIPFrameWnd[2];
  261.     new CAsyncMonikerFile[2];
  262.     new CCachedDataPathProperty[2];
  263.     new CDataPathProperty[2];
  264.  
  265.     new COleVariant[2];
  266.  
  267.     new CRichEditView[2];
  268.     new CRichEditCntrItem[2];
  269. }
  270. void (*_afxForceVectorDelete_mfco)() = &_AfxForceVectorDelete;
  271.  
  272. /////////////////////////////////////////////////////////////////////////////
  273.