?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push eb25bf65c4616aa55a810ed5c29198b1a080b208
[wine/hacks.git] / dlls / comctl32 / tests / monthcal.c
blobf116da52ec1ffcdef4b34be142ee8e1f30a12c6d
1 /*
2 * comctl32 month calendar unit tests
3 *
4 * Copyright (C) 2006 Vitaliy Margolen
5 * Copyright (C) 2007 Farshad Agah
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23
24 #include "windef.h"
25 #include "winbase.h"
26 #include "winuser.h"
27
28 #include "commctrl.h"
29
30 #include "wine/test.h"
31 #include <assert.h>
32 #include <windows.h>
33 #include "msg.h"
34
35 #define expect(expected, got) ok(expected == got, "Expected %d, got %d\n", expected, got);
36
37 #define NUM_MSG_SEQUENCES 2
38 #define PARENT_SEQ_INDEX 0
39 #define MONTHCAL_SEQ_INDEX 1
40
41 struct subclass_info
42 {
43 WNDPROC oldproc;
44 };
45
46 static struct msg_sequence *sequences[NUM_MSG_SEQUENCES];
47
48 static const struct message create_parent_window_seq[] = {
49 { WM_GETMINMAXINFO, sent },
50 { WM_NCCREATE, sent },
51 { WM_NCCALCSIZE, sent|wparam, 0 },
52 { WM_CREATE, sent },
53 { WM_SHOWWINDOW, sent|wparam, 1 },
54 { WM_WINDOWPOSCHANGING, sent|wparam, 0 },
55 { WM_QUERYNEWPALETTE, sent|optional },
56 { WM_WINDOWPOSCHANGING, sent|wparam|optional, 0 },
57 { WM_WINDOWPOSCHANGED, sent|optional },
58 { WM_ACTIVATEAPP, sent|wparam, 1 },
59 { WM_NCACTIVATE, sent|wparam, 1 },
60 { WM_ACTIVATE, sent|wparam, 1 },
61 { WM_IME_SETCONTEXT, sent|wparam|defwinproc|optional, 1 },
62 { WM_IME_NOTIFY, sent|defwinproc|optional },
63 { WM_SETFOCUS, sent|wparam|defwinproc, 0 },
64 /* Win9x adds SWP_NOZORDER below */
65 { WM_WINDOWPOSCHANGED, sent, /*|wparam, SWP_SHOWWINDOW|SWP_NOSIZE|SWP_NOMOVE|SWP_NOCLIENTSIZE|SWP_NOCLIENTMOVE*/ },
66 { WM_NCCALCSIZE, sent|wparam|optional, 1 },
67 { WM_SIZE, sent },
68 { WM_MOVE, sent },
69 { 0 }
70 };
71
72 static const struct message create_monthcal_control_seq[] = {
73 { WM_NOTIFYFORMAT, sent|lparam, 0, NF_QUERY },
74 { WM_QUERYUISTATE, sent|optional },
75 { WM_GETFONT, sent },
76 { WM_PARENTNOTIFY, sent|wparam, WM_CREATE},
77 { 0 }
78 };
79
80 static const struct message create_monthcal_multi_sel_style_seq[] = {
81 { WM_NOTIFYFORMAT, sent|lparam, 0, NF_QUERY },
82 { WM_QUERYUISTATE, sent|optional },
83 { WM_GETFONT, sent },
84 { 0 }
85 };
86
87 static const struct message monthcal_color_seq[] = {
88 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_BACKGROUND, 0},
89 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_BACKGROUND, RGB(0,0,0)},
90 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_BACKGROUND, 0},
91 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_BACKGROUND, RGB(255,255,255)},
92 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_BACKGROUND, 0},
93
94 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_MONTHBK, 0},
95 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_MONTHBK, RGB(0,0,0)},
96 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_MONTHBK, 0},
97 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_MONTHBK, RGB(255,255,255)},
98 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_MONTHBK, 0},
99
100 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TEXT, 0},
101 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_TEXT, RGB(0,0,0)},
102 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TEXT, 0},
103 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_TEXT, RGB(255,255,255)},
104 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TEXT, 0},
105
106 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TITLEBK, 0},
107 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_TITLEBK, RGB(0,0,0)},
108 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TITLEBK, 0},
109 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_TITLEBK, RGB(255,255,255)},
110 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TITLEBK, 0},
111
112 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TITLETEXT, 0},
113 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_TITLETEXT, RGB(0,0,0)},
114 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TITLETEXT, 0},
115 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_TITLETEXT, RGB(255,255,255)},
116 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TITLETEXT, 0},
117
118 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TRAILINGTEXT, 0},
119 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_TRAILINGTEXT, RGB(0,0,0)},
120 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TRAILINGTEXT, 0},
121 { MCM_SETCOLOR, sent|wparam|lparam, MCSC_TRAILINGTEXT, RGB(255,255,255)},
122 { MCM_GETCOLOR, sent|wparam|lparam, MCSC_TRAILINGTEXT, 0},
123 { 0 }
124 };
125
126 static const struct message monthcal_curr_date_seq[] = {
127 { MCM_SETCURSEL, sent|wparam, 0},
128 { WM_PAINT, sent|wparam|lparam|defwinproc, 0, 0},
129 { WM_ERASEBKGND, sent|lparam|defwinproc, 0},
130 { MCM_SETCURSEL, sent|wparam, 0},
131 { MCM_SETCURSEL, sent|wparam, 0},
132 { MCM_GETCURSEL, sent|wparam, 0},
133 { MCM_GETCURSEL, sent|wparam|lparam, 0, 0},
134 { 0 }
135 };
136
137 static const struct message monthcal_first_day_seq[] = {
138 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
139
140 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, -5},
141 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
142
143 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, -4},
144 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
145
146 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, -3},
147 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
148
149 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, -2},
150 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
151
152 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, -1},
153 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
154
155 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
156 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
157
158 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 1},
159 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
160
161 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 2},
162 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
163
164 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 3},
165 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
166
167 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 4},
168 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
169
170 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 5},
171 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
172
173 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 6},
174 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
175
176 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 7},
177 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
178
179 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 8},
180 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
181
182 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 9},
183 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
184
185 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 10},
186 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
187
188 { MCM_SETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 11},
189 { MCM_GETFIRSTDAYOFWEEK, sent|wparam|lparam, 0, 0},
190 { 0 }
191 };
192
193 static const struct message monthcal_unicode_seq[] = {
194 { MCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0},
195 { MCM_SETUNICODEFORMAT, sent|wparam|lparam, 1, 0},
196 { MCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0},
197 { MCM_SETUNICODEFORMAT, sent|wparam|lparam, 0, 0},
198 { MCM_GETUNICODEFORMAT, sent|wparam|lparam, 0, 0},
199 { MCM_SETUNICODEFORMAT, sent|wparam|lparam, 1, 0},
200 { 0 }
201 };
202
203 static const struct message monthcal_hit_test_seq[] = {
204 { MCM_SETCURSEL, sent|wparam, 0},
205 { WM_PAINT, sent|wparam|lparam|defwinproc, 0, 0},
206 { MCM_HITTEST, sent|wparam, 0},
207 { MCM_HITTEST, sent|wparam, 0},
208 { MCM_HITTEST, sent|wparam, 0},
209 { MCM_HITTEST, sent|wparam, 0},
210 { MCM_HITTEST, sent|wparam, 0},
211 { MCM_HITTEST, sent|wparam, 0},
212 { MCM_HITTEST, sent|wparam, 0},
213 { MCM_HITTEST, sent|wparam, 0},
214 { MCM_HITTEST, sent|wparam, 0},
215 { MCM_HITTEST, sent|wparam, 0},
216 { MCM_HITTEST, sent|wparam, 0},
217 { MCM_HITTEST, sent|wparam, 0},
218 { MCM_HITTEST, sent|wparam, 0},
219 { 0 }
220 };
221
222 static const struct message monthcal_todaylink_seq[] = {
223 { MCM_HITTEST, sent|wparam, 0},
224 { MCM_SETTODAY, sent|wparam, 0},
225 { WM_PAINT, sent|wparam|lparam|defwinproc, 0, 0},
226 { MCM_GETTODAY, sent|wparam, 0},
227 { WM_LBUTTONDOWN, sent|wparam|lparam, MK_LBUTTON, MAKELONG(70, 370)},
228 { WM_CAPTURECHANGED, sent|wparam|lparam|defwinproc, 0, 0},
229 { WM_PAINT, sent|wparam|lparam|defwinproc, 0, 0},
230 { MCM_GETCURSEL, sent|wparam, 0},
231 { 0 }
232 };
233
234 static const struct message monthcal_today_seq[] = {
235 { MCM_SETTODAY, sent|wparam, 0},
236 { WM_PAINT, sent|wparam|lparam|defwinproc, 0, 0},
237 { MCM_GETTODAY, sent|wparam, 0},
238 { MCM_SETTODAY, sent|wparam, 0},
239 { WM_PAINT, sent|wparam|lparam|defwinproc, 0, 0},
240 { MCM_GETTODAY, sent|wparam, 0},
241 { 0 }
242 };
243
244 static const struct message monthcal_scroll_seq[] = {
245 { MCM_SETMONTHDELTA, sent|wparam|lparam, 2, 0},
246 { MCM_SETMONTHDELTA, sent|wparam|lparam, 3, 0},
247 { MCM_GETMONTHDELTA, sent|wparam|lparam, 0, 0},
248 { MCM_SETMONTHDELTA, sent|wparam|lparam, 12, 0},
249 { MCM_GETMONTHDELTA, sent|wparam|lparam, 0, 0},
250 { MCM_SETMONTHDELTA, sent|wparam|lparam, 15, 0},
251 { MCM_GETMONTHDELTA, sent|wparam|lparam, 0, 0},
252 { MCM_SETMONTHDELTA, sent|wparam|lparam, -5, 0},
253 { MCM_GETMONTHDELTA, sent|wparam|lparam, 0, 0},
254 { 0 }
255 };
256
257 static const struct message monthcal_monthrange_seq[] = {
258 { MCM_GETMONTHRANGE, sent|wparam, GMR_VISIBLE},
259 { MCM_GETMONTHRANGE, sent|wparam, GMR_DAYSTATE},
260 { 0 }
261 };
262
263 static const struct message monthcal_max_sel_day_seq[] = {
264 { MCM_SETMAXSELCOUNT, sent|wparam|lparam, 5, 0},
265 { MCM_GETMAXSELCOUNT, sent|wparam|lparam, 0, 0},
266 { MCM_SETMAXSELCOUNT, sent|wparam|lparam, 15, 0},
267 { MCM_GETMAXSELCOUNT, sent|wparam|lparam, 0, 0},
268 { MCM_SETMAXSELCOUNT, sent|wparam|lparam, -1, 0},
269 { MCM_GETMAXSELCOUNT, sent|wparam|lparam, 0, 0},
270 { 0 }
271 };
272
273 /* expected message sequence for parent*/
274 static const struct message destroy_monthcal_parent_msgs_seq[] = {
275 { WM_PARENTNOTIFY, sent|wparam, WM_DESTROY},
276 { 0 }
277 };
278
279 /* expected message sequence for child*/
280 static const struct message destroy_monthcal_child_msgs_seq[] = {
281 { 0x0090, sent|optional }, /* Vista */
282 { WM_SHOWWINDOW, sent|wparam|lparam, 0, 0},
283 { WM_WINDOWPOSCHANGING, sent|wparam, 0},
284 { WM_WINDOWPOSCHANGED, sent|wparam, 0},
285 { WM_DESTROY, sent|wparam|lparam, 0, 0},
286 { WM_NCDESTROY, sent|wparam|lparam, 0, 0},
287 { 0 }
288 };
289
290 static const struct message destroy_monthcal_multi_sel_style_seq[] = {
291 { 0x0090, sent|optional }, /* Vista */
292 { WM_DESTROY, sent|wparam|lparam, 0, 0},
293 { WM_NCDESTROY, sent|wparam|lparam, 0, 0},
294 { 0 }
295 };
296
297 /* expected message sequence for parent window*/
298 static const struct message destroy_parent_seq[] = {
299 { 0x0090, sent|optional }, /* Vista */
300 { WM_WINDOWPOSCHANGING, sent|wparam, 0},
301 { WM_WINDOWPOSCHANGED, sent|wparam, 0},
302 { WM_NCACTIVATE, sent|wparam, 0},
303 { WM_ACTIVATE, sent|wparam, 0},
304 { WM_NCACTIVATE, sent|wparam|lparam|optional, 0, 0},
305 { WM_ACTIVATE, sent|wparam|lparam|optional, 0, 0},
306 { WM_ACTIVATEAPP, sent|wparam, 0},
307 { WM_KILLFOCUS, sent|wparam|lparam, 0, 0},
308 { WM_IME_SETCONTEXT, sent|wparam|optional, 0},
309 { WM_IME_NOTIFY, sent|wparam|lparam|defwinproc|optional, 1, 0},
310 { WM_DESTROY, sent|wparam|lparam, 0, 0},
311 { WM_NCDESTROY, sent|wparam|lparam, 0, 0},
312 { 0 }
313 };
314
315 static void test_monthcal(void)
316 {
317 HWND hwnd;
318 SYSTEMTIME st[2], st1[2];
319 int res, month_range;
320
321 hwnd = CreateWindowA(MONTHCAL_CLASSA, "MonthCal", WS_POPUP | WS_VISIBLE, CW_USEDEFAULT,
322 0, 300, 300, 0, 0, NULL, NULL);
323 ok(hwnd != NULL, "Failed to create MonthCal\n");
324 GetSystemTime(&st[0]);
325 st[1] = st[0];
326
327 /* Invalid date/time */
328 st[0].wYear = 2000;
329 /* Time should not matter */
330 st[1].wHour = st[1].wMinute = st[1].wSecond = 70;
331 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set MAX limit\n");
332 ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
333 ok(st1[0].wYear != 2000, "Lover limit changed\n");
334
335 st[1].wMonth = 0;
336 ok(!SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Should have failed to set limits\n");
337 ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
338 ok(st1[0].wYear != 2000, "Lover limit changed\n");
339 ok(!SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Should have failed to set MAX limit\n");
340 ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "No limits should be set\n");
341 ok(st1[0].wYear != 2000, "Lover limit changed\n");
342
343 GetSystemTime(&st[0]);
344 st[0].wDay = 20;
345 st[0].wMonth = 5;
346 st[1] = st[0];
347
348 month_range = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
349 st[1].wMonth--;
350 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Failed to set both min and max limits\n");
351 res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
352 ok(res == month_range, "Invalid month range (%d)\n", res);
353 ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == (GDTR_MIN|GDTR_MAX), "Limits should be set\n");
354
355 st[1].wMonth += 2;
356 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Failed to set both min and max limits\n");
357 res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st1);
358 ok(res == month_range, "Invalid month range (%d)\n", res);
359
360 st[1].wYear --;
361 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Failed to set both min and max limits\n");
362 st[1].wYear += 1;
363 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MIN | GDTR_MAX, (LPARAM)st), "Failed to set both min and max limits\n");
364
365 st[1].wMonth -= 3;
366 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
367 ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "Only MAX limit should be set\n");
368 st[1].wMonth += 4;
369 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
370 st[1].wYear -= 3;
371 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
372 st[1].wYear += 4;
373 ok(SendMessage(hwnd, MCM_SETRANGE, GDTR_MAX, (LPARAM)st), "Failed to set max limit\n");
374 ok(SendMessage(hwnd, MCM_GETRANGE, 0, (LPARAM)st1) == GDTR_MAX, "Only MAX limit should be set\n");
375
376 DestroyWindow(hwnd);
377 }
378
379 static LRESULT WINAPI parent_wnd_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
380 {
381 static long defwndproc_counter = 0;
382 LRESULT ret;
383 struct message msg;
384
385 /* log system messages, except for painting */
386 if (message < WM_USER &&
387 message != WM_PAINT &&
388 message != WM_ERASEBKGND &&
389 message != WM_NCPAINT &&
390 message != WM_NCHITTEST &&
391 message != WM_GETTEXT &&
392 message != WM_GETICON &&
393 message != WM_DEVICECHANGE)
394 {
395 trace("parent: %p, %04x, %08lx, %08lx\n", hwnd, message, wParam, lParam);
396
397 msg.message = message;
398 msg.flags = sent|wparam|lparam;
399 if (defwndproc_counter) msg.flags |= defwinproc;
400 msg.wParam = wParam;
401 msg.lParam = lParam;
402 add_message(sequences, PARENT_SEQ_INDEX, &msg);
403 }
404
405 defwndproc_counter++;
406 ret = DefWindowProcA(hwnd, message, wParam, lParam);
407 defwndproc_counter--;
408
409 return ret;
410 }
411
412 static BOOL register_parent_wnd_class(void)
413 {
414 WNDCLASSA cls;
415
416 cls.style = 0;
417 cls.lpfnWndProc = parent_wnd_proc;
418 cls.cbClsExtra = 0;
419 cls.cbWndExtra = 0;
420 cls.hInstance = GetModuleHandleA(NULL);
421 cls.hIcon = 0;
422 cls.hCursor = LoadCursorA(0, IDC_ARROW);
423 cls.hbrBackground = GetStockObject(WHITE_BRUSH);
424 cls.lpszMenuName = NULL;
425 cls.lpszClassName = "Month-Cal test parent class";
426 return RegisterClassA(&cls);
427 }
428
429 static HWND create_parent_window(void)
430 {
431 HWND hwnd;
432
433 InitCommonControls();
434
435 /* flush message sequences, so we can check the new sequence by the end of function */
436 flush_sequences(sequences, NUM_MSG_SEQUENCES);
437
438 if (!register_parent_wnd_class())
439 return NULL;
440
441 hwnd = CreateWindowEx(0, "Month-Cal test parent class",
442 "Month-Cal test parent window",
443 WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX |
444 WS_MAXIMIZEBOX | WS_VISIBLE,
445 0, 0, 500, 500,
446 GetDesktopWindow(), NULL, GetModuleHandleA(NULL), NULL);
447
448 assert(hwnd);
449
450 /* check for message sequences */
451 ok_sequence(sequences, PARENT_SEQ_INDEX, create_parent_window_seq, "create parent window", FALSE);
452
453 return hwnd;
454 }
455
456 static LRESULT WINAPI monthcal_subclass_proc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
457 {
458 struct subclass_info *info = (struct subclass_info *)GetWindowLongPtrA(hwnd, GWLP_USERDATA);
459 static long defwndproc_counter = 0;
460 LRESULT ret;
461 struct message msg;
462
463 msg.message = message;
464 msg.flags = sent|wparam|lparam;
465 if (defwndproc_counter) msg.flags |= defwinproc;
466 msg.wParam = wParam;
467 msg.lParam = lParam;
468 add_message(sequences, MONTHCAL_SEQ_INDEX, &msg);
469
470 defwndproc_counter++;
471 ret = CallWindowProcA(info->oldproc, hwnd, message, wParam, lParam);
472 defwndproc_counter--;
473
474 return ret;
475 }
476
477 static HWND create_monthcal_control(DWORD style, HWND parent_window)
478 {
479 struct subclass_info *info;
480 HWND hwnd;
481
482 info = HeapAlloc(GetProcessHeap(), 0, sizeof(struct subclass_info));
483 if (!info)
484 return NULL;
485
486 hwnd = CreateWindowEx(0,
487 MONTHCAL_CLASS,
488 "",
489 style,
490 0, 0, 300, 400,
491 parent_window, NULL, GetModuleHandleA(NULL), NULL);
492
493 if (!hwnd)
494 {
495 HeapFree(GetProcessHeap(), 0, info);
496 return NULL;
497 }
498
499 info->oldproc = (WNDPROC)SetWindowLongPtrA(hwnd, GWLP_WNDPROC,
500 (LONG_PTR)monthcal_subclass_proc);
501 SetWindowLongPtrA(hwnd, GWLP_USERDATA, (LONG_PTR)info);
502
503 return hwnd;
504 }
505
506
507 /* Setter and Getters Tests */
508
509 static void test_monthcal_color(HWND hwnd)
510 {
511 int res, temp;
512
513 flush_sequences(sequences, NUM_MSG_SEQUENCES);
514
515 /* Setter and Getters for color*/
516 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
517 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_BACKGROUND, RGB(0,0,0));
518 expect(temp, res);
519 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
520 expect(RGB(0,0,0), temp);
521 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_BACKGROUND, RGB(255,255,255));
522 expect(temp, res);
523 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_BACKGROUND, 0);
524 expect(RGB(255,255,255), temp);
525
526 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
527 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_MONTHBK, RGB(0,0,0));
528 expect(temp, res);
529 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
530 expect(RGB(0,0,0), temp);
531 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_MONTHBK, RGB(255,255,255));
532 expect(temp, res);
533 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_MONTHBK, 0);
534 expect(RGB(255,255,255), temp);
535
536 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
537 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TEXT, RGB(0,0,0));
538 expect(temp, res);
539 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
540 expect(RGB(0,0,0), temp);
541 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TEXT, RGB(255,255,255));
542 expect(temp, res);
543 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TEXT, 0);
544 expect(RGB(255,255,255), temp);
545
546 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
547 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TITLEBK, RGB(0,0,0));
548 expect(temp, res);
549 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
550 expect(RGB(0,0,0), temp);
551 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TITLEBK, RGB(255,255,255));
552 expect(temp, res);
553 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLEBK, 0);
554 expect(RGB(255,255,255), temp);
555
556 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
557 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TITLETEXT, RGB(0,0,0));
558 expect(temp, res);
559 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
560 expect(RGB(0,0,0), temp);
561 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TITLETEXT, RGB(255,255,255));
562 expect(temp, res);
563 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TITLETEXT, 0);
564 expect(RGB(255,255,255), temp);
565
566 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
567 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TRAILINGTEXT, RGB(0,0,0));
568 expect(temp, res);
569 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
570 expect(RGB(0,0,0), temp);
571 res = SendMessage(hwnd, MCM_SETCOLOR, MCSC_TRAILINGTEXT, RGB(255,255,255));
572 expect(temp, res);
573 temp = SendMessage(hwnd, MCM_GETCOLOR, MCSC_TRAILINGTEXT, 0);
574 expect(RGB(255,255,255), temp);
575
576 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_color_seq, "monthcal color", FALSE);
577 }
578
579 static void test_monthcal_currDate(HWND hwnd)
580 {
581 SYSTEMTIME st_original, st_new, st_test;
582 int res;
583
584 flush_sequences(sequences, NUM_MSG_SEQUENCES);
585
586 /* Setter and Getters for current date selected */
587 st_original.wYear = 2000;
588 st_original.wMonth = 11;
589 st_original.wDay = 28;
590 st_original.wHour = 11;
591 st_original.wMinute = 59;
592 st_original.wSecond = 30;
593 st_original.wMilliseconds = 0;
594 st_original.wDayOfWeek = 0;
595
596 st_new = st_test = st_original;
597
598 /* Should not validate the time */
599 res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
600 expect(1,res);
601
602 /* Overflow matters, check for wDay */
603 st_test.wDay += 4;
604 res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
605 expect(0,res);
606
607 /* correct wDay before checking for wMonth */
608 st_test.wDay -= 4;
609 expect(st_original.wDay, st_test.wDay);
610
611 /* Overflow matters, check for wMonth */
612 st_test.wMonth += 4;
613 res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st_test);
614 expect(0,res);
615
616 /* checking if gets the information right, modify st_new */
617 st_new.wYear += 4;
618 st_new.wMonth += 4;
619 st_new.wDay += 4;
620 st_new.wHour += 4;
621 st_new.wMinute += 4;
622 st_new.wSecond += 4;
623
624 res = SendMessage(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_new);
625 expect(1, res);
626
627 /* st_new change to st_origin, above settings with overflow */
628 /* should not change the current settings */
629 expect(st_original.wYear, st_new.wYear);
630 expect(st_original.wMonth, st_new.wMonth);
631 expect(st_original.wDay, st_new.wDay);
632 expect(st_original.wHour, st_new.wHour);
633 expect(st_original.wMinute, st_new.wMinute);
634 expect(st_original.wSecond, st_new.wSecond);
635
636 /* lparam cannot be NULL */
637 res = SendMessage(hwnd, MCM_GETCURSEL, 0, 0);
638 expect(0, res);
639
640 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_curr_date_seq, "monthcal currDate", TRUE);
641 }
642
643 static void test_monthcal_firstDay(HWND hwnd)
644 {
645 int res, fday, i, prev;
646 TCHAR b[128];
647 LCID lcid = LOCALE_USER_DEFAULT;
648
649 flush_sequences(sequences, NUM_MSG_SEQUENCES);
650
651 /* Setter and Getters for first day of week */
652 /* check for locale first day */
653 if(GetLocaleInfo(lcid, LOCALE_IFIRSTDAYOFWEEK, b, 128)){
654 fday = atoi(b);
655 trace("fday: %d\n", fday);
656 res = SendMessage(hwnd, MCM_GETFIRSTDAYOFWEEK, 0, 0);
657 expect(fday, res);
658 prev = fday;
659
660 /* checking for the values that actually will be stored as */
661 /* current first day when we set a new value */
662 for (i = -5; i < 12; i++){
663 res = SendMessage(hwnd, MCM_SETFIRSTDAYOFWEEK, 0, (LPARAM) i);
664 expect(prev, res);
665 res = SendMessage(hwnd, MCM_GETFIRSTDAYOFWEEK, 0, 0);
666 prev = res;
667
668 if (i == -1){
669 expect(MAKELONG(fday, FALSE), res);
670 }else if (i >= 7){
671 /* out of range sets max first day of week, locale is ignored */
672 expect(MAKELONG(6, TRUE), res);
673 }else{
674 expect(MAKELONG(i, TRUE), res);
675 }
676 }
677
678 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_first_day_seq, "monthcal firstDay", FALSE);
679
680 }else{
681 skip("Cannot retrieve first day of the week\n");
682 }
683
684 }
685
686 static void test_monthcal_unicode(HWND hwnd)
687 {
688 int res, temp;
689
690 flush_sequences(sequences, NUM_MSG_SEQUENCES);
691
692 /* Setter and Getters for Unicode format */
693
694 /* getting the current settings */
695 temp = SendMessage(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
696
697 /* setting to 1, should return previous settings */
698 res = SendMessage(hwnd, MCM_SETUNICODEFORMAT, 1, 0);
699 expect(temp, res);
700
701 /* current setting is 1, so, should return 1 */
702 res = SendMessage(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
703 todo_wine {expect(1, res);}
704
705 /* setting to 0, should return previous settings */
706 res = SendMessage(hwnd, MCM_SETUNICODEFORMAT, 0, 0);
707 todo_wine {expect(1, res);}
708
709 /* current setting is 0, so, it should return 0 */
710 res = SendMessage(hwnd, MCM_GETUNICODEFORMAT, 0, 0);
711 expect(0, res);
712
713 /* should return previous settings */
714 res = SendMessage(hwnd, MCM_SETUNICODEFORMAT, 1, 0);
715 expect(0, res);
716
717 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_unicode_seq, "monthcal unicode", FALSE);
718 }
719
720 static void test_monthcal_HitTest(HWND hwnd)
721 {
722 MCHITTESTINFO mchit;
723 UINT res;
724 SYSTEMTIME st;
725 LONG x;
726 UINT title_index;
727 static const UINT title_hits[] =
728 { MCHT_NOWHERE, MCHT_TITLEBK, MCHT_TITLEBTNPREV, MCHT_TITLEBK,
729 MCHT_TITLEMONTH, MCHT_TITLEBK, MCHT_TITLEYEAR, MCHT_TITLEBK,
730 MCHT_TITLEBTNNEXT, MCHT_TITLEBK, MCHT_NOWHERE };
731
732 memset(&mchit, 0, sizeof(MCHITTESTINFO));
733
734 flush_sequences(sequences, NUM_MSG_SEQUENCES);
735
736 st.wYear = 2007;
737 st.wMonth = 4;
738 st.wDay = 11;
739 st.wHour = 1;
740 st.wMinute = 0;
741 st.wSecond = 0;
742 st.wMilliseconds = 0;
743 st.wDayOfWeek = 0;
744
745 res = SendMessage(hwnd, MCM_SETCURSEL, 0, (LPARAM)&st);
746 expect(1,res);
747
748 /* (0, 0) is the top left of the control and should not be active */
749 mchit.cbSize = sizeof(MCHITTESTINFO);
750 mchit.pt.x = 0;
751 mchit.pt.y = 0;
752 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
753 expect(0, mchit.pt.x);
754 expect(0, mchit.pt.y);
755 expect(mchit.uHit, res);
756 todo_wine {expect(MCHT_NOWHERE, res);}
757
758 /* (300, 400) is the bottom right of the control and should not be active */
759 mchit.pt.x = 300;
760 mchit.pt.y = 400;
761 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
762 expect(300, mchit.pt.x);
763 expect(400, mchit.pt.y);
764 expect(mchit.uHit, res);
765 todo_wine {expect(MCHT_NOWHERE, res);}
766
767 /* (500, 500) is completely out of the control and should not be active */
768 mchit.pt.x = 500;
769 mchit.pt.y = 500;
770 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
771 expect(500, mchit.pt.x);
772 expect(500, mchit.pt.y);
773 expect(mchit.uHit, res);
774 todo_wine {expect(MCHT_NOWHERE, res);}
775
776 /* (120, 180) is in active area - calendar background */
777 mchit.pt.x = 120;
778 mchit.pt.y = 180;
779 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
780 expect(120, mchit.pt.x);
781 expect(180, mchit.pt.y);
782 expect(mchit.uHit, res);
783 expect(MCHT_CALENDARBK, res);
784
785 /* (70, 70) is in active area - day of the week */
786 mchit.pt.x = 70;
787 mchit.pt.y = 70;
788 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
789 expect(70, mchit.pt.x);
790 expect(70, mchit.pt.y);
791 expect(mchit.uHit, res);
792 todo_wine {expect(MCHT_CALENDARDAY, res);}
793
794 /* (70, 90) is in active area - date from prev month */
795 mchit.pt.x = 70;
796 mchit.pt.y = 90;
797 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
798 expect(70, mchit.pt.x);
799 expect(90, mchit.pt.y);
800 expect(mchit.uHit, res);
801 todo_wine {expect(MCHT_CALENDARDATEPREV, res);}
802
803 #if 0
804 /* (125, 115) is in active area - date from this month */
805 mchit.pt.x = 125;
806 mchit.pt.y = 115;
807 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
808 expect(125, mchit.pt.x);
809 expect(115, mchit.pt.y);
810 expect(mchit.uHit, res);
811 expect(MCHT_CALENDARDATE, res);
812 #endif
813
814 /* (80, 220) is in active area - background section of the title */
815 mchit.pt.x = 80;
816 mchit.pt.y = 220;
817 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
818 expect(80, mchit.pt.x);
819 expect(220, mchit.pt.y);
820 expect(mchit.uHit, res);
821 todo_wine {expect(MCHT_TITLEBK, res);}
822
823 /* (140, 215) is in active area - month section of the title */
824 mchit.pt.x = 140;
825 mchit.pt.y = 215;
826 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
827 expect(140, mchit.pt.x);
828 expect(215, mchit.pt.y);
829 expect(mchit.uHit, res);
830 todo_wine {expect(MCHT_TITLEMONTH, res);}
831
832 /* (170, 215) is in active area - year section of the title */
833 mchit.pt.x = 170;
834 mchit.pt.y = 215;
835 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
836 expect(170, mchit.pt.x);
837 expect(215, mchit.pt.y);
838 expect(mchit.uHit, res);
839 todo_wine {expect(MCHT_TITLEYEAR, res);}
840
841 /* (150, 260) is in active area - date from this month */
842 mchit.pt.x = 150;
843 mchit.pt.y = 260;
844 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
845 expect(150, mchit.pt.x);
846 expect(260, mchit.pt.y);
847 expect(mchit.uHit, res);
848 todo_wine {expect(MCHT_CALENDARDATE, res);}
849
850 /* (150, 350) is in active area - date from next month */
851 mchit.pt.x = 150;
852 mchit.pt.y = 350;
853 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
854 expect(150, mchit.pt.x);
855 expect(350, mchit.pt.y);
856 expect(mchit.uHit, res);
857 todo_wine {expect(MCHT_CALENDARDATENEXT, res);}
858
859 /* (150, 370) is in active area - today link */
860 mchit.pt.x = 150;
861 mchit.pt.y = 370;
862 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
863 expect(150, mchit.pt.x);
864 expect(370, mchit.pt.y);
865 expect(mchit.uHit, res);
866 todo_wine {expect(MCHT_TODAYLINK, res);}
867
868 /* (70, 370) is in active area - today link */
869 mchit.pt.x = 70;
870 mchit.pt.y = 370;
871 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
872 expect(70, mchit.pt.x);
873 expect(370, mchit.pt.y);
874 expect(mchit.uHit, res);
875 todo_wine {expect(MCHT_TODAYLINK, res);}
876
877 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_hit_test_seq, "monthcal hit test", TRUE);
878
879 /* The horizontal position of title bar elements depends on locale (y pos
880 is constant), so we sample across a horizontal line and make sure we
881 find all elements. */
882 mchit.pt.y = 40;
883 title_index = 0;
884 for (x = 0; x < 300; x++){
885 mchit.pt.x = x;
886 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
887 expect(x, mchit.pt.x);
888 expect(40, mchit.pt.y);
889 expect(mchit.uHit, res);
890 if (res != title_hits[title_index]){
891 title_index++;
892 if (sizeof(title_hits) / sizeof(title_hits[0]) <= title_index)
893 break;
894 todo_wine {expect(title_hits[title_index], res);}
895 }
896 }
897 todo_wine {ok(300 <= x && title_index + 1 == sizeof(title_hits) / sizeof(title_hits[0]),
898 "Wrong title layout\n");}
899 }
900
901 static void test_monthcal_todaylink(HWND hwnd)
902 {
903 MCHITTESTINFO mchit;
904 SYSTEMTIME st_test, st_new;
905 BOOL error = FALSE;
906 UINT res;
907
908 memset(&mchit, 0, sizeof(MCHITTESTINFO));
909
910 flush_sequences(sequences, NUM_MSG_SEQUENCES);
911
912 /* (70, 370) is in active area - today link */
913 mchit.cbSize = sizeof(MCHITTESTINFO);
914 mchit.pt.x = 70;
915 mchit.pt.y = 370;
916 res = SendMessage(hwnd, MCM_HITTEST, 0, (LPARAM) & mchit);
917 expect(70, mchit.pt.x);
918 expect(370, mchit.pt.y);
919 expect(mchit.uHit, res);
920 todo_wine {expect(MCHT_TODAYLINK, res);}
921 if (70 != mchit.pt.x || 370 != mchit.pt.y || mchit.uHit != res
922 || MCHT_TODAYLINK != res)
923 error = TRUE;
924
925 st_test.wDay = 1;
926 st_test.wMonth = 1;
927 st_test.wYear = 2005;
928 memset(&st_new, 0, sizeof(SYSTEMTIME));
929
930 SendMessage(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
931
932 res = SendMessage(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
933 expect(1, res);
934 expect(1, st_new.wDay);
935 expect(1, st_new.wMonth);
936 expect(2005, st_new.wYear);
937 if (1 != res || 1 != st_new.wDay || 1 != st_new.wMonth
938 || 2005 != st_new.wYear)
939 error = TRUE;
940
941 if (error) {
942 skip("cannot perform today link test\n");
943 return;
944 }
945
946 res = SendMessage(hwnd, WM_LBUTTONDOWN, MK_LBUTTON, MAKELONG(70, 370));
947 expect(0, res);
948
949 memset(&st_new, 0, sizeof(SYSTEMTIME));
950 res = SendMessage(hwnd, MCM_GETCURSEL, 0, (LPARAM)&st_new);
951 expect(1, res);
952 expect(1, st_new.wDay);
953 expect(1, st_new.wMonth);
954 expect(2005, st_new.wYear);
955
956 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_todaylink_seq, "monthcal hit test", TRUE);
957 }
958
959 static void test_monthcal_today(HWND hwnd)
960 {
961 SYSTEMTIME st_test, st_new;
962 int res;
963
964 flush_sequences(sequences, NUM_MSG_SEQUENCES);
965
966 /* Setter and Getters for "today" information */
967
968 /* check for overflow, should be ok */
969 st_test.wDay = 38;
970 st_test.wMonth = 38;
971
972 st_new.wDay = 27;
973 st_new.wMonth = 27;
974
975 SendMessage(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
976
977 res = SendMessage(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
978 expect(1, res);
979
980 /* st_test should not change */
981 expect(38, st_test.wDay);
982 expect(38, st_test.wMonth);
983
984 /* st_new should change, overflow does not matter */
985 expect(38, st_new.wDay);
986 expect(38, st_new.wMonth);
987
988 /* check for zero, should be ok*/
989 st_test.wDay = 0;
990 st_test.wMonth = 0;
991
992 SendMessage(hwnd, MCM_SETTODAY, 0, (LPARAM)&st_test);
993
994 res = SendMessage(hwnd, MCM_GETTODAY, 0, (LPARAM)&st_new);
995 expect(1, res);
996
997 /* st_test should not change */
998 expect(0, st_test.wDay);
999 expect(0, st_test.wMonth);
1000
1001 /* st_new should change to zero*/
1002 expect(0, st_new.wDay);
1003 expect(0, st_new.wMonth);
1004
1005 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_today_seq, "monthcal today", TRUE);
1006 }
1007
1008 static void test_monthcal_scroll(HWND hwnd)
1009 {
1010 int res;
1011
1012 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1013
1014 /* Setter and Getters for scroll rate */
1015 res = SendMessage(hwnd, MCM_SETMONTHDELTA, 2, 0);
1016 expect(0, res);
1017
1018 res = SendMessage(hwnd, MCM_SETMONTHDELTA, 3, 0);
1019 expect(2, res);
1020 res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
1021 expect(3, res);
1022
1023 res = SendMessage(hwnd, MCM_SETMONTHDELTA, 12, 0);
1024 expect(3, res);
1025 res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
1026 expect(12, res);
1027
1028 res = SendMessage(hwnd, MCM_SETMONTHDELTA, 15, 0);
1029 expect(12, res);
1030 res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
1031 expect(15, res);
1032
1033 res = SendMessage(hwnd, MCM_SETMONTHDELTA, -5, 0);
1034 expect(15, res);
1035 res = SendMessage(hwnd, MCM_GETMONTHDELTA, 0, 0);
1036 expect(-5, res);
1037
1038 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_scroll_seq, "monthcal scroll", FALSE);
1039 }
1040
1041 static void test_monthcal_monthrange(HWND hwnd)
1042 {
1043 int res;
1044 SYSTEMTIME st_visible[2], st_daystate[2];
1045
1046 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1047 st_visible[0].wYear = 0;
1048 st_visible[0].wMonth = 0;
1049 st_visible[0].wDay = 0;
1050 st_daystate[1] = st_daystate[0] = st_visible[1] = st_visible[0];
1051
1052 res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_VISIBLE, (LPARAM)st_visible);
1053 todo_wine {
1054 expect(2, res);
1055 expect(2000, st_visible[0].wYear);
1056 expect(11, st_visible[0].wMonth);
1057 expect(1, st_visible[0].wDay);
1058 expect(2000, st_visible[1].wYear);
1059 expect(12, st_visible[1].wMonth);
1060 expect(31, st_visible[1].wDay);
1061 }
1062 res = SendMessage(hwnd, MCM_GETMONTHRANGE, GMR_DAYSTATE, (LPARAM)st_daystate);
1063 todo_wine {
1064 expect(4, res);
1065 expect(2000, st_daystate[0].wYear);
1066 expect(10, st_daystate[0].wMonth);
1067 expect(29, st_daystate[0].wDay);
1068 expect(2001, st_daystate[1].wYear);
1069 expect(1, st_daystate[1].wMonth);
1070 expect(6, st_daystate[1].wDay);
1071 }
1072
1073 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_monthrange_seq, "monthcal monthrange", FALSE);
1074 }
1075
1076 static void test_monthcal_MaxSelDay(HWND hwnd)
1077 {
1078 int res;
1079
1080 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1081
1082 /* Setter and Getters for max selected days */
1083 res = SendMessage(hwnd, MCM_SETMAXSELCOUNT, 5, 0);
1084 expect(1, res);
1085 res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
1086 expect(5, res);
1087
1088 res = SendMessage(hwnd, MCM_SETMAXSELCOUNT, 15, 0);
1089 expect(1, res);
1090 res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
1091 expect(15, res);
1092
1093 res = SendMessage(hwnd, MCM_SETMAXSELCOUNT, -1, 0);
1094 todo_wine {expect(0, res);}
1095 res = SendMessage(hwnd, MCM_GETMAXSELCOUNT, 0, 0);
1096 todo_wine {expect(15, res);}
1097
1098 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, monthcal_max_sel_day_seq, "monthcal MaxSelDay", FALSE);
1099 }
1100
1101 static void test_monthcal_size(HWND hwnd)
1102 {
1103 int res;
1104 RECT r1, r2;
1105 HFONT hFont1, hFont2;
1106 LOGFONTA logfont;
1107
1108 lstrcpyA(logfont.lfFaceName, "Arial");
1109 memset(&logfont, 0, sizeof(logfont));
1110 logfont.lfHeight = 12;
1111 hFont1 = CreateFontIndirectA(&logfont);
1112
1113 logfont.lfHeight = 24;
1114 hFont2 = CreateFontIndirectA(&logfont);
1115
1116 /* initialize to a font we can compare against */
1117 SendMessage(hwnd, WM_SETFONT, (WPARAM)hFont1, 0);
1118 res = SendMessage(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r1);
1119
1120 /* check that setting a larger font results in an larger rect */
1121 SendMessage(hwnd, WM_SETFONT, (WPARAM)hFont2, 0);
1122 res = SendMessage(hwnd, MCM_GETMINREQRECT, 0, (LPARAM)&r2);
1123
1124 OffsetRect(&r1, -r1.left, -r1.top);
1125 OffsetRect(&r2, -r2.left, -r2.top);
1126
1127 ok(r1.bottom < r2.bottom, "Failed to get larger rect with larger font\n");
1128 }
1129
1130 START_TEST(monthcal)
1131 {
1132 HMODULE hComctl32;
1133 BOOL (WINAPI *pInitCommonControlsEx)(const INITCOMMONCONTROLSEX*);
1134 INITCOMMONCONTROLSEX iccex;
1135 HWND hwnd, parent_wnd;
1136
1137 hComctl32 = GetModuleHandleA("comctl32.dll");
1138 pInitCommonControlsEx = (void*)GetProcAddress(hComctl32, "InitCommonControlsEx");
1139 if (!pInitCommonControlsEx)
1140 {
1141 skip("InitCommonControlsEx() is missing. Skipping the tests\n");
1142 return;
1143 }
1144 iccex.dwSize = sizeof(iccex);
1145 iccex.dwICC = ICC_DATE_CLASSES;
1146 pInitCommonControlsEx(&iccex);
1147
1148 test_monthcal();
1149
1150 init_msg_sequences(sequences, NUM_MSG_SEQUENCES);
1151
1152 parent_wnd = create_parent_window();
1153
1154 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1155 hwnd = create_monthcal_control(WS_CHILD | WS_BORDER | WS_VISIBLE, parent_wnd);
1156 assert(hwnd);
1157 ok_sequence(sequences, PARENT_SEQ_INDEX, create_monthcal_control_seq, "create monthcal control", TRUE);
1158
1159 SendMessage(hwnd, WM_SETFONT, (WPARAM)GetStockObject(SYSTEM_FONT), 0);
1160
1161 test_monthcal_color(hwnd);
1162 test_monthcal_currDate(hwnd);
1163 test_monthcal_firstDay(hwnd);
1164 test_monthcal_unicode(hwnd);
1165 test_monthcal_today(hwnd);
1166 test_monthcal_scroll(hwnd);
1167 test_monthcal_monthrange(hwnd);
1168 test_monthcal_HitTest(hwnd);
1169 test_monthcal_todaylink(hwnd);
1170 test_monthcal_size(hwnd);
1171
1172 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1173 DestroyWindow(hwnd);
1174 ok_sequence(sequences, PARENT_SEQ_INDEX, destroy_monthcal_parent_msgs_seq, "Destroy monthcal (parent msg)", FALSE);
1175 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, destroy_monthcal_child_msgs_seq, "Destroy monthcal (child msg)", FALSE);
1176
1177 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1178 hwnd = create_monthcal_control(MCS_MULTISELECT, parent_wnd);
1179 assert(hwnd);
1180 ok_sequence(sequences, PARENT_SEQ_INDEX, create_monthcal_multi_sel_style_seq, "create monthcal (multi sel style)", TRUE);
1181
1182 test_monthcal_MaxSelDay(hwnd);
1183
1184 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1185 DestroyWindow(hwnd);
1186 ok_sequence(sequences, MONTHCAL_SEQ_INDEX, destroy_monthcal_multi_sel_style_seq, "Destroy monthcal (multi sel style)", FALSE);
1187
1188 flush_sequences(sequences, NUM_MSG_SEQUENCES);
1189 DestroyWindow(parent_wnd);
1190 ok_sequence(sequences, PARENT_SEQ_INDEX, destroy_parent_seq, "Destroy parent window", FALSE);
1191 }
useful hacks and other patches not (yet) suitable for mainline