class.c File Reference

#include <user32.h>

Include dependency graph for class.c:

Go to the source code of this file.

Classes
struct	strsection_header
struct	wndclass_redirect_data

Macros
#define	USE_VERSIONED_CLASSES

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (user32)
LPCWSTR	is_comctl32_class (const WCHAR *name)
LPCWSTR FASTCALL	ClassNameToVersion (const void *lpszClass, LPCWSTR lpszMenuName, LPCWSTR *plpLibFileName, HANDLE *pContext, BOOL bAnsi)
BOOL FASTCALL	VersionRegisterClass (PCWSTR pszClass, LPCWSTR lpLibFileName, HANDLE Contex, HMODULE *phLibModule)
BOOL WINAPI	GetClassInfoExA (HINSTANCE hInstance, LPCSTR lpszClass, LPWNDCLASSEXA lpwcx)
BOOL WINAPI	GetClassInfoExW (HINSTANCE hInstance, LPCWSTR lpszClass, LPWNDCLASSEXW lpwcx)
BOOL WINAPI	GetClassInfoA (HINSTANCE hInstance, LPCSTR lpClassName, LPWNDCLASSA lpWndClass)
BOOL WINAPI	GetClassInfoW (HINSTANCE hInstance, LPCWSTR lpClassName, LPWNDCLASSW lpWndClass)
ULONG_PTR FASTCALL	IntGetClsWndProc (PWND pWnd, PCLS Class, BOOL Ansi)
WNDPROC FASTCALL	IntGetWndProc (PWND pWnd, BOOL Ansi)
static ULONG_PTR FASTCALL	IntGetClassLongA (PWND Wnd, PCLS Class, int nIndex)
static ULONG_PTR FASTCALL	IntGetClassLongW (PWND Wnd, PCLS Class, int nIndex)
DWORD WINAPI	GetClassLongA (HWND hWnd, int nIndex)
DWORD WINAPI	GetClassLongW (HWND hWnd, int nIndex)
int WINAPI	GetClassNameA (HWND hWnd, LPSTR lpClassName, int nMaxCount)
int WINAPI	GetClassNameW (HWND hWnd, LPWSTR lpClassName, int nMaxCount)
WORD WINAPI	GetClassWord (HWND hwnd, int offset)
LONG_PTR	IntGetWindowLong (HWND hwnd, INT offset, UINT size, BOOL unicode)
LONG WINAPI	GetWindowLongA (HWND hWnd, int nIndex)
LONG WINAPI	GetWindowLongW (HWND hWnd, int nIndex)
WORD WINAPI	GetWindowWord (HWND hWnd, int nIndex)
UINT WINAPI	RealGetWindowClassW (HWND hwnd, LPWSTR pszType, UINT cchType)
UINT WINAPI	RealGetWindowClassA (HWND hwnd, LPSTR pszType, UINT cchType)
ATOM WINAPI	RegisterClassExWOWW (WNDCLASSEXW *lpwcx, LPDWORD pdwWowData, WORD fnID, DWORD dwFlags, BOOL ChkRegCls)
ATOM WINAPI	RegisterClassExA (CONST WNDCLASSEXA *lpwcx)
ATOM WINAPI	RegisterClassExW (CONST WNDCLASSEXW *lpwcx)
ATOM WINAPI	RegisterClassA (CONST WNDCLASSA *lpWndClass)
ATOM WINAPI	RegisterClassW (CONST WNDCLASSW *lpWndClass)
DWORD WINAPI	SetClassLongA (HWND hWnd, int nIndex, LONG dwNewLong)
DWORD WINAPI	SetClassLongW (HWND hWnd, int nIndex, LONG dwNewLong)
WORD WINAPI	SetClassWord (HWND hWnd, int nIndex, WORD wNewWord)
WORD WINAPI	SetWindowWord (HWND hWnd, int nIndex, WORD wNewWord)
LONG WINAPI DECLSPEC_HOTPATCH	SetWindowLongA (HWND hWnd, int nIndex, LONG dwNewLong)
LONG WINAPI	SetWindowLongW (HWND hWnd, int nIndex, LONG dwNewLong)
BOOL WINAPI	UnregisterClassA (LPCSTR lpClassName, HINSTANCE hInstance)
BOOL WINAPI	UnregisterClassW (LPCWSTR lpClassName, HINSTANCE hInstance)

Macro Definition Documentation

USE_VERSIONED_CLASSES

#define USE_VERSIONED_CLASSES

Definition at line 15 of file class.c.

Function Documentation

ClassNameToVersion()

LPCWSTR FASTCALL ClassNameToVersion	(	const void *	lpszClass,
		LPCWSTR	lpszMenuName,
		LPCWSTR *	plpLibFileName,
		HANDLE *	pContext,
		BOOL	bAnsi
	)

Definition at line 85 of file class.c.

{
    LPCWSTR VersionedClass = NULL;
#ifdef USE_VERSIONED_CLASSES
    NTSTATUS Status;
#endif
    UNICODE_STRING SectionName;
    WCHAR SectionNameBuf[MAX_PATH] = {0};
    ACTCTX_SECTION_KEYED_DATA KeyedData = { sizeof(KeyedData) };
 
    if(!lpszClass)
    {
        ERR("Null class given !\n");
        return NULL;
    }
 
    if (IS_ATOM(lpszClass))
    {
        RtlInitEmptyUnicodeString(&SectionName, SectionNameBuf, sizeof(SectionNameBuf));
        if(!NtUserGetAtomName(LOWORD((DWORD_PTR)lpszClass), &SectionName))
        {
            ERR("Couldn't get atom name for atom %x !\n", LOWORD((DWORD_PTR)lpszClass));
            return NULL;
        }
        SectionName.Length = (USHORT)wcslen(SectionNameBuf) * sizeof(WCHAR);
        TRACE("ClassNameToVersion got name %wZ from atom\n", &SectionName);
    }
    else
    {
        if (bAnsi)
        {
            ANSI_STRING AnsiString;
            RtlInitAnsiString(&AnsiString, lpszClass);
            RtlInitEmptyUnicodeString(&SectionName, SectionNameBuf, sizeof(SectionNameBuf));
            RtlAnsiStringToUnicodeString(&SectionName, &AnsiString, FALSE);
        }
        else
        {
            RtlInitUnicodeString(&SectionName, lpszClass);
        }
    }
#ifdef USE_VERSIONED_CLASSES
    Status = RtlFindActivationContextSectionString( FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX,
                                                    NULL,
                                                    ACTIVATION_CONTEXT_SECTION_WINDOW_CLASS_REDIRECTION,
                                                   &SectionName,
                                                   &KeyedData );
 
    if (NT_SUCCESS(Status) && KeyedData.ulDataFormatVersion == 1)
    {
        struct strsection_header *SectionHeader = KeyedData.lpSectionBase;
 
        /* Find activation context */
        if(SectionHeader && SectionHeader->count > 0)
        {
            struct wndclass_redirect_data *WindowRedirectionData = KeyedData.lpData;
            if(WindowRedirectionData && WindowRedirectionData->module_len)
            {
                LPCWSTR lpLibFileName;
 
                VersionedClass = (WCHAR*)((BYTE*)WindowRedirectionData + WindowRedirectionData->name_offset);
                lpLibFileName = (WCHAR*)((BYTE*)KeyedData.lpSectionBase + WindowRedirectionData->module_offset);
                TRACE("Returning VersionedClass=%S, plpLibFileName=%S for class %S\n", VersionedClass, lpLibFileName, SectionName.Buffer);
 
                if (pContext) *pContext = KeyedData.hActCtx;
                if (plpLibFileName) *plpLibFileName = lpLibFileName;
 
            }
        }
    }
 
    if (KeyedData.hActCtx)
        RtlReleaseActivationContext(KeyedData.hActCtx);
#endif
 
#ifndef DEFAULT_ACTIVATION_CONTEXTS_SUPPORTED
    /* This block is a hack! */
    if (!VersionedClass)
    {
        /*
         * In windows the default activation context always contains comctl32v5
         * In reactos we don't have a default activation context so we
         * mimic wine here.
         */
        VersionedClass = is_comctl32_class(SectionName.Buffer);
        if (VersionedClass)
        {
            if (pContext) *pContext = 0;
            if (plpLibFileName) *plpLibFileName = L"comctl32";
        }
    }
#endif
 
    /*
     * The returned strings are pointers in the activation context and
     * will get freed when the activation context gets freed
     */
    return VersionedClass;
}

Referenced by GetClassInfoExA(), GetClassInfoExW(), RegisterClassExWOWW(), UnregisterClassA(), UnregisterClassW(), and User32CreateWindowEx().

GetClassInfoA()

BOOL WINAPI GetClassInfoA	(	HINSTANCE	hInstance,
		LPCSTR	lpClassName,
		LPWNDCLASSA	lpWndClass
	)

Definition at line 476 of file class.c.

{
    WNDCLASSEXA wcex;
    BOOL retval;
 
    retval = GetClassInfoExA(hInstance, lpClassName, &wcex);
    if (retval)
    {
        lpWndClass->style         = wcex.style;
        lpWndClass->lpfnWndProc   = wcex.lpfnWndProc;
        lpWndClass->cbClsExtra    = wcex.cbClsExtra;
        lpWndClass->cbWndExtra    = wcex.cbWndExtra;
        lpWndClass->hInstance     = wcex.hInstance;
        lpWndClass->hIcon         = wcex.hIcon;
        lpWndClass->hCursor       = wcex.hCursor;
        lpWndClass->hbrBackground = wcex.hbrBackground;
        lpWndClass->lpszMenuName  = wcex.lpszMenuName;
        lpWndClass->lpszClassName = wcex.lpszClassName;
    }
 
    return retval;
}

GetClassInfoExA()

BOOL WINAPI GetClassInfoExA	(	HINSTANCE	hInstance,
		LPCSTR	lpszClass,
		LPWNDCLASSEXA	lpwcx
	)

Definition at line 264 of file class.c.

{
    UNICODE_STRING ClassName = {0};
    LPCSTR pszMenuName;
    HMODULE hLibModule = NULL;
    DWORD dwLastError;
    BOOL Ret, ClassFound = FALSE, ConvertedString = FALSE;
    LPCWSTR lpszClsVersion;
    HANDLE pCtx = NULL;
    LPCWSTR lpLibFileName = NULL;
 
    TRACE("%p class/atom: %s/%04x %p\n", hInstance,
        IS_ATOM(lpszClass) ? NULL : lpszClass,
        IS_ATOM(lpszClass) ? lpszClass : 0,
        lpwcx);
 
    if (!lpwcx)
    {
        SetLastError(ERROR_NOACCESS);
        return FALSE;
    }
 
    if (hInstance == User32Instance)
    {
        hInstance = NULL;
    }
 
    if (lpszClass == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    lpszClsVersion = ClassNameToVersion(lpszClass, NULL, &lpLibFileName, &pCtx, TRUE);
    if (lpszClsVersion)
    {
        RtlInitUnicodeString(&ClassName, lpszClsVersion);
    }
    else if (IS_ATOM(lpszClass))
    {
        ClassName.Buffer = (PWSTR)((ULONG_PTR)lpszClass);
    }
    else
    {
        ConvertedString = TRUE;
        if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, lpszClass))
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return FALSE;
        }
    }
 
    if (!RegisterDefaultClasses)
    {
        TRACE("RegisterSystemControls\n");
        RegisterSystemControls();
    }
 
    for(;;)
    {
        Ret = NtUserGetClassInfo(hInstance,
                                 &ClassName,
                                 (LPWNDCLASSEXW)lpwcx,
                                 (LPWSTR *)&pszMenuName,
                                 TRUE);
        if (Ret) break;
        if (!lpLibFileName) break;
        if (!ClassFound)
        {
            dwLastError = GetLastError();
            if ( dwLastError == ERROR_CANNOT_FIND_WND_CLASS ||
                 dwLastError == ERROR_CLASS_DOES_NOT_EXIST )
            {
                ClassFound = VersionRegisterClass(ClassName.Buffer, lpLibFileName, pCtx, &hLibModule);
                if (ClassFound) continue;
            }
        }
        if (hLibModule)
        {
            dwLastError = GetLastError();
            FreeLibrary(hLibModule);
            SetLastError(dwLastError);
            hLibModule = 0;
        }
        break;
    }
 
    if (Ret)
    {
        lpwcx->lpszClassName = lpszClass;
//       lpwcx->lpszMenuName  = pszMenuName;
    }
 
    if (ConvertedString)
    {
        RtlFreeUnicodeString(&ClassName);
    }
 
    return Ret;
}

GetClassInfoExW()

BOOL WINAPI GetClassInfoExW	(	HINSTANCE	hInstance,
		LPCWSTR	lpszClass,
		LPWNDCLASSEXW	lpwcx
	)

Definition at line 374 of file class.c.

{
    UNICODE_STRING ClassName = {0};
    LPWSTR pszMenuName;
    HMODULE hLibModule = NULL;
    DWORD dwLastError;
    BOOL Ret, ClassFound = FALSE;
    LPCWSTR lpszClsVersion;
    HANDLE pCtx = NULL;
    LPCWSTR lpLibFileName = NULL;
 
    TRACE("%p class/atom: %S/%04x %p\n", hInstance,
        IS_ATOM(lpszClass) ? NULL : lpszClass,
        IS_ATOM(lpszClass) ? lpszClass : 0,
        lpwcx);
 
    /* From wine, for speed only, ReactOS supports the correct return in
     * Win32k. cbSize is ignored.
     */
    if (!lpwcx)
    {
       SetLastError( ERROR_NOACCESS );
       return FALSE;
    }
 
    if (hInstance == User32Instance)
    {
        hInstance = NULL;
    }
 
    if (lpszClass == NULL)
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }
 
    lpszClsVersion = ClassNameToVersion(lpszClass, NULL, &lpLibFileName, &pCtx, FALSE);
    if (lpszClsVersion)
    {
        RtlInitUnicodeString(&ClassName, lpszClsVersion);
    }
    else if (IS_ATOM(lpszClass))
    {
        ClassName.Buffer = (PWSTR)((ULONG_PTR)lpszClass);
    }
    else
    {
        RtlInitUnicodeString(&ClassName, lpszClass);
    }
 
    if (!RegisterDefaultClasses)
    {
       TRACE("RegisterSystemControls\n");
       RegisterSystemControls();
    }
 
    for(;;)
    {
        Ret = NtUserGetClassInfo( hInstance,
                                 &ClassName,
                                  lpwcx,
                                 &pszMenuName,
                                  FALSE);
        if (Ret) break;
        if (!lpLibFileName) break;
        if (!ClassFound)
        {
            dwLastError = GetLastError();
            if ( dwLastError == ERROR_CANNOT_FIND_WND_CLASS ||
                 dwLastError == ERROR_CLASS_DOES_NOT_EXIST )
            {
                ClassFound = VersionRegisterClass(ClassName.Buffer, lpLibFileName, pCtx, &hLibModule);
                if (ClassFound) continue;
            }
        }
        if (hLibModule)
        {
            dwLastError = GetLastError();
            FreeLibrary(hLibModule);
            SetLastError(dwLastError);
            hLibModule = 0;
        }
        break;
    }
 
    if (Ret)
    {
        lpwcx->lpszClassName = lpszClass;
//       lpwcx->lpszMenuName  = pszMenuName;
    }
    return Ret;
}

GetClassInfoW()

BOOL WINAPI GetClassInfoW	(	HINSTANCE	hInstance,
		LPCWSTR	lpClassName,
		LPWNDCLASSW	lpWndClass
	)

Definition at line 507 of file class.c.

{
    WNDCLASSEXW wcex;
    BOOL retval;
 
    retval = GetClassInfoExW(hInstance, lpClassName, &wcex);
    if (retval)
    {
        lpWndClass->style         = wcex.style;
        lpWndClass->lpfnWndProc   = wcex.lpfnWndProc;
        lpWndClass->cbClsExtra    = wcex.cbClsExtra;
        lpWndClass->cbWndExtra    = wcex.cbWndExtra;
        lpWndClass->hInstance     = wcex.hInstance;
        lpWndClass->hIcon         = wcex.hIcon;
        lpWndClass->hCursor       = wcex.hCursor;
        lpWndClass->hbrBackground = wcex.hbrBackground;
        lpWndClass->lpszMenuName  = wcex.lpszMenuName;
        lpWndClass->lpszClassName = wcex.lpszClassName;
    }
    return retval;
}

GetClassLongA()

DWORD WINAPI GetClassLongA	(	HWND	hWnd,
		int	nIndex
	)

Definition at line 805 of file class.c.

{
    PWND Wnd;
    PCLS Class;
    ULONG_PTR Ret = 0;
 
    TRACE("%p %d\n", hWnd, nIndex);
 
    Wnd = ValidateHwnd(hWnd);
    if (!Wnd)
        return 0;
 
    _SEH2_TRY
    {
        Class = DesktopPtrToUser(Wnd->pcls);
        if (Class != NULL)
        {
#ifdef _WIN64
            switch (nIndex)
            {
                case GCLP_HBRBACKGROUND:
                case GCLP_HCURSOR:
                case GCLP_HICON:
                case GCLP_HICONSM:
                case GCLP_HMODULE:
                case GCLP_MENUNAME:
                case GCLP_WNDPROC:
                    SetLastError(ERROR_INVALID_INDEX);
                    break;
 
                default:
                    Ret = IntGetClassLongA(Wnd, Class, nIndex);
                    break;
            }
#else
            Ret = IntGetClassLongA(Wnd, Class, nIndex);
#endif
        }
        else
        {
            WARN("Invalid class for hwnd 0x%p!\n", hWnd);
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Ret = 0;
    }
    _SEH2_END;
 
    return (DWORD)Ret;
}

Referenced by GetClassWord().

GetClassLongW()

DWORD WINAPI GetClassLongW	(	HWND	hWnd,
		int	nIndex
	)

Definition at line 861 of file class.c.

{
    PWND Wnd;
    PCLS Class;
    ULONG_PTR Ret = 0;
 
    TRACE("%p %d\n", hWnd, nIndex);
 
    Wnd = ValidateHwnd(hWnd);
    if (!Wnd)
        return 0;
 
    _SEH2_TRY
    {
        Class = DesktopPtrToUser(Wnd->pcls);
        if (Class != NULL)
        {
#ifdef _WIN64
            switch (nIndex)
            {
                case GCLP_HBRBACKGROUND:
                case GCLP_HCURSOR:
                case GCLP_HICON:
                case GCLP_HICONSM:
                case GCLP_HMODULE:
                case GCLP_MENUNAME:
                case GCLP_WNDPROC:
                    SetLastError(ERROR_INVALID_INDEX);
                    break;
 
                default:
                    Ret = IntGetClassLongW(Wnd, Class, nIndex);
                    break;
            }
#else
            Ret = IntGetClassLongW(Wnd, Class, nIndex);
#endif
        }
        else
        {
            WARN("Invalid class for hwnd 0x%p!\n", hWnd);
        }
    }
    _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
    {
        Ret = 0;
    }
    _SEH2_END;
 
    return (DWORD)Ret;
}

GetClassNameA()

int WINAPI GetClassNameA	(	HWND	hWnd,
		LPSTR	lpClassName,
		int	nMaxCount
	)

Definition at line 998 of file class.c.

{
    WCHAR tmpbuf[MAX_ATOM_LEN + 1];
    int len;
 
    if (nMaxCount <= 0) return 0;
    if (!GetClassNameW( hWnd, tmpbuf, sizeof(tmpbuf)/sizeof(WCHAR) )) return 0;
    RtlUnicodeToMultiByteN( lpClassName, nMaxCount - 1, (PULONG)&len, tmpbuf, strlenW(tmpbuf) * sizeof(WCHAR) );
    lpClassName[len] = 0;
 
    TRACE("%p class/atom: %s/%04x %x\n", hWnd,
        IS_ATOM(lpClassName) ? NULL : lpClassName,
        IS_ATOM(lpClassName) ? lpClassName : 0,
        nMaxCount);
 
    return len;
}

GetClassNameW()

int WINAPI GetClassNameW	(	HWND	hWnd,
		LPWSTR	lpClassName,
		int	nMaxCount
	)

Definition at line 1025 of file class.c.

{
    UNICODE_STRING ClassName;
    int Result;
 
    RtlInitEmptyUnicodeString(&ClassName,
                              lpClassName,
                              nMaxCount * sizeof(WCHAR));
 
    Result = NtUserGetClassName(hWnd,
                                FALSE,
                                &ClassName);
 
    TRACE("%p class/atom: %S/%04x %x\n", hWnd,
        IS_ATOM(lpClassName) ? NULL : lpClassName,
        IS_ATOM(lpClassName) ? lpClassName : 0,
        nMaxCount);
 
    return Result;
}

GetClassWord()

WORD WINAPI GetClassWord	(	HWND	hwnd,
		int	offset
	)

Definition at line 1055 of file class.c.

{
    PWND Wnd;
    PCLS class;
    WORD retvalue = 0;
 
    if (offset < 0) return GetClassLongA( hwnd, offset );
 
    Wnd = ValidateHwnd(hwnd);
    if (!Wnd)
        return 0;
 
    class = DesktopPtrToUser(Wnd->pcls);
    if (class == NULL) return 0;
 
    if (offset <= class->cbclsExtra - sizeof(WORD))
        memcpy( &retvalue, (char *)(class + 1) + offset, sizeof(retvalue) );
    else
        SetLastError( ERROR_INVALID_INDEX );
 
    return retvalue;
}

GetWindowLongA()

LONG WINAPI GetWindowLongA	(	HWND	hWnd,
		int	nIndex
	)

Definition at line 1156 of file class.c.

{
    return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), FALSE );
}

GetWindowLongW()

LONG WINAPI GetWindowLongW	(	HWND	hWnd,
		int	nIndex
	)

Definition at line 1166 of file class.c.

{
    return IntGetWindowLong( hWnd, nIndex, sizeof(LONG), TRUE );
}

GetWindowWord()

WORD WINAPI GetWindowWord	(	HWND	hWnd,
		int	nIndex
	)

Definition at line 1201 of file class.c.

{
    switch(nIndex)
    {
    case GWLP_ID:
    case GWLP_HINSTANCE:
    case GWLP_HWNDPARENT:
        break;
    default:
        if (nIndex < 0)
        {
            WARN("Invalid offset %d\n", nIndex );
            SetLastError( ERROR_INVALID_INDEX );
            return 0;
        }
        break;
    }
    return IntGetWindowLong( hWnd, nIndex, sizeof(WORD), FALSE );
}

IntGetClassLongA()

static ULONG_PTR FASTCALL IntGetClassLongA ( PWND  Wnd, PCLS  Class, int  nIndex  )

static

Definition at line 653 of file class.c.

{
    ULONG_PTR Ret = 0;
 
    if (nIndex >= 0)
    {
        if (nIndex + sizeof(ULONG_PTR) < nIndex ||
            nIndex + sizeof(ULONG_PTR) > Class->cbclsExtra)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
        }
        else
            Ret = *(PULONG_PTR)((ULONG_PTR)(Class + 1) + nIndex);
    }
    else
    {
        switch (nIndex)
        {
            case GCL_CBWNDEXTRA:
                Ret = (ULONG_PTR)Class->cbwndExtra;
                break;
 
            case GCL_CBCLSEXTRA:
                Ret = (ULONG_PTR)Class->cbclsExtra;
                break;
 
            case GCL_HBRBACKGROUND:
                Ret = (ULONG_PTR)Class->hbrBackground;
                if (Ret != 0 && Ret < 0x4000)
                    Ret = (ULONG_PTR)GetSysColorBrush((ULONG)Ret - 1);
                break;
 
            case GCL_HMODULE:
                //ERR("Cls 0x%x GCL_HMODULE 0x%x\n", Wnd->pcls, Class->hModule);
                Ret = (ULONG_PTR)Class->hModule;
                break;
 
            case GCL_MENUNAME:
                Ret = (ULONG_PTR)Class->lpszClientAnsiMenuName;
                break;
 
            case GCL_STYLE:
                Ret = (ULONG_PTR)Class->style;
                break;
 
            case GCW_ATOM:
                Ret = (ULONG_PTR)Class->atomNVClassName;
                break;
 
            case GCLP_HCURSOR:
                Ret = Class->spcur ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spcur))->h : 0;
                break;
 
            case GCLP_HICON:
                Ret = Class->spicn ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spicn))->h : 0;
                break;
 
            case GCLP_HICONSM:
                Ret = Class->spicnSm ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spicnSm))->h : 0;
                break;
 
            case GCLP_WNDPROC:
                Ret = IntGetClsWndProc(Wnd, Class, TRUE);
                break;
 
            default:
                SetLastError(ERROR_INVALID_INDEX);
                break;
        }
    }
 
    return Ret;
}

Referenced by GetClassLongA().

IntGetClassLongW()

static ULONG_PTR FASTCALL IntGetClassLongW ( PWND  Wnd, PCLS  Class, int  nIndex  )

static

Definition at line 728 of file class.c.

{
    ULONG_PTR Ret = 0;
 
    if (nIndex >= 0)
    {
        if (nIndex + sizeof(ULONG_PTR) < nIndex ||
            nIndex + sizeof(ULONG_PTR) > Class->cbclsExtra)
        {
            SetLastError(ERROR_INVALID_PARAMETER);
        }
        else
            Ret = *(PULONG_PTR)((ULONG_PTR)(Class + 1) + nIndex);
    }
    else
    {
        switch (nIndex)
        {
            case GCL_CBWNDEXTRA:
                Ret = (ULONG_PTR)Class->cbwndExtra;
                break;
 
            case GCL_CBCLSEXTRA:
                Ret = (ULONG_PTR)Class->cbclsExtra;
                break;
 
            case GCLP_HBRBACKGROUND:
                Ret = (ULONG_PTR)Class->hbrBackground;
                if (Ret != 0 && Ret < 0x4000)
                    Ret = (ULONG_PTR)GetSysColorBrush((ULONG)Ret - 1);
                break;
 
            case GCL_HMODULE:
                Ret = (ULONG_PTR)Class->hModule;
                break;
 
            case GCLP_MENUNAME:
                Ret = (ULONG_PTR)Class->lpszClientUnicodeMenuName;
                break;
 
            case GCL_STYLE:
                Ret = (ULONG_PTR)Class->style;
                break;
 
            case GCW_ATOM:
                Ret = (ULONG_PTR)Class->atomNVClassName;
                break;
 
            case GCLP_HCURSOR:
                Ret = Class->spcur ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spcur))->h : 0;
                break;
 
            case GCLP_HICON:
                Ret = Class->spicn ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spicn))->h : 0;
                break;
 
            case GCLP_HICONSM:
                Ret = Class->spicnSm ? (ULONG_PTR)((PPROCMARKHEAD)SharedPtrToUser(Class->spicnSm))->h : 0;
                break;
 
            case GCLP_WNDPROC:
                Ret = IntGetClsWndProc(Wnd, Class, FALSE);
                break;
 
            default:
                SetLastError(ERROR_INVALID_INDEX);
                break;
        }
    }
 
    return Ret;
}

Referenced by GetClassLongW().

IntGetClsWndProc()

ULONG_PTR FASTCALL IntGetClsWndProc	(	PWND	pWnd,
		PCLS	Class,
		BOOL	Ansi
	)

Definition at line 536 of file class.c.

{
    INT i;
    ULONG_PTR gcpd, Ret = 0;
 // If server side, sweep through proc list and return the client side proc.
    if (Class->CSF_flags & CSF_SERVERSIDEPROC)
    {  // Always scan through the list due to wine class "deftest".
        for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
        {
            if (GETPFNSERVER(i) == Class->lpfnWndProc)
            {
                if (Ansi)
                    Ret = (ULONG_PTR)GETPFNCLIENTA(i);
                else
                    Ret = (ULONG_PTR)GETPFNCLIENTW(i);
            }
        }
         return Ret;
    }
    // Set return proc.
    Ret = (ULONG_PTR)Class->lpfnWndProc;
    // Return the proc if one of the FnId default class type.
    if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
    {
        if (Ansi)
        { // If match return the right proc by type.
            if (GETPFNCLIENTW(Class->fnid) == Class->lpfnWndProc)
                Ret = (ULONG_PTR)GETPFNCLIENTA(Class->fnid);
        }
        else
        {
            if (GETPFNCLIENTA(Class->fnid) == Class->lpfnWndProc)
               Ret = (ULONG_PTR)GETPFNCLIENTW(Class->fnid);
        }
    }
    // Return on change or Ansi/Unicode proc equal.
    if ( Ret != (ULONG_PTR)Class->lpfnWndProc ||
         Ansi == !!(Class->CSF_flags & CSF_ANSIPROC) )
        return Ret;
 
    /* We have an Ansi and Unicode swap! If Ansi create Unicode proc handle.
       This will force CallWindowProc to deal with it. */
    gcpd = NtUserGetCPD( UserHMGetHandle(pWnd),
                         (Ansi ? UserGetCPDA2U : UserGetCPDU2A )|UserGetCPDWndtoCls,
                         Ret);
 
    return (gcpd ? gcpd : Ret);
}

Referenced by IntGetClassLongA(), and IntGetClassLongW().

IntGetWindowLong()

LONG_PTR IntGetWindowLong	(	HWND	hwnd,
		INT	offset,
		UINT	size,
		BOOL	unicode
	)

Definition at line 1081 of file class.c.

{
    LONG_PTR retvalue = 0;
    WND *wndPtr;
 
    if (offset == GWLP_HWNDPARENT)
    {
        HWND parent = GetAncestor( hwnd, GA_PARENT );
        if (parent == GetDesktopWindow()) parent = GetWindow( hwnd, GW_OWNER );
        return (ULONG_PTR)parent;
    }
 
    if (!(wndPtr = ValidateHwnd( hwnd )))
    {
        SetLastError( ERROR_INVALID_WINDOW_HANDLE );
        return 0;
    }
 
    if (offset >= 0 && wndPtr->fnid != FNID_DESKTOP)
    {
        if (offset > (int)(wndPtr->cbwndExtra - size))
        {
            WARN("Invalid offset %d\n", offset );
            SetLastError( ERROR_INVALID_INDEX );
            return 0;
        }
        retvalue = *((LONG_PTR *)((PCHAR)(wndPtr + 1) + offset));
 
        /* WINE: special case for dialog window procedure */
        //if ((offset == DWLP_DLGPROC) && (size == sizeof(LONG_PTR)) && (wndPtr->flags & WIN_ISDIALOG))
        //    retvalue = (LONG_PTR)IntGetWndProc( (WNDPROC)retvalue, unicode );
        return retvalue;
    }
 
    switch(offset)
    {
    case GWLP_USERDATA:  retvalue = wndPtr->dwUserData; break;
    case GWL_STYLE:      retvalue = wndPtr->style; break;
    case GWL_EXSTYLE:    retvalue = wndPtr->ExStyle; break;
    case GWLP_ID:        retvalue = wndPtr->IDMenu; break;
    case GWLP_HINSTANCE: retvalue = (ULONG_PTR)wndPtr->hModule; break;
#if 0
    /* -1 is an undocumented case which returns WW* */
    /* source: http://www.geoffchappell.com/studies/windows/win32/user32/structs/wnd/index.htm*/
    case -1:             retvalue = (ULONG_PTR)&wndPtr->ww; break;
#else
    /* We don't have a WW but WND already contains the same fields in the right order, */
    /* so we can return a pointer to its first field */
    case -1:             retvalue = (ULONG_PTR)&wndPtr->state; break;
#endif
    case GWLP_WNDPROC:
    {
        if (!TestWindowProcess(wndPtr))
        {
            SetLastError(ERROR_ACCESS_DENIED);
            retvalue = 0;
            ERR("Outside Access and Denied!\n");
            break;
        }
        retvalue = (ULONG_PTR)IntGetWndProc(wndPtr, !unicode);
        break;
    }
    default:
        WARN("Unknown offset %d\n", offset );
        SetLastError( ERROR_INVALID_INDEX );
        break;
    }
    return retvalue;
 
}

Referenced by GetWindowLongA(), GetWindowLongW(), and GetWindowWord().

IntGetWndProc()

WNDPROC FASTCALL IntGetWndProc	(	PWND	pWnd,
		BOOL	Ansi
	)

Definition at line 589 of file class.c.

{
    INT i;
    WNDPROC gcpd, Ret = 0;
    PCLS Class = DesktopPtrToUser(pWnd->pcls);
 
    if (!Class) return Ret;
 
    if (pWnd->state & WNDS_SERVERSIDEWINDOWPROC)
    {
        for ( i = FNID_FIRST; i <= FNID_SWITCH; i++)
        {
            if (GETPFNSERVER(i) == pWnd->lpfnWndProc)
            {
                if (Ansi)
                    Ret = GETPFNCLIENTA(i);
                else
                    Ret = GETPFNCLIENTW(i);
            }
        }
        return Ret;
    }
    // Wine Class tests:
    /*  Edit controls are special - they return a wndproc handle when
        GetWindowLongPtr is called with a different A/W.
        On the other hand there is no W->A->W conversion so this control
        is treated specially.
     */
    if (Class->fnid == FNID_EDIT)
        Ret = pWnd->lpfnWndProc;
    else
    {
        // Set return proc.
        Ret = pWnd->lpfnWndProc;
 
        if (Class->fnid <= FNID_GHOST && Class->fnid >= FNID_BUTTON)
        {
            if (Ansi)
            {
                if (GETPFNCLIENTW(Class->fnid) == pWnd->lpfnWndProc)
                    Ret = GETPFNCLIENTA(Class->fnid);
            }
            else
            {
                if (GETPFNCLIENTA(Class->fnid) == pWnd->lpfnWndProc)
                    Ret = GETPFNCLIENTW(Class->fnid);
            }
        }
        // Return on the change.
        if ( Ret != pWnd->lpfnWndProc)
            return Ret;
    }
 
    if ( Ansi == !!(pWnd->state & WNDS_ANSIWINDOWPROC) )
        return Ret;
 
    gcpd = (WNDPROC)NtUserGetCPD( UserHMGetHandle(pWnd),
                                  (Ansi ? UserGetCPDA2U : UserGetCPDU2A )|UserGetCPDWindow,
                                  (ULONG_PTR)Ret);
 
    return (gcpd ? gcpd : Ret);
}

Referenced by IntGetWindowLong().

is_comctl32_class()

LPCWSTR is_comctl32_class

(

const WCHAR *

name

)

Definition at line 46 of file class.c.

{
    static const WCHAR classesW[][20] =
    {
        {'C','o','m','b','o','B','o','x','E','x','3','2',0},
        {'m','s','c','t','l','s','_','h','o','t','k','e','y','3','2',0},
        {'m','s','c','t','l','s','_','p','r','o','g','r','e','s','s','3','2',0},
        {'m','s','c','t','l','s','_','s','t','a','t','u','s','b','a','r','3','2',0},
        {'m','s','c','t','l','s','_','t','r','a','c','k','b','a','r','3','2',0},
        {'m','s','c','t','l','s','_','u','p','d','o','w','n','3','2',0},
        {'N','a','t','i','v','e','F','o','n','t','C','t','l',0},
        {'R','e','B','a','r','W','i','n','d','o','w','3','2',0},
        {'S','y','s','A','n','i','m','a','t','e','3','2',0},
        {'S','y','s','D','a','t','e','T','i','m','e','P','i','c','k','3','2',0},
        {'S','y','s','H','e','a','d','e','r','3','2',0},
        {'S','y','s','I','P','A','d','d','r','e','s','s','3','2',0},
        {'S','y','s','L','i','s','t','V','i','e','w','3','2',0},
        {'S','y','s','M','o','n','t','h','C','a','l','3','2',0},
        {'S','y','s','P','a','g','e','r',0},
        {'S','y','s','T','a','b','C','o','n','t','r','o','l','3','2',0},
        {'S','y','s','T','r','e','e','V','i','e','w','3','2',0},
        {'T','o','o','l','b','a','r','W','i','n','d','o','w','3','2',0},
        {'t','o','o','l','t','i','p','s','_','c','l','a','s','s','3','2',0},
    };
 
    int min = 0, max = (sizeof(classesW) / sizeof(classesW[0])) - 1;
 
    while (min <= max)
    {
        int res, pos = (min + max) / 2;
        if (!(res = strcmpiW( name, classesW[pos] ))) return classesW[pos];
        if (res < 0) max = pos - 1;
        else min = pos + 1;
    }
    return NULL;
}

Referenced by ClassNameToVersion().

RealGetWindowClassA()

UINT WINAPI RealGetWindowClassA	(	HWND	hwnd,
		LPSTR	pszType,
		UINT	cchType
	)

Definition at line 1246 of file class.c.

{
    WCHAR tmpbuf[MAX_ATOM_LEN + 1];
    UINT len;
 
    if ((INT)cchType <= 0) return 0;
    if (!RealGetWindowClassW( hwnd, tmpbuf, sizeof(tmpbuf)/sizeof(WCHAR) )) return 0;
    RtlUnicodeToMultiByteN( pszType, cchType - 1, (PULONG)&len, tmpbuf, strlenW(tmpbuf) * sizeof(WCHAR) );
    pszType[len] = 0;
    return len;
}

RealGetWindowClassW()

UINT WINAPI RealGetWindowClassW	(	HWND	hwnd,
		LPWSTR	pszType,
		UINT	cchType
	)

Definition at line 1226 of file class.c.

{
    UNICODE_STRING ClassName;
 
    RtlInitEmptyUnicodeString(&ClassName,
                              pszType,
                              cchType * sizeof(WCHAR));
 
    return NtUserGetClassName(hwnd,TRUE,&ClassName);
}

Referenced by RealGetWindowClassA().

RegisterClassA()

ATOM WINAPI RegisterClassA

(

CONST WNDCLASSA *

lpWndClass

)

Definition at line 1593 of file class.c.

{
    WNDCLASSEXA Class;
 
    if (lpWndClass == NULL)
        return 0;
 
    /* These MUST be copied manually, since on 64 bit architectures the
       alignment of the members is different between the 2 structs! */
    Class.style = lpWndClass->style;
    Class.lpfnWndProc = lpWndClass->lpfnWndProc;
    Class.cbClsExtra = lpWndClass->cbClsExtra;
    Class.cbWndExtra = lpWndClass->cbWndExtra;
    Class.hInstance = lpWndClass->hInstance;
    Class.hIcon = lpWndClass->hIcon;
    Class.hCursor = lpWndClass->hCursor;
    Class.hbrBackground = lpWndClass->hbrBackground;
    Class.lpszMenuName = lpWndClass->lpszMenuName;
    Class.lpszClassName = lpWndClass->lpszClassName;
 
    Class.cbSize = sizeof(WNDCLASSEXA);
    Class.hIconSm = NULL;
 
    return RegisterClassExA(&Class);
}

RegisterClassExA()

ATOM WINAPI RegisterClassExA

(

CONST WNDCLASSEXA *

lpwcx

)

Definition at line 1530 of file class.c.

{
    RTL_ATOM Atom;
    WNDCLASSEXW WndClass;
    WCHAR mname[MAX_BUFFER_LEN];
    WCHAR cname[MAX_BUFFER_LEN];
 
    RtlCopyMemory(&WndClass, lpwcx, sizeof(WNDCLASSEXA));
 
    if (WndClass.lpszMenuName != NULL)
    {
        if (!IS_INTRESOURCE(WndClass.lpszMenuName))
        {
            if (WndClass.lpszMenuName[0])
            {
                if (!MultiByteToWideChar( CP_ACP, 0, lpwcx->lpszMenuName, -1, mname, MAX_ATOM_LEN + 1 )) return 0;
 
                WndClass.lpszMenuName = mname;
            }
        }
    }
 
    if (!IS_ATOM(WndClass.lpszClassName))
    {
        if (!MultiByteToWideChar( CP_ACP, 0, lpwcx->lpszClassName, -1, cname, MAX_ATOM_LEN + 1 )) return 0;
 
        WndClass.lpszClassName = cname;
    }
 
    Atom = RegisterClassExWOWW( &WndClass,
                                0,
                                0,
                                CSF_ANSIPROC,
                                TRUE);
 
    TRACE("A 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)Atom;
}

RegisterClassExW()

ATOM WINAPI RegisterClassExW

(

CONST WNDCLASSEXW *

lpwcx

)

Definition at line 1576 of file class.c.

{
    ATOM Atom;
 
    Atom = RegisterClassExWOWW( (WNDCLASSEXW *)lpwcx, 0, 0, 0, TRUE);
 
    TRACE("W atom=%04x wndproc=%p hinst=%p bg=%p style=%08x clsExt=%d winExt=%d\n",
          Atom, lpwcx->lpfnWndProc, lpwcx->hInstance, lpwcx->hbrBackground,
          lpwcx->style, lpwcx->cbClsExtra, lpwcx->cbWndExtra);
 
    return Atom;
}

RegisterClassExWOWW()

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

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().

RegisterClassW()

ATOM WINAPI RegisterClassW

(

CONST WNDCLASSW *

lpWndClass

)

Definition at line 1623 of file class.c.

{
    WNDCLASSEXW Class;
 
    if (lpWndClass == NULL)
        return 0;
 
    /* These MUST be copied manually, since on 64 bit architectures the
       alignment of the members is different between the 2 structs! */
    Class.style = lpWndClass->style;
    Class.lpfnWndProc = lpWndClass->lpfnWndProc;
    Class.cbClsExtra = lpWndClass->cbClsExtra;
    Class.cbWndExtra = lpWndClass->cbWndExtra;
    Class.hInstance = lpWndClass->hInstance;
    Class.hIcon = lpWndClass->hIcon;
    Class.hCursor = lpWndClass->hCursor;
    Class.hbrBackground = lpWndClass->hbrBackground;
    Class.lpszMenuName = lpWndClass->lpszMenuName;
    Class.lpszClassName = lpWndClass->lpszClassName;
 
    Class.cbSize = sizeof(WNDCLASSEXW);
    Class.hIconSm = NULL;
 
    return RegisterClassExW(&Class);
}

SetClassLongA()

DWORD WINAPI SetClassLongA	(	HWND	hWnd,
		int	nIndex,
		LONG	dwNewLong
	)

Definition at line 1654 of file class.c.

{
    PSTR lpStr = (PSTR)(ULONG_PTR)dwNewLong;
    UNICODE_STRING Value = {0};
    BOOL Allocated = FALSE;
    DWORD Ret;
 
    /* FIXME - portability!!!! */
 
    if (nIndex == GCL_MENUNAME && lpStr != NULL)
    {
        if (!IS_INTRESOURCE(lpStr))
        {
            if (!RtlCreateUnicodeStringFromAsciiz(&Value,
                                                  lpStr))
            {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return 0;
            }
 
            Allocated = TRUE;
        }
        else
            Value.Buffer = (PWSTR)lpStr;
 
        dwNewLong = (LONG_PTR)&Value;
    }
    else if (nIndex == GCW_ATOM && lpStr != NULL)
    {
        if (!IS_ATOM(lpStr))
        {
            if (!RtlCreateUnicodeStringFromAsciiz(&Value,
                                                  lpStr))
            {
                SetLastError(ERROR_NOT_ENOUGH_MEMORY);
                return 0;
            }
 
            Allocated = TRUE;
        }
        else
            Value.Buffer = (PWSTR)lpStr;
 
        dwNewLong = (LONG_PTR)&Value;
    }
 
    Ret = (DWORD)NtUserSetClassLong(hWnd,
                                    nIndex,
                                    dwNewLong,
                                    TRUE);
 
    if (Allocated)
    {
        RtlFreeUnicodeString(&Value);
    }
 
    return Ret;
}

SetClassLongW()

DWORD WINAPI SetClassLongW	(	HWND	hWnd,
		int	nIndex,
		LONG	dwNewLong
	)

Definition at line 1721 of file class.c.

{
    PWSTR lpStr = (PWSTR)(ULONG_PTR)dwNewLong;
    UNICODE_STRING Value = {0};
 
    TRACE("%p %d %lx\n", hWnd, nIndex, dwNewLong);
 
    /* FIXME - portability!!!! */
 
    if (nIndex == GCL_MENUNAME && lpStr != NULL)
    {
        if (!IS_INTRESOURCE(lpStr))
        {
            RtlInitUnicodeString(&Value,
                                 lpStr);
        }
        else
            Value.Buffer = lpStr;
 
        dwNewLong = (LONG_PTR)&Value;
    }
    else if (nIndex == GCW_ATOM && lpStr != NULL)
    {
        if (!IS_ATOM(lpStr))
        {
            RtlInitUnicodeString(&Value,
                                 lpStr);
        }
        else
            Value.Buffer = lpStr;
 
        dwNewLong = (LONG_PTR)&Value;
    }
 
    return (DWORD)NtUserSetClassLong(hWnd,
                                     nIndex,
                                     dwNewLong,
                                     FALSE);
}

SetClassWord()

WORD WINAPI SetClassWord	(	HWND	hWnd,
		int	nIndex,
		WORD	wNewWord
	)

Definition at line 1796 of file class.c.

{
    if ((nIndex < 0) && (nIndex != GCW_ATOM))
        return 0;
 
    return (WORD) SetClassLongW ( hWnd, nIndex, wNewWord );
}

SetWindowLongA()

LONG WINAPI DECLSPEC_HOTPATCH SetWindowLongA	(	HWND	hWnd,
		int	nIndex,
		LONG	dwNewLong
	)

Definition at line 1841 of file class.c.

{
    return (LONG)NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, TRUE);
}

SetWindowLongW()

LONG WINAPI SetWindowLongW	(	HWND	hWnd,
		int	nIndex,
		LONG	dwNewLong
	)

Definition at line 1854 of file class.c.

{
    return (LONG)NtUserSetWindowLongPtr(hWnd, nIndex, dwNewLong, FALSE);
}

SetWindowWord()

WORD WINAPI SetWindowWord	(	HWND	hWnd,
		int	nIndex,
		WORD	wNewWord
	)

Definition at line 1815 of file class.c.

{
    switch(nIndex)
    {
    case GWLP_ID:
    case GWLP_HINSTANCE:
    case GWLP_HWNDPARENT:
        break;
    default:
        if (nIndex < 0)
        {
            WARN("Invalid offset %d\n", nIndex );
            SetLastError( ERROR_INVALID_INDEX );
            return 0;
        }
        break;
    }
    return (WORD)NtUserSetWindowLongPtr(hWnd, nIndex, wNewWord, FALSE);
}

UnregisterClassA()

BOOL WINAPI UnregisterClassA	(	LPCSTR	lpClassName,
		HINSTANCE	hInstance
	)

Definition at line 1893 of file class.c.

{
    UNICODE_STRING ClassName = {0};
    BOOL Ret;
    LPCWSTR lpszClsVersion;
    BOOL ConvertedString = FALSE;
 
    TRACE("class/atom: %s/%04x %p\n",
        IS_ATOM(lpClassName) ? NULL : lpClassName,
        IS_ATOM(lpClassName) ? lpClassName : 0,
        hInstance);
 
    lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, TRUE);
    if (lpszClsVersion)
    {
        RtlInitUnicodeString(&ClassName, lpszClsVersion);
    }
    else if (!IS_ATOM(lpClassName))
    {
        ConvertedString = TRUE;
        if (!RtlCreateUnicodeStringFromAsciiz(&ClassName, lpClassName))
        {
            SetLastError(ERROR_NOT_ENOUGH_MEMORY);
            return 0;
        }
    }
    else
    {
        ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
    }
 
    Ret = NtUserUnregisterClass(&ClassName, hInstance, 0);
 
    if (ConvertedString)
        RtlFreeUnicodeString(&ClassName);
 
    return Ret;
}

UnregisterClassW()

BOOL WINAPI UnregisterClassW	(	LPCWSTR	lpClassName,
		HINSTANCE	hInstance
	)

Definition at line 1940 of file class.c.

{
    UNICODE_STRING ClassName = {0};
    LPCWSTR lpszClsVersion;
 
    TRACE("class/atom: %S/%04x %p\n",
        IS_ATOM(lpClassName) ? NULL : lpClassName,
        IS_ATOM(lpClassName) ? lpClassName : 0,
        hInstance);
 
    lpszClsVersion = ClassNameToVersion(lpClassName, NULL, NULL, NULL, FALSE);
    if (lpszClsVersion)
    {
        RtlInitUnicodeString(&ClassName, lpszClsVersion);
    }
    else if (!IS_ATOM(lpClassName))
    {
        RtlInitUnicodeString(&ClassName, lpClassName);
    }
    else
    {
        ClassName.Buffer = (PWSTR)((ULONG_PTR)lpClassName);
    }
 
    return NtUserUnregisterClass(&ClassName, hInstance, 0);
}

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

Referenced by GetClassInfoExA(), GetClassInfoExW(), and User32CreateWindowEx().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

user32

)