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