?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
comctl32/datetime: Ensure up/down/home/end increments remain within bounds.
[wine/multimedia.git] / dlls / comctl32 / datetime.c
blob3ad9204bcc90d9ef8f7c7afaf64a944f85940ad9
1 /*
2 * Date and time picker control
3 *
4 * Copyright 1998, 1999 Eric Kohl
5 * Copyright 1999, 2000 Alex Priem <alexp@sci.kun.nl>
6 * Copyright 2000 Chris Morgan <cmorgan@wpi.edu>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 *
22 * NOTE
23 *
24 * This code was audited for completeness against the documented features
25 * of Comctl32.dll version 6.0 on Oct. 20, 2004, by Dimitrie O. Paun.
26 *
27 * Unless otherwise noted, we believe this code to be complete, as per
28 * the specification mentioned above.
29 * If you discover missing features, or bugs, please note them below.
30 *
31 * TODO:
32 * -- DTS_APPCANPARSE
33 * -- DTS_SHORTDATECENTURYFORMAT
34 * -- DTN_FORMAT
35 * -- DTN_FORMATQUERY
36 * -- DTN_USERSTRING
37 * -- DTN_WMKEYDOWN
38 * -- FORMATCALLBACK
39 */
40
41 #include <math.h>
42 #include <string.h>
43 #include <stdarg.h>
44 #include <stdio.h>
45 #include <limits.h>
46
47 #include "windef.h"
48 #include "winbase.h"
49 #include "wingdi.h"
50 #include "winuser.h"
51 #include "winnls.h"
52 #include "commctrl.h"
53 #include "comctl32.h"
54 #include "wine/debug.h"
55 #include "wine/unicode.h"
56
57 WINE_DEFAULT_DEBUG_CHANNEL(datetime);
58
59 typedef struct
60 {
61 HWND hwndSelf;
62 HWND hMonthCal;
63 HWND hwndNotify;
64 HWND hUpdown;
65 DWORD dwStyle;
66 SYSTEMTIME date;
67 BOOL dateValid;
68 HWND hwndCheckbut;
69 RECT rcClient; /* rect around the edge of the window */
70 RECT rcDraw; /* rect inside of the border */
71 RECT checkbox; /* checkbox allowing the control to be enabled/disabled */
72 RECT calbutton; /* button that toggles the dropdown of the monthcal control */
73 BOOL bCalDepressed; /* TRUE = cal button is depressed */
74 int bDropdownEnabled;
75 int select;
76 WCHAR charsEntered[4];
77 int nCharsEntered;
78 HFONT hFont;
79 int nrFieldsAllocated;
80 int nrFields;
81 int haveFocus;
82 int *fieldspec;
83 RECT *fieldRect;
84 int *buflen;
85 WCHAR textbuf[256];
86 POINT monthcal_pos;
87 int pendingUpdown;
88 } DATETIME_INFO, *LPDATETIME_INFO;
89
90 /* in monthcal.c */
91 extern int MONTHCAL_MonthLength(int month, int year);
92 extern int MONTHCAL_CalculateDayOfWeek(SYSTEMTIME *date, BOOL inplace);
93
94 /* this list of defines is closely related to `allowedformatchars' defined
95 * in datetime.c; the high nibble indicates the `base type' of the format
96 * specifier.
97 * Do not change without first reading DATETIME_UseFormat.
98 *
99 */
100
101 #define DT_END_FORMAT 0
102 #define ONEDIGITDAY 0x01
103 #define TWODIGITDAY 0x02
104 #define THREECHARDAY 0x03
105 #define FULLDAY 0x04
106 #define ONEDIGIT12HOUR 0x11
107 #define TWODIGIT12HOUR 0x12
108 #define ONEDIGIT24HOUR 0x21
109 #define TWODIGIT24HOUR 0x22
110 #define ONEDIGITMINUTE 0x31
111 #define TWODIGITMINUTE 0x32
112 #define ONEDIGITMONTH 0x41
113 #define TWODIGITMONTH 0x42
114 #define THREECHARMONTH 0x43
115 #define FULLMONTH 0x44
116 #define ONEDIGITSECOND 0x51
117 #define TWODIGITSECOND 0x52
118 #define ONELETTERAMPM 0x61
119 #define TWOLETTERAMPM 0x62
120 #define ONEDIGITYEAR 0x71
121 #define TWODIGITYEAR 0x72
122 #define INVALIDFULLYEAR 0x73 /* FIXME - yyy is not valid - we'll treat it as yyyy */
123 #define FULLYEAR 0x74
124 #define FORMATCALLBACK 0x81 /* -> maximum of 0x80 callbacks possible */
125 #define FORMATCALLMASK 0x80
126 #define DT_STRING 0x0100
127
128 #define DTHT_DATEFIELD 0xff /* for hit-testing */
129
130 #define DTHT_NONE 0x1000
131 #define DTHT_CHECKBOX 0x2000 /* these should end at '00' , to make */
132 #define DTHT_MCPOPUP 0x3000 /* & DTHT_DATEFIELD 0 when DATETIME_KeyDown */
133 #define DTHT_GOTFOCUS 0x4000 /* tests for date-fields */
134 #define DTHT_NODATEMASK 0xf000 /* to mask check and drop down from others */
135
136 static BOOL DATETIME_SendSimpleNotify (const DATETIME_INFO *infoPtr, UINT code);
137 static BOOL DATETIME_SendDateTimeChangeNotify (const DATETIME_INFO *infoPtr);
138 static const WCHAR allowedformatchars[] = {'d', 'h', 'H', 'm', 'M', 's', 't', 'y', 'X', 0};
139 static const int maxrepetition [] = {4,2,2,2,4,2,2,4,-1};
140
141 /* valid date limits */
142 static const SYSTEMTIME max_allowed_date = { /* wYear */ 9999, /* wMonth */ 12, /* wDayOfWeek */ 0, /* wDay */ 31 };
143 static const SYSTEMTIME min_allowed_date = { /* wYear */ 1752, /* wMonth */ 9, /* wDayOfWeek */ 0, /* wDay */ 14 };
144
145 static DWORD
146 DATETIME_GetSystemTime (const DATETIME_INFO *infoPtr, SYSTEMTIME *systime)
147 {
148 if (!systime) return GDT_NONE;
149
150 if ((infoPtr->dwStyle & DTS_SHOWNONE) &&
151 (SendMessageW (infoPtr->hwndCheckbut, BM_GETCHECK, 0, 0) == BST_UNCHECKED))
152 return GDT_NONE;
153
154 *systime = infoPtr->date;
155
156 return GDT_VALID;
157 }
158
159 /* Checks value is within configured date range
160 *
161 * PARAMETERS
162 *
163 * [I] infoPtr : valid pointer to control data
164 * [I] date : pointer to valid date data to check
165 *
166 * RETURN VALUE
167 *
168 * TRUE - date within configured range
169 * FALSE - date is outside configured range
170 */
171 static BOOL DATETIME_IsDateInValidRange(const DATETIME_INFO *infoPtr, const SYSTEMTIME *date)
172 {
173 SYSTEMTIME range[2];
174 DWORD limits;
175
176 if ((MONTHCAL_CompareSystemTime(date, &max_allowed_date) == 1) ||
177 (MONTHCAL_CompareSystemTime(date, &min_allowed_date) == -1))
178 return FALSE;
179
180 limits = SendMessageW (infoPtr->hMonthCal, MCM_GETRANGE, 0, (LPARAM) &range);
181
182 if (limits & GDTR_MAX)
183 {
184 if (MONTHCAL_CompareSystemTime(date, &range[1]) == 1)
185 return FALSE;
186 }
187
188 if (limits & GDTR_MIN)
189 {
190 if (MONTHCAL_CompareSystemTime(date, &range[0]) == -1)
191 return FALSE;
192 }
193
194 return TRUE;
195 }
196
197 static BOOL
198 DATETIME_SetSystemTime (DATETIME_INFO *infoPtr, DWORD flag, const SYSTEMTIME *systime)
199 {
200 if (!systime) return 0;
201
202 TRACE("%04d/%02d/%02d %02d:%02d:%02d\n",
203 systime->wYear, systime->wMonth, systime->wDay,
204 systime->wHour, systime->wMinute, systime->wSecond);
205
206 if (flag == GDT_VALID) {
207 if (systime->wYear == 0 ||
208 systime->wMonth < 1 || systime->wMonth > 12 ||
209 systime->wDay < 1 ||
210 systime->wDay > MONTHCAL_MonthLength(systime->wMonth, systime->wYear) ||
211 systime->wHour > 23 ||
212 systime->wMinute > 59 ||
213 systime->wSecond > 59 ||
214 systime->wMilliseconds > 999
215 )
216 return FALSE;
217
218 /* Windows returns true if the date is valid but outside the limits set */
219 if (DATETIME_IsDateInValidRange(infoPtr, systime) == FALSE)
220 return TRUE;
221
222 infoPtr->dateValid = TRUE;
223 infoPtr->date = *systime;
224 /* always store a valid day of week */
225 MONTHCAL_CalculateDayOfWeek(&infoPtr->date, TRUE);
226
227 SendMessageW (infoPtr->hMonthCal, MCM_SETCURSEL, 0, (LPARAM)(&infoPtr->date));
228 SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, BST_CHECKED, 0);
229 } else if ((infoPtr->dwStyle & DTS_SHOWNONE) && (flag == GDT_NONE)) {
230 infoPtr->dateValid = FALSE;
231 SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, BST_UNCHECKED, 0);
232 }
233 else
234 return FALSE;
235
236 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
237 return TRUE;
238 }
239
240
241 /***
242 * Split up a formattxt in actions.
243 * See ms documentation for the meaning of the letter codes/'specifiers'.
244 *
245 * Notes:
246 * *'dddddd' is handled as 'dddd' plus 'dd'.
247 * *unrecognized formats are strings (here given the type DT_STRING;
248 * start of the string is encoded in lower bits of DT_STRING.
249 * Therefore, 'string' ends finally up as '<show seconds>tring'.
250 *
251 */
252 static void
253 DATETIME_UseFormat (DATETIME_INFO *infoPtr, LPCWSTR formattxt)
254 {
255 unsigned int i;
256 int j, k, len;
257 BOOL inside_literal = FALSE; /* inside '...' */
258 int *nrFields = &infoPtr->nrFields;
259
260 *nrFields = 0;
261 infoPtr->fieldspec[*nrFields] = 0;
262 len = strlenW(allowedformatchars);
263 k = 0;
264
265 for (i = 0; formattxt[i]; i++) {
266 TRACE ("\n%d %c:", i, formattxt[i]);
267 if (!inside_literal) {
268 for (j = 0; j < len; j++) {
269 if (allowedformatchars[j]==formattxt[i]) {
270 TRACE ("%c[%d,%x]", allowedformatchars[j], *nrFields, infoPtr->fieldspec[*nrFields]);
271 if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
272 infoPtr->fieldspec[*nrFields] = (j<<4) + 1;
273 break;
274 }
275 if (infoPtr->fieldspec[*nrFields] >> 4 != j) {
276 (*nrFields)++;
277 infoPtr->fieldspec[*nrFields] = (j<<4) + 1;
278 break;
279 }
280 if ((infoPtr->fieldspec[*nrFields] & 0x0f) == maxrepetition[j]) {
281 (*nrFields)++;
282 infoPtr->fieldspec[*nrFields] = (j<<4) + 1;
283 break;
284 }
285 infoPtr->fieldspec[*nrFields]++;
286 break;
287 } /* if allowedformatchar */
288 } /* for j */
289 }
290 else
291 j = len;
292
293 if (formattxt[i] == '\'')
294 {
295 inside_literal = !inside_literal;
296 continue;
297 }
298
299 /* char is not a specifier: handle char like a string */
300 if (j == len) {
301 if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
302 infoPtr->fieldspec[*nrFields] = DT_STRING + k;
303 infoPtr->buflen[*nrFields] = 0;
304 } else if ((infoPtr->fieldspec[*nrFields] & DT_STRING) != DT_STRING) {
305 (*nrFields)++;
306 infoPtr->fieldspec[*nrFields] = DT_STRING + k;
307 infoPtr->buflen[*nrFields] = 0;
308 }
309 infoPtr->textbuf[k] = formattxt[i];
310 k++;
311 infoPtr->buflen[*nrFields]++;
312 } /* if j=len */
313
314 if (*nrFields == infoPtr->nrFieldsAllocated) {
315 FIXME ("out of memory; should reallocate. crash ahead.\n");
316 }
317 } /* for i */
318
319 TRACE("\n");
320
321 if (infoPtr->fieldspec[*nrFields] != 0) (*nrFields)++;
322 }
323
324
325 static BOOL
326 DATETIME_SetFormatW (DATETIME_INFO *infoPtr, LPCWSTR format)
327 {
328 WCHAR format_buf[80];
329
330 if (!format) {
331 DWORD format_item;
332
333 if (infoPtr->dwStyle & DTS_LONGDATEFORMAT)
334 format_item = LOCALE_SLONGDATE;
335 else if ((infoPtr->dwStyle & DTS_TIMEFORMAT) == DTS_TIMEFORMAT)
336 format_item = LOCALE_STIMEFORMAT;
337 else /* DTS_SHORTDATEFORMAT */
338 format_item = LOCALE_SSHORTDATE;
339 GetLocaleInfoW(LOCALE_USER_DEFAULT, format_item, format_buf, sizeof(format_buf)/sizeof(format_buf[0]));
340 format = format_buf;
341 }
342
343 DATETIME_UseFormat (infoPtr, format);
344 InvalidateRect (infoPtr->hwndSelf, NULL, TRUE);
345
346 return TRUE;
347 }
348
349
350 static BOOL
351 DATETIME_SetFormatA (DATETIME_INFO *infoPtr, LPCSTR lpszFormat)
352 {
353 if (lpszFormat) {
354 BOOL retval;
355 INT len = MultiByteToWideChar(CP_ACP, 0, lpszFormat, -1, NULL, 0);
356 LPWSTR wstr = Alloc(len * sizeof(WCHAR));
357 if (wstr) MultiByteToWideChar(CP_ACP, 0, lpszFormat, -1, wstr, len);
358 retval = DATETIME_SetFormatW (infoPtr, wstr);
359 Free (wstr);
360 return retval;
361 }
362 else
363 return DATETIME_SetFormatW (infoPtr, 0);
364
365 }
366
367
368 static void
369 DATETIME_ReturnTxt (const DATETIME_INFO *infoPtr, int count, LPWSTR result, int resultSize)
370 {
371 static const WCHAR fmt_dW[] = { '%', 'd', 0 };
372 static const WCHAR fmt__2dW[] = { '%', '.', '2', 'd', 0 };
373 static const WCHAR fmt__3sW[] = { '%', '.', '3', 's', 0 };
374 SYSTEMTIME date = infoPtr->date;
375 int spec;
376 WCHAR buffer[80];
377
378 *result=0;
379 TRACE ("%d,%d\n", infoPtr->nrFields, count);
380 if (count>infoPtr->nrFields || count < 0) {
381 WARN ("buffer overrun, have %d want %d\n", infoPtr->nrFields, count);
382 return;
383 }
384
385 if (!infoPtr->fieldspec) return;
386
387 spec = infoPtr->fieldspec[count];
388 if (spec & DT_STRING) {
389 int txtlen = infoPtr->buflen[count];
390
391 if (txtlen > resultSize)
392 txtlen = resultSize - 1;
393 memcpy (result, infoPtr->textbuf + (spec &~ DT_STRING), txtlen * sizeof(WCHAR));
394 result[txtlen] = 0;
395 TRACE ("arg%d=%x->[%s]\n", count, infoPtr->fieldspec[count], debugstr_w(result));
396 return;
397 }
398
399
400 switch (spec) {
401 case DT_END_FORMAT:
402 *result = 0;
403 break;
404 case ONEDIGITDAY:
405 wsprintfW (result, fmt_dW, date.wDay);
406 break;
407 case TWODIGITDAY:
408 wsprintfW (result, fmt__2dW, date.wDay);
409 break;
410 case THREECHARDAY:
411 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1+(date.wDayOfWeek+6)%7, result, 4);
412 /*wsprintfW (result,"%.3s",days[date.wDayOfWeek]);*/
413 break;
414 case FULLDAY:
415 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME1+(date.wDayOfWeek+6)%7, result, resultSize);
416 break;
417 case ONEDIGIT12HOUR:
418 if (date.wHour == 0) {
419 result[0] = '1';
420 result[1] = '2';
421 result[2] = 0;
422 }
423 else
424 wsprintfW (result, fmt_dW, date.wHour - (date.wHour > 12 ? 12 : 0));
425 break;
426 case TWODIGIT12HOUR:
427 if (date.wHour == 0) {
428 result[0] = '1';
429 result[1] = '2';
430 result[2] = 0;
431 }
432 else
433 wsprintfW (result, fmt__2dW, date.wHour - (date.wHour > 12 ? 12 : 0));
434 break;
435 case ONEDIGIT24HOUR:
436 wsprintfW (result, fmt_dW, date.wHour);
437 break;
438 case TWODIGIT24HOUR:
439 wsprintfW (result, fmt__2dW, date.wHour);
440 break;
441 case ONEDIGITSECOND:
442 wsprintfW (result, fmt_dW, date.wSecond);
443 break;
444 case TWODIGITSECOND:
445 wsprintfW (result, fmt__2dW, date.wSecond);
446 break;
447 case ONEDIGITMINUTE:
448 wsprintfW (result, fmt_dW, date.wMinute);
449 break;
450 case TWODIGITMINUTE:
451 wsprintfW (result, fmt__2dW, date.wMinute);
452 break;
453 case ONEDIGITMONTH:
454 wsprintfW (result, fmt_dW, date.wMonth);
455 break;
456 case TWODIGITMONTH:
457 wsprintfW (result, fmt__2dW, date.wMonth);
458 break;
459 case THREECHARMONTH:
460 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME1+date.wMonth -1,
461 buffer, sizeof(buffer)/sizeof(buffer[0]));
462 wsprintfW (result, fmt__3sW, buffer);
463 break;
464 case FULLMONTH:
465 GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME1+date.wMonth -1,
466 result, resultSize);
467 break;
468 case ONELETTERAMPM:
469 result[0] = (date.wHour < 12 ? 'A' : 'P');
470 result[1] = 0;
471 break;
472 case TWOLETTERAMPM:
473 result[0] = (date.wHour < 12 ? 'A' : 'P');
474 result[1] = 'M';
475 result[2] = 0;
476 break;
477 case FORMATCALLBACK:
478 FIXME ("Not implemented\n");
479 result[0] = 'x';
480 result[1] = 0;
481 break;
482 case ONEDIGITYEAR:
483 wsprintfW (result, fmt_dW, date.wYear-10* (int) floor(date.wYear/10));
484 break;
485 case TWODIGITYEAR:
486 wsprintfW (result, fmt__2dW, date.wYear-100* (int) floor(date.wYear/100));
487 break;
488 case INVALIDFULLYEAR:
489 case FULLYEAR:
490 wsprintfW (result, fmt_dW, date.wYear);
491 break;
492 }
493
494 TRACE ("arg%d=%x->[%s]\n", count, infoPtr->fieldspec[count], debugstr_w(result));
495 }
496
497 static int wrap(int val, int delta, int minVal, int maxVal)
498 {
499 val += delta;
500 if (delta == INT_MIN || val < minVal) return maxVal;
501 if (delta == INT_MAX || val > maxVal) return minVal;
502 return val;
503 }
504
505 static void
506 DATETIME_IncreaseField (DATETIME_INFO *infoPtr, int number, int delta)
507 {
508 SYSTEMTIME *date = &infoPtr->date;
509 SYSTEMTIME range[2];
510 DWORD limits;
511 BOOL min;
512
513 TRACE ("%d\n", number);
514 if ((number > infoPtr->nrFields) || (number < 0)) return;
515
516 if ((infoPtr->fieldspec[number] & DTHT_DATEFIELD) == 0) return;
517
518 switch (infoPtr->fieldspec[number]) {
519 case ONEDIGITYEAR:
520 case TWODIGITYEAR:
521 case FULLYEAR:
522 if (delta == INT_MIN)
523 date->wYear = 1752;
524 else if (delta == INT_MAX)
525 date->wYear = 9999;
526 else
527 date->wYear = max(min(date->wYear + delta, 9999), 1752);
528
529 if (date->wDay > MONTHCAL_MonthLength(date->wMonth, date->wYear))
530 /* This can happen when moving away from a leap year. */
531 date->wDay = MONTHCAL_MonthLength(date->wMonth, date->wYear);
532 MONTHCAL_CalculateDayOfWeek(date, TRUE);
533 break;
534 case ONEDIGITMONTH:
535 case TWODIGITMONTH:
536 case THREECHARMONTH:
537 case FULLMONTH:
538 date->wMonth = wrap(date->wMonth, delta, 1, 12);
539 MONTHCAL_CalculateDayOfWeek(date, TRUE);
540 delta = 0;
541 /* fall through */
542 case ONEDIGITDAY:
543 case TWODIGITDAY:
544 case THREECHARDAY:
545 case FULLDAY:
546 date->wDay = wrap(date->wDay, delta, 1, MONTHCAL_MonthLength(date->wMonth, date->wYear));
547 MONTHCAL_CalculateDayOfWeek(date, TRUE);
548 break;
549 case ONELETTERAMPM:
550 case TWOLETTERAMPM:
551 delta *= 12;
552 /* fall through */
553 case ONEDIGIT12HOUR:
554 case TWODIGIT12HOUR:
555 case ONEDIGIT24HOUR:
556 case TWODIGIT24HOUR:
557 date->wHour = wrap(date->wHour, delta, 0, 23);
558 break;
559 case ONEDIGITMINUTE:
560 case TWODIGITMINUTE:
561 date->wMinute = wrap(date->wMinute, delta, 0, 59);
562 break;
563 case ONEDIGITSECOND:
564 case TWODIGITSECOND:
565 date->wSecond = wrap(date->wSecond, delta, 0, 59);
566 break;
567 case FORMATCALLBACK:
568 FIXME ("Not implemented\n");
569 break;
570 }
571
572 /* FYI: On 1752/9/14 the calendar changed and England and the
573 * American colonies changed to the Gregorian calendar. This change
574 * involved having September 14th follow September 2nd. So no date
575 * algorithm works before that date.
576 */
577 if (10000 * date->wYear + 100 * date->wMonth + date->wDay < 17520914) {
578 date->wYear = 1752;
579 date->wMonth = 9;
580 date->wDay = 14;
581 date->wSecond = 0;
582 date->wMinute = 0;
583 date->wHour = 0;
584 }
585
586 /* Ensure time is within bounds */
587 limits = SendMessageW (infoPtr->hMonthCal, MCM_GETRANGE, 0, (LPARAM) &range);
588 min = ((delta < 0) ? TRUE : FALSE);
589
590 if (limits & (min ? GDTR_MIN : GDTR_MAX))
591 {
592 int i = (min ? 0 : 1);
593
594 if (MONTHCAL_CompareSystemTime(date, &range[i]) == (min ? -1 : 1))
595 {
596 date->wYear = range[i].wYear;
597 date->wMonth = range[i].wMonth;
598 date->wDayOfWeek = range[i].wDayOfWeek;
599 date->wDay = range[i].wDay;
600 date->wHour = range[i].wHour;
601 date->wMinute = range[i].wMinute;
602 date->wSecond = range[i].wSecond;
603 date->wMilliseconds = range[i].wMilliseconds;
604 }
605 }
606 }
607
608 static void
609 DATETIME_ReturnFieldWidth (const DATETIME_INFO *infoPtr, HDC hdc, int count, SHORT *width)
610 {
611 /* fields are a fixed width, determined by the largest possible string */
612 /* presumably, these widths should be language dependent */
613 static const WCHAR fld_d1W[] = { '2', 0 };
614 static const WCHAR fld_d2W[] = { '2', '2', 0 };
615 static const WCHAR fld_d4W[] = { '2', '2', '2', '2', 0 };
616 static const WCHAR fld_am1[] = { 'A', 0 };
617 static const WCHAR fld_am2[] = { 'A', 'M', 0 };
618 int spec;
619 WCHAR buffer[80];
620 LPCWSTR bufptr;
621 SIZE size;
622
623 TRACE ("%d,%d\n", infoPtr->nrFields, count);
624 if (count>infoPtr->nrFields || count < 0) {
625 WARN ("buffer overrun, have %d want %d\n", infoPtr->nrFields, count);
626 return;
627 }
628
629 if (!infoPtr->fieldspec) return;
630
631 spec = infoPtr->fieldspec[count];
632 if (spec & DT_STRING) {
633 int txtlen = infoPtr->buflen[count];
634
635 if (txtlen > 79)
636 txtlen = 79;
637 memcpy (buffer, infoPtr->textbuf + (spec &~ DT_STRING), txtlen * sizeof(WCHAR));
638 buffer[txtlen] = 0;
639 bufptr = buffer;
640 }
641 else {
642 switch (spec) {
643 case ONEDIGITDAY:
644 case ONEDIGIT12HOUR:
645 case ONEDIGIT24HOUR:
646 case ONEDIGITSECOND:
647 case ONEDIGITMINUTE:
648 case ONEDIGITMONTH:
649 case ONEDIGITYEAR:
650 /* these seem to use a two byte field */
651 case TWODIGITDAY:
652 case TWODIGIT12HOUR:
653 case TWODIGIT24HOUR:
654 case TWODIGITSECOND:
655 case TWODIGITMINUTE:
656 case TWODIGITMONTH:
657 case TWODIGITYEAR:
658 bufptr = fld_d2W;
659 break;
660 case INVALIDFULLYEAR:
661 case FULLYEAR:
662 bufptr = fld_d4W;
663 break;
664 case THREECHARMONTH:
665 case FULLMONTH:
666 case THREECHARDAY:
667 case FULLDAY:
668 {
669 static const WCHAR fld_day[] = {'W','e','d','n','e','s','d','a','y',0};
670 static const WCHAR fld_abbrday[] = {'W','e','d',0};
671 static const WCHAR fld_mon[] = {'S','e','p','t','e','m','b','e','r',0};
672 static const WCHAR fld_abbrmon[] = {'D','e','c',0};
673
674 const WCHAR *fall;
675 LCTYPE lctype;
676 INT i, max_count;
677 LONG cx;
678
679 /* choose locale data type and fallback string */
680 switch (spec) {
681 case THREECHARDAY:
682 fall = fld_abbrday;
683 lctype = LOCALE_SABBREVDAYNAME1;
684 max_count = 7;
685 break;
686 case FULLDAY:
687 fall = fld_day;
688 lctype = LOCALE_SDAYNAME1;
689 max_count = 7;
690 break;
691 case THREECHARMONTH:
692 fall = fld_abbrmon;
693 lctype = LOCALE_SABBREVMONTHNAME1;
694 max_count = 12;
695 break;
696 default: /* FULLMONTH */
697 fall = fld_mon;
698 lctype = LOCALE_SMONTHNAME1;
699 max_count = 12;
700 break;
701 }
702
703 cx = 0;
704 for (i = 0; i < max_count; i++)
705 {
706 if(GetLocaleInfoW(LOCALE_USER_DEFAULT, lctype + i,
707 buffer, lstrlenW(buffer)))
708 {
709 GetTextExtentPoint32W(hdc, buffer, lstrlenW(buffer), &size);
710 if (size.cx > cx) cx = size.cx;
711 }
712 else /* locale independent fallback on failure */
713 {
714 GetTextExtentPoint32W(hdc, fall, lstrlenW(fall), &size);
715 cx = size.cx;
716 break;
717 }
718 }
719 *width = cx;
720 return;
721 }
722 case ONELETTERAMPM:
723 bufptr = fld_am1;
724 break;
725 case TWOLETTERAMPM:
726 bufptr = fld_am2;
727 break;
728 default:
729 bufptr = fld_d1W;
730 break;
731 }
732 }
733 GetTextExtentPoint32W (hdc, bufptr, strlenW(bufptr), &size);
734 *width = size.cx;
735 }
736
737 static void
738 DATETIME_Refresh (DATETIME_INFO *infoPtr, HDC hdc)
739 {
740 TRACE("\n");
741
742 if (infoPtr->dateValid) {
743 int i, prevright;
744 RECT *field;
745 RECT *rcDraw = &infoPtr->rcDraw;
746 SIZE size;
747 COLORREF oldTextColor;
748 SHORT fieldWidth = 0;
749 HFONT oldFont = SelectObject (hdc, infoPtr->hFont);
750 INT oldBkMode = SetBkMode (hdc, TRANSPARENT);
751 WCHAR txt[80];
752
753 DATETIME_ReturnTxt (infoPtr, 0, txt, sizeof(txt)/sizeof(txt[0]));
754 GetTextExtentPoint32W (hdc, txt, strlenW(txt), &size);
755 rcDraw->bottom = size.cy + 2;
756
757 prevright = infoPtr->checkbox.right = ((infoPtr->dwStyle & DTS_SHOWNONE) ? 18 : 2);
758
759 for (i = 0; i < infoPtr->nrFields; i++) {
760 DATETIME_ReturnTxt (infoPtr, i, txt, sizeof(txt)/sizeof(txt[0]));
761 GetTextExtentPoint32W (hdc, txt, strlenW(txt), &size);
762 DATETIME_ReturnFieldWidth (infoPtr, hdc, i, &fieldWidth);
763 field = &infoPtr->fieldRect[i];
764 field->left = prevright;
765 field->right = prevright + fieldWidth;
766 field->top = rcDraw->top;
767 field->bottom = rcDraw->bottom;
768 prevright = field->right;
769
770 if (infoPtr->dwStyle & WS_DISABLED)
771 oldTextColor = SetTextColor (hdc, comctl32_color.clrGrayText);
772 else if ((infoPtr->haveFocus) && (i == infoPtr->select)) {
773 RECT selection;
774
775 /* fill if focused */
776 HBRUSH hbr = CreateSolidBrush (comctl32_color.clrActiveCaption);
777
778 if (infoPtr->nCharsEntered)
779 {
780 memcpy(txt, infoPtr->charsEntered, infoPtr->nCharsEntered * sizeof(WCHAR));
781 txt[infoPtr->nCharsEntered] = 0;
782 GetTextExtentPoint32W (hdc, txt, strlenW(txt), &size);
783 }
784
785 selection.left = 0;
786 selection.top = 0;
787 selection.right = size.cx;
788 selection.bottom = size.cy;
789 /* center rectangle */
790 OffsetRect(&selection, (field->right + field->left - size.cx)/2,
791 (field->bottom - size.cy)/2);
792
793 FillRect(hdc, &selection, hbr);
794 DeleteObject (hbr);
795 oldTextColor = SetTextColor (hdc, comctl32_color.clrWindow);
796 }
797 else
798 oldTextColor = SetTextColor (hdc, comctl32_color.clrWindowText);
799
800 /* draw the date text using the colour set above */
801 DrawTextW (hdc, txt, strlenW(txt), field, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
802 SetTextColor (hdc, oldTextColor);
803 }
804 SetBkMode (hdc, oldBkMode);
805 SelectObject (hdc, oldFont);
806 }
807
808 if (!(infoPtr->dwStyle & DTS_UPDOWN)) {
809 DrawFrameControl(hdc, &infoPtr->calbutton, DFC_SCROLL,
810 DFCS_SCROLLDOWN | (infoPtr->bCalDepressed ? DFCS_PUSHED : 0) |
811 (infoPtr->dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0) );
812 }
813 }
814
815
816 static INT
817 DATETIME_HitTest (const DATETIME_INFO *infoPtr, POINT pt)
818 {
819 int i;
820
821 TRACE ("%d, %d\n", pt.x, pt.y);
822
823 if (PtInRect (&infoPtr->calbutton, pt)) return DTHT_MCPOPUP;
824 if (PtInRect (&infoPtr->checkbox, pt)) return DTHT_CHECKBOX;
825
826 for (i = 0; i < infoPtr->nrFields; i++) {
827 if (PtInRect (&infoPtr->fieldRect[i], pt)) return i;
828 }
829
830 return DTHT_NONE;
831 }
832
833 /* Returns index of a closest date field from given counting to left
834 or -1 if there's no such fields at left */
835 static int DATETIME_GetPrevDateField(const DATETIME_INFO *infoPtr, int i)
836 {
837 for(--i; i >= 0; i--)
838 {
839 if (infoPtr->fieldspec[i] & DTHT_DATEFIELD) return i;
840 }
841 return -1;
842 }
843
844 static void
845 DATETIME_ApplySelectedField (DATETIME_INFO *infoPtr)
846 {
847 int fieldNum = infoPtr->select & DTHT_DATEFIELD;
848 int i, val=0, clamp_day=0;
849 SYSTEMTIME date = infoPtr->date;
850
851 if (infoPtr->select == -1 || infoPtr->nCharsEntered == 0)
852 return;
853
854 for (i=0; i<infoPtr->nCharsEntered; i++)
855 val = val * 10 + infoPtr->charsEntered[i] - '0';
856
857 infoPtr->nCharsEntered = 0;
858
859 switch (infoPtr->fieldspec[fieldNum]) {
860 case ONEDIGITYEAR:
861 case TWODIGITYEAR:
862 date.wYear = date.wYear - (date.wYear%100) + val;
863 clamp_day = 1;
864 break;
865 case INVALIDFULLYEAR:
866 case FULLYEAR:
867 date.wYear = val;
868 clamp_day = 1;
869 break;
870 case ONEDIGITMONTH:
871 case TWODIGITMONTH:
872 date.wMonth = val;
873 clamp_day = 1;
874 break;
875 case ONEDIGITDAY:
876 case TWODIGITDAY:
877 date.wDay = val;
878 break;
879 case ONEDIGIT12HOUR:
880 case TWODIGIT12HOUR:
881 case ONEDIGIT24HOUR:
882 case TWODIGIT24HOUR:
883 /* FIXME: Preserve AM/PM for 12HOUR? */
884 date.wHour = val;
885 break;
886 case ONEDIGITMINUTE:
887 case TWODIGITMINUTE:
888 date.wMinute = val;
889 break;
890 case ONEDIGITSECOND:
891 case TWODIGITSECOND:
892 date.wSecond = val;
893 break;
894 }
895
896 if (clamp_day && date.wDay > MONTHCAL_MonthLength(date.wMonth, date.wYear))
897 date.wDay = MONTHCAL_MonthLength(date.wMonth, date.wYear);
898
899 if (DATETIME_SetSystemTime(infoPtr, GDT_VALID, &date))
900 DATETIME_SendDateTimeChangeNotify (infoPtr);
901 }
902
903 static void
904 DATETIME_SetSelectedField (DATETIME_INFO *infoPtr, int select)
905 {
906 DATETIME_ApplySelectedField(infoPtr);
907
908 infoPtr->select = select;
909 infoPtr->nCharsEntered = 0;
910 }
911
912 static LRESULT
913 DATETIME_LButtonDown (DATETIME_INFO *infoPtr, INT x, INT y)
914 {
915 POINT pt;
916 int new;
917
918 pt.x = x;
919 pt.y = y;
920 new = DATETIME_HitTest (infoPtr, pt);
921
922 SetFocus(infoPtr->hwndSelf);
923
924 if (!(new & DTHT_NODATEMASK) || (new == DTHT_NONE))
925 {
926 if (new == DTHT_NONE)
927 new = infoPtr->nrFields - 1;
928 else
929 {
930 /* hitting string part moves selection to next date field to left */
931 if (infoPtr->fieldspec[new] & DT_STRING)
932 {
933 new = DATETIME_GetPrevDateField(infoPtr, new);
934 if (new == -1) return 0;
935 }
936 /* never select full day of week */
937 if (infoPtr->fieldspec[new] == FULLDAY) return 0;
938 }
939 }
940
941 DATETIME_SetSelectedField(infoPtr, new);
942
943 if (infoPtr->select == DTHT_MCPOPUP) {
944 RECT rcMonthCal;
945 POINT pos;
946 SendMessageW(infoPtr->hMonthCal, MCM_GETMINREQRECT, 0, (LPARAM)&rcMonthCal);
947
948 /* FIXME: button actually is only depressed during dropdown of the */
949 /* calendar control and when the mouse is over the button window */
950 infoPtr->bCalDepressed = TRUE;
951
952 /* recalculate the position of the monthcal popup */
953 if(infoPtr->dwStyle & DTS_RIGHTALIGN)
954 pos.x = infoPtr->calbutton.left - (rcMonthCal.right - rcMonthCal.left);
955 else
956 /* FIXME: this should be after the area reserved for the checkbox */
957 pos.x = infoPtr->rcDraw.left;
958
959 pos.y = infoPtr->rcClient.bottom;
960 OffsetRect( &rcMonthCal, pos.x, pos.y );
961 MapWindowPoints( infoPtr->hwndSelf, 0, (POINT *)&rcMonthCal, 2 );
962 SetWindowPos(infoPtr->hMonthCal, 0, rcMonthCal.left, rcMonthCal.top,
963 rcMonthCal.right - rcMonthCal.left, rcMonthCal.bottom - rcMonthCal.top, 0);
964
965 if(IsWindowVisible(infoPtr->hMonthCal)) {
966 ShowWindow(infoPtr->hMonthCal, SW_HIDE);
967 infoPtr->bDropdownEnabled = FALSE;
968 DATETIME_SendSimpleNotify (infoPtr, DTN_CLOSEUP);
969 } else {
970 const SYSTEMTIME *lprgSysTimeArray = &infoPtr->date;
971 TRACE("update calendar %04d/%02d/%02d\n",
972 lprgSysTimeArray->wYear, lprgSysTimeArray->wMonth, lprgSysTimeArray->wDay);
973 SendMessageW(infoPtr->hMonthCal, MCM_SETCURSEL, 0, (LPARAM)(&infoPtr->date));
974
975 if (infoPtr->bDropdownEnabled) {
976 ShowWindow(infoPtr->hMonthCal, SW_SHOW);
977 DATETIME_SendSimpleNotify (infoPtr, DTN_DROPDOWN);
978 }
979 infoPtr->bDropdownEnabled = TRUE;
980 }
981
982 TRACE ("dt:%p mc:%p mc parent:%p, desktop:%p\n",
983 infoPtr->hwndSelf, infoPtr->hMonthCal, infoPtr->hwndNotify, GetDesktopWindow ());
984 }
985
986 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
987
988 return 0;
989 }
990
991
992 static LRESULT
993 DATETIME_LButtonUp (DATETIME_INFO *infoPtr)
994 {
995 if(infoPtr->bCalDepressed) {
996 infoPtr->bCalDepressed = FALSE;
997 InvalidateRect(infoPtr->hwndSelf, &(infoPtr->calbutton), TRUE);
998 }
999
1000 return 0;
1001 }
1002
1003
1004 static LRESULT
1005 DATETIME_Paint (DATETIME_INFO *infoPtr, HDC hdc)
1006 {
1007 if (!hdc) {
1008 PAINTSTRUCT ps;
1009 hdc = BeginPaint (infoPtr->hwndSelf, &ps);
1010 DATETIME_Refresh (infoPtr, hdc);
1011 EndPaint (infoPtr->hwndSelf, &ps);
1012 } else {
1013 DATETIME_Refresh (infoPtr, hdc);
1014 }
1015
1016 /* Not a click on the dropdown box, enabled it */
1017 infoPtr->bDropdownEnabled = TRUE;
1018
1019 return 0;
1020 }
1021
1022
1023 static LRESULT
1024 DATETIME_Button_Command (DATETIME_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
1025 {
1026 if( HIWORD(wParam) == BN_CLICKED) {
1027 DWORD state = SendMessageW((HWND)lParam, BM_GETCHECK, 0, 0);
1028 infoPtr->dateValid = (state == BST_CHECKED);
1029 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1030 }
1031 return 0;
1032 }
1033
1034
1035
1036 static LRESULT
1037 DATETIME_Command (DATETIME_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
1038 {
1039 TRACE("hwndbutton = %p\n", infoPtr->hwndCheckbut);
1040 if(infoPtr->hwndCheckbut == (HWND)lParam)
1041 return DATETIME_Button_Command(infoPtr, wParam, lParam);
1042 return 0;
1043 }
1044
1045
1046 static LRESULT
1047 DATETIME_Enable (DATETIME_INFO *infoPtr, BOOL bEnable)
1048 {
1049 TRACE("%p %s\n", infoPtr, bEnable ? "TRUE" : "FALSE");
1050 if (bEnable)
1051 infoPtr->dwStyle &= ~WS_DISABLED;
1052 else
1053 infoPtr->dwStyle |= WS_DISABLED;
1054
1055 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1056
1057 return 0;
1058 }
1059
1060
1061 static LRESULT
1062 DATETIME_EraseBackground (const DATETIME_INFO *infoPtr, HDC hdc)
1063 {
1064 HBRUSH hBrush, hSolidBrush = NULL;
1065 RECT rc;
1066
1067 if (infoPtr->dwStyle & WS_DISABLED)
1068 hBrush = hSolidBrush = CreateSolidBrush(comctl32_color.clrBtnFace);
1069 else
1070 {
1071 hBrush = (HBRUSH)SendMessageW(infoPtr->hwndNotify, WM_CTLCOLOREDIT,
1072 (WPARAM)hdc, (LPARAM)infoPtr->hwndSelf);
1073 if (!hBrush)
1074 hBrush = hSolidBrush = CreateSolidBrush(comctl32_color.clrWindow);
1075 }
1076
1077 GetClientRect (infoPtr->hwndSelf, &rc);
1078
1079 FillRect (hdc, &rc, hBrush);
1080
1081 if (hSolidBrush)
1082 DeleteObject(hSolidBrush);
1083
1084 return -1;
1085 }
1086
1087
1088 static LRESULT
1089 DATETIME_Notify (DATETIME_INFO *infoPtr, const NMHDR *lpnmh)
1090 {
1091 TRACE ("Got notification %x from %p\n", lpnmh->code, lpnmh->hwndFrom);
1092 TRACE ("info: %p %p %p\n", infoPtr->hwndSelf, infoPtr->hMonthCal, infoPtr->hUpdown);
1093
1094 if (lpnmh->code == MCN_SELECT) {
1095 ShowWindow(infoPtr->hMonthCal, SW_HIDE);
1096 infoPtr->dateValid = TRUE;
1097 SendMessageW (infoPtr->hMonthCal, MCM_GETCURSEL, 0, (LPARAM)&infoPtr->date);
1098 TRACE("got from calendar %04d/%02d/%02d day of week %d\n",
1099 infoPtr->date.wYear, infoPtr->date.wMonth, infoPtr->date.wDay, infoPtr->date.wDayOfWeek);
1100 SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, BST_CHECKED, 0);
1101 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1102 DATETIME_SendDateTimeChangeNotify (infoPtr);
1103 DATETIME_SendSimpleNotify(infoPtr, DTN_CLOSEUP);
1104 }
1105 if ((lpnmh->hwndFrom == infoPtr->hUpdown) && (lpnmh->code == UDN_DELTAPOS)) {
1106 const NM_UPDOWN *lpnmud = (const NM_UPDOWN*)lpnmh;
1107 TRACE("Delta pos %d\n", lpnmud->iDelta);
1108 infoPtr->pendingUpdown = lpnmud->iDelta;
1109 }
1110 return 0;
1111 }
1112
1113
1114 static LRESULT
1115 DATETIME_KeyDown (DATETIME_INFO *infoPtr, DWORD vkCode)
1116 {
1117 int fieldNum = infoPtr->select & DTHT_DATEFIELD;
1118 int wrap = 0;
1119 int new;
1120
1121 if (!(infoPtr->haveFocus)) return 0;
1122 if ((fieldNum==0) && (infoPtr->select)) return 0;
1123
1124 if (infoPtr->select & FORMATCALLMASK) {
1125 FIXME ("Callbacks not implemented yet\n");
1126 }
1127
1128 switch (vkCode) {
1129 case VK_ADD:
1130 case VK_UP:
1131 infoPtr->nCharsEntered = 0;
1132 DATETIME_IncreaseField (infoPtr, fieldNum, 1);
1133 DATETIME_SendDateTimeChangeNotify (infoPtr);
1134 break;
1135 case VK_SUBTRACT:
1136 case VK_DOWN:
1137 infoPtr->nCharsEntered = 0;
1138 DATETIME_IncreaseField (infoPtr, fieldNum, -1);
1139 DATETIME_SendDateTimeChangeNotify (infoPtr);
1140 break;
1141 case VK_HOME:
1142 infoPtr->nCharsEntered = 0;
1143 DATETIME_IncreaseField (infoPtr, fieldNum, INT_MIN);
1144 DATETIME_SendDateTimeChangeNotify (infoPtr);
1145 break;
1146 case VK_END:
1147 infoPtr->nCharsEntered = 0;
1148 DATETIME_IncreaseField (infoPtr, fieldNum, INT_MAX);
1149 DATETIME_SendDateTimeChangeNotify (infoPtr);
1150 break;
1151 case VK_LEFT:
1152 new = infoPtr->select;
1153 do {
1154 if (new == 0) {
1155 new = new - 1;
1156 wrap++;
1157 } else {
1158 new--;
1159 }
1160 } while ((infoPtr->fieldspec[new] & DT_STRING) && (wrap<2));
1161 if (new != infoPtr->select)
1162 DATETIME_SetSelectedField(infoPtr, new);
1163 break;
1164 case VK_RIGHT:
1165 new = infoPtr->select;
1166 do {
1167 new++;
1168 if (new==infoPtr->nrFields) {
1169 new = 0;
1170 wrap++;
1171 }
1172 } while ((infoPtr->fieldspec[new] & DT_STRING) && (wrap<2));
1173 if (new != infoPtr->select)
1174 DATETIME_SetSelectedField(infoPtr, new);
1175 break;
1176 }
1177
1178 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1179
1180 return 0;
1181 }
1182
1183
1184 static LRESULT
1185 DATETIME_Char (DATETIME_INFO *infoPtr, WPARAM vkCode)
1186 {
1187 int fieldNum = infoPtr->select & DTHT_DATEFIELD;
1188
1189 if (vkCode >= '0' && vkCode <= '9') {
1190 int maxChars;
1191 int fieldSpec;
1192
1193 infoPtr->charsEntered[infoPtr->nCharsEntered++] = vkCode;
1194
1195 fieldSpec = infoPtr->fieldspec[fieldNum];
1196
1197 if (fieldSpec == INVALIDFULLYEAR || fieldSpec == FULLYEAR)
1198 maxChars = 4;
1199 else
1200 maxChars = 2;
1201
1202 if (maxChars == infoPtr->nCharsEntered)
1203 DATETIME_ApplySelectedField(infoPtr);
1204 }
1205 return 0;
1206 }
1207
1208
1209 static LRESULT
1210 DATETIME_VScroll (DATETIME_INFO *infoPtr, WORD wScroll)
1211 {
1212 int fieldNum = infoPtr->select & DTHT_DATEFIELD;
1213
1214 if ((SHORT)LOWORD(wScroll) != SB_THUMBPOSITION) return 0;
1215 if (!(infoPtr->haveFocus)) return 0;
1216 if ((fieldNum==0) && (infoPtr->select)) return 0;
1217
1218 if (infoPtr->pendingUpdown >= 0) {
1219 DATETIME_IncreaseField (infoPtr, fieldNum, 1);
1220 DATETIME_SendDateTimeChangeNotify (infoPtr);
1221 }
1222 else {
1223 DATETIME_IncreaseField (infoPtr, fieldNum, -1);
1224 DATETIME_SendDateTimeChangeNotify (infoPtr);
1225 }
1226
1227 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1228
1229 return 0;
1230 }
1231
1232
1233 static LRESULT
1234 DATETIME_KillFocus (DATETIME_INFO *infoPtr, HWND lostFocus)
1235 {
1236 TRACE("lost focus to %p\n", lostFocus);
1237
1238 if (infoPtr->haveFocus) {
1239 DATETIME_SendSimpleNotify (infoPtr, NM_KILLFOCUS);
1240 infoPtr->haveFocus = 0;
1241 DATETIME_SetSelectedField (infoPtr, -1);
1242 }
1243
1244 InvalidateRect (infoPtr->hwndSelf, NULL, TRUE);
1245
1246 return 0;
1247 }
1248
1249
1250 static LRESULT
1251 DATETIME_NCCreate (HWND hwnd, const CREATESTRUCTW *lpcs)
1252 {
1253 DWORD dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
1254 /* force control to have client edge */
1255 dwExStyle |= WS_EX_CLIENTEDGE;
1256 SetWindowLongW(hwnd, GWL_EXSTYLE, dwExStyle);
1257
1258 return DefWindowProcW(hwnd, WM_NCCREATE, 0, (LPARAM)lpcs);
1259 }
1260
1261
1262 static LRESULT
1263 DATETIME_SetFocus (DATETIME_INFO *infoPtr, HWND lostFocus)
1264 {
1265 TRACE("got focus from %p\n", lostFocus);
1266
1267 /* if monthcal is open and it loses focus, close monthcal */
1268 if (infoPtr->hMonthCal && (lostFocus == infoPtr->hMonthCal) &&
1269 IsWindowVisible(infoPtr->hMonthCal))
1270 {
1271 ShowWindow(infoPtr->hMonthCal, SW_HIDE);
1272 DATETIME_SendSimpleNotify(infoPtr, DTN_CLOSEUP);
1273 /* note: this get triggered even if monthcal loses focus to a dropdown
1274 * box click, which occurs without an intermediate WM_PAINT call
1275 */
1276 infoPtr->bDropdownEnabled = FALSE;
1277 return 0;
1278 }
1279
1280 if (infoPtr->haveFocus == 0) {
1281 DATETIME_SendSimpleNotify (infoPtr, NM_SETFOCUS);
1282 infoPtr->haveFocus = DTHT_GOTFOCUS;
1283 }
1284
1285 InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1286
1287 return 0;
1288 }
1289
1290
1291 static BOOL
1292 DATETIME_SendDateTimeChangeNotify (const DATETIME_INFO *infoPtr)
1293 {
1294 NMDATETIMECHANGE dtdtc;
1295
1296 dtdtc.nmhdr.hwndFrom = infoPtr->hwndSelf;
1297 dtdtc.nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
1298 dtdtc.nmhdr.code = DTN_DATETIMECHANGE;
1299
1300 dtdtc.dwFlags = infoPtr->dateValid ? GDT_VALID : GDT_NONE;
1301
1302 dtdtc.st = infoPtr->date;
1303 return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
1304 dtdtc.nmhdr.idFrom, (LPARAM)&dtdtc);
1305 }
1306
1307
1308 static BOOL
1309 DATETIME_SendSimpleNotify (const DATETIME_INFO *infoPtr, UINT code)
1310 {
1311 NMHDR nmhdr;
1312
1313 TRACE("%x\n", code);
1314 nmhdr.hwndFrom = infoPtr->hwndSelf;
1315 nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
1316 nmhdr.code = code;
1317
1318 return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
1319 nmhdr.idFrom, (LPARAM)&nmhdr);
1320 }
1321
1322 static LRESULT
1323 DATETIME_Size (DATETIME_INFO *infoPtr, INT width, INT height)
1324 {
1325 /* set size */
1326 infoPtr->rcClient.bottom = height;
1327 infoPtr->rcClient.right = width;
1328
1329 TRACE("Height=%d, Width=%d\n", infoPtr->rcClient.bottom, infoPtr->rcClient.right);
1330
1331 infoPtr->rcDraw = infoPtr->rcClient;
1332
1333 if (infoPtr->dwStyle & DTS_UPDOWN) {
1334 SetWindowPos(infoPtr->hUpdown, NULL,
1335 infoPtr->rcClient.right-14, 0,
1336 15, infoPtr->rcClient.bottom - infoPtr->rcClient.top,
1337 SWP_NOACTIVATE | SWP_NOZORDER);
1338 }
1339 else {
1340 /* set the size of the button that drops the calendar down */
1341 /* FIXME: account for style that allows button on left side */
1342 infoPtr->calbutton.top = infoPtr->rcDraw.top;
1343 infoPtr->calbutton.bottom= infoPtr->rcDraw.bottom;
1344 infoPtr->calbutton.left = infoPtr->rcDraw.right-15;
1345 infoPtr->calbutton.right = infoPtr->rcDraw.right;
1346 }
1347
1348 /* set enable/disable button size for show none style being enabled */
1349 /* FIXME: these dimensions are completely incorrect */
1350 infoPtr->checkbox.top = infoPtr->rcDraw.top;
1351 infoPtr->checkbox.bottom = infoPtr->rcDraw.bottom;
1352 infoPtr->checkbox.left = infoPtr->rcDraw.left;
1353 infoPtr->checkbox.right = infoPtr->rcDraw.left + 10;
1354
1355 InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1356
1357 return 0;
1358 }
1359
1360 static LRESULT
1361 DATETIME_StyleChanging(DATETIME_INFO *infoPtr, WPARAM wStyleType, STYLESTRUCT *lpss)
1362 {
1363 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
1364 wStyleType, lpss->styleOld, lpss->styleNew);
1365
1366 /* block DTS_SHOWNONE change */
1367 if ((lpss->styleNew ^ lpss->styleOld) & DTS_SHOWNONE)
1368 {
1369 if (lpss->styleOld & DTS_SHOWNONE)
1370 lpss->styleNew |= DTS_SHOWNONE;
1371 else
1372 lpss->styleNew &= ~DTS_SHOWNONE;
1373 }
1374
1375 return 0;
1376 }
1377
1378 static LRESULT
1379 DATETIME_StyleChanged(DATETIME_INFO *infoPtr, WPARAM wStyleType, const STYLESTRUCT *lpss)
1380 {
1381 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
1382 wStyleType, lpss->styleOld, lpss->styleNew);
1383
1384 if (wStyleType != GWL_STYLE) return 0;
1385
1386 infoPtr->dwStyle = lpss->styleNew;
1387
1388 if ( !(lpss->styleOld & DTS_SHOWNONE) && (lpss->styleNew & DTS_SHOWNONE) ) {
1389 infoPtr->hwndCheckbut = CreateWindowExW (0, WC_BUTTONW, 0, WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
1390 2, 2, 13, 13, infoPtr->hwndSelf, 0,
1391 (HINSTANCE)GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_HINSTANCE), 0);
1392 SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, 1, 0);
1393 }
1394 if ( (lpss->styleOld & DTS_SHOWNONE) && !(lpss->styleNew & DTS_SHOWNONE) ) {
1395 DestroyWindow(infoPtr->hwndCheckbut);
1396 infoPtr->hwndCheckbut = 0;
1397 }
1398 if ( !(lpss->styleOld & DTS_UPDOWN) && (lpss->styleNew & DTS_UPDOWN) ) {
1399 infoPtr->hUpdown = CreateUpDownControl (WS_CHILD | WS_BORDER | WS_VISIBLE, 120, 1, 20, 20,
1400 infoPtr->hwndSelf, 1, 0, 0, UD_MAXVAL, UD_MINVAL, 0);
1401 }
1402 if ( (lpss->styleOld & DTS_UPDOWN) && !(lpss->styleNew & DTS_UPDOWN) ) {
1403 DestroyWindow(infoPtr->hUpdown);
1404 infoPtr->hUpdown = 0;
1405 }
1406
1407 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1408 return 0;
1409 }
1410
1411
1412 static LRESULT
1413 DATETIME_SetFont (DATETIME_INFO *infoPtr, HFONT font, BOOL repaint)
1414 {
1415 infoPtr->hFont = font;
1416 if (repaint) InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1417 return 0;
1418 }
1419
1420
1421 static LRESULT
1422 DATETIME_Create (HWND hwnd, const CREATESTRUCTW *lpcs)
1423 {
1424 DATETIME_INFO *infoPtr = Alloc (sizeof(DATETIME_INFO));
1425 STYLESTRUCT ss = { 0, lpcs->style };
1426
1427 if (!infoPtr) return -1;
1428
1429 infoPtr->hwndSelf = hwnd;
1430 infoPtr->dwStyle = lpcs->style;
1431
1432 infoPtr->nrFieldsAllocated = 32;
1433 infoPtr->fieldspec = Alloc (infoPtr->nrFieldsAllocated * sizeof(int));
1434 infoPtr->fieldRect = Alloc (infoPtr->nrFieldsAllocated * sizeof(RECT));
1435 infoPtr->buflen = Alloc (infoPtr->nrFieldsAllocated * sizeof(int));
1436 infoPtr->hwndNotify = lpcs->hwndParent;
1437 infoPtr->select = -1; /* initially, nothing is selected */
1438 infoPtr->bDropdownEnabled = TRUE;
1439
1440 DATETIME_StyleChanged(infoPtr, GWL_STYLE, &ss);
1441 DATETIME_SetFormatW (infoPtr, 0);
1442
1443 /* create the monthcal control */
1444 infoPtr->hMonthCal = CreateWindowExW (0, MONTHCAL_CLASSW, 0, WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
1445 0, 0, 0, 0, infoPtr->hwndSelf, 0, 0, 0);
1446
1447 /* initialize info structure */
1448 GetLocalTime (&infoPtr->date);
1449 infoPtr->dateValid = TRUE;
1450 infoPtr->hFont = GetStockObject(DEFAULT_GUI_FONT);
1451
1452 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
1453
1454 return 0;
1455 }
1456
1457
1458
1459 static LRESULT
1460 DATETIME_Destroy (DATETIME_INFO *infoPtr)
1461 {
1462 if (infoPtr->hwndCheckbut)
1463 DestroyWindow(infoPtr->hwndCheckbut);
1464 if (infoPtr->hUpdown)
1465 DestroyWindow(infoPtr->hUpdown);
1466 if (infoPtr->hMonthCal)
1467 DestroyWindow(infoPtr->hMonthCal);
1468 SetWindowLongPtrW( infoPtr->hwndSelf, 0, 0 ); /* clear infoPtr */
1469 Free (infoPtr->buflen);
1470 Free (infoPtr->fieldRect);
1471 Free (infoPtr->fieldspec);
1472 Free (infoPtr);
1473 return 0;
1474 }
1475
1476
1477 static INT
1478 DATETIME_GetText (const DATETIME_INFO *infoPtr, INT count, LPWSTR dst)
1479 {
1480 WCHAR buf[80];
1481 int i;
1482
1483 if (!dst || (count <= 0)) return 0;
1484
1485 dst[0] = 0;
1486 for (i = 0; i < infoPtr->nrFields; i++)
1487 {
1488 DATETIME_ReturnTxt(infoPtr, i, buf, sizeof(buf)/sizeof(buf[0]));
1489 if ((strlenW(dst) + strlenW(buf)) < count)
1490 strcatW(dst, buf);
1491 else break;
1492 }
1493 return strlenW(dst);
1494 }
1495
1496
1497 static LRESULT WINAPI
1498 DATETIME_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1499 {
1500 DATETIME_INFO *infoPtr = ((DATETIME_INFO *)GetWindowLongPtrW (hwnd, 0));
1501 LRESULT ret;
1502
1503 TRACE ("%x, %lx, %lx\n", uMsg, wParam, lParam);
1504
1505 if (!infoPtr && (uMsg != WM_CREATE) && (uMsg != WM_NCCREATE))
1506 return DefWindowProcW( hwnd, uMsg, wParam, lParam );
1507
1508 switch (uMsg) {
1509
1510 case DTM_GETSYSTEMTIME:
1511 return DATETIME_GetSystemTime (infoPtr, (SYSTEMTIME *) lParam);
1512
1513 case DTM_SETSYSTEMTIME:
1514 return DATETIME_SetSystemTime (infoPtr, wParam, (SYSTEMTIME *) lParam);
1515
1516 case DTM_GETRANGE:
1517 ret = SendMessageW (infoPtr->hMonthCal, MCM_GETRANGE, wParam, lParam);
1518 return ret ? ret : 1; /* bug emulation */
1519
1520 case DTM_SETRANGE:
1521 return SendMessageW (infoPtr->hMonthCal, MCM_SETRANGE, wParam, lParam);
1522
1523 case DTM_SETFORMATA:
1524 return DATETIME_SetFormatA (infoPtr, (LPCSTR)lParam);
1525
1526 case DTM_SETFORMATW:
1527 return DATETIME_SetFormatW (infoPtr, (LPCWSTR)lParam);
1528
1529 case DTM_GETMONTHCAL:
1530 return (LRESULT)infoPtr->hMonthCal;
1531
1532 case DTM_SETMCCOLOR:
1533 return SendMessageW (infoPtr->hMonthCal, MCM_SETCOLOR, wParam, lParam);
1534
1535 case DTM_GETMCCOLOR:
1536 return SendMessageW (infoPtr->hMonthCal, MCM_GETCOLOR, wParam, 0);
1537
1538 case DTM_SETMCFONT:
1539 return SendMessageW (infoPtr->hMonthCal, WM_SETFONT, wParam, lParam);
1540
1541 case DTM_GETMCFONT:
1542 return SendMessageW (infoPtr->hMonthCal, WM_GETFONT, wParam, lParam);
1543
1544 case WM_NOTIFY:
1545 return DATETIME_Notify (infoPtr, (LPNMHDR)lParam);
1546
1547 case WM_ENABLE:
1548 return DATETIME_Enable (infoPtr, (BOOL)wParam);
1549
1550 case WM_ERASEBKGND:
1551 return DATETIME_EraseBackground (infoPtr, (HDC)wParam);
1552
1553 case WM_GETDLGCODE:
1554 return DLGC_WANTARROWS | DLGC_WANTCHARS;
1555
1556 case WM_PRINTCLIENT:
1557 case WM_PAINT:
1558 return DATETIME_Paint (infoPtr, (HDC)wParam);
1559
1560 case WM_KEYDOWN:
1561 return DATETIME_KeyDown (infoPtr, wParam);
1562
1563 case WM_CHAR:
1564 return DATETIME_Char (infoPtr, wParam);
1565
1566 case WM_KILLFOCUS:
1567 return DATETIME_KillFocus (infoPtr, (HWND)wParam);
1568
1569 case WM_NCCREATE:
1570 return DATETIME_NCCreate (hwnd, (LPCREATESTRUCTW)lParam);
1571
1572 case WM_SETFOCUS:
1573 return DATETIME_SetFocus (infoPtr, (HWND)wParam);
1574
1575 case WM_SIZE:
1576 return DATETIME_Size (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
1577
1578 case WM_LBUTTONDOWN:
1579 return DATETIME_LButtonDown (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
1580
1581 case WM_LBUTTONUP:
1582 return DATETIME_LButtonUp (infoPtr);
1583
1584 case WM_VSCROLL:
1585 return DATETIME_VScroll (infoPtr, (WORD)wParam);
1586
1587 case WM_CREATE:
1588 return DATETIME_Create (hwnd, (LPCREATESTRUCTW)lParam);
1589
1590 case WM_DESTROY:
1591 return DATETIME_Destroy (infoPtr);
1592
1593 case WM_COMMAND:
1594 return DATETIME_Command (infoPtr, wParam, lParam);
1595
1596 case WM_STYLECHANGING:
1597 return DATETIME_StyleChanging(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
1598
1599 case WM_STYLECHANGED:
1600 return DATETIME_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
1601
1602 case WM_SETFONT:
1603 return DATETIME_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
1604
1605 case WM_GETFONT:
1606 return (LRESULT) infoPtr->hFont;
1607
1608 case WM_GETTEXT:
1609 return (LRESULT) DATETIME_GetText(infoPtr, wParam, (LPWSTR)lParam);
1610
1611 case WM_SETTEXT:
1612 return CB_ERR;
1613
1614 default:
1615 if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
1616 ERR("unknown msg %04x wp=%08lx lp=%08lx\n",
1617 uMsg, wParam, lParam);
1618 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
1619 }
1620 }
1621
1622
1623 void
1624 DATETIME_Register (void)
1625 {
1626 WNDCLASSW wndClass;
1627
1628 ZeroMemory (&wndClass, sizeof(WNDCLASSW));
1629 wndClass.style = CS_GLOBALCLASS;
1630 wndClass.lpfnWndProc = DATETIME_WindowProc;
1631 wndClass.cbClsExtra = 0;
1632 wndClass.cbWndExtra = sizeof(DATETIME_INFO *);
1633 wndClass.hCursor = LoadCursorW (0, (LPCWSTR)IDC_ARROW);
1634 wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
1635 wndClass.lpszClassName = DATETIMEPICK_CLASSW;
1636
1637 RegisterClassW (&wndClass);
1638 }
1639
1640
1641 void
1642 DATETIME_Unregister (void)
1643 {
1644 UnregisterClassW (DATETIMEPICK_CLASSW, NULL);
1645 }
Maarten's multimedia branch