subclass.c File Reference

#include <assert.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "wingdi.h"
#include "winuser.h"
#include "commctrl.h"
#include "wine/heap.h"
#include "wine/test.h"

Include dependency graph for subclass.c:

Go to the source code of this file.

Classes
struct	message

Macros
#define	_WIN32_WINNT   0x0501 /* For SetWindowSubclass/etc */
#define	SEND_NEST   0x01
#define	DELETE_SELF   0x02
#define	DELETE_PREV   0x04
#define	MAKEFUNC_ORD(f, ord)   (p##f = (void*)GetProcAddress(hmod, (LPSTR)(ord)))
#define	TESTNAMED(f)

Functions
static	BOOL (WINAPI *pSetWindowSubclass)(HWND
static	LRESULT (WINAPI *pDefSubclassProc)(HWND
static void	add_message (const struct message *msg)
static void	flush_sequence (void)
static void	ok_sequence (const struct message *expected, const char *context)
static LRESULT WINAPI	wnd_proc_1 (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
static LRESULT WINAPI	wnd_proc_3 (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
static LRESULT WINAPI	wnd_proc_sub (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam, UINT_PTR uldSubclass, DWORD_PTR dwRefData)
static void	test_subclass (void)
static BOOL	register_window_classes (void)
static BOOL	init_function_pointers (void)
	START_TEST (subclass)

Variables
static	SUBCLASSPROC
static	UINT_PTR
static	DWORD_PTR
static	UINT
static	WPARAM
static	LPARAM
static int	sequence_cnt
static int	sequence_size
static struct message *	sequence
static const struct message	Sub_BasicTest []
static const struct message	Sub_DeletedTest []
static const struct message	Sub_AfterDeletedTest []
static const struct message	Sub_OldAfterNewTest []
static const struct message	Sub_MixTest []
static const struct message	Sub_MixAndNestTest []
static const struct message	Sub_MixNestDelTest []
static const struct message	Sub_MixDelPrevTest []
static WNDPROC	orig_proc_3

Macro Definition Documentation

_WIN32_WINNT

#define _WIN32_WINNT   0x0501 /* For SetWindowSubclass/etc */

Definition at line 20 of file subclass.c.

DELETE_PREV

#define DELETE_PREV   0x04

Definition at line 40 of file subclass.c.

DELETE_SELF

#define DELETE_SELF   0x02

Definition at line 39 of file subclass.c.

MAKEFUNC_ORD

#define MAKEFUNC_ORD	(		f,
			ord
	)		(p##f = (void*)GetProcAddress(hmod, (LPSTR)(ord)))

SEND_NEST

#define SEND_NEST   0x01

Definition at line 38 of file subclass.c.

TESTNAMED

#define TESTNAMED

(

f

)

Value:

    ptr = (void*)GetProcAddress(hmod, #f); \
    ok(ptr != 0, "expected named export for " #f "\n");

Function Documentation

add_message()

static void add_message ( const struct message *  msg )

static

Definition at line 118 of file subclass.c.

{
    if (!sequence)
    {
        sequence_size = 10;
        sequence = heap_alloc( sequence_size * sizeof (struct message) );
    }
    if (sequence_cnt == sequence_size)
    {
        sequence_size *= 2;
        sequence = heap_realloc( sequence, sequence_size * sizeof (struct message) );
    }
    assert(sequence);
 
    sequence[sequence_cnt].wParam  = msg->wParam;
    sequence[sequence_cnt].procnum = msg->procnum;
 
    sequence_cnt++;
}

BOOL()

static BOOL ( WINAPI *  pSetWindowSubclass )

static

flush_sequence()

static void flush_sequence ( void  )

static

Definition at line 138 of file subclass.c.

{
    heap_free(sequence);
    sequence = NULL;
    sequence_cnt = sequence_size = 0;
}

Referenced by ok_sequence().

init_function_pointers()

static BOOL init_function_pointers ( void  )

static

Definition at line 303 of file subclass.c.

{
    HMODULE hmod;
    void *ptr;
 
    hmod = LoadLibraryA("comctl32.dll");
    ok(hmod != NULL, "got %p\n", hmod);
 
    /* Functions have to be loaded by ordinal. Only XP and W2K3 export
     * them by name.
     */
#define MAKEFUNC_ORD(f, ord) (p##f = (void*)GetProcAddress(hmod, (LPSTR)(ord)))
    MAKEFUNC_ORD(SetWindowSubclass, 410);
    MAKEFUNC_ORD(RemoveWindowSubclass, 412);
    MAKEFUNC_ORD(DefSubclassProc, 413);
#undef MAKEFUNC_ORD
 
    if(!pSetWindowSubclass || !pRemoveWindowSubclass || !pDefSubclassProc)
    {
        win_skip("SetWindowSubclass and friends are not available\n");
        return FALSE;
    }
 
    /* test named exports */
    ptr = GetProcAddress(hmod, "SetWindowSubclass");
    ok(broken(ptr == 0) || ptr != 0, "expected named export for SetWindowSubclass\n");
    if(ptr)
    {
#define TESTNAMED(f) \
    ptr = (void*)GetProcAddress(hmod, #f); \
    ok(ptr != 0, "expected named export for " #f "\n");
        TESTNAMED(RemoveWindowSubclass);
        TESTNAMED(DefSubclassProc);
        /* GetWindowSubclass exported for V6 only */
#undef TESTNAMED
    }
 
    return TRUE;
}

Referenced by START_TEST().

LRESULT()

static LRESULT ( WINAPI *  pDefSubclassProc )

static

ok_sequence()

static void ok_sequence ( const struct message *  expected, const char *  context  )

static

Definition at line 145 of file subclass.c.

{
    static const struct message end_of_sequence = { 0, 0 };
    const struct message *actual;
 
    add_message(&end_of_sequence);
 
    actual = sequence;
 
    while(expected->procnum && actual->procnum)
    {
        ok(expected->procnum == actual->procnum,
            "%s: the procnum %d was expected, but got procnum %d instead\n",
            context, expected->procnum, actual->procnum);
        ok(expected->wParam == actual->wParam,
            "%s: in procnum %d expecting wParam 0x%lx got 0x%lx\n",
            context, expected->procnum, expected->wParam, actual->wParam);
        expected++;
        actual++;
    }
    ok(!expected->procnum, "Received fewer messages than expected\n");
    ok(!actual->procnum, "Received more messages than expected\n");
    flush_sequence();
}

register_window_classes()

static BOOL register_window_classes ( void  )

static

Definition at line 282 of file subclass.c.

{
    WNDCLASSA cls;
    ATOM atom;
 
    cls.style = 0;
    cls.lpfnWndProc = wnd_proc_1;
    cls.cbClsExtra = 0;
    cls.cbWndExtra = 0;
    cls.hInstance = GetModuleHandleA(0);
    cls.hIcon = 0;
    cls.hCursor = NULL;
    cls.hbrBackground = NULL;
    cls.lpszMenuName = NULL;
    cls.lpszClassName = "TestSubclass";
    atom = RegisterClassA(&cls);
    ok(atom, "failed to register test class\n");
 
    return atom != 0;
}

Referenced by START_TEST().

START_TEST()

START_TEST

(

subclass

)

Definition at line 343 of file subclass.c.

{
    if(!init_function_pointers()) return;
 
    if(!register_window_classes()) return;
 
    test_subclass();
}

test_subclass()

static void test_subclass ( void  )

static

Definition at line 219 of file subclass.c.

{
    BOOL ret;
    HWND hwnd = CreateWindowExA(0, "TestSubclass", "Test subclass", WS_OVERLAPPEDWINDOW,
                           100, 100, 200, 200, 0, 0, 0, NULL);
    ok(hwnd != NULL, "failed to create test subclass wnd\n");
 
    ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, 0);
    ok(ret == TRUE, "Expected TRUE\n");
    SendMessageA(hwnd, WM_USER, 1, 0);
    SendMessageA(hwnd, WM_USER, 2, 0);
    ok_sequence(Sub_BasicTest, "Basic");
 
    ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, DELETE_SELF);
    ok(ret == TRUE, "Expected TRUE\n");
    SendMessageA(hwnd, WM_USER, 1, 1);
    ok_sequence(Sub_DeletedTest, "Deleted");
 
    SendMessageA(hwnd, WM_USER, 1, 0);
    ok_sequence(Sub_AfterDeletedTest, "After Deleted");
 
    ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 2, 0);
    ok(ret == TRUE, "Expected TRUE\n");
    orig_proc_3 = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)wnd_proc_3);
    SendMessageA(hwnd, WM_USER, 1, 0);
    SendMessageA(hwnd, WM_USER, 2, 0);
    ok_sequence(Sub_OldAfterNewTest, "Old after New");
 
    ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, 0);
    ok(ret == TRUE, "Expected TRUE\n");
    SendMessageA(hwnd, WM_USER, 1, 0);
    ok_sequence(Sub_MixTest, "Mix");
 
    /* Now the fun starts */
    ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, SEND_NEST);
    ok(ret == TRUE, "Expected TRUE\n");
    SendMessageA(hwnd, WM_USER, 1, 1);
    ok_sequence(Sub_MixAndNestTest, "Mix and nest");
 
    ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, SEND_NEST | DELETE_SELF);
    ok(ret == TRUE, "Expected TRUE\n");
    SendMessageA(hwnd, WM_USER, 1, 1);
    ok_sequence(Sub_MixNestDelTest, "Mix, nest, del");
 
    ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 4, 0);
    ok(ret == TRUE, "Expected TRUE\n");
    ret = pSetWindowSubclass(hwnd, wnd_proc_sub, 5, DELETE_PREV);
    ok(ret == TRUE, "Expected TRUE\n");
    SendMessageA(hwnd, WM_USER, 1, 1);
    ok_sequence(Sub_MixDelPrevTest, "Mix and del prev");
 
    ret = pSetWindowSubclass(NULL, wnd_proc_sub, 1, 0);
    ok(ret == FALSE, "Expected FALSE\n");
 
    ret = pSetWindowSubclass(hwnd, NULL, 1, 0);
    ok(ret == FALSE, "Expected FALSE\n");
 
    pRemoveWindowSubclass(hwnd, wnd_proc_sub, 2);
    pRemoveWindowSubclass(hwnd, wnd_proc_sub, 5);
 
    DestroyWindow(hwnd);
}

Referenced by START_TEST().

wnd_proc_1()

static LRESULT WINAPI wnd_proc_1 ( HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 170 of file subclass.c.

{
    struct message msg;
    
    if(message == WM_USER) {
        msg.wParam = wParam;
        msg.procnum = 1;
        add_message(&msg);
    }
    return DefWindowProcA(hwnd, message, wParam, lParam);
}

Referenced by register_window_classes().

wnd_proc_3()

static LRESULT WINAPI wnd_proc_3 ( HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 184 of file subclass.c.

{
    struct message msg;
    
    if(message == WM_USER) {
        msg.wParam = wParam;
        msg.procnum = 3;
        add_message(&msg);
    }
    return CallWindowProcA(orig_proc_3, hwnd, message, wParam, lParam);
}

Referenced by test_subclass().

wnd_proc_sub()

static LRESULT WINAPI wnd_proc_sub ( HWND  hwnd, UINT  message, WPARAM  wParam, LPARAM  lParam, UINT_PTR  uldSubclass, DWORD_PTR  dwRefData  )

static

Definition at line 196 of file subclass.c.

{
    struct message msg;
    
    if(message == WM_USER) {
        msg.wParam = wParam;
        msg.procnum = uldSubclass;
        add_message(&msg);
        
        if(lParam) {
            if(dwRefData & DELETE_SELF) {
                pRemoveWindowSubclass(hwnd, wnd_proc_sub, uldSubclass);
                pRemoveWindowSubclass(hwnd, wnd_proc_sub, uldSubclass);
            }
            if(dwRefData & DELETE_PREV)
                pRemoveWindowSubclass(hwnd, wnd_proc_sub, uldSubclass-1);
            if(dwRefData & SEND_NEST)
                SendMessageA(hwnd, WM_USER, wParam+1, 0);
        }
    }
    return pDefSubclassProc(hwnd, message, wParam, lParam);
}

Referenced by test_subclass(), and wnd_proc_sub().

Variable Documentation

DWORD_PTR

DWORD_PTR

Definition at line 34 of file subclass.c.

LPARAM

LPARAM

Definition at line 36 of file subclass.c.

orig_proc_3

WNDPROC orig_proc_3

static

Definition at line 183 of file subclass.c.

Referenced by test_subclass(), and wnd_proc_3().

sequence

struct message* sequence

static

Definition at line 48 of file subclass.c.

Referenced by add_message(), flush_sequence(), and ok_sequence().

sequence_cnt

int sequence_cnt

static

Definition at line 47 of file subclass.c.

Referenced by add_message(), and flush_sequence().

sequence_size

int sequence_size

static

Definition at line 47 of file subclass.c.

Referenced by add_message(), and flush_sequence().

Sub_AfterDeletedTest

const struct message Sub_AfterDeletedTest[]

static

Initial value:

= {
    { 1, 1 },
    { 0 }
}

Definition at line 64 of file subclass.c.

Referenced by test_subclass().

Sub_BasicTest

const struct message Sub_BasicTest[]

static

Initial value:

= {
    { 2, 1 },
    { 1, 1 },
    { 2, 2 },
    { 1, 2 },
    { 0 }
}

Definition at line 50 of file subclass.c.

Referenced by test_subclass().

Sub_DeletedTest

const struct message Sub_DeletedTest[]

static

Initial value:

= {
    { 2, 1 },
    { 1, 1 },
    { 0 }
}

Definition at line 58 of file subclass.c.

Referenced by test_subclass().

Sub_MixAndNestTest

const struct message Sub_MixAndNestTest[]

static

Initial value:

= {
    { 3, 1 },
    { 4, 1 },
    { 3, 2 },
    { 4, 2 },
    { 2, 2 },
    { 1, 2 },
    { 2, 1 },
    { 1, 1 },
    { 0 }
}

Definition at line 87 of file subclass.c.

Referenced by test_subclass().

Sub_MixDelPrevTest

const struct message Sub_MixDelPrevTest[]

static

Initial value:

= {
    { 3, 1 },
    { 5, 1 },
    { 2, 1 },
    { 1, 1 },
    { 0 }
}

Definition at line 110 of file subclass.c.

Referenced by test_subclass().

Sub_MixNestDelTest

const struct message Sub_MixNestDelTest[]

static

Initial value:

= {
    { 3, 1 },
    { 4, 1 },
    { 3, 2 },
    { 2, 2 },
    { 1, 2 },
    { 2, 1 },
    { 1, 1 },
    { 0 }
}

Definition at line 99 of file subclass.c.

Referenced by test_subclass().

Sub_MixTest

const struct message Sub_MixTest[]

static

Initial value:

= {
    { 3, 1 },
    { 4, 1 },
    { 2, 1 },
    { 1, 1 },
    { 0 }
}

Definition at line 79 of file subclass.c.

Referenced by test_subclass().

Sub_OldAfterNewTest

const struct message Sub_OldAfterNewTest[]

static

Initial value:

= {
    { 3, 1 },
    { 2, 1 },
    { 1, 1 },
    { 3, 2 },
    { 2, 2 },
    { 1, 2 },
    { 0 }
}

Definition at line 69 of file subclass.c.

Referenced by test_subclass().

SUBCLASSPROC

SUBCLASSPROC

Definition at line 34 of file subclass.c.

UINT

UINT

Definition at line 36 of file subclass.c.

UINT_PTR

UINT_PTR

Definition at line 34 of file subclass.c.

WPARAM

WPARAM

Definition at line 36 of file subclass.c.