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