f48dc039543ea39a644dc671b610d7438649aa9a
[reactos.git] / modules / rostests / winetests / comctl32 / pager.c
1 /*
2 * Unit tests for the pager control
3 *
4 * Copyright 2012 Alexandre Julliard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <windows.h>
22 #include <commctrl.h>
23
24 #include "wine/test.h"
25 #include "msg.h"
26
27 #define NUM_MSG_SEQUENCES 1
28 #define PAGER_SEQ_INDEX 0
29
30 static HWND parent_wnd, child1_wnd, child2_wnd;
31 static INT notify_format;
32 static BOOL notify_query_received;
33 static WCHAR test_w[] = {'t', 'e', 's', 't', 0};
34 static CHAR test_a[] = {'t', 'e', 's', 't', 0};
35 /* Double zero so that it's safe to cast it to WCHAR * */
36 static CHAR te_a[] = {'t', 'e', 0, 0};
37 static WCHAR empty_w[] = {0};
38 static CHAR empty_a[] = {0};
39 static CHAR large_a[] = "You should have received a copy of the GNU Lesser General Public License along with this ...";
40 static WCHAR large_w[] =
41 {
42 'Y', 'o', 'u', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ', 'h', 'a', 'v', 'e', ' ', 'r', 'e', 'c', 'e', 'i', 'v', 'e',
43 'd', ' ', 'a', ' ', 'c', 'o', 'p', 'y', ' ', 'o', 'f', ' ', 't', 'h', 'e', ' ', 'G', 'N', 'U', ' ', 'L', 'e', 's',
44 's', 'e', 'r', ' ', 'G', 'e', 'n', 'e', 'r', 'a', 'l', ' ', 'P', 'u', 'b', 'l', 'i', 'c', ' ', 'L', 'i', 'c', 'e',
45 'n', 's', 'e', ' ', 'a', 'l', 'o', 'n', 'g', ' ', 'w', 'i', 't', 'h', ' ', 't', 'h', 'i', 's', ' ', '.', '.', '.', 0
46 };
47 static WCHAR large_truncated_65_w[65] =
48 {
49 'Y', 'o', 'u', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ', 'h', 'a', 'v', 'e', ' ', 'r', 'e', 'c', 'e', 'i', 'v',
50 'e', 'd', ' ', 'a', ' ', 'c', 'o', 'p', 'y', ' ', 'o', 'f', ' ', 't', 'h', 'e', ' ', 'G', 'N', 'U', ' ', 'L',
51 'e', 's', 's', 'e', 'r', ' ', 'G', 'e', 'n', 'e', 'r', 'a', 'l', ' ', 'P', 'u', 'b', 'l', 'i', 'c', 0
52 };
53 static WCHAR large_truncated_80_w[80] =
54 {
55 'Y', 'o', 'u', ' ', 's', 'h', 'o', 'u', 'l', 'd', ' ', 'h', 'a', 'v', 'e', ' ', 'r', 'e', 'c', 'e',
56 'i', 'v', 'e', 'd', ' ', 'a', ' ', 'c', 'o', 'p', 'y', ' ', 'o', 'f', ' ', 't', 'h', 'e', ' ', 'G',
57 'N', 'U', ' ', 'L', 'e', 's', 's', 'e', 'r', ' ', 'G', 'e', 'n', 'e', 'r', 'a', 'l', ' ', 'P', 'u',
58 'b', 'l', 'i', 'c', ' ', 'L', 'i', 'c', 'e', 'n', 's', 'e', ' ', 'a', 'l', 'o', 'n', 'g', ' ', 'w'
59 };
60 static WCHAR buffer[64];
61
62 /* Text field conversion test behavior flags. */
63 enum test_conversion_flags
64 {
65 CONVERT_SEND = 0x01,
66 DONT_CONVERT_SEND = 0x02,
67 CONVERT_RECEIVE = 0x04,
68 DONT_CONVERT_RECEIVE = 0x08,
69 SEND_EMPTY_IF_NULL = 0x10,
70 DONT_SEND_EMPTY_IF_NULL = 0x20,
71 SET_NULL_IF_NO_MASK = 0x40,
72 ZERO_SEND = 0x80
73 };
74
75 enum handler_ids
76 {
77 TVITEM_NEW_HANDLER,
78 TVITEM_OLD_HANDLER
79 };
80
81 static struct notify_test_info
82 {
83 UINT unicode;
84 UINT ansi;
85 UINT_PTR id_from;
86 HWND hwnd_from;
87 /* Whether parent received notification */
88 BOOL received;
89 UINT test_id;
90 UINT sub_test_id;
91 UINT handler_id;
92 /* Text field conversion test behavior flag */
93 DWORD flags;
94 } notify_test_info;
95
96 struct notify_test_send
97 {
98 /* Data sent to pager */
99 WCHAR *send_text;
100 INT send_text_size;
101 INT send_text_max;
102 /* Data expected by parent of pager */
103 void *expect_text;
104 };
105
106 struct notify_test_receive
107 {
108 /* Data sent to pager */
109 WCHAR *send_text;
110 INT send_text_size;
111 INT send_text_max;
112 /* Data for parent to write */
113 CHAR *write_pointer;
114 CHAR *write_text;
115 INT write_text_size;
116 INT write_text_max;
117 /* Data when message returned */
118 void *return_text;
119 INT return_text_max;
120 };
121
122 struct generic_text_helper_para
123 {
124 void *ptr;
125 size_t size;
126 UINT *mask;
127 UINT required_mask;
128 WCHAR **text;
129 INT *text_max;
130 UINT code_unicode;
131 UINT code_ansi;
132 DWORD flags;
133 UINT handler_id;
134 };
135
136 static const struct notify_test_send test_convert_send_data[] =
137 {
138 {test_w, sizeof(test_w), ARRAY_SIZE(buffer), test_a}
139 };
140
141 static const struct notify_test_send test_dont_convert_send_data[] =
142 {
143 {test_w, sizeof(test_w), ARRAY_SIZE(buffer), test_w}
144 };
145
146 static const struct notify_test_receive test_convert_receive_data[] =
147 {
148 {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), NULL, test_a, sizeof(test_a), -1, test_w, ARRAY_SIZE(buffer)},
149 {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, test_w, ARRAY_SIZE(buffer)},
150 {NULL, sizeof(empty_w), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, NULL, ARRAY_SIZE(buffer)},
151 {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), large_a, NULL, 0, -1, large_truncated_65_w, ARRAY_SIZE(buffer)},
152 {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), empty_a, 0, 0, 1, empty_w, 1},
153 };
154
155 static const struct notify_test_receive test_dont_convert_receive_data[] =
156 {
157 {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), NULL, test_a, sizeof(test_a), -1, test_a, ARRAY_SIZE(buffer)},
158 {empty_w, sizeof(empty_w), ARRAY_SIZE(buffer), test_a, NULL, 0, -1, test_a, ARRAY_SIZE(buffer)},
159 };
160
161 static const struct notify_test_tooltip
162 {
163 /* Data for parent to write */
164 CHAR *write_sztext;
165 INT write_sztext_size;
166 CHAR *write_lpsztext;
167 HMODULE write_hinst;
168 /* Data when message returned */
169 WCHAR *return_sztext;
170 INT return_sztext_size;
171 WCHAR *return_lpsztext;
172 HMODULE return_hinst;
173 /* Data expected by parent */
174 CHAR *expect_sztext;
175 /* Data send to parent */
176 WCHAR *send_sztext;
177 INT send_sztext_size;
178 WCHAR *send_lpsztext;
179 } test_tooltip_data[] =
180 {
181 {NULL, 0, NULL, NULL, empty_w, -1, empty_w},
182 {test_a, sizeof(test_a), NULL, NULL, test_w, -1, test_w},
183 {test_a, sizeof(test_a), test_a, NULL, test_w, -1, test_w},
184 {test_a, sizeof(test_a), (CHAR *)1, (HMODULE)0xdeadbeef, empty_w, -1, (WCHAR *)1, (HMODULE)0xdeadbeef},
185 {test_a, sizeof(test_a), test_a, (HMODULE)0xdeadbeef, test_w, -1, test_w, (HMODULE)0xdeadbeef},
186 {NULL, 0, test_a, NULL, test_w, -1, test_w},
187 {test_a, 2, test_a, NULL, test_w, -1, test_w},
188 {NULL, 0, NULL, NULL, test_w, -1, test_w, NULL, test_a, test_w, sizeof(test_w)},
189 {NULL, 0, NULL, NULL, empty_w, -1, empty_w, NULL, empty_a, NULL, 0, test_w},
190 {NULL, 0, large_a, NULL, large_truncated_80_w, sizeof(large_truncated_80_w), large_w}
191 };
192
193 static const struct notify_test_datetime_format
194 {
195 /* Data send to parent */
196 WCHAR *send_pszformat;
197 /* Data expected by parent */
198 CHAR *expect_pszformat;
199 /* Data for parent to write */
200 CHAR *write_szdisplay;
201 INT write_szdisplay_size;
202 CHAR *write_pszdisplay;
203 /* Data when message returned */
204 WCHAR *return_szdisplay;
205 INT return_szdisplay_size;
206 WCHAR *return_pszdisplay;
207 } test_datetime_format_data[] =
208 {
209 {test_w, test_a},
210 {NULL, NULL, NULL, 0, test_a, empty_w, -1, test_w},
211 {NULL, NULL, test_a, sizeof(test_a), NULL, test_w, -1, test_w},
212 {NULL, NULL, test_a, 2, test_a, (WCHAR *)te_a, -1, test_w},
213 {NULL, NULL, NULL, 0, large_a, NULL, 0, large_w}
214 };
215
216 #define CHILD1_ID 1
217 #define CHILD2_ID 2
218
219 static BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
220 static BOOL (WINAPI *pSetWindowSubclass)(HWND, SUBCLASSPROC, UINT_PTR, DWORD_PTR);
221
222 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
223
224 static const struct message set_child_seq[] = {
225 { PGM_SETCHILD, sent },
226 { WM_WINDOWPOSCHANGING, sent },
227 { WM_NCCALCSIZE, sent|wparam, TRUE },
228 { WM_NOTIFY, sent|id|parent, 0, 0, PGN_CALCSIZE },
229 { WM_WINDOWPOSCHANGED, sent },
230 { WM_WINDOWPOSCHANGING, sent|id, 0, 0, CHILD1_ID },
231 { WM_NCCALCSIZE, sent|wparam|id|optional, TRUE, 0, CHILD1_ID },
232 { WM_CHILDACTIVATE, sent|id, 0, 0, CHILD1_ID },
233 { WM_WINDOWPOSCHANGED, sent|id, 0, 0, CHILD1_ID },
234 { WM_SIZE, sent|id|defwinproc|optional, 0, 0, CHILD1_ID },
235 { 0 }
236 };
237
238 /* This differs from the above message list only in the child window that is
239 * expected to receive the child messages. No message is sent to the old child.
240 * Also child 2 is hidden while child 1 is visible. The pager does not make the
241 * hidden child visible. */
242 static const struct message switch_child_seq[] = {
243 { PGM_SETCHILD, sent },
244 { WM_WINDOWPOSCHANGING, sent },
245 { WM_NCCALCSIZE, sent|wparam, TRUE },
246 { WM_NOTIFY, sent|id|parent, 0, 0, PGN_CALCSIZE },
247 { WM_WINDOWPOSCHANGED, sent },
248 { WM_WINDOWPOSCHANGING, sent|id, 0, 0, CHILD2_ID },
249 { WM_NCCALCSIZE, sent|wparam|id, TRUE, 0, CHILD2_ID },
250 { WM_CHILDACTIVATE, sent|id, 0, 0, CHILD2_ID },
251 { WM_WINDOWPOSCHANGED, sent|id, 0, 0, CHILD2_ID },
252 { WM_SIZE, sent|id|defwinproc, 0, 0, CHILD2_ID },
253 { 0 }
254 };
255
256 static const struct message set_pos_seq[] = {
257 { PGM_SETPOS, sent },
258 { WM_WINDOWPOSCHANGING, sent },
259 { WM_NCCALCSIZE, sent|wparam, TRUE },
260 { WM_NOTIFY, sent|id|parent, 0, 0, PGN_CALCSIZE },
261 { WM_WINDOWPOSCHANGED, sent },
262 { WM_MOVE, sent|optional },
263 /* The WM_SIZE handler sends WM_WINDOWPOSCHANGING, WM_CHILDACTIVATE
264 * and WM_WINDOWPOSCHANGED (which sends WM_MOVE) to the child.
265 * Another WM_WINDOWPOSCHANGING is sent afterwards.
266 *
267 * The 2nd WM_WINDOWPOSCHANGING is unconditional, but the comparison
268 * function is too simple to roll back an accepted message, so we have
269 * to mark the 2nd message optional. */
270 { WM_SIZE, sent|optional },
271 { WM_WINDOWPOSCHANGING, sent|id, 0, 0, CHILD1_ID }, /* Actually optional. */
272 { WM_CHILDACTIVATE, sent|id, 0, 0, CHILD1_ID }, /* Actually optional. */
273 { WM_WINDOWPOSCHANGED, sent|id|optional, TRUE, 0, CHILD1_ID},
274 { WM_MOVE, sent|id|optional|defwinproc, 0, 0, CHILD1_ID },
275 { WM_WINDOWPOSCHANGING, sent|id|optional, 0, 0, CHILD1_ID }, /* Actually not optional. */
276 { WM_CHILDACTIVATE, sent|id|optional, 0, 0, CHILD1_ID }, /* Actually not optional. */
277 { 0 }
278 };
279
280 static const struct message set_pos_empty_seq[] = {
281 { PGM_SETPOS, sent },
282 { 0 }
283 };
284
285 static CHAR *heap_strdup(const CHAR *str)
286 {
287 int len = lstrlenA(str) + 1;
288 CHAR *ret = heap_alloc(len * sizeof(CHAR));
289 lstrcpyA(ret, str);
290 return ret;
291 }
292
293 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
294 {
295 static LONG defwndproc_counter = 0;
296 LRESULT ret;
297 struct message msg;
298
299 /* log system messages, except for painting */
300 if (message < WM_USER &&
301 message != WM_PAINT &&
302 message != WM_ERASEBKGND &&
303 message != WM_NCPAINT &&
304 message != WM_NCHITTEST &&
305 message != WM_GETTEXT &&
306 message != WM_GETICON &&
307 message != WM_DEVICECHANGE)
308 {
309 msg.message = message;
310 msg.flags = sent|wparam|lparam|parent;
311 if (defwndproc_counter) msg.flags |= defwinproc;
312 msg.wParam = wParam;
313 msg.lParam = lParam;
314 if (message == WM_NOTIFY && lParam) msg.id = ((NMHDR*)lParam)->code;
315 add_message(sequences, PAGER_SEQ_INDEX, &msg);
316 }
317
318 if (message == WM_NOTIFY)
319 {
320 NMHDR *nmhdr = (NMHDR *)lParam;
321
322 switch (nmhdr->code)
323 {
324 case PGN_CALCSIZE:
325 {
326 NMPGCALCSIZE *nmpgcs = (NMPGCALCSIZE *)lParam;
327 DWORD style = GetWindowLongA(nmpgcs->hdr.hwndFrom, GWL_STYLE);
328
329 if (style & PGS_HORZ)
330 ok(nmpgcs->dwFlag == PGF_CALCWIDTH, "Unexpected flags %#x.\n", nmpgcs->dwFlag);
331 else
332 ok(nmpgcs->dwFlag == PGF_CALCHEIGHT, "Unexpected flags %#x.\n", nmpgcs->dwFlag);
333 break;
334 }
335 default:
336 ;
337 }
338 }
339
340 defwndproc_counter++;
341 ret = DefWindowProcA(hwnd, message, wParam, lParam);
342 defwndproc_counter--;
343
344 return ret;
345 }
346
347 static BOOL register_parent_wnd_class(void)
348 {
349 WNDCLASSA cls;
350
351 cls.style = 0;
352 cls.lpfnWndProc = parent_wnd_proc;
353 cls.cbClsExtra = 0;
354 cls.cbWndExtra = 0;
355 cls.hInstance = GetModuleHandleA(NULL);
356 cls.hIcon = 0;
357 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
358 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
359 cls.lpszMenuName = NULL;
360 cls.lpszClassName = "Pager test parent class";
361 return RegisterClassA(&cls);
362 }
363
364 static HWND create_parent_window(void)
365 {
366 if (!register_parent_wnd_class())
367 return NULL;
368
369 return CreateWindowA("Pager test parent class", "Pager test parent window",
370 WS_OVERLAPPED | WS_VISIBLE,
371 0, 0, 200, 200, 0, NULL, GetModuleHandleA(NULL), NULL );
372 }
373
374 static LRESULT WINAPI pager_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
375 {
376 WNDPROC oldproc = (WNDPROC)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
377 struct message msg = { 0 };
378
379 msg.message = message;
380 msg.flags = sent|wparam|lparam;
381 msg.wParam = wParam;
382 msg.lParam = lParam;
383 add_message(sequences, PAGER_SEQ_INDEX, &msg);
384 return CallWindowProcA(oldproc, hwnd, message, wParam, lParam);
385 }
386
387 static HWND create_pager_control( DWORD style )
388 {
389 WNDPROC oldproc;
390 HWND hwnd;
391 RECT rect;
392
393 GetClientRect( parent_wnd, &rect );
394 hwnd = CreateWindowA( WC_PAGESCROLLERA, "pager", WS_CHILD | WS_BORDER | WS_VISIBLE | style,
395 0, 0, 100, 100, parent_wnd, 0, GetModuleHandleA(0), 0 );
396 oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC, (LONG_PTR)pager_subclass_proc);
397 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)oldproc);
398 return hwnd;
399 }
400
401 static LRESULT WINAPI child_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
402 {
403 static LONG defwndproc_counter;
404 struct message msg = { 0 };
405 LRESULT ret;
406
407 msg.message = message;
408 msg.flags = sent | wparam | lparam;
409 if (defwndproc_counter)
410 msg.flags |= defwinproc;
411 msg.wParam = wParam;
412 msg.lParam = lParam;
413
414 if (hwnd == child1_wnd)
415 msg.id = CHILD1_ID;
416 else if (hwnd == child2_wnd)
417 msg.id = CHILD2_ID;
418 else
419 msg.id = 0;
420
421 add_message(sequences, PAGER_SEQ_INDEX, &msg);
422
423 defwndproc_counter++;
424 ret = DefWindowProcA(hwnd, message, wParam, lParam);
425 defwndproc_counter--;
426
427 return ret;
428 }
429
430 static BOOL register_child_wnd_class(void)
431 {
432 WNDCLASSA cls;
433
434 cls.style = 0;
435 cls.lpfnWndProc = child_proc;
436 cls.cbClsExtra = 0;
437 cls.cbWndExtra = 0;
438 cls.hInstance = GetModuleHandleA(NULL);
439 cls.hIcon = 0;
440 cls.hCursor = LoadCursorA(0, (LPCSTR)IDC_ARROW);
441 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
442 cls.lpszMenuName = NULL;
443 cls.lpszClassName = "Pager test child class";
444 return RegisterClassA(&cls);
445 }
446
447 static void test_pager(void)
448 {
449 HWND pager;
450 RECT rect, rect2;
451
452 pager = create_pager_control( PGS_HORZ );
453 ok(pager != NULL, "Fail to create pager\n");
454
455 register_child_wnd_class();
456
457 child1_wnd = CreateWindowA( "Pager test child class", "button", WS_CHILD | WS_BORDER | WS_VISIBLE, 0, 0, 300, 300,
458 pager, 0, GetModuleHandleA(0), 0 );
459 child2_wnd = CreateWindowA("Pager test child class", "button", WS_CHILD | WS_BORDER, 0, 0, 300, 300,
460 pager, 0, GetModuleHandleA(0), 0);
461
462 flush_sequences( sequences, NUM_MSG_SEQUENCES );
463 SendMessageA( pager, PGM_SETCHILD, 0, (LPARAM)child1_wnd );
464 ok_sequence(sequences, PAGER_SEQ_INDEX, set_child_seq, "set child", FALSE);
465 GetWindowRect( pager, &rect );
466 ok( rect.right - rect.left == 100 && rect.bottom - rect.top == 100,
467 "pager resized %dx%d\n", rect.right - rect.left, rect.bottom - rect.top );
468
469 flush_sequences(sequences, NUM_MSG_SEQUENCES);
470 SendMessageA(pager, PGM_SETCHILD, 0, (LPARAM)child2_wnd);
471 ok_sequence(sequences, PAGER_SEQ_INDEX, switch_child_seq, "switch to invisible child", FALSE);
472 GetWindowRect(pager, &rect);
473 ok(rect.right - rect.left == 100 && rect.bottom - rect.top == 100,
474 "pager resized %dx%d\n", rect.right - rect.left, rect.bottom - rect.top);
475 ok(!IsWindowVisible(child2_wnd), "Child window 2 is visible\n");
476
477 flush_sequences(sequences, NUM_MSG_SEQUENCES);
478 SendMessageA(pager, PGM_SETCHILD, 0, (LPARAM)child1_wnd);
479 ok_sequence(sequences, PAGER_SEQ_INDEX, set_child_seq, "switch to visible child", FALSE);
480 GetWindowRect(pager, &rect);
481 ok(rect.right - rect.left == 100 && rect.bottom - rect.top == 100,
482 "pager resized %dx%d\n", rect.right - rect.left, rect.bottom - rect.top);
483
484 flush_sequences( sequences, NUM_MSG_SEQUENCES );
485 SendMessageA( pager, PGM_SETPOS, 0, 10 );
486 ok_sequence(sequences, PAGER_SEQ_INDEX, set_pos_seq, "set pos", TRUE);
487 GetWindowRect( pager, &rect );
488 ok( rect.right - rect.left == 100 && rect.bottom - rect.top == 100,
489 "pager resized %dx%d\n", rect.right - rect.left, rect.bottom - rect.top );
490
491 flush_sequences( sequences, NUM_MSG_SEQUENCES );
492 SendMessageA( pager, PGM_SETPOS, 0, 10 );
493 ok_sequence(sequences, PAGER_SEQ_INDEX, set_pos_empty_seq, "set pos empty", TRUE);
494
495 flush_sequences( sequences, NUM_MSG_SEQUENCES );
496 SendMessageA( pager, PGM_SETPOS, 0, 9 );
497 ok_sequence(sequences, PAGER_SEQ_INDEX, set_pos_seq, "set pos", TRUE);
498
499 DestroyWindow( pager );
500
501 /* Test if resizing works */
502 pager = create_pager_control( CCS_NORESIZE );
503 ok(pager != NULL, "failed to create pager control\n");
504
505 GetWindowRect( pager, &rect );
506 MoveWindow( pager, 0, 0, 200, 100, TRUE );
507 GetWindowRect( pager, &rect2 );
508 ok(rect2.right - rect2.left > rect.right - rect.left, "expected pager window to resize, %s\n",
509 wine_dbgstr_rect( &rect2 ));
510
511 DestroyWindow( pager );
512
513 pager = create_pager_control( CCS_NORESIZE | PGS_HORZ );
514 ok(pager != NULL, "failed to create pager control\n");
515
516 GetWindowRect( pager, &rect );
517 MoveWindow( pager, 0, 0, 100, 200, TRUE );
518 GetWindowRect( pager, &rect2 );
519 ok(rect2.bottom - rect2.top > rect.bottom - rect.top, "expected pager window to resize, %s\n",
520 wine_dbgstr_rect( &rect2 ));
521
522 DestroyWindow( pager );
523 }
524
525 static LRESULT WINAPI test_notifyformat_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
526 {
527 switch (message)
528 {
529 case WM_NOTIFYFORMAT:
530 if (lParam == NF_QUERY)
531 {
532 notify_query_received = TRUE;
533 return notify_format;
534 }
535 else if (lParam == NF_REQUERY)
536 return SendMessageA(GetParent(hwnd), WM_NOTIFYFORMAT, (WPARAM)hwnd, NF_QUERY);
537 else
538 return 0;
539 default:
540 return notify_format == NFR_UNICODE ? DefWindowProcW(hwnd, message, wParam, lParam)
541 : DefWindowProcA(hwnd, message, wParam, lParam);
542 }
543 }
544
545 static BOOL register_notifyformat_class(void)
546 {
547 static const WCHAR class_w[] = {'P', 'a', 'g', 'e', 'r', ' ', 'n', 'o', 't', 'i', 'f', 'y', 'f',
548 'o', 'r', 'm', 'a', 't', ' ', 'c', 'l', 'a', 's', 's', 0};
549 WNDCLASSW cls = {0};
550
551 cls.lpfnWndProc = test_notifyformat_proc;
552 cls.hInstance = GetModuleHandleW(NULL);
553 cls.lpszClassName = class_w;
554 return RegisterClassW(&cls);
555 }
556
557 static void test_wm_notifyformat(void)
558 {
559 static const WCHAR class_w[] = {'P', 'a', 'g', 'e', 'r', ' ', 'n', 'o', 't', 'i', 'f', 'y', 'f',
560 'o', 'r', 'm', 'a', 't', ' ', 'c', 'l', 'a', 's', 's', 0};
561 static const WCHAR parent_w[] = {'p', 'a', 'r', 'e', 'n', 't', 0};
562 static const WCHAR pager_w[] = {'p', 'a', 'g', 'e', 'r', 0};
563 static const WCHAR child_w[] = {'c', 'h', 'i', 'l', 'd', 0};
564 static const INT formats[] = {NFR_UNICODE, NFR_ANSI};
565 HWND parent, pager, child;
566 LRESULT ret;
567 INT i;
568
569 ok(register_notifyformat_class(), "Register test class failed, error 0x%08x\n", GetLastError());
570
571 for (i = 0; i < ARRAY_SIZE(formats); i++)
572 {
573 notify_format = formats[i];
574 parent = CreateWindowW(class_w, parent_w, WS_OVERLAPPED, 0, 0, 100, 100, 0, 0, GetModuleHandleW(0), 0);
575 ok(parent != NULL, "CreateWindow failed\n");
576 pager = CreateWindowW(WC_PAGESCROLLERW, pager_w, WS_CHILD, 0, 0, 100, 100, parent, 0, GetModuleHandleW(0), 0);
577 ok(pager != NULL, "CreateWindow failed\n");
578 child = CreateWindowW(class_w, child_w, WS_CHILD, 0, 0, 100, 100, pager, 0, GetModuleHandleW(0), 0);
579 ok(child != NULL, "CreateWindow failed\n");
580 SendMessageW(pager, PGM_SETCHILD, 0, (LPARAM)child);
581
582 /* Test parent */
583 notify_query_received = FALSE;
584 ret = SendMessageW(pager, WM_NOTIFYFORMAT, (WPARAM)parent, NF_REQUERY);
585 ok(ret == notify_format, "Expect %d, got %ld\n", notify_format, ret);
586 ok(notify_query_received, "Didn't receive notify\n");
587
588 /* Send NF_QUERY directly to parent */
589 notify_query_received = FALSE;
590 ret = SendMessageW(parent, WM_NOTIFYFORMAT, (WPARAM)pager, NF_QUERY);
591 ok(ret == notify_format, "Expect %d, got %ld\n", notify_format, ret);
592 ok(notify_query_received, "Didn't receive notify\n");
593
594 /* Pager send notifications to its parent regardless of wParam */
595 notify_query_received = FALSE;
596 ret = SendMessageW(pager, WM_NOTIFYFORMAT, (WPARAM)parent_wnd, NF_REQUERY);
597 ok(ret == notify_format, "Expect %d, got %ld\n", notify_format, ret);
598 ok(notify_query_received, "Didn't receive notify\n");
599
600 /* Pager always wants Unicode notifications from children */
601 ret = SendMessageW(child, WM_NOTIFYFORMAT, (WPARAM)pager, NF_REQUERY);
602 ok(ret == NFR_UNICODE, "Expect %d, got %ld\n", NFR_UNICODE, ret);
603 ret = SendMessageW(pager, WM_NOTIFYFORMAT, (WPARAM)child, NF_QUERY);
604 ok(ret == NFR_UNICODE, "Expect %d, got %ld\n", NFR_UNICODE, ret);
605
606 DestroyWindow(parent);
607 }
608
609 UnregisterClassW(class_w, GetModuleHandleW(NULL));
610 }
611
612 static void notify_generic_text_handler(CHAR **text, INT *text_max)
613 {
614 const struct notify_test_send *send_data;
615 const struct notify_test_receive *receive_data;
616
617 switch (notify_test_info.test_id)
618 {
619 case CONVERT_SEND:
620 case DONT_CONVERT_SEND:
621 {
622 send_data = (notify_test_info.test_id == CONVERT_SEND ? test_convert_send_data : test_dont_convert_send_data)
623 + notify_test_info.sub_test_id;
624 if (notify_test_info.flags & ZERO_SEND)
625 ok(!lstrcmpA(*text, empty_a), "Code 0x%08x test 0x%08x sub test %d expect empty text, got %s\n",
626 notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, *text);
627 else if (notify_test_info.flags & CONVERT_SEND)
628 ok(!lstrcmpA(send_data->expect_text, *text), "Code 0x%08x test 0x%08x sub test %d expect %s, got %s\n",
629 notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id,
630 (CHAR *)send_data->expect_text, *text);
631 else
632 ok(!lstrcmpW((WCHAR *)send_data->expect_text, (WCHAR *)*text),
633 "Code 0x%08x test 0x%08x sub test %d expect %s, got %s\n", notify_test_info.unicode,
634 notify_test_info.test_id, notify_test_info.sub_test_id, wine_dbgstr_w((WCHAR *)send_data->expect_text),
635 wine_dbgstr_w((WCHAR *)*text));
636 if (text_max)
637 ok(*text_max == send_data->send_text_max, "Code 0x%08x test 0x%08x sub test %d expect %d, got %d\n",
638 notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id,
639 send_data->send_text_max, *text_max);
640 break;
641 }
642 case CONVERT_RECEIVE:
643 case DONT_CONVERT_RECEIVE:
644 {
645 receive_data = (notify_test_info.test_id == CONVERT_RECEIVE ? test_convert_receive_data : test_dont_convert_receive_data)
646 + notify_test_info.sub_test_id;
647 if (text_max)
648 ok(*text_max == receive_data->send_text_max, "Code 0x%08x test 0x%08x sub test %d expect %d, got %d\n",
649 notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id,
650 receive_data->send_text_max, *text_max);
651
652 if (receive_data->write_text)
653 memcpy(*text, receive_data->write_text, receive_data->write_text_size);
654 /* 64bit Windows will try to free the text pointer even if it's application provided when handling
655 * HDN_GETDISPINFOW. Deliberate leak here. */
656 else if(notify_test_info.unicode == HDN_GETDISPINFOW)
657 *text = heap_strdup(receive_data->write_pointer);
658 else
659 *text = receive_data->write_pointer;
660 if (text_max && receive_data->write_text_max != -1) *text_max = receive_data->write_text_max;
661 break;
662 }
663 case SEND_EMPTY_IF_NULL:
664 ok(!lstrcmpA(*text, empty_a), "Code 0x%08x test 0x%08x sub test %d expect empty text, got %s\n",
665 notify_test_info.unicode, notify_test_info.test_id, notify_test_info.sub_test_id, *text);
666 break;
667 case DONT_SEND_EMPTY_IF_NULL:
668 ok(!*text, "Code 0x%08x test 0x%08x sub test %d expect null text\n", notify_test_info.unicode,
669 notify_test_info.test_id, notify_test_info.sub_test_id);
670 break;
671 }
672 }
673
674 static void notify_tooltip_handler(NMTTDISPINFOA *nm)
675 {
676 const struct notify_test_tooltip *data = test_tooltip_data + notify_test_info.sub_test_id;
677 ok(nm->lpszText == nm->szText, "Sub test %d expect %p, got %p\n", notify_test_info.sub_test_id, nm->szText,
678 nm->lpszText);
679 if (data->expect_sztext)
680 ok(!lstrcmpA(data->expect_sztext, nm->szText), "Sub test %d expect %s, got %s\n", notify_test_info.sub_test_id,
681 data->expect_sztext, nm->szText);
682 if (data->write_sztext) memcpy(nm->szText, data->write_sztext, data->write_sztext_size);
683 if (data->write_lpsztext) nm->lpszText = data->write_lpsztext;
684 if (data->write_hinst) nm->hinst = data->write_hinst;
685 }
686
687 static void notify_datetime_handler(NMDATETIMEFORMATA *nm)
688 {
689 const struct notify_test_datetime_format *data = test_datetime_format_data + notify_test_info.sub_test_id;
690 if (data->expect_pszformat)
691 ok(!lstrcmpA(data->expect_pszformat, nm->pszFormat), "Sub test %d expect %s, got %s\n",
692 notify_test_info.sub_test_id, data->expect_pszformat, nm->pszFormat);
693 ok(nm->pszDisplay == nm->szDisplay, "Test %d expect %p, got %p\n", notify_test_info.sub_test_id, nm->szDisplay,
694 nm->pszDisplay);
695 if (data->write_szdisplay) memcpy(nm->szDisplay, data->write_szdisplay, data->write_szdisplay_size);
696 if (data->write_pszdisplay) nm->pszDisplay = data->write_pszdisplay;
697 }
698
699 static LRESULT WINAPI test_notify_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
700 {
701 static const WCHAR test[] = {'t', 'e', 's', 't', 0};
702 switch (message)
703 {
704 case WM_NOTIFY:
705 {
706 NMHDR *hdr = (NMHDR *)lParam;
707
708 /* Not notifications we want to test */
709 if (!notify_test_info.unicode) break;
710 ok(!notify_test_info.received, "Extra notification received\n");
711
712 ok(wParam == notify_test_info.id_from, "Expect %ld, got %ld\n", notify_test_info.id_from, wParam);
713 ok(hdr->code == notify_test_info.ansi, "Expect 0x%08x, got 0x%08x\n", notify_test_info.ansi, hdr->code);
714 ok(hdr->idFrom == notify_test_info.id_from, "Expect %ld, got %ld\n", notify_test_info.id_from, wParam);
715 ok(hdr->hwndFrom == notify_test_info.hwnd_from, "Expect %p, got %p\n", notify_test_info.hwnd_from, hdr->hwndFrom);
716
717 if (hdr->code != notify_test_info.ansi)
718 {
719 skip("Notification code mismatch, skipping lParam check\n");
720 return 0;
721 }
722 switch (hdr->code)
723 {
724 /* ComboBoxEx */
725 case CBEN_INSERTITEM:
726 case CBEN_DELETEITEM:
727 {
728 NMCOMBOBOXEXW *nmcbe = (NMCOMBOBOXEXW *)hdr;
729 notify_generic_text_handler((CHAR **)&nmcbe->ceItem.pszText, NULL);
730 break;
731 }
732 case CBEN_DRAGBEGINA:
733 {
734 NMCBEDRAGBEGINA *nmcbedb = (NMCBEDRAGBEGINA *)hdr;
735 ok(!lstrcmpA(nmcbedb->szText, test_a), "Expect %s, got %s\n", nmcbedb->szText, test_a);
736 break;
737 }
738 case CBEN_ENDEDITA:
739 {
740 NMCBEENDEDITA *nmcbeed = (NMCBEENDEDITA *)hdr;
741 ok(!lstrcmpA(nmcbeed->szText, test_a), "Expect %s, got %s\n", nmcbeed->szText, test_a);
742 break;
743 }
744 case CBEN_GETDISPINFOA:
745 {
746 NMCOMBOBOXEXA *nmcbe = (NMCOMBOBOXEXA *)hdr;
747 notify_generic_text_handler(&nmcbe->ceItem.pszText, &nmcbe->ceItem.cchTextMax);
748 break;
749 }
750 /* Date and Time Picker */
751 case DTN_FORMATA:
752 {
753 notify_datetime_handler((NMDATETIMEFORMATA *)hdr);
754 break;
755 }
756 case DTN_FORMATQUERYA:
757 {
758 NMDATETIMEFORMATQUERYA *nmdtfq = (NMDATETIMEFORMATQUERYA *)hdr;
759 notify_generic_text_handler((CHAR **)&nmdtfq->pszFormat, NULL);
760 break;
761 }
762 case DTN_WMKEYDOWNA:
763 {
764 NMDATETIMEWMKEYDOWNA *nmdtkd = (NMDATETIMEWMKEYDOWNA *)hdr;
765 notify_generic_text_handler((CHAR **)&nmdtkd->pszFormat, NULL);
766 break;
767 }
768 case DTN_USERSTRINGA:
769 {
770 NMDATETIMESTRINGA *nmdts = (NMDATETIMESTRINGA *)hdr;
771 notify_generic_text_handler((CHAR **)&nmdts->pszUserString, NULL);
772 break;
773 }
774 /* Header */
775 case HDN_BEGINDRAG:
776 case HDN_ENDDRAG:
777 case HDN_BEGINFILTEREDIT:
778 case HDN_ENDFILTEREDIT:
779 case HDN_DROPDOWN:
780 case HDN_FILTERCHANGE:
781 case HDN_ITEMKEYDOWN:
782 case HDN_ITEMSTATEICONCLICK:
783 case HDN_OVERFLOWCLICK:
784 {
785 NMHEADERW *nmhd = (NMHEADERW *)hdr;
786 ok(!lstrcmpW(nmhd->pitem->pszText, test_w), "Expect %s, got %s\n", wine_dbgstr_w(test_w),
787 wine_dbgstr_w(nmhd->pitem->pszText));
788 ok(!lstrcmpW(((HD_TEXTFILTERW *)nmhd->pitem->pvFilter)->pszText, test_w), "Expect %s, got %s\n",
789 wine_dbgstr_w(test_w), wine_dbgstr_w(((HD_TEXTFILTERW *)nmhd->pitem->pvFilter)->pszText));
790 break;
791 }
792 case HDN_BEGINTRACKA:
793 case HDN_DIVIDERDBLCLICKA:
794 case HDN_ENDTRACKA:
795 case HDN_ITEMCHANGEDA:
796 case HDN_ITEMCHANGINGA:
797 case HDN_ITEMCLICKA:
798 case HDN_ITEMDBLCLICKA:
799 case HDN_TRACKA:
800 {
801 NMHEADERA *nmhd = (NMHEADERA *)hdr;
802 ok(!lstrcmpA(nmhd->pitem->pszText, test_a), "Expect %s, got %s\n", test_a, nmhd->pitem->pszText);
803 ok(!lstrcmpA(((HD_TEXTFILTERA *)nmhd->pitem->pvFilter)->pszText, test_a), "Expect %s, got %s\n", test_a,
804 ((HD_TEXTFILTERA *)nmhd->pitem->pvFilter)->pszText);
805 break;
806 }
807 case HDN_GETDISPINFOA:
808 {
809 NMHDDISPINFOA *nmhddi = (NMHDDISPINFOA *)hdr;
810 notify_generic_text_handler(&nmhddi->pszText, &nmhddi->cchTextMax);
811 break;
812 }
813 /* List View */
814 case LVN_BEGINLABELEDITA:
815 case LVN_ENDLABELEDITA:
816 case LVN_GETDISPINFOA:
817 case LVN_SETDISPINFOA:
818 {
819 NMLVDISPINFOA *nmlvdi = (NMLVDISPINFOA *)hdr;
820 notify_generic_text_handler(&nmlvdi->item.pszText, &nmlvdi->item.cchTextMax);
821 break;
822 }
823 case LVN_GETINFOTIPA:
824 {
825 NMLVGETINFOTIPA *nmlvgit = (NMLVGETINFOTIPA *)hdr;
826 notify_generic_text_handler(&nmlvgit->pszText, &nmlvgit->cchTextMax);
827 break;
828 }
829 case LVN_INCREMENTALSEARCHA:
830 case LVN_ODFINDITEMA:
831 {
832 NMLVFINDITEMA *nmlvfi = (NMLVFINDITEMA *)hdr;
833 notify_generic_text_handler((CHAR **)&nmlvfi->lvfi.psz, NULL);
834 break;
835 }
836 /* Toolbar */
837 case TBN_SAVE:
838 {
839 NMTBSAVE *nmtbs = (NMTBSAVE *)hdr;
840 notify_generic_text_handler((CHAR **)&nmtbs->tbButton.iString, NULL);
841 break;
842 }
843 case TBN_RESTORE:
844 {
845 NMTBRESTORE *nmtbr = (NMTBRESTORE *)hdr;
846 notify_generic_text_handler((CHAR **)&nmtbr->tbButton.iString, NULL);
847 break;
848 }
849 case TBN_GETBUTTONINFOA:
850 {
851 NMTOOLBARA *nmtb = (NMTOOLBARA *)hdr;
852 notify_generic_text_handler(&nmtb->pszText, &nmtb->cchText);
853 break;
854 }
855 case TBN_GETDISPINFOW:
856 {
857 NMTBDISPINFOW *nmtbdi = (NMTBDISPINFOW *)hdr;
858 notify_generic_text_handler((CHAR **)&nmtbdi->pszText, &nmtbdi->cchText);
859 break;
860 }
861 case TBN_GETINFOTIPA:
862 {
863 NMTBGETINFOTIPA *nmtbgit = (NMTBGETINFOTIPA *)hdr;
864 notify_generic_text_handler(&nmtbgit->pszText, &nmtbgit->cchTextMax);
865 break;
866 }
867 /* Tooltip */
868 case TTN_GETDISPINFOA:
869 {
870 notify_tooltip_handler((NMTTDISPINFOA *)hdr);
871 break;
872 }
873 /* Tree View */
874 case TVN_BEGINLABELEDITA:
875 case TVN_ENDLABELEDITA:
876 case TVN_GETDISPINFOA:
877 case TVN_SETDISPINFOA:
878 {
879 NMTVDISPINFOA *nmtvdi = (NMTVDISPINFOA *)hdr;
880 notify_generic_text_handler(&nmtvdi->item.pszText, &nmtvdi->item.cchTextMax);
881 break;
882 }
883 case TVN_GETINFOTIPA:
884 {
885 NMTVGETINFOTIPA *nmtvgit = (NMTVGETINFOTIPA *)hdr;
886 notify_generic_text_handler(&nmtvgit->pszText, &nmtvgit->cchTextMax);
887 break;
888 }
889 case TVN_SINGLEEXPAND:
890 case TVN_BEGINDRAGA:
891 case TVN_BEGINRDRAGA:
892 case TVN_ITEMEXPANDEDA:
893 case TVN_ITEMEXPANDINGA:
894 case TVN_DELETEITEMA:
895 case TVN_SELCHANGINGA:
896 case TVN_SELCHANGEDA:
897 {
898 NMTREEVIEWA *nmtv = (NMTREEVIEWA *)hdr;
899 if (notify_test_info.handler_id == TVITEM_NEW_HANDLER)
900 notify_generic_text_handler((CHAR **)&nmtv->itemNew.pszText, &nmtv->itemNew.cchTextMax);
901 else
902 notify_generic_text_handler((CHAR **)&nmtv->itemOld.pszText, &nmtv->itemOld.cchTextMax);
903 break;
904 }
905
906 default:
907 ok(0, "Unexpected message 0x%08x\n", hdr->code);
908 }
909 notify_test_info.received = TRUE;
910 ok(!lstrcmpA(test_a, "test"), "test_a got modified\n");
911 ok(!lstrcmpW(test_w, test), "test_w got modified\n");
912 return 0;
913 }
914 case WM_NOTIFYFORMAT:
915 if (lParam == NF_QUERY) return NFR_ANSI;
916 break;
917 }
918 return DefWindowProcA(hwnd, message, wParam, lParam);
919 }
920
921 static BOOL register_test_notify_class(void)
922 {
923 WNDCLASSA cls = {0};
924
925 cls.lpfnWndProc = test_notify_proc;
926 cls.hInstance = GetModuleHandleA(NULL);
927 cls.lpszClassName = "Pager notify class";
928 return RegisterClassA(&cls);
929 }
930
931 static void send_notify(HWND pager, UINT unicode, UINT ansi, LPARAM lParam, BOOL code_change)
932 {
933 NMHDR *hdr = (NMHDR *)lParam;
934
935 notify_test_info.unicode = unicode;
936 notify_test_info.id_from = 1;
937 notify_test_info.hwnd_from = child1_wnd;
938 notify_test_info.ansi = ansi;
939 notify_test_info.received = FALSE;
940
941 hdr->code = unicode;
942 hdr->idFrom = 1;
943 hdr->hwndFrom = child1_wnd;
944
945 SendMessageW(pager, WM_NOTIFY, hdr->idFrom, lParam);
946 ok(notify_test_info.received, "Expect notification received\n");
947 ok(hdr->code == code_change ? ansi : unicode, "Expect 0x%08x, got 0x%08x\n", hdr->code,
948 code_change ? ansi : unicode);
949 }
950
951 /* Send notify to test text field conversion. In parent proc notify_generic_text_handler() handles these messages */
952 static void test_notify_generic_text_helper(HWND pager, const struct generic_text_helper_para *para)
953 {
954 const struct notify_test_send *send_data;
955 const struct notify_test_receive *receive_data;
956 INT array_size;
957 INT i;
958
959 notify_test_info.flags = para->flags;
960 notify_test_info.handler_id = para->handler_id;
961
962 if (para->flags & (CONVERT_SEND | DONT_CONVERT_SEND))
963 {
964 if (para->flags & CONVERT_SEND)
965 {
966 notify_test_info.test_id = CONVERT_SEND;
967 send_data = test_convert_send_data;
968 array_size = ARRAY_SIZE(test_convert_send_data);
969 }
970 else
971 {
972 notify_test_info.test_id = DONT_CONVERT_SEND;
973 send_data = test_dont_convert_send_data;
974 array_size = ARRAY_SIZE(test_dont_convert_send_data);
975 }
976
977 for (i = 0; i < array_size; i++)
978 {
979 const struct notify_test_send *data = send_data + i;
980 notify_test_info.sub_test_id = i;
981
982 memset(para->ptr, 0, para->size);
983 if (para->mask) *para->mask = para->required_mask;
984 if (data->send_text)
985 {
986 memcpy(buffer, data->send_text, data->send_text_size);
987 *para->text = buffer;
988 }
989 if (para->text_max) *para->text_max = data->send_text_max;
990 send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE);
991 }
992 }
993
994 if (para->flags & (CONVERT_RECEIVE | DONT_CONVERT_RECEIVE))
995 {
996 if (para->flags & CONVERT_RECEIVE)
997 {
998 notify_test_info.test_id = CONVERT_RECEIVE;
999 receive_data = test_convert_receive_data;
1000 array_size = ARRAY_SIZE(test_convert_receive_data);
1001 }
1002 else
1003 {
1004 notify_test_info.test_id = DONT_CONVERT_RECEIVE;
1005 receive_data = test_dont_convert_receive_data;
1006 array_size = ARRAY_SIZE(test_dont_convert_receive_data);
1007 }
1008
1009 for (i = 0; i < array_size; i++)
1010 {
1011 const struct notify_test_receive *data = receive_data + i;
1012 notify_test_info.sub_test_id = i;
1013
1014 memset(para->ptr, 0, para->size);
1015 if (para->mask) *para->mask = para->required_mask;
1016 if (data->send_text)
1017 {
1018 memcpy(buffer, data->send_text, data->send_text_size);
1019 *para->text = buffer;
1020 }
1021 if (para->text_max) *para->text_max = data->send_text_max;
1022 send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE);
1023 if (data->return_text)
1024 {
1025 if (para->flags & CONVERT_RECEIVE)
1026 ok(!lstrcmpW(data->return_text, *para->text), "Code 0x%08x sub test %d expect %s, got %s\n",
1027 para->code_unicode, i, wine_dbgstr_w((WCHAR *)data->return_text), wine_dbgstr_w(*para->text));
1028 else
1029 ok(!lstrcmpA(data->return_text, (CHAR *)*para->text), "Code 0x%08x sub test %d expect %s, got %s\n",
1030 para->code_unicode, i, (CHAR *)data->return_text, (CHAR *)*para->text);
1031 }
1032 if (para->text_max)
1033 ok(data->return_text_max == *para->text_max, "Code 0x%08x sub test %d expect %d, got %d\n",
1034 para->code_unicode, i, data->return_text_max, *para->text_max);
1035 }
1036 }
1037
1038 /* Extra tests for other behavior flags that are not worth it to create their own test arrays */
1039 memset(para->ptr, 0, para->size);
1040 if (para->mask) *para->mask = para->required_mask;
1041 if (para->text_max) *para->text_max = 1;
1042 if (para->flags & SEND_EMPTY_IF_NULL)
1043 notify_test_info.test_id = SEND_EMPTY_IF_NULL;
1044 else
1045 notify_test_info.test_id = DONT_SEND_EMPTY_IF_NULL;
1046 send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE);
1047
1048 notify_test_info.test_id = SET_NULL_IF_NO_MASK;
1049 memset(para->ptr, 0, para->size);
1050 memset(buffer, 0, sizeof(buffer));
1051 *para->text = buffer;
1052 if (para->text_max) *para->text_max = ARRAY_SIZE(buffer);
1053 send_notify(pager, para->code_unicode, para->code_ansi, (LPARAM)para->ptr, TRUE);
1054 if(para->flags & SET_NULL_IF_NO_MASK)
1055 ok(!*para->text, "Expect null text\n");
1056 }
1057
1058 static void test_wm_notify_comboboxex(HWND pager)
1059 {
1060 static NMCBEDRAGBEGINW nmcbedb;
1061 static NMCBEENDEDITW nmcbeed;
1062
1063 /* CBEN_DRAGBEGIN */
1064 memset(&nmcbedb, 0, sizeof(nmcbedb));
1065 memcpy(nmcbedb.szText, test_w, sizeof(test_w));
1066 send_notify(pager, CBEN_DRAGBEGINW, CBEN_DRAGBEGINA, (LPARAM)&nmcbedb, FALSE);
1067 ok(!lstrcmpW(nmcbedb.szText, test_w), "Expect %s, got %s\n", wine_dbgstr_w(test_w), wine_dbgstr_w(nmcbedb.szText));
1068
1069 /* CBEN_ENDEDIT */
1070 memset(&nmcbeed, 0, sizeof(nmcbeed));
1071 memcpy(nmcbeed.szText, test_w, sizeof(test_w));
1072 send_notify(pager, CBEN_ENDEDITW, CBEN_ENDEDITA, (LPARAM)&nmcbeed, FALSE);
1073 ok(!lstrcmpW(nmcbeed.szText, test_w), "Expect %s, got %s\n", wine_dbgstr_w(test_w), wine_dbgstr_w(nmcbeed.szText));
1074 }
1075
1076 static void test_wm_notify_datetime(HWND pager)
1077 {
1078 const struct notify_test_datetime_format *data;
1079 NMDATETIMEFORMATW nmdtf;
1080 INT i;
1081
1082 for (i = 0; i < ARRAY_SIZE(test_datetime_format_data); i++)
1083 {
1084 data = test_datetime_format_data + i;
1085 notify_test_info.sub_test_id = i;
1086
1087 memset(&nmdtf, 0, sizeof(nmdtf));
1088 if(data->send_pszformat) nmdtf.pszFormat = data->send_pszformat;
1089 nmdtf.pszDisplay = nmdtf.szDisplay;
1090 send_notify(pager, DTN_FORMATW, DTN_FORMATA, (LPARAM)&nmdtf, TRUE);
1091 if (data->return_szdisplay)
1092 ok(!lstrcmpW(nmdtf.szDisplay, data->return_szdisplay), "Sub test %d expect %s, got %s\n", i,
1093 wine_dbgstr_w(data->return_szdisplay), wine_dbgstr_w(nmdtf.szDisplay));
1094 if (data->return_pszdisplay)
1095 ok(!lstrcmpW(nmdtf.pszDisplay, data->return_pszdisplay), "Sub test %d expect %s, got %s\n", i,
1096 wine_dbgstr_w(data->return_pszdisplay), wine_dbgstr_w(nmdtf.pszDisplay));
1097 }
1098 }
1099
1100 static void test_wm_notify_header(HWND pager)
1101 {
1102 NMHEADERW nmh = {{0}};
1103 HDITEMW hdi = {0};
1104 HD_TEXTFILTERW hdtf = {0};
1105
1106 hdi.mask = HDI_TEXT | HDI_FILTER;
1107 hdi.pszText = test_w;
1108 hdtf.pszText = test_w;
1109 nmh.pitem = &hdi;
1110 nmh.pitem->pvFilter = &hdtf;
1111 send_notify(pager, HDN_BEGINDRAG, HDN_BEGINDRAG, (LPARAM)&nmh, TRUE);
1112 send_notify(pager, HDN_ENDDRAG, HDN_ENDDRAG, (LPARAM)&nmh, TRUE);
1113 send_notify(pager, HDN_BEGINFILTEREDIT, HDN_BEGINFILTEREDIT, (LPARAM)&nmh, TRUE);
1114 send_notify(pager, HDN_ENDFILTEREDIT, HDN_ENDFILTEREDIT, (LPARAM)&nmh, TRUE);
1115 send_notify(pager, HDN_DROPDOWN, HDN_DROPDOWN, (LPARAM)&nmh, TRUE);
1116 send_notify(pager, HDN_FILTERCHANGE, HDN_FILTERCHANGE, (LPARAM)&nmh, TRUE);
1117 send_notify(pager, HDN_ITEMKEYDOWN, HDN_ITEMKEYDOWN, (LPARAM)&nmh, TRUE);
1118 send_notify(pager, HDN_ITEMSTATEICONCLICK, HDN_ITEMSTATEICONCLICK, (LPARAM)&nmh, TRUE);
1119 send_notify(pager, HDN_OVERFLOWCLICK, HDN_OVERFLOWCLICK, (LPARAM)&nmh, TRUE);
1120 send_notify(pager, HDN_BEGINTRACKW, HDN_BEGINTRACKA, (LPARAM)&nmh, TRUE);
1121 send_notify(pager, HDN_DIVIDERDBLCLICKW, HDN_DIVIDERDBLCLICKA, (LPARAM)&nmh, TRUE);
1122 send_notify(pager, HDN_ENDTRACKW, HDN_ENDTRACKA, (LPARAM)&nmh, TRUE);
1123 send_notify(pager, HDN_ITEMCHANGEDW, HDN_ITEMCHANGEDA, (LPARAM)&nmh, TRUE);
1124 send_notify(pager, HDN_ITEMCHANGINGW, HDN_ITEMCHANGINGA, (LPARAM)&nmh, TRUE);
1125 send_notify(pager, HDN_ITEMCLICKW, HDN_ITEMCLICKA, (LPARAM)&nmh, TRUE);
1126 send_notify(pager, HDN_ITEMDBLCLICKW, HDN_ITEMDBLCLICKA, (LPARAM)&nmh, TRUE);
1127 send_notify(pager, HDN_TRACKW, HDN_TRACKA, (LPARAM)&nmh, TRUE);
1128 }
1129
1130 static void test_wm_notify_tooltip(HWND pager)
1131 {
1132 NMTTDISPINFOW nmttdi;
1133 const struct notify_test_tooltip *data;
1134 INT i;
1135
1136 for (i = 0; i < ARRAY_SIZE(test_tooltip_data); i++)
1137 {
1138 data = test_tooltip_data + i;
1139 notify_test_info.sub_test_id = i;
1140
1141 memset(&nmttdi, 0, sizeof(nmttdi));
1142 if (data->send_sztext) memcpy(nmttdi.szText, data->send_sztext, data->send_sztext_size);
1143 if (data->send_lpsztext) nmttdi.lpszText = data->send_lpsztext;
1144 send_notify(pager, TTN_GETDISPINFOW, TTN_GETDISPINFOA, (LPARAM)&nmttdi, FALSE);
1145 if (data->return_sztext)
1146 {
1147 if (data->return_sztext_size == -1)
1148 ok(!lstrcmpW(nmttdi.szText, data->return_sztext), "Sub test %d expect %s, got %s\n", i,
1149 wine_dbgstr_w(data->return_sztext), wine_dbgstr_w(nmttdi.szText));
1150 else
1151 ok(!memcmp(nmttdi.szText, data->return_sztext, data->return_sztext_size), "Wrong szText content\n");
1152 }
1153 if (data->return_lpsztext)
1154 {
1155 if (IS_INTRESOURCE(data->return_lpsztext))
1156 ok(nmttdi.lpszText == data->return_lpsztext, "Sub test %d expect %s, got %s\n", i,
1157 wine_dbgstr_w(data->return_lpsztext), wine_dbgstr_w(nmttdi.lpszText));
1158 else
1159 ok(!lstrcmpW(nmttdi.lpszText, data->return_lpsztext), "Test %d expect %s, got %s\n", i,
1160 wine_dbgstr_w(data->return_lpsztext), wine_dbgstr_w(nmttdi.lpszText));
1161 }
1162 if (data->return_hinst)
1163 ok(nmttdi.hinst == data->return_hinst, "Sub test %d expect %p, got %p\n", i, data->return_hinst,
1164 nmttdi.hinst);
1165 }
1166 }
1167
1168 static void test_wm_notify(void)
1169 {
1170 static const CHAR *class = "Pager notify class";
1171 HWND parent, pager;
1172 /* Combo Box Ex */
1173 static NMCOMBOBOXEXW nmcbe;
1174 /* Date and Time Picker */
1175 static NMDATETIMEFORMATQUERYW nmdtfq;
1176 static NMDATETIMEWMKEYDOWNW nmdtkd;
1177 static NMDATETIMESTRINGW nmdts;
1178 /* Header */
1179 static NMHDDISPINFOW nmhddi;
1180 /* List View */
1181 static NMLVDISPINFOW nmlvdi;
1182 static NMLVGETINFOTIPW nmlvgit;
1183 static NMLVFINDITEMW nmlvfi;
1184 /* Tool Bar */
1185 static NMTBRESTORE nmtbr;
1186 static NMTBSAVE nmtbs;
1187 static NMTOOLBARW nmtb;
1188 static NMTBDISPINFOW nmtbdi;
1189 static NMTBGETINFOTIPW nmtbgit;
1190 /* Tree View */
1191 static NMTVDISPINFOW nmtvdi;
1192 static NMTVGETINFOTIPW nmtvgit;
1193 static NMTREEVIEWW nmtv;
1194 static const struct generic_text_helper_para paras[] =
1195 {
1196 /* Combo Box Ex */
1197 {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax,
1198 CBEN_INSERTITEM, CBEN_INSERTITEM, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1199 {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax,
1200 CBEN_DELETEITEM, CBEN_DELETEITEM, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1201 {&nmcbe, sizeof(nmcbe), &nmcbe.ceItem.mask, CBEIF_TEXT, &nmcbe.ceItem.pszText, &nmcbe.ceItem.cchTextMax,
1202 CBEN_GETDISPINFOW, CBEN_GETDISPINFOA, ZERO_SEND | SET_NULL_IF_NO_MASK | DONT_CONVERT_SEND | CONVERT_RECEIVE},
1203 /* Date and Time Picker */
1204 {&nmdtfq, sizeof(nmdtfq), NULL, 0, (WCHAR **)&nmdtfq.pszFormat, NULL, DTN_FORMATQUERYW, DTN_FORMATQUERYA,
1205 CONVERT_SEND},
1206 {&nmdtkd, sizeof(nmdtkd), NULL, 0, (WCHAR **)&nmdtkd.pszFormat, NULL, DTN_WMKEYDOWNW, DTN_WMKEYDOWNA,
1207 CONVERT_SEND},
1208 {&nmdts, sizeof(nmdts), NULL, 0, (WCHAR **)&nmdts.pszUserString, NULL, DTN_USERSTRINGW, DTN_USERSTRINGA,
1209 CONVERT_SEND},
1210 /* Header */
1211 {&nmhddi, sizeof(nmhddi), &nmhddi.mask, HDI_TEXT, &nmhddi.pszText, &nmhddi.cchTextMax, HDN_GETDISPINFOW,
1212 HDN_GETDISPINFOA, SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE},
1213 /* List View */
1214 {&nmlvfi, sizeof(nmlvfi), &nmlvfi.lvfi.flags, LVFI_STRING, (WCHAR **)&nmlvfi.lvfi.psz, NULL,
1215 LVN_INCREMENTALSEARCHW, LVN_INCREMENTALSEARCHA, CONVERT_SEND},
1216 {&nmlvfi, sizeof(nmlvfi), &nmlvfi.lvfi.flags, LVFI_SUBSTRING, (WCHAR **)&nmlvfi.lvfi.psz, NULL, LVN_ODFINDITEMW,
1217 LVN_ODFINDITEMA, CONVERT_SEND},
1218 {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax,
1219 LVN_BEGINLABELEDITW, LVN_BEGINLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1220 {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax,
1221 LVN_ENDLABELEDITW, LVN_ENDLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1222 {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax,
1223 LVN_GETDISPINFOW, LVN_GETDISPINFOA, DONT_CONVERT_SEND | CONVERT_RECEIVE},
1224 {&nmlvdi, sizeof(nmlvdi), &nmlvdi.item.mask, LVIF_TEXT, &nmlvdi.item.pszText, &nmlvdi.item.cchTextMax,
1225 LVN_SETDISPINFOW, LVN_SETDISPINFOA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1226 {&nmlvgit, sizeof(nmlvgit), NULL, 0, &nmlvgit.pszText, &nmlvgit.cchTextMax, LVN_GETINFOTIPW, LVN_GETINFOTIPA,
1227 CONVERT_SEND | CONVERT_RECEIVE},
1228 /* Tool Bar */
1229 {&nmtbs, sizeof(nmtbs), NULL, 0, (WCHAR **)&nmtbs.tbButton.iString, NULL, TBN_SAVE, TBN_SAVE,
1230 DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1231 {&nmtbr, sizeof(nmtbr), NULL, 0, (WCHAR **)&nmtbr.tbButton.iString, NULL, TBN_RESTORE, TBN_RESTORE,
1232 DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1233 {&nmtbdi, sizeof(nmtbdi), &nmtbdi.dwMask, TBNF_TEXT, &nmtbdi.pszText, &nmtbdi.cchText, TBN_GETDISPINFOW,
1234 TBN_GETDISPINFOW, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE},
1235 {&nmtb, sizeof(nmtb), NULL, 0, &nmtb.pszText, &nmtb.cchText, TBN_GETBUTTONINFOW, TBN_GETBUTTONINFOA,
1236 SEND_EMPTY_IF_NULL | CONVERT_SEND | CONVERT_RECEIVE},
1237 {&nmtbgit, sizeof(nmtbgit), NULL, 0, &nmtbgit.pszText, &nmtbgit.cchTextMax, TBN_GETINFOTIPW, TBN_GETINFOTIPA,
1238 DONT_CONVERT_SEND | CONVERT_RECEIVE},
1239 /* Tree View */
1240 {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax,
1241 TVN_BEGINLABELEDITW, TVN_BEGINLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1242 {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax,
1243 TVN_ENDLABELEDITW, TVN_ENDLABELEDITA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1244 {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax,
1245 TVN_GETDISPINFOW, TVN_GETDISPINFOA, ZERO_SEND | DONT_CONVERT_SEND| CONVERT_RECEIVE},
1246 {&nmtvdi, sizeof(nmtvdi), &nmtvdi.item.mask, TVIF_TEXT, &nmtvdi.item.pszText, &nmtvdi.item.cchTextMax,
1247 TVN_SETDISPINFOW, TVN_SETDISPINFOA, SET_NULL_IF_NO_MASK | CONVERT_SEND | CONVERT_RECEIVE},
1248 {&nmtvgit, sizeof(nmtvgit), NULL, 0, &nmtvgit.pszText, &nmtvgit.cchTextMax, TVN_GETINFOTIPW, TVN_GETINFOTIPA,
1249 DONT_CONVERT_SEND | CONVERT_RECEIVE},
1250 {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1251 TVN_SINGLEEXPAND, TVN_SINGLEEXPAND, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE, TVITEM_NEW_HANDLER},
1252 {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1253 TVN_SINGLEEXPAND, TVN_SINGLEEXPAND, DONT_CONVERT_SEND | DONT_CONVERT_RECEIVE, TVITEM_OLD_HANDLER},
1254 {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1255 TVN_BEGINDRAGW, TVN_BEGINDRAGA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1256 {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1257 TVN_BEGINDRAGW, TVN_BEGINDRAGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER},
1258 {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1259 TVN_BEGINRDRAGW, TVN_BEGINRDRAGA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1260 {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1261 TVN_BEGINRDRAGW, TVN_BEGINRDRAGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER},
1262 {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1263 TVN_ITEMEXPANDEDW, TVN_ITEMEXPANDEDA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1264 {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1265 TVN_ITEMEXPANDEDW, TVN_ITEMEXPANDEDA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER},
1266 {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1267 TVN_ITEMEXPANDINGW, TVN_ITEMEXPANDINGA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1268 {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1269 TVN_ITEMEXPANDINGW, TVN_ITEMEXPANDINGA, DONT_CONVERT_SEND, TVITEM_OLD_HANDLER},
1270 {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1271 TVN_DELETEITEMW, TVN_DELETEITEMA, DONT_CONVERT_SEND, TVITEM_NEW_HANDLER},
1272 {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1273 TVN_DELETEITEMW, TVN_DELETEITEMA, CONVERT_SEND, TVITEM_OLD_HANDLER},
1274 {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1275 TVN_SELCHANGINGW, TVN_SELCHANGINGA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1276 {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1277 TVN_SELCHANGINGW, TVN_SELCHANGINGA, CONVERT_SEND, TVITEM_OLD_HANDLER},
1278 {&nmtv, sizeof(nmtv), &nmtv.itemNew.mask, TVIF_TEXT, &nmtv.itemNew.pszText, &nmtv.itemNew.cchTextMax,
1279 TVN_SELCHANGEDW, TVN_SELCHANGEDA, CONVERT_SEND, TVITEM_NEW_HANDLER},
1280 {&nmtv, sizeof(nmtv), &nmtv.itemOld.mask, TVIF_TEXT, &nmtv.itemOld.pszText, &nmtv.itemOld.cchTextMax,
1281 TVN_SELCHANGEDW, TVN_SELCHANGEDA, CONVERT_SEND, TVITEM_OLD_HANDLER}
1282 };
1283 INT i;
1284
1285 ok(register_test_notify_class(), "Register test class failed, error 0x%08x\n", GetLastError());
1286
1287 parent = CreateWindowA(class, "parent", WS_OVERLAPPED, 0, 0, 100, 100, 0, 0, GetModuleHandleA(0), 0);
1288 ok(parent != NULL, "CreateWindow failed\n");
1289 pager = CreateWindowA(WC_PAGESCROLLERA, "pager", WS_CHILD, 0, 0, 100, 100, parent, 0, GetModuleHandleA(0), 0);
1290 ok(pager != NULL, "CreateWindow failed\n");
1291 child1_wnd = CreateWindowA(class, "child", WS_CHILD, 0, 0, 100, 100, pager, (HMENU)1, GetModuleHandleA(0), 0);
1292 ok(child1_wnd != NULL, "CreateWindow failed\n");
1293 SendMessageW(pager, PGM_SETCHILD, 0, (LPARAM)child1_wnd);
1294
1295 for (i = 0; i < ARRAY_SIZE(paras); i++)
1296 test_notify_generic_text_helper(pager, paras + i);
1297
1298 /* Tests for those that can't be covered by generic text test helper */
1299 test_wm_notify_comboboxex(pager);
1300 test_wm_notify_datetime(pager);
1301 test_wm_notify_header(pager);
1302 test_wm_notify_tooltip(pager);
1303
1304 DestroyWindow(parent);
1305 UnregisterClassA(class, GetModuleHandleA(NULL));
1306 }
1307
1308 static void init_functions(void)
1309 {
1310 HMODULE mod = LoadLibraryA("comctl32.dll");
1311
1312 #define X(f) p##f = (void*)GetProcAddress(mod, #f);
1313 X(InitCommonControlsEx);
1314 #undef X
1315
1316 pSetWindowSubclass = (void*)GetProcAddress(mod, (LPSTR)410);
1317 }
1318
1319 START_TEST(pager)
1320 {
1321 INITCOMMONCONTROLSEX iccex;
1322
1323 init_functions();
1324
1325 iccex.dwSize = sizeof(iccex);
1326 iccex.dwICC = ICC_PAGESCROLLER_CLASS;
1327 pInitCommonControlsEx(&iccex);
1328
1329 init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1330
1331 parent_wnd = create_parent_window();
1332 ok(parent_wnd != NULL, "Failed to create parent window!\n");
1333
1334 test_pager();
1335 test_wm_notifyformat();
1336 test_wm_notify();
1337
1338 DestroyWindow(parent_wnd);
1339 }