//+------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1992 - 1993. // // File: ole2.cpp // // Contents: LibMain and initialization routines // // Classes: // // Functions: LibMain // OleInitialize // OleInitializeWOW // OleInitializeEx // OleUnitialize // OleBuildVersion - !WIN32 // // // History: dd-mmm-yy Author Comment // 16-Feb-94 AlexT alias OleBuildVersion, remove OleGetMalloc // remove DisableThreadLibaryCalls // 11-Jan-94 alexgo added VDATEHEAP macros to every function // 10-Dec-93 alexgo added support for LEDebugOut // 06-Dec-93 ChrisWe remove declaration of ClipboardInitialize() // and ClipboardUninitialize(), which are declared in // clipbrd.h; include that instead // 15-Mar-94 KevinRo Added OleInitializeWOW(); // //-------------------------------------------------------------------------- #include #include #include #include #pragma SEG(ole) #include #include #include #include #include #include // // DECLARE_INFOLEVEL is a macro used with cairo-style debugging output. // it creates a global variable LEInfoLevel which contains bits flags // of the various debugging output that should be sent to the debugger. // // Note that info level may be set within the debugger once ole232.dll // has loaded. // // Currently LEInfoLevel defaults to DEB_WARN | DEB_ERROR // DECLARE_INFOLEVEL(LE); DECLARE_INFOLEVEL(Ref); DECLARE_INFOLEVEL(DD); DECLARE_INFOLEVEL(VDATE); NAME_SEG(Ole2Main) // these are globals HMODULE g_hmodOLE2 = NULL; HINSTANCE g_hinst = NULL; ULONG g_cOleProcessInits = 0; CLIPFORMAT g_cfObjectLink = NULL; CLIPFORMAT g_cfOwnerLink = NULL; CLIPFORMAT g_cfNative = NULL; CLIPFORMAT g_cfLink = NULL; CLIPFORMAT g_cfBinary = NULL; CLIPFORMAT g_cfFileName = NULL; CLIPFORMAT g_cfFileNameW = NULL; CLIPFORMAT g_cfNetworkName = NULL; CLIPFORMAT g_cfDataObject = NULL; CLIPFORMAT g_cfEmbeddedObject = NULL; CLIPFORMAT g_cfEmbedSource = NULL; CLIPFORMAT g_cfCustomLinkSource = NULL; CLIPFORMAT g_cfLinkSource = NULL; CLIPFORMAT g_cfLinkSrcDescriptor = NULL; CLIPFORMAT g_cfObjectDescriptor = NULL; CLIPFORMAT g_cfOleDraw = NULL; CLIPFORMAT g_cfPBrush = NULL; CLIPFORMAT g_cfMSDraw = NULL; CLIPFORMAT g_cfOlePrivateData = NULL; CLIPFORMAT g_cfScreenPicture = NULL; ATOM g_aDropTarget = NULL; ASSERTDATA ASSERTOUTDATA // more globals extern UINT uOmPostWmCommand; extern UINT uOleMessage; extern COleStaticMutexSem g_mxsSingleThreadOle; // this dummy function is used to avoid a copy of the environment variables. // NOTE: the moniker and dde code still use the windows heap. extern "C" void _setenvp(void) { VDATEHEAP(); } #ifdef _CHICAGO_ // Private Chicago Defines // // The Chicago Shell will dynamically load the OLE32.DLL to improve // bootup start time. When an application calls CoInitialize, post // a message to the shell to inform it to load OLE32.DLL if it hasn't // already. The Shell will never unload OLE32.DLL. // // We are using an undocumented Shell interface. // BOOL gfShellInitialized = FALSE; #define WM_SHELLNOTIFY 0x0034 #define SHELLNOTIFY_OLELOADED 0x0002 extern "C" HWND WINAPI GetShellWindow(void); #endif // _CHICAGO_ //+--------------------------------------------------------------------------- // // Function: OleInitializeWOW // Synopsis: Entry point to initialize the 16-bit WOW thunk layer. // // Effects: This routine is called when OLE32 is loaded by a VDM. // It serves two functions: It lets OLE know that it is // running in a VDM, and it passes in the address to a set // of functions that are called by the thunk layer. This // allows normal 32-bit processes to avoid loading the WOW // DLL since the thunk layer references it. // // Arguments: [vlpmalloc] -- 16:16 pointer to the 16 bit allocator. // [lpthk] -- Flat pointer to the OleThunkWOW virtual // interface. This is NOT an OLE/IUnknown style // interface. // Requires: // // Returns: // // Signals: // // Modifies: // // Algorithm: // // History: 3-15-94 kevinro Created // // Notes: // //---------------------------------------------------------------------------- STDAPI OleInitializeWOW( LPMALLOC vlpmalloc, LPOLETHUNKWOW lpthk ) { OLETRACEIN((API_OleInitializeWOW, PARAMFMT("vlpmalloc= %x, lpthk= %p"), vlpmalloc, lpthk)); SetOleThunkWowPtr(lpthk); HRESULT hr; hr = OleInitializeEx( NULL, COINIT_APARTMENTTHREADED ); OLETRACEOUT((API_OleInitializeWOW, hr)); return hr; } //+------------------------------------------------------------------------- // // Function: OleInitialize // // Synopsis: Initializes OLE in single threaded mode // // Effects: // // Arguments: [pMalloc] -- the memory allocator to use // // Requires: // // Returns: HRESULT // // Signals: // // Modifies: // // Algorithm: // // History: dd-mmm-yy Author Comment // 06-Dec-93 alexgo 32bit port // // Notes: // //-------------------------------------------------------------------------- STDAPI OleInitialize(void * pMalloc) { OLETRACEIN((API_OleInitialize, PARAMFMT("pMalloc= %p"), pMalloc)); VDATEHEAP(); HRESULT hr; hr = OleInitializeEx( pMalloc, COINIT_APARTMENTTHREADED ); OLETRACEOUT((API_OleInitialize, hr)); return hr; } //+------------------------------------------------------------------------- // // Function: OleInitializeEx // // Synopsis: Initializes ole // // Effects: // // Arguments: [pMalloc] -- the task memory allocator to use // [flags] -- single or multi-threaded // // Requires: // // Returns: HRESULT // // Signals: // // Modifies: // // Algorithm: // // History: dd-mmm-yy Author Comment // 06-Dec-93 alexgo 32bit port // 24-May-94 AlexT Propagate CoInitializeEx's return code // 21-Jul-94 AlexT Allow nested OleInit/Uninit calls // 24-Aug-94 AlexT Return S_OK for first success and S_FALSE // thereafter (unless an allocator was // passed in) // // Notes: This routine may be called multiple times per apartment // //-------------------------------------------------------------------------- #pragma SEG(OleInitialize) STDAPI OleInitializeEx(LPVOID pMalloc, ULONG ulFlags) { OLETRACEIN((API_OleInitialize, PARAMFMT("pMalloc= %p, ulFlags= %x"), pMalloc, ulFlags)); VDATEHEAP(); HRESULT hr; #if DBG==1 HRESULT hrCoInit = S_OK; #endif DWORD cThreadOleInits; StartPerfCounter(CoInitialize); hr = CoInitializeEx(pMalloc, ulFlags); EndPerfCounter(CoInitialize); if (SUCCEEDED(hr)) { Assert (g_hmodOLE2); #if DBG==1 hrCoInit = hr; #endif COleTls tls; cThreadOleInits = ++ tls->cOleInits; do { // We only want to do the below initialization once per apartment if (cThreadOleInits > 1) { // We've already been this way before, just return Assert(SUCCEEDED(hr) && "Bad OleInitializeEx logic"); break; } // single thread registration of DDE and clipboard formats. // Only do this once per process. COleStaticLock lck(g_mxsSingleThreadOle); if (++g_cOleProcessInits != 1) { // already done the per-process initialization break; } if (FALSE==DDELibMain (g_hmodOLE2, (WORD)0, (WORD)0, NULL)) { Assert (!"DDELibMain failed()"); hr = E_OUTOFMEMORY; break; } // Only need to do the initialization once so check the global // that gets assigned last. if( !g_aDropTarget ) { #ifndef _CHICAGO_ // on NT3.51, clipboard formats are pre-registered for us by user32. // We know they are going to be sequential. This gives us a // good performance improvement (since the clipboard formats never // change. // BUGBUG(alexgo); Chicago needs to get this behaviour too g_cfObjectLink = RegisterClipboardFormat(OLESTR("ObjectLink")); g_cfOwnerLink = g_cfObjectLink + 1; Assert(g_cfOwnerLink == RegisterClipboardFormat(OLESTR("OwnerLink"))); g_cfNative = g_cfObjectLink + 2; Assert(g_cfNative == RegisterClipboardFormat(OLESTR("Native"))); g_cfBinary = g_cfObjectLink + 3; Assert(g_cfBinary == RegisterClipboardFormat(OLESTR("Binary"))); g_cfFileName = g_cfObjectLink + 4; Assert(g_cfFileName == RegisterClipboardFormat(OLESTR("FileName"))); g_cfFileNameW = g_cfObjectLink + 5; Assert(g_cfFileNameW == RegisterClipboardFormat(OLESTR("FileNameW"))); g_cfNetworkName = g_cfObjectLink + 6; Assert(g_cfNetworkName == RegisterClipboardFormat(OLESTR("NetworkName"))); g_cfDataObject = g_cfObjectLink + 7; Assert(g_cfDataObject == RegisterClipboardFormat(OLESTR("DataObject"))); g_cfEmbeddedObject = g_cfObjectLink + 8; Assert(g_cfEmbeddedObject == RegisterClipboardFormat(OLESTR("Embedded Object"))); g_cfEmbedSource = g_cfObjectLink + 9; Assert(g_cfEmbedSource == RegisterClipboardFormat(OLESTR("Embed Source"))); g_cfCustomLinkSource = g_cfObjectLink + 10; Assert(g_cfCustomLinkSource == RegisterClipboardFormat(OLESTR("Custom Link Source"))); g_cfLinkSource = g_cfObjectLink + 11; Assert(g_cfLinkSource == RegisterClipboardFormat(OLESTR("Link Source"))); g_cfObjectDescriptor = g_cfObjectLink + 12; Assert(g_cfObjectDescriptor == RegisterClipboardFormat(OLESTR("Object Descriptor"))); g_cfLinkSrcDescriptor = g_cfObjectLink + 13; Assert(g_cfLinkSrcDescriptor == RegisterClipboardFormat(OLESTR("Link Source Descriptor"))); g_cfOleDraw = g_cfObjectLink + 14; Assert(g_cfOleDraw == RegisterClipboardFormat(OLESTR("OleDraw"))); g_cfPBrush = g_cfObjectLink + 15; Assert(g_cfPBrush == RegisterClipboardFormat(OLESTR("PBrush"))); g_cfMSDraw = g_cfObjectLink + 16; Assert(g_cfMSDraw == RegisterClipboardFormat(OLESTR("MSDraw"))); g_cfOlePrivateData = g_cfObjectLink + 17; Assert(g_cfOlePrivateData == RegisterClipboardFormat(OLESTR("Ole Private Data"))); g_cfScreenPicture = g_cfObjectLink + 18; Assert(g_cfScreenPicture == RegisterClipboardFormat(OLESTR("Screen Picture"))); g_aDropTarget = GlobalAddAtom(OLE_DROP_TARGET_PROP); AssertSz(g_aDropTarget, "Couldn't add drop target atom\n"); } // Used in Inplace editing uOmPostWmCommand = RegisterWindowMessage(OLESTR("OM_POST_WM_COMMAND")); uOleMessage = RegisterWindowMessage(OLESTR("OLE_MESSAHE")); #else // !_CHICAGO_ g_cfObjectLink = SSRegisterClipboardFormatA("ObjectLink"); g_cfOwnerLink = SSRegisterClipboardFormatA("OwnerLink"); g_cfNative = SSRegisterClipboardFormatA("Native"); g_cfBinary = SSRegisterClipboardFormatA("Binary"); g_cfFileName = SSRegisterClipboardFormatA("FileName"); g_cfFileNameW = SSRegisterClipboardFormatA("FileNameW"); g_cfNetworkName = SSRegisterClipboardFormatA("NetworkName"); g_cfDataObject = SSRegisterClipboardFormatA("DataObject"); g_cfEmbeddedObject = SSRegisterClipboardFormatA("Embedded Object"); g_cfEmbedSource = SSRegisterClipboardFormatA("Embed Source"); g_cfCustomLinkSource = SSRegisterClipboardFormatA("Custom Link Source"); g_cfLinkSource = SSRegisterClipboardFormatA("Link Source"); g_cfObjectDescriptor = SSRegisterClipboardFormatA("Object Descriptor"); g_cfLinkSrcDescriptor = SSRegisterClipboardFormatA("Link Source Descriptor"); g_cfOleDraw = SSRegisterClipboardFormatA("OleDraw"); g_cfPBrush = SSRegisterClipboardFormatA("PBrush"); g_cfMSDraw = SSRegisterClipboardFormatA("MSDraw"); g_cfOlePrivateData = SSRegisterClipboardFormatA("Ole Private Data"); g_cfScreenPicture = SSRegisterClipboardFormatA("Screen Picture"); g_aDropTarget = GlobalAddAtomA(OLE_DROP_TARGET_PROPA); AssertSz(g_aDropTarget, "Couldn't add drop target atom\n"); } // Used in Inplace editing uOmPostWmCommand = RegisterWindowMessageA("OM_POST_WM_COMMAND"); uOleMessage = RegisterWindowMessageA("OLE_MESSAHE"); #endif // !_CHICAGO_ } while (FALSE); // end of do if (FAILED(hr)) { // clean up and break out DDEWEP (WEP_FREE_DLL); tls->cOleInits--; CoUninitialize(); } else { #if defined(_CHICAGO_) if (!gfShellInitialized && CoGetCurrentProcess() == 1) { // The Chicago Shell will dynamically load the OLE32.DLL to improve // bootup start time. When an application calls CoInitialize, post // a message to the shell to inform it to load OLE32.DLL if it hasn't // already. The Shell will never unload OLE32.DLL. // // We are using an undocumented Shell interface. // // We do this last so that we dont take a task switch while in // CoInitialize. #if DBG==1 if (RegQueryValueEx(HKEY_CURRENT_USER, L"Software\\Microsoft\\OLE2\\NoShellNotify", NULL, // reserved NULL, // lpdwType NULL, // lpbData NULL) != ERROR_SUCCESS) // lpcbData #endif { HWND hwndShell = GetShellWindow(); if (hwndShell) { PostMessage(hwndShell,WM_SHELLNOTIFY, SHELLNOTIFY_OLELOADED,0L); } } } gfShellInitialized = TRUE; #endif // _CHICAGO_ Assert(SUCCEEDED(hr) && "Bad OleInitializeEx logic"); // If we're overriding the allocator, we return whatever // CoInitializeEx returned if (NULL != pMalloc) { Assert(hr == hrCoInit && "Bad OleInit logic"); } else if (1 == cThreadOleInits) { // First successful call to OleInitializeEx - S_OK hr = S_OK; } else { // Second or greater succesful call to OleInitializeEx - S_FALSE hr = S_FALSE; } } } OLETRACEOUT((API_OleInitialize, hr)); return hr; } //+------------------------------------------------------------------------- // // Function: OleUnitialize // // Synopsis: Unitializes OLE, releasing any grabbed resources // // Effects: // // Arguments: void // // Requires: // // Returns: void // // Signals: // // Modifies: // // Algorithm: // // History: dd-mmm-yy Author Comment // 06-Dec-93 alexgo 32bit port // 21-Jul-94 AlexT Allow nested OleInit/Uninit calls // // Notes: // //-------------------------------------------------------------------------- #pragma SEG(OleUninitialize) STDAPI_(void) OleUninitialize(void) { OLETRACEIN((API_OleUninitialize, NOPARAM)); VDATEHEAP(); COleTls tls(TRUE); if (tls.IsNULL() || 0 == tls->cOleInits) { LEDebugOut((DEB_ERROR, "(0 == thread inits) Unbalanced call to OleUninitialize\n")); goto errRtn; } if (0 == -- tls->cOleInits) { // This thread has called OleUninitialize for the last time. Check if // we need to do per process uninit now. ClipboardUninitialize(); // Must be first thing DestroyCommonDdeWindow(); COleStaticLock lck(g_mxsSingleThreadOle); if (--g_cOleProcessInits == 0) { DragDropProcessUninitialize(); // after this point, the uninit should not fail (because we don't // have code to redo the init). DDEWEP (WEP_FREE_DLL); #if DBG==1 // check for unreleased globals UtGlobalFlushTracking(); #endif } } // We call CoInitialize each time we call OleInitialize, so here we // balance that call CoUninitialize(); errRtn: OLETRACEOUTEX((API_OleUninitialize, NORETURN)); return; }