/*************************************************************************** * msctls.c * * Utils library initialization code * ***************************************************************************/ #include "ctlspriv.h" #include HINSTANCE g_hinst = 0; BOOL g_fCriticalInitialized = FALSE; CRITICAL_SECTION g_csDll = {{0},0, 0, NULL, NULL, 0 }; ATOM g_aCC32Subclass = 0; ATOM g_atomThemeScrollBar = 0; UINT g_uiACP = CP_ACP; // // Global DCs used during mirroring an Icon. // HDC g_hdc=NULL, g_hdcMask=NULL; // per process mem to store PlugUI information LANGID g_PUILangId = MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL); BOOL InitAnimateClass(HINSTANCE hInstance); BOOL ListView_Init(HINSTANCE hinst); BOOL TV_Init(HINSTANCE hinst); BOOL InitComboExClass(HINSTANCE hinst); BOOL Header_Init(HINSTANCE hinst); BOOL Tab_Init(HINSTANCE hinst); int InitIPAddr(HANDLE hInstance); BOOL InitPager(HINSTANCE hinst); BOOL InitNativeFontCtl(HINSTANCE hinst); void UnregisterClasses(); void Mem_Terminate(); #define DECLARE_DELAYED_FUNC(_ret, _fn, _args, _nargs) \ _ret (__stdcall * g_pfn##_fn) _args = NULL; \ _ret __stdcall _fn _args \ { \ if (!g_pfn##_fn) { \ return 0; \ } \ return g_pfn##_fn _nargs; \ } #define LOAD_DELAYED_FUNC(_ret, _fn, _args) \ (*(FARPROC*)&(g_pfn##_fn) = GetProcAddress(hinst, #_fn)) DECLARE_DELAYED_FUNC(BOOL, ImmNotifyIME, (HIMC himc, DWORD dw1, DWORD dw2, DWORD dw3), (himc, dw1, dw2, dw3)); DECLARE_DELAYED_FUNC(HIMC, ImmAssociateContext, (HWND hwnd, HIMC himc), (hwnd, himc)); DECLARE_DELAYED_FUNC(BOOL, ImmReleaseContext, (HWND hwnd, HIMC himc), (hwnd, himc)); DECLARE_DELAYED_FUNC(HIMC, ImmGetContext, (HWND hwnd), (hwnd)); DECLARE_DELAYED_FUNC(LONG, ImmGetCompositionStringA, (HIMC himc, DWORD dw1, LPVOID p1, DWORD dw2), (himc, dw1, p1, dw2) ); DECLARE_DELAYED_FUNC(BOOL, ImmSetCompositionStringA, (HIMC himc, DWORD dw1, LPCVOID p1, DWORD dw2, LPCVOID p2, DWORD dw3), (himc, dw1, p1, dw2, p2, dw3)); #ifndef UNICODE_WIN9x DECLARE_DELAYED_FUNC(LONG, ImmGetCompositionStringW, (HIMC himc, DWORD dw1, LPVOID p1, DWORD dw2), (himc, dw1, p1, dw2) ); DECLARE_DELAYED_FUNC(BOOL, ImmSetCompositionStringW, (HIMC himc, DWORD dw1, LPCVOID p1, DWORD dw2, LPCVOID p2, DWORD dw3), (himc, dw1, p1, dw2, p2, dw3)); #endif DECLARE_DELAYED_FUNC(BOOL, ImmSetCandidateWindow, (HIMC himc, LPCANDIDATEFORM pcf), (himc, pcf)); DECLARE_DELAYED_FUNC(HIMC, ImmCreateContext, (void), ()); DECLARE_DELAYED_FUNC(BOOL, ImmDestroyContext, (HIMC himc), (himc)); DECLARE_DELAYED_FUNC(BOOL, ImmIsIME, (HKL hKl), (hKl)); DECLARE_DELAYED_FUNC(BOOL, ImmUnlockIMC, (HIMC himc), (himc)); DECLARE_DELAYED_FUNC(LPINPUTCONTEXT, ImmLockIMC, (HIMC himc), (himc)); DECLARE_DELAYED_FUNC(BOOL, ImmSetCompositionWindow, (HIMC himc, LPCOMPOSITIONFORM lpCompForm), (himc, lpCompForm)); DECLARE_DELAYED_FUNC(BOOL, ImmGetCompositionWindow, (HIMC himc, LPCOMPOSITIONFORM lpCompForm), (himc, lpCompForm)); DECLARE_DELAYED_FUNC(BOOL, ImmSetCompositionFontW, (HIMC himc, LPLOGFONT lplf), (himc, lplf)); DECLARE_DELAYED_FUNC(LRESULT, ImmEscapeA, (HKL hKl, HIMC himc, UINT uEscape, LPVOID lpData), (hKl, himc, uEscape, lpData)); DECLARE_DELAYED_FUNC(LRESULT, ImmEscapeW, (HKL hKl, HIMC himc, UINT uEscape, LPVOID lpData), (hKl, himc, uEscape, lpData)); DECLARE_DELAYED_FUNC(BOOL, ImmSetOpenStatus, (HIMC himc, BOOL fOpen), (himc, fOpen)); DECLARE_DELAYED_FUNC(BOOL, ImmGetOpenStatus, (HIMC himc), (himc)); DECLARE_DELAYED_FUNC(BOOL, ImmGetConversionStatus, (HIMC himc, LPDWORD lpfdwConversion, LPDWORD lpfdwSentence), (himc, lpfdwConversion, lpfdwSentence)); DECLARE_DELAYED_FUNC(BOOL, ImmSetConversionStatus, (HIMC himc, DWORD fdwConversion, DWORD fdwSentence), (himc, fdwConversion, fdwSentence)); DECLARE_DELAYED_FUNC(DWORD, ImmGetProperty, (HKL hKl, DWORD fdwIndex), (hKl, fdwIndex)); DECLARE_DELAYED_FUNC(BOOL, ImmEnumInputContext, (DWORD idThread, IMCENUMPROC lpfn, LPARAM lParam), (idThread, lpfn, lParam)); DECLARE_DELAYED_FUNC(DWORD, ImmGetGuideLineW, (HIMC himc, DWORD dwIndex, LPTSTR lpBuf, DWORD dwBufLen), (himc, dwIndex, lpBuf, dwBufLen)); BOOL g_fDBCSEnabled = FALSE; BOOL g_fMEEnabled = FALSE; BOOL g_fDBCSInputEnabled = FALSE; BOOL g_fIMMEnabled = FALSE; #if defined(FE_IME) || !defined(WINNT) void InitIme() { g_fMEEnabled = GetSystemMetrics(SM_MIDEASTENABLED); g_fDBCSEnabled = g_fDBCSInputEnabled = GetSystemMetrics(SM_DBCSENABLED); g_fIMMEnabled = GetSystemMetrics(SM_IMMENABLED); if (!g_fDBCSInputEnabled) { g_fDBCSInputEnabled = g_fIMMEnabled; } // We load imm32.dll per process, but initialize proc pointers just once. // this is to solve two different problems. // 1) Debugging process on win95 would get our shared table trashed // if we rewrite proc address each time we get loaded. // 2) Some lotus application rely upon us to load imm32. They do not // load/link to imm yet they use imm(!) // if (g_fDBCSInputEnabled || g_fIMMEnabled) { HANDLE hinst = LoadLibrary(TEXT("imm32.dll")); if (! g_pfnImmSetCandidateWindow && (! hinst || ! LOAD_DELAYED_FUNC(HIMC, ImmCreateContext, (void)) || ! LOAD_DELAYED_FUNC(HIMC, ImmDestroyContext, (HIMC)) || ! LOAD_DELAYED_FUNC(BOOL, ImmIsIME, (HKL)) || ! LOAD_DELAYED_FUNC(BOOL, ImmGetOpenStatus, (HIMC)) || ! LOAD_DELAYED_FUNC(BOOL, ImmSetOpenStatus, (HIMC, BOOL)) || ! LOAD_DELAYED_FUNC(BOOL, ImmGetConversionStatus, (HIMC, LPDWORD, LPDWORD)) || ! LOAD_DELAYED_FUNC(BOOL, ImmSetConversionStatus, (HIMC, DWORD, DWORD)) || ! LOAD_DELAYED_FUNC(DWORD, ImmGetProperty, (HKL, DWORD)) || ! LOAD_DELAYED_FUNC(BOOL, ImmUnlockIMC, (HIMC)) || ! LOAD_DELAYED_FUNC(LPINPUTCONTEXT, ImmLockIMC, (HIMC)) || ! LOAD_DELAYED_FUNC(BOOL, ImmSetCompositionWindow, (HIMC, LPCOMPOSITIONFORM)) || ! LOAD_DELAYED_FUNC(BOOL, ImmGetCompositionWindow, (HIMC, LPCOMPOSITIONFORM)) || ! LOAD_DELAYED_FUNC(BOOL, ImmSetCompositionFontW, (HIMC, LPLOGFONT)) || ! LOAD_DELAYED_FUNC(LRESULT, ImmEscapeA, (HKL, HIMC, UINT, LPVOID)) || ! LOAD_DELAYED_FUNC(LRESULT, ImmEscapeW, (HKL, HIMC, UINT, LPVOID)) || ! LOAD_DELAYED_FUNC(BOOL, ImmNotifyIME, (HIMC, DWORD, DWORD, DWORD)) || ! LOAD_DELAYED_FUNC(HIMC, ImmAssociateContext, (HWND, HIMC)) || ! LOAD_DELAYED_FUNC(BOOL, ImmReleaseContext, (HWND, HIMC)) || ! LOAD_DELAYED_FUNC(HIMC, ImmGetContext, (HWND)) || ! LOAD_DELAYED_FUNC(LONG, ImmGetCompositionStringA, (HIMC, DWORD, LPVOID, DWORD)) || ! LOAD_DELAYED_FUNC(BOOL, ImmSetCompositionStringA, (HIMC, DWORD, LPCVOID, DWORD, LPCVOID, DWORD)) || #ifndef UNICODE_WIN9x ! LOAD_DELAYED_FUNC(LONG, ImmGetCompositionStringW, (HIMC, DWORD, LPVOID, DWORD)) || ! LOAD_DELAYED_FUNC(BOOL, ImmSetCompositionStringW, (HIMC, DWORD, LPCVOID, DWORD, LPCVOID, DWORD)) || #endif ! LOAD_DELAYED_FUNC(BOOL, ImmEnumInputContext, (DWORD, IMCENUMPROC, LPARAM)) || ! LOAD_DELAYED_FUNC(DWORD, ImmGetGuideLineW, (HIMC, DWORD, LPTSTR, DWORD)) || ! LOAD_DELAYED_FUNC(BOOL, ImmSetCandidateWindow, (HIMC, LPCANDIDATEFORM)))) { // if we were unable to load then bail on using IME. g_fDBCSEnabled = FALSE; g_fDBCSInputEnabled = FALSE; } } } #else #define InitIme() 0 #endif #ifdef DEBUG // Verify that the localizers didn't accidentally change // DLG_PROPSHEET from a DIALOG to a DIALOGEX. _RealPropertySheet // relies on this (as well as any apps which parse the dialog template // in their PSCB_PRECREATE handler). BOOL IsSimpleDialog(LPCTSTR ptszDialog) { HRSRC hrsrc; LPDLGTEMPLATE pdlg; BOOL fSimple = FALSE; if ( (hrsrc = FindResource(HINST_THISDLL, ptszDialog, RT_DIALOG)) && (pdlg = LoadResource(HINST_THISDLL, hrsrc))) { fSimple = HIWORD(pdlg->style) != 0xFFFF; } return fSimple; } // // For sublanguages to work, every language in our resources must contain // a SUBLANG_NEUTRAL variation so that (for example) Austria gets // German dialog boxes instead of English ones. // // The DPA is really a DSA of WORDs, but DPA's are easier to deal with. // We just collect all the languages into the DPA, and study them afterwards. // BOOL CALLBACK CheckLangProc(HINSTANCE hinst, LPCTSTR lpszType, LPCTSTR lpszName, WORD wIdLang, LPARAM lparam) { HDPA hdpa = (HDPA)lparam; DPA_AppendPtr(hdpa, (LPVOID)(UINT_PTR)wIdLang); return TRUE; } void CheckResourceLanguages(void) { HDPA hdpa = DPA_Create(8); if (hdpa) { int i, j; EnumResourceLanguages(HINST_THISDLL, RT_DIALOG, MAKEINTRESOURCE(DLG_PROPSHEET), CheckLangProc, (LPARAM)hdpa); // Walk the language list. For each language we find, make sure // there is a SUBLANG_NEUTRAL version of it somewhere else // in the list. We use an O(n^2) algorithm because this is debug // only code and happens only at DLL load. for (i = 0; i < DPA_GetPtrCount(hdpa); i++) { UINT_PTR uLangI = (UINT_PTR)DPA_FastGetPtr(hdpa, i); BOOL fFound = FALSE; // // It is okay to have English (American) with no // English (Neutral) because Kernel32 uses English (American) // as its fallback, so we fall back to the correct language // after all. // if (uLangI == MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)) continue; // // If this language is already the Neutral one, then there's // no point looking for it - here it is! // if (SUBLANGID(uLangI) == SUBLANG_NEUTRAL) continue; // // Otherwise, this language is a dialect. See if there is // a Neutral version elsewhere in the table. // for (j = 0; j < DPA_GetPtrCount(hdpa); j++) { UINT_PTR uLangJ = (UINT_PTR)DPA_FastGetPtr(hdpa, j); if (PRIMARYLANGID(uLangI) == PRIMARYLANGID(uLangJ) && SUBLANGID(uLangJ) == SUBLANG_NEUTRAL) { fFound = TRUE; break; } } // // If this assertion fires, it means that the localization team // added support for a new language but chose to specify the // language as a dialect instead of the Neutral version. E.g., // specifying Romanian (Romanian) instead of Romanian (Neutral). // This means that people who live in Moldavia will see English // strings, even though Romanian (Romanian) would almost // certainly have been acceptable. // // If you want to support multiple dialects of a language // (e.g., Chinese), you should nominate one of the dialects // as the Neutral one. For example, we currently support // both Chinese (PRC) and Chinese (Taiwan), but the Taiwanese // version is marked as Chinese (Neutral), so people who live in // Singapore get Chinese instead of English. Sure, it's // Taiwanese Chinese, but at least it's Chinese. // AssertMsg(fFound, TEXT("Localization bug: No SUBLANG_NEUTRAL for language %04x"), uLangI); } DPA_Destroy(hdpa); } } #endif int _ProcessAttach(HANDLE hInstance) { INITCOMMONCONTROLSEX icce; g_hinst = hInstance; g_uiACP = GetACP(); g_atomThemeScrollBar = GlobalAddAtom(TEXT("ThemePropScrollBarCtl")); SHFusionInitialize(NULL); #ifdef DEBUG CcshellGetDebugFlags(); #endif InitializeCriticalSection(&g_csDll); g_fCriticalInitialized = TRUE; InitGlobalMetrics(0); InitGlobalColors(); InitIme(); // // Initialize special language pack callouts for // the edit controls. Once per process. // InitEditLpk(); // only do this for GetProcessVersion apps <= 0x40000 // Newer apps MUST use InitCommonControlsEx. icce.dwSize = sizeof(icce); icce.dwICC = ICC_ALL_CLASSES; InitCommonControlsEx(&icce); return TRUE; } void _ProcessDetach(HANDLE hInstance) { // // Cleanup cached DCs. No need to synchronize the following section of // code since it is only called in DLL_PROCESS_DETACH which is // synchronized by the OS Loader. // if (g_hdc) DeleteDC(g_hdc); if (g_hdcMask) DeleteDC(g_hdcMask); g_hdc = g_hdcMask = NULL; UnregisterClasses(); g_fCriticalInitialized = FALSE; DeleteCriticalSection(&g_csDll); SHFusionUninitialize(); } STDAPI_(BOOL) LibMain(HANDLE hDll, DWORD dwReason, LPVOID pv) { switch(dwReason) { case DLL_PROCESS_ATTACH: #ifdef DEBUG GdiSetBatchLimit(1); #else DisableThreadLibraryCalls(hDll); #endif return _ProcessAttach(hDll); case DLL_PROCESS_DETACH: _ProcessDetach(hDll); break; case DLL_THREAD_ATTACH: #ifdef DEBUG GdiSetBatchLimit(1); #endif case DLL_THREAD_DETACH: default: break; } // end switch() return TRUE; } // end DllEntryPoint() /* Stub function to call if all you want to do is make sure this DLL is loaded */ void WINAPI InitCommonControls(void) { } STDAPI_(void) FixupSubclassRecordsAfterLogoff(); BOOL InitForWinlogon(HINSTANCE hInstance) { // Some people like to use comctl32 from inside winlogon, and // for C2 security reasons, all global atoms are nuked from the // window station when you log off. // // So the rule is that all winlogon clients of comctl32 must // call InitCommonControlsEx(ICC_WINLOGON_REINIT) immediately // before doing any common control things (creating windows // or property sheets/wizards) from winlogon. FixupSubclassRecordsAfterLogoff(); InitGlobalMetrics(0); InitGlobalColors(); return TRUE; } /* InitCommonControlsEx creates the classes. Only those classes requested are created! ** The process attach figures out if it's an old app and supplies ICC_WIN95_CLASSES. */ typedef BOOL (PASCAL *PFNINIT)(HINSTANCE); typedef struct { PFNINIT pfnInit; LPCTSTR pszName; DWORD dw; } INITCOMMONCONTROLSINFO; #define MAKEICC(pfnInit, pszClass, dwFlags) { pfnInit, pszClass, dwFlags } const INITCOMMONCONTROLSINFO icc[] = { // Init function Class name Requested class sets which use this class MAKEICC(InitToolbarClass, TOOLBARCLASSNAME, ICC_BAR_CLASSES), MAKEICC(InitReBarClass, REBARCLASSNAME, ICC_COOL_CLASSES), MAKEICC(InitToolTipsClass, TOOLTIPS_CLASS, ICC_TREEVIEW_CLASSES|ICC_BAR_CLASSES|ICC_TAB_CLASSES), MAKEICC(InitStatusClass, STATUSCLASSNAME, ICC_BAR_CLASSES), MAKEICC(ListView_Init, WC_LISTVIEW, ICC_LISTVIEW_CLASSES), MAKEICC(Header_Init, WC_HEADER, ICC_LISTVIEW_CLASSES), MAKEICC(Tab_Init, WC_TABCONTROL, ICC_TAB_CLASSES), MAKEICC(TV_Init, WC_TREEVIEW, ICC_TREEVIEW_CLASSES), MAKEICC(InitTrackBar, TRACKBAR_CLASS, ICC_BAR_CLASSES), MAKEICC(InitUpDownClass, UPDOWN_CLASS, ICC_UPDOWN_CLASS), MAKEICC(InitProgressClass, PROGRESS_CLASS, ICC_PROGRESS_CLASS), MAKEICC(InitHotKeyClass, HOTKEY_CLASS, ICC_HOTKEY_CLASS), MAKEICC(InitAnimateClass, ANIMATE_CLASS, ICC_ANIMATE_CLASS), MAKEICC(InitDateClasses, DATETIMEPICK_CLASS,ICC_DATE_CLASSES), MAKEICC(InitComboExClass, WC_COMBOBOXEX, ICC_USEREX_CLASSES), MAKEICC(InitIPAddr, WC_IPADDRESS, ICC_INTERNET_CLASSES), MAKEICC(InitPager, WC_PAGESCROLLER, ICC_PAGESCROLLER_CLASS), MAKEICC(InitNativeFontCtl, WC_NATIVEFONTCTL, ICC_NATIVEFNTCTL_CLASS), MAKEICC(InitButtonClass, WC_BUTTON, ICC_STANDARD_CLASSES), MAKEICC(InitStaticClass, WC_STATIC, ICC_STANDARD_CLASSES), MAKEICC(InitEditClass, WC_EDIT, ICC_STANDARD_CLASSES), MAKEICC(InitListBoxClass, WC_LISTBOX, ICC_STANDARD_CLASSES), MAKEICC(InitComboboxClass, WC_COMBOBOX, ICC_STANDARD_CLASSES), MAKEICC(InitComboLBoxClass,WC_COMBOLBOX, ICC_STANDARD_CLASSES), MAKEICC(InitScrollBarClass,WC_SCROLLBAR, ICC_STANDARD_CLASSES), MAKEICC(InitLinkClass, WC_LINK, ICC_LINK_CLASS), MAKEICC(InitReaderModeClass,WC_READERMODE, ICC_STANDARD_CLASSES), // // These aren't really classes. They're just goofy flags. // MAKEICC(InitForWinlogon, NULL, ICC_WINLOGON_REINIT), }; BOOL WINAPI InitCommonControlsEx(LPINITCOMMONCONTROLSEX picce) { int i; if (!picce || (picce->dwSize != sizeof(INITCOMMONCONTROLSEX)) || (picce->dwICC & ~ICC_ALL_VALID)) { DebugMsg(DM_WARNING, TEXT("comctl32 - picce is bad")); return(FALSE); } for (i=0 ; i < ARRAYSIZE(icc) ; i++) if (picce->dwICC & icc[i].dw) if (!icc[i].pfnInit(HINST_THISDLL)) return(FALSE); return(TRUE); } // // InitMUILanguage / GetMUILanguage implementation // // we have a per process PUI language setting. For NT it's just a global // initialized with LANG_NEUTRAL and SUBLANG_NEUTRAL // For Win95 it's DPA slot for the current process. // InitMUILanguage sets callers preferred language id for common control // GetMUILangauge returns what the caller has set to us // LANGID PUIGetLangId(void) { return g_PUILangId; } void WINAPI InitMUILanguage(LANGID wLang) { ENTERCRITICAL; g_PUILangId = wLang; LEAVECRITICAL; } LANGID WINAPI GetMUILanguage(void) { return g_PUILangId; } // end MUI functions // // Unlike Win9x, WinNT does not automatically unregister classes // when a DLL unloads. We have to do it manually. Leaving the // class lying around means that if an app loads our DLL, then // unloads it, then reloads it at a different address, all our // leftover RegisterClass()es will point the WndProc at the wrong // place and we fault at the next CreateWindow(). // // This is not purely theoretical - NT4/FE hit this bug. // void UnregisterClasses() { WNDCLASS wc; int i; for (i=0 ; i < ARRAYSIZE(icc) ; i++) { if (icc[i].pszName && GetClassInfo(HINST_THISDLL, icc[i].pszName, &wc)) { UnregisterClass(icc[i].pszName, HINST_THISDLL); } } } #if defined(DEBUG) LRESULT WINAPI SendMessageD(HWND hWnd, UINT Msg, WPARAM wParam, LPARAM lParam) { ASSERTNONCRITICAL; return SendMessageW(hWnd, Msg, wParam, lParam); } #endif // defined(DEBUG)