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	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam,
		BOOL	unicode
	)

Definition at line 989 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	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1143 of file imm.c.

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

Referenced by RegisterClientPFN().

◆ ImeWndProcW()

LRESULT WINAPI ImeWndProcW	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1148 of file imm.c.

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

Referenced by RegisterClientPFN(), and RegisterIMEClass().

◆ RegisterClassExWOWW()

ATOM WINAPI RegisterClassExWOWW	(	WNDCLASSEXW *	lpwcx,
		LPDWORD	pdwWowData,
		WORD	fnID,
		DWORD	dwFlags,
		BOOL	ChkRegCls
	)

Definition at line 1262 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(*lpwcx) ||
        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(*lpwcx));
 
    RtlInitEmptyAnsiString(&AnsiMenuName, NULL, 0);
    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 (WndClass.lpszClassName && !IS_ATOM(WndClass.lpszClassName))
    {
        RtlInitUnicodeString(&ClassName, WndClass.lpszClassName);
    }
    else
    {
        ClassName.Length = ClassName.MaximumLength = 0;
        ClassName.Buffer = (LPWSTR)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 1178 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	pszClass,
		LPCWSTR	lpLibFileName,
		HANDLE	Contex,
		HMODULE *	phLibModule
	)

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