This graph shows which files directly or indirectly include this file:

Classes
struct	builtin_class_descr

Functions
BOOL WINAPI	RegisterSystemControls (VOID)

ATOM WINAPI	RegisterClassExWOWW (WNDCLASSEXW *, LPDWORD, WORD, DWORD, BOOL)

BOOL FASTCALL	VersionRegisterClass (PCWSTR, LPCWSTR, HANDLE, HMODULE *)

LRESULT WINAPI	ImeWndProc_common (HWND, UINT, WPARAM, LPARAM, BOOL)

LRESULT WINAPI	ImeWndProcA (HWND, UINT, WPARAM, LPARAM)

LRESULT WINAPI	ImeWndProcW (HWND, UINT, WPARAM, LPARAM)

BOOL WINAPI	RegisterIMEClass (VOID)

Variables
DWORD	RegisterDefaultClasses

const struct builtin_class_descr	BUTTON_builtin_class

const struct builtin_class_descr	COMBO_builtin_class

const struct builtin_class_descr	COMBOLBOX_builtin_class

const struct builtin_class_descr	DIALOG_builtin_class

const struct builtin_class_descr	POPUPMENU_builtin_class

const struct builtin_class_descr	DESKTOP_builtin_class

const struct builtin_class_descr	EDIT_builtin_class

const struct builtin_class_descr	ICONTITLE_builtin_class

const struct builtin_class_descr	LISTBOX_builtin_class

const struct builtin_class_descr	MDICLIENT_builtin_class

const struct builtin_class_descr	MENU_builtin_class

const struct builtin_class_descr	SCROLL_builtin_class

const struct builtin_class_descr	STATIC_builtin_class

const struct builtin_class_descr	GHOST_builtin_class

Function Documentation

◆ ImeWndProc_common()

LRESULT WINAPI ImeWndProc_common	(	HWND	,
		UINT	,
		WPARAM	,
		LPARAM	,
		BOOL
	)

Definition at line 935 of file imm.c.

 {
     PWND pWnd;
     PIMEUI pimeui;
     LRESULT ret;
 
     pWnd = ValidateHwnd(hwnd);
     if (pWnd == NULL)
     {
         ERR("hwnd was %p\n", hwnd);
         return 0;
     }
 
     if (!pWnd->fnid)
     {
         NtUserSetWindowFNID(hwnd, FNID_IME);
     }
     else if (pWnd->fnid != FNID_IME)
     {
         ERR("fnid was 0x%x\n", pWnd->fnid);
         return 0;
     }
 
     pimeui = (PIMEUI)GetWindowLongPtrW(hwnd, 0);
     if (pimeui == NULL)
     {
         pimeui = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IMEUI));
         if (pimeui == NULL)
         {
             ERR("HeapAlloc failed\n");
             NtUserSetWindowFNID(hwnd, FNID_DESTROY);
             DestroyWindow(hwnd);
             return 0;
         }
 
         SetWindowLongPtrW(hwnd, 0, (LONG_PTR)pimeui);
         pimeui->spwnd = pWnd;
     }
 
     if (IS_CICERO_MODE())
     {
         ret = IMM_FN(CtfImmDispatchDefImeMessage)(hwnd, msg, wParam, lParam);
         if (ret)
             return ret;
     }
 
     if (pimeui->nCntInIMEProc > 0)
     {
         switch (msg)
         {
             case WM_IME_CHAR:
             case WM_IME_COMPOSITIONFULL:
             case WM_IME_CONTROL:
             case WM_IME_REQUEST:
             case WM_IME_SELECT:
             case WM_IME_SETCONTEXT:
             case WM_IME_STARTCOMPOSITION:
             case WM_IME_COMPOSITION:
             case WM_IME_ENDCOMPOSITION:
                 return 0;
 
             case WM_IME_NOTIFY:
                 if (wParam < IMN_PRIVATE || IS_IME_HKL(pimeui->hKL) || !IS_CICERO_MODE())
                     return 0;
                 break;
 
             case WM_IME_SYSTEM:
                 switch (wParam)
                 {
                     case 0x03:
                     case 0x10:
                     case 0x13:
                         break;
 
                     default:
                         return 0;
                 }
                 break;
 
             default:
                 goto Finish;
         }
     }
 
     if ((pWnd->state2 & WNDS2_INDESTROY) || (pWnd->state & WNDS_DESTROYED))
     {
         switch (msg)
         {
             case WM_DESTROY:
             case WM_NCDESTROY:
             case WM_FINALDESTROY:
                 break;
 
             default:
                 return 0;
         }
     }
 
     switch (msg)
     {
         case WM_CREATE:
             return ImeWnd_OnCreate(pimeui, (LPCREATESTRUCT)lParam);
 
         case WM_DESTROY:
             User32DestroyImeUIWindow(pimeui);
             return 0;
 
         case WM_NCDESTROY:
         case WM_FINALDESTROY:
             pimeui->spwnd = NULL;
             HeapFree(GetProcessHeap(), 0, pimeui);
             NtUserSetWindowFNID(hwnd, FNID_DESTROY);
             break;
 
         case WM_ERASEBKGND:
             return TRUE;
 
         case WM_PAINT:
             return 0;
 
         case WM_IME_STARTCOMPOSITION:
         case WM_IME_COMPOSITION:
         case WM_IME_ENDCOMPOSITION:
             return User32SendImeUIMessage(pimeui, msg, wParam, lParam, unicode);
 
         case WM_IME_CONTROL:
             return ImeWnd_OnImeControl(pimeui, wParam, lParam, unicode);
 
         case WM_IME_NOTIFY:
             return ImeWnd_OnImeNotify(pimeui, wParam, lParam);
 
         case WM_IME_REQUEST:
             return 0;
 
         case WM_IME_SELECT:
             ImeWnd_OnImeSelect(pimeui, wParam, lParam);
             return (LRESULT)pimeui;
 
         case WM_IME_SETCONTEXT:
             return ImeWnd_OnImeSetContext(pimeui, wParam, lParam);
 
         case WM_IME_SYSTEM:
             return ImeWnd_OnImeSystem(pimeui, wParam, lParam);
 
         default:
             break;
     }
 
 Finish:
     if (unicode)
         return DefWindowProcW(hwnd, msg, wParam, lParam);
     return DefWindowProcA(hwnd, msg, wParam, lParam);
 }

Referenced by ImeWndProcA(), ImeWndProcW(), RealDefWindowProcA(), RealDefWindowProcW(), and RegisterClientPFN().

◆ ImeWndProcA()

LRESULT WINAPI ImeWndProcA	(	HWND	,
		UINT	,
		WPARAM	,
		LPARAM
	)

Definition at line 1090 of file imm.c.

 {
     return ImeWndProc_common(hwnd, msg, wParam, lParam, FALSE);
 }

Referenced by RegisterClientPFN().

◆ ImeWndProcW()

LRESULT WINAPI ImeWndProcW	(	HWND	,
		UINT	,
		WPARAM	,
		LPARAM
	)

Definition at line 1096 of file imm.c.

 {
     return ImeWndProc_common(hwnd, msg, wParam, lParam, TRUE);
 }

Referenced by RegisterClientPFN(), and RegisterIMEClass().

◆ RegisterClassExWOWW()

ATOM WINAPI RegisterClassExWOWW	(	WNDCLASSEXW *	,
		LPDWORD	,
		WORD	,
		DWORD	,
		BOOL
	)

Definition at line 1413 of file class.c.

 {
     ATOM Atom;
     WNDCLASSEXW WndClass;
     UNICODE_STRING ClassName;
     UNICODE_STRING ClassVersion;
     UNICODE_STRING MenuName = {0};
     CLSMENUNAME clsMenuName;
     ANSI_STRING AnsiMenuName;
     LPCWSTR lpszClsVersion;
 
     if (lpwcx == NULL || lpwcx->cbSize != sizeof(WNDCLASSEXW) ||
         lpwcx->cbClsExtra < 0 || lpwcx->cbWndExtra < 0 ||
         lpwcx->lpszClassName == NULL)
     {
         TRACE("RegisterClassExWOWW Invalid Parameter Error!\n");
         SetLastError(ERROR_INVALID_PARAMETER);
         return 0;
     }
 
     if (ChkRegCls)
     {
         if (!RegisterDefaultClasses) RegisterSystemControls();
     }
     /*
      * On real Windows this looks more like:
      *    if (lpwcx->hInstance == User32Instance &&
      *        *(PULONG)((ULONG_PTR)NtCurrentTeb() + 0x6D4) & 0x400)
      * But since I have no idea what the magic field in the
      * TEB structure means, I rather decided to omit that.
      * -- Filip Navara
 
         GetWin32ClientInfo()->dwExpWinVer & (WINVER == 0x400)
      */
     if (lpwcx->hInstance == User32Instance)
     {
         TRACE("RegisterClassExWOWW User32Instance!\n");
         SetLastError(ERROR_INVALID_PARAMETER);
         return 0;
     }
     /* Yes, this is correct. We should modify the passed structure. */
     if (lpwcx->hInstance == NULL)
        ((WNDCLASSEXW*)lpwcx)->hInstance = GetModuleHandleW(NULL);
 
     RtlCopyMemory(&WndClass, lpwcx, sizeof(WNDCLASSEXW));
 /*
     if (NULL == WndClass.hIconSm)
     {
         WndClass.hIconSm = CreateSmallIcon(WndClass.hIcon);
     }
 */
     RtlInitEmptyAnsiString(&AnsiMenuName, NULL, 0);
     if (WndClass.lpszMenuName != NULL)
     {
         if (!IS_INTRESOURCE(WndClass.lpszMenuName))
         {
             if (WndClass.lpszMenuName[0])
             {
                RtlInitUnicodeString(&MenuName, WndClass.lpszMenuName);
                RtlUnicodeStringToAnsiString( &AnsiMenuName, &MenuName, TRUE);
             }
         }
         else
         {
             MenuName.Buffer = (LPWSTR)WndClass.lpszMenuName;
              AnsiMenuName.Buffer = (PCHAR)WndClass.lpszMenuName;
         }
     }
 
     if (IS_ATOM(WndClass.lpszClassName))
     {
         ClassName.Length =
         ClassName.MaximumLength = 0;
         ClassName.Buffer = (LPWSTR)WndClass.lpszClassName;
     }
     else
     {
         RtlInitUnicodeString(&ClassName, WndClass.lpszClassName);
     }
 
     ClassVersion = ClassName;
     if (fnID == 0)
     {
         lpszClsVersion = ClassNameToVersion(lpwcx->lpszClassName, NULL, NULL, NULL, FALSE);
         if (lpszClsVersion)
         {
             RtlInitUnicodeString(&ClassVersion, lpszClsVersion);
         }
     }
 
     clsMenuName.pszClientAnsiMenuName = AnsiMenuName.Buffer;
     clsMenuName.pwszClientUnicodeMenuName = MenuName.Buffer;
     clsMenuName.pusMenuName = &MenuName;
 
     Atom = NtUserRegisterClassExWOW( &WndClass,
                                      &ClassName,
                                      &ClassVersion,
                                      &clsMenuName,
                                      fnID,
                                      dwFlags,
                                      pdwWowData);
 
     TRACE("atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d class=%p\n",
            Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
            lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra, WndClass);
 
     return Atom;
 }

Referenced by RegisterClassExA(), RegisterClassExW(), RegisterIMEClass(), and RegisterSystemControls().

◆ RegisterIMEClass()

BOOL WINAPI RegisterIMEClass ( VOID )

Definition at line 1127 of file imm.c.

 {
     ATOM atom;
     WNDCLASSEXW WndClass = { sizeof(WndClass) };
 
     WndClass.lpszClassName  = L"IME";
     WndClass.style          = CS_GLOBALCLASS;
     WndClass.lpfnWndProc    = ImeWndProcW;
     WndClass.cbWndExtra     = sizeof(LONG_PTR);
     WndClass.hCursor        = LoadCursorW(NULL, IDC_ARROW);
 
     atom = RegisterClassExWOWW(&WndClass, 0, FNID_IME, 0, FALSE);
     if (!atom)
     {
         ERR("Failed to register IME Class!\n");
         return FALSE;
     }
 
     RegisterDefaultClasses |= ICLASS_TO_MASK(ICLS_IME);
     TRACE("RegisterIMEClass atom = %u\n", atom);
     return TRUE;
 }

Referenced by RegisterSystemControls().

◆ RegisterSystemControls()

BOOL WINAPI RegisterSystemControls ( VOID )

Definition at line 70 of file regcontrol.c.

 {
     WNDCLASSEXW WndClass;
     UINT i;
     ATOM atom;
 
     if (RegisterDefaultClasses) return TRUE;
 
     ZeroMemory(&WndClass, sizeof(WndClass));
 
     WndClass.cbSize = sizeof(WndClass);
 
     for (i = 0; i != sizeof(g_SysClasses) / sizeof(g_SysClasses[0]); i++)
     {
         WndClass.lpszClassName = g_SysClasses[i].desc->name;
 
         // Set Global bit!
         WndClass.style = g_SysClasses[i].desc->style|CS_GLOBALCLASS;
         WndClass.lpfnWndProc = g_SysClasses[i].desc->procW;
         WndClass.cbWndExtra = g_SysClasses[i].desc->extra;
         WndClass.hCursor = LoadCursorW(NULL, g_SysClasses[i].desc->cursor);
         WndClass.hbrBackground= g_SysClasses[i].desc->brush;
 
         atom = RegisterClassExWOWW( &WndClass,
                                      0,
                                      g_SysClasses[i].fnid,
                                      0,
                                      FALSE);
         if (atom)
            RegisterDefaultClasses |= ICLASS_TO_MASK(g_SysClasses[i].ClsId);
     }
 
     if ( //gpsi->dwSRVIFlags & SRVINFO_IMM32 && Not supported yet, need NlsMbCodePageTag working in Win32k.
         !(RegisterDefaultClasses & ICLASS_TO_MASK(ICLS_IME))) // So, work like XP.
     {
        RegisterIMEClass();
     }
 
     return TRUE;
 }

Referenced by CreateWindowExA(), CreateWindowExW(), GetClassInfoExA(), GetClassInfoExW(), RegisterClassExWOWW(), and User32CreateWindowEx().

◆ VersionRegisterClass()

BOOL FASTCALL VersionRegisterClass	(	PCWSTR	,
		LPCWSTR	,
		HANDLE	,
		HMODULE *
	)

Definition at line 195 of file class.c.

 {
     BOOL Ret = FALSE;
     HMODULE hLibModule = NULL;
     PREGISTERCLASSNAMEW pRegisterClassNameW;
     UNICODE_STRING ClassName;
     WCHAR ClassNameBuf[MAX_PATH] = {0};
     RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_EXTENDED Frame = { sizeof(Frame), 1 };
 
     ERR("VersionRegisterClass: Attempting to call RegisterClassNameW in %S.\n", lpLibFileName);
 
     RtlActivateActivationContextUnsafeFast(&Frame, Contex);
 
     _SEH2_TRY
     {
         hLibModule = LoadLibraryW(lpLibFileName);
         if (hLibModule)
         {
             if ((pRegisterClassNameW = (void*)GetProcAddress(hLibModule, "RegisterClassNameW")))
             {
                 if (IS_ATOM(pszClass))
                 {
                     RtlInitEmptyUnicodeString(&ClassName, ClassNameBuf, sizeof(ClassNameBuf));
                     if (!NtUserGetAtomName(LOWORD((DWORD_PTR)pszClass), &ClassName))
                     {
                         ERR("Error while verifying ATOM\n");
                         _SEH2_YIELD(goto Error_Exit);
                     }
                     pszClass = ClassName.Buffer;
                 }
                 Ret = pRegisterClassNameW(pszClass);
             }
             else
             {
                 WARN("No RegisterClassNameW PROC\n");
             }
         }
     }
     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
     {
        ERR("Got exception while trying to call RegisterClassNameW!\n");
     }
     _SEH2_END
 
 Error_Exit:
     if (Ret || !hLibModule)
     {
         if (phLibModule) *phLibModule = hLibModule;
     }
     else
     {
         DWORD dwLastError = GetLastError();
         FreeLibrary(hLibModule);
         SetLastError(dwLastError);
     }
 
     RtlDeactivateActivationContextUnsafeFast(&Frame);
     return Ret;
 }