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 224 of file imm.c.

 {
     PWND pWnd;
     PIMEUI pimeui;
 
     pWnd = ValidateHwnd(hwnd);
     if (pWnd)
     {
        if (!pWnd->fnid)
        {
           if (msg != WM_NCCREATE)
           {
              if (unicode)
                 return DefWindowProcW(hwnd, msg, wParam, lParam);
              return DefWindowProcA(hwnd, msg, wParam, lParam);
           }
           NtUserSetWindowFNID(hwnd, FNID_IME);
           pimeui = HeapAlloc( GetProcessHeap(), 0, sizeof(IMEUI) );
           SetWindowLongPtrW(hwnd, 0, (LONG_PTR)pimeui);
        }
        else
        {
           if (pWnd->fnid != FNID_IME)
           {
              ERR("Wrong window class for Ime! fnId 0x%x\n",pWnd->fnid);
              return 0;
           }
           pimeui = ((PIMEWND)pWnd)->pimeui;
           if (pimeui == NULL)
           {
              ERR("Window is not set to IME!\n");
              return 0;
           }
        }
     }
 
     if (msg==WM_CREATE || msg==WM_NCCREATE)
         return TRUE;
 
     if (msg==WM_NCDESTROY)
     {
         HeapFree( GetProcessHeap(), 0, pimeui );
         SetWindowLongPtrW(hwnd, 0, 0);
         NtUserSetWindowFNID(hwnd, FNID_DESTROY);
     }
 
     if (unicode)
        return DefWindowProcW(hwnd, msg, wParam, lParam);
     return DefWindowProcA(hwnd, msg, wParam, lParam);
 }

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

◆ ImeWndProcA()

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

Definition at line 275 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 280 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 1411 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 313 of file imm.c.

 {
     WNDCLASSEXW WndClass;
     ATOM atom;
 
     ZeroMemory(&WndClass, sizeof(WndClass));
 
     WndClass.cbSize = sizeof(WndClass);
     WndClass.lpszClassName = imeW;
     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)
     {
        RegisterDefaultClasses |= ICLASS_TO_MASK(ICLS_IME);
        TRACE("Register IME Class!\n");
        return TRUE;
     }
     ERR("Failed to register IME Class!\n");
     return FALSE;
 }

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;
 }