?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
netcfgx: Add INetCfgLock support.
[wine/multimedia.git] / dlls / comctl32 / datetime.c
blob5c73a90be5e76ff54f671c47f89f8aca5214ca32
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 BOOL 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 FALSE;
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))
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 the nearest preceding date field from given,
835 or -1 if none was found */
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;
850 BOOL clamp_day = FALSE;
851 SYSTEMTIME date = infoPtr->date;
852 int oldyear;
853
854 if (infoPtr->select == -1 || infoPtr->nCharsEntered == 0)
855 return;
856
857 if ((infoPtr->fieldspec[fieldNum] == ONELETTERAMPM) ||
858 (infoPtr->fieldspec[fieldNum] == TWOLETTERAMPM))
859 val = infoPtr->charsEntered[0];
860 else {
861 for (i=0; i<infoPtr->nCharsEntered; i++)
862 val = val * 10 + infoPtr->charsEntered[i] - '0';
863 }
864
865 infoPtr->nCharsEntered = 0;
866
867 switch (infoPtr->fieldspec[fieldNum]) {
868 case ONEDIGITYEAR:
869 case TWODIGITYEAR:
870 oldyear = date.wYear;
871 date.wYear = date.wYear - (date.wYear%100) + val;
872
873 if (DATETIME_IsDateInValidRange(infoPtr, &date))
874 clamp_day = TRUE;
875 else
876 date.wYear = oldyear;
877
878 break;
879 case INVALIDFULLYEAR:
880 case FULLYEAR:
881 oldyear = date.wYear;
882 date.wYear = val;
883
884 if (DATETIME_IsDateInValidRange(infoPtr, &date))
885 clamp_day = TRUE;
886 else
887 date.wYear = oldyear;
888
889 break;
890 case ONEDIGITMONTH:
891 case TWODIGITMONTH:
892 date.wMonth = val;
893 clamp_day = TRUE;
894 break;
895 case ONEDIGITDAY:
896 case TWODIGITDAY:
897 date.wDay = val;
898 break;
899 case ONEDIGIT12HOUR:
900 case TWODIGIT12HOUR:
901 if (val >= 24)
902 val -= 20;
903
904 if (val >= 13)
905 date.wHour = val;
906 else if (val != 0) {
907 if (date.wHour >= 12) /* preserve current AM/PM state */
908 date.wHour = (val == 12 ? 12 : val + 12);
909 else
910 date.wHour = (val == 12 ? 0 : val);
911 }
912 break;
913 case ONEDIGIT24HOUR:
914 case TWODIGIT24HOUR:
915 date.wHour = val;
916 break;
917 case ONEDIGITMINUTE:
918 case TWODIGITMINUTE:
919 date.wMinute = val;
920 break;
921 case ONEDIGITSECOND:
922 case TWODIGITSECOND:
923 date.wSecond = val;
924 break;
925 case ONELETTERAMPM:
926 case TWOLETTERAMPM:
927 if (val == 'a' || val == 'A') {
928 if (date.wHour >= 12)
929 date.wHour -= 12;
930 } else if (val == 'p' || val == 'P') {
931 if (date.wHour < 12)
932 date.wHour += 12;
933 }
934 break;
935 }
936
937 if (clamp_day && date.wDay > MONTHCAL_MonthLength(date.wMonth, date.wYear))
938 date.wDay = MONTHCAL_MonthLength(date.wMonth, date.wYear);
939
940 if (DATETIME_SetSystemTime(infoPtr, GDT_VALID, &date))
941 DATETIME_SendDateTimeChangeNotify (infoPtr);
942 }
943
944 static void
945 DATETIME_SetSelectedField (DATETIME_INFO *infoPtr, int select)
946 {
947 DATETIME_ApplySelectedField(infoPtr);
948
949 infoPtr->select = select;
950 infoPtr->nCharsEntered = 0;
951 }
952
953 static LRESULT
954 DATETIME_LButtonDown (DATETIME_INFO *infoPtr, INT x, INT y)
955 {
956 POINT pt;
957 int new;
958
959 pt.x = x;
960 pt.y = y;
961 new = DATETIME_HitTest (infoPtr, pt);
962
963 SetFocus(infoPtr->hwndSelf);
964
965 if (!(new & DTHT_NODATEMASK) || (new == DTHT_NONE))
966 {
967 if (new == DTHT_NONE)
968 new = infoPtr->nrFields - 1;
969 else
970 {
971 /* hitting string part moves selection to next date field to left */
972 if (infoPtr->fieldspec[new] & DT_STRING)
973 {
974 new = DATETIME_GetPrevDateField(infoPtr, new);
975 if (new == -1) return 0;
976 }
977 /* never select full day of week */
978 if (infoPtr->fieldspec[new] == FULLDAY) return 0;
979 }
980 }
981
982 DATETIME_SetSelectedField(infoPtr, new);
983
984 if (infoPtr->select == DTHT_MCPOPUP) {
985 RECT rcMonthCal;
986 POINT pos;
987 SendMessageW(infoPtr->hMonthCal, MCM_GETMINREQRECT, 0, (LPARAM)&rcMonthCal);
988
989 /* FIXME: button actually is only depressed during dropdown of the */
990 /* calendar control and when the mouse is over the button window */
991 infoPtr->bCalDepressed = TRUE;
992
993 /* recalculate the position of the monthcal popup */
994 if(infoPtr->dwStyle & DTS_RIGHTALIGN)
995 pos.x = infoPtr->calbutton.left - (rcMonthCal.right - rcMonthCal.left);
996 else
997 /* FIXME: this should be after the area reserved for the checkbox */
998 pos.x = infoPtr->rcDraw.left;
999
1000 pos.y = infoPtr->rcClient.bottom;
1001 OffsetRect( &rcMonthCal, pos.x, pos.y );
1002 MapWindowPoints( infoPtr->hwndSelf, 0, (POINT *)&rcMonthCal, 2 );
1003 SetWindowPos(infoPtr->hMonthCal, 0, rcMonthCal.left, rcMonthCal.top,
1004 rcMonthCal.right - rcMonthCal.left, rcMonthCal.bottom - rcMonthCal.top, 0);
1005
1006 if(IsWindowVisible(infoPtr->hMonthCal)) {
1007 ShowWindow(infoPtr->hMonthCal, SW_HIDE);
1008 infoPtr->bDropdownEnabled = FALSE;
1009 DATETIME_SendSimpleNotify (infoPtr, DTN_CLOSEUP);
1010 } else {
1011 const SYSTEMTIME *lprgSysTimeArray = &infoPtr->date;
1012 TRACE("update calendar %04d/%02d/%02d\n",
1013 lprgSysTimeArray->wYear, lprgSysTimeArray->wMonth, lprgSysTimeArray->wDay);
1014 SendMessageW(infoPtr->hMonthCal, MCM_SETCURSEL, 0, (LPARAM)(&infoPtr->date));
1015
1016 if (infoPtr->bDropdownEnabled) {
1017 ShowWindow(infoPtr->hMonthCal, SW_SHOW);
1018 DATETIME_SendSimpleNotify (infoPtr, DTN_DROPDOWN);
1019 }
1020 infoPtr->bDropdownEnabled = TRUE;
1021 }
1022
1023 TRACE ("dt:%p mc:%p mc parent:%p, desktop:%p\n",
1024 infoPtr->hwndSelf, infoPtr->hMonthCal, infoPtr->hwndNotify, GetDesktopWindow ());
1025 }
1026
1027 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1028
1029 return 0;
1030 }
1031
1032
1033 static LRESULT
1034 DATETIME_LButtonUp (DATETIME_INFO *infoPtr)
1035 {
1036 if(infoPtr->bCalDepressed) {
1037 infoPtr->bCalDepressed = FALSE;
1038 InvalidateRect(infoPtr->hwndSelf, &(infoPtr->calbutton), TRUE);
1039 }
1040
1041 return 0;
1042 }
1043
1044
1045 static LRESULT
1046 DATETIME_Paint (DATETIME_INFO *infoPtr, HDC hdc)
1047 {
1048 if (!hdc) {
1049 PAINTSTRUCT ps;
1050 hdc = BeginPaint (infoPtr->hwndSelf, &ps);
1051 DATETIME_Refresh (infoPtr, hdc);
1052 EndPaint (infoPtr->hwndSelf, &ps);
1053 } else {
1054 DATETIME_Refresh (infoPtr, hdc);
1055 }
1056
1057 /* Not a click on the dropdown box, enabled it */
1058 infoPtr->bDropdownEnabled = TRUE;
1059
1060 return 0;
1061 }
1062
1063
1064 static LRESULT
1065 DATETIME_Button_Command (DATETIME_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
1066 {
1067 if( HIWORD(wParam) == BN_CLICKED) {
1068 DWORD state = SendMessageW((HWND)lParam, BM_GETCHECK, 0, 0);
1069 infoPtr->dateValid = (state == BST_CHECKED);
1070 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1071 }
1072 return 0;
1073 }
1074
1075
1076
1077 static LRESULT
1078 DATETIME_Command (DATETIME_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
1079 {
1080 TRACE("hwndbutton = %p\n", infoPtr->hwndCheckbut);
1081 if(infoPtr->hwndCheckbut == (HWND)lParam)
1082 return DATETIME_Button_Command(infoPtr, wParam, lParam);
1083 return 0;
1084 }
1085
1086
1087 static LRESULT
1088 DATETIME_Enable (DATETIME_INFO *infoPtr, BOOL bEnable)
1089 {
1090 TRACE("%p %s\n", infoPtr, bEnable ? "TRUE" : "FALSE");
1091 if (bEnable)
1092 infoPtr->dwStyle &= ~WS_DISABLED;
1093 else
1094 infoPtr->dwStyle |= WS_DISABLED;
1095
1096 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1097
1098 return 0;
1099 }
1100
1101
1102 static LRESULT
1103 DATETIME_EraseBackground (const DATETIME_INFO *infoPtr, HDC hdc)
1104 {
1105 HBRUSH hBrush, hSolidBrush = NULL;
1106 RECT rc;
1107
1108 if (infoPtr->dwStyle & WS_DISABLED)
1109 hBrush = hSolidBrush = CreateSolidBrush(comctl32_color.clrBtnFace);
1110 else
1111 {
1112 hBrush = (HBRUSH)SendMessageW(infoPtr->hwndNotify, WM_CTLCOLOREDIT,
1113 (WPARAM)hdc, (LPARAM)infoPtr->hwndSelf);
1114 if (!hBrush)
1115 hBrush = hSolidBrush = CreateSolidBrush(comctl32_color.clrWindow);
1116 }
1117
1118 GetClientRect (infoPtr->hwndSelf, &rc);
1119
1120 FillRect (hdc, &rc, hBrush);
1121
1122 if (hSolidBrush)
1123 DeleteObject(hSolidBrush);
1124
1125 return -1;
1126 }
1127
1128
1129 static LRESULT
1130 DATETIME_Notify (DATETIME_INFO *infoPtr, const NMHDR *lpnmh)
1131 {
1132 TRACE ("Got notification %x from %p\n", lpnmh->code, lpnmh->hwndFrom);
1133 TRACE ("info: %p %p %p\n", infoPtr->hwndSelf, infoPtr->hMonthCal, infoPtr->hUpdown);
1134
1135 if (lpnmh->code == MCN_SELECT) {
1136 ShowWindow(infoPtr->hMonthCal, SW_HIDE);
1137 infoPtr->dateValid = TRUE;
1138 SendMessageW (infoPtr->hMonthCal, MCM_GETCURSEL, 0, (LPARAM)&infoPtr->date);
1139 TRACE("got from calendar %04d/%02d/%02d day of week %d\n",
1140 infoPtr->date.wYear, infoPtr->date.wMonth, infoPtr->date.wDay, infoPtr->date.wDayOfWeek);
1141 SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, BST_CHECKED, 0);
1142 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1143 DATETIME_SendDateTimeChangeNotify (infoPtr);
1144 DATETIME_SendSimpleNotify(infoPtr, DTN_CLOSEUP);
1145 }
1146 if ((lpnmh->hwndFrom == infoPtr->hUpdown) && (lpnmh->code == UDN_DELTAPOS)) {
1147 const NM_UPDOWN *lpnmud = (const NM_UPDOWN*)lpnmh;
1148 TRACE("Delta pos %d\n", lpnmud->iDelta);
1149 infoPtr->pendingUpdown = lpnmud->iDelta;
1150 }
1151 return 0;
1152 }
1153
1154
1155 static LRESULT
1156 DATETIME_KeyDown (DATETIME_INFO *infoPtr, DWORD vkCode)
1157 {
1158 int fieldNum = infoPtr->select & DTHT_DATEFIELD;
1159 int wrap = 0;
1160 int new;
1161
1162 if (!(infoPtr->haveFocus)) return 0;
1163 if ((fieldNum==0) && (infoPtr->select)) return 0;
1164
1165 if (infoPtr->select & FORMATCALLMASK) {
1166 FIXME ("Callbacks not implemented yet\n");
1167 }
1168
1169 switch (vkCode) {
1170 case VK_ADD:
1171 case VK_UP:
1172 infoPtr->nCharsEntered = 0;
1173 DATETIME_IncreaseField (infoPtr, fieldNum, 1);
1174 DATETIME_SendDateTimeChangeNotify (infoPtr);
1175 break;
1176 case VK_SUBTRACT:
1177 case VK_DOWN:
1178 infoPtr->nCharsEntered = 0;
1179 DATETIME_IncreaseField (infoPtr, fieldNum, -1);
1180 DATETIME_SendDateTimeChangeNotify (infoPtr);
1181 break;
1182 case VK_HOME:
1183 infoPtr->nCharsEntered = 0;
1184 DATETIME_IncreaseField (infoPtr, fieldNum, INT_MIN);
1185 DATETIME_SendDateTimeChangeNotify (infoPtr);
1186 break;
1187 case VK_END:
1188 infoPtr->nCharsEntered = 0;
1189 DATETIME_IncreaseField (infoPtr, fieldNum, INT_MAX);
1190 DATETIME_SendDateTimeChangeNotify (infoPtr);
1191 break;
1192 case VK_LEFT:
1193 new = infoPtr->select;
1194 do {
1195 if (new == 0) {
1196 new = new - 1;
1197 wrap++;
1198 } else {
1199 new--;
1200 }
1201 } while ((infoPtr->fieldspec[new] & DT_STRING) && (wrap<2));
1202 if (new != infoPtr->select)
1203 DATETIME_SetSelectedField(infoPtr, new);
1204 break;
1205 case VK_RIGHT:
1206 new = infoPtr->select;
1207 do {
1208 new++;
1209 if (new==infoPtr->nrFields) {
1210 new = 0;
1211 wrap++;
1212 }
1213 } while ((infoPtr->fieldspec[new] & DT_STRING) && (wrap<2));
1214 if (new != infoPtr->select)
1215 DATETIME_SetSelectedField(infoPtr, new);
1216 break;
1217 }
1218
1219 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1220
1221 return 0;
1222 }
1223
1224
1225 static LRESULT
1226 DATETIME_Char (DATETIME_INFO *infoPtr, WPARAM vkCode)
1227 {
1228 int fieldNum, fieldSpec;
1229
1230 fieldNum = infoPtr->select & DTHT_DATEFIELD;
1231 fieldSpec = infoPtr->fieldspec[fieldNum];
1232
1233 if (fieldSpec == ONELETTERAMPM || fieldSpec == TWOLETTERAMPM) {
1234 infoPtr->charsEntered[0] = vkCode;
1235 infoPtr->nCharsEntered = 1;
1236
1237 DATETIME_ApplySelectedField(infoPtr);
1238 } else if (vkCode >= '0' && vkCode <= '9') {
1239 int maxChars;
1240
1241 infoPtr->charsEntered[infoPtr->nCharsEntered++] = vkCode;
1242
1243 if (fieldSpec == INVALIDFULLYEAR || fieldSpec == FULLYEAR)
1244 maxChars = 4;
1245 else
1246 maxChars = 2;
1247
1248 if ((fieldSpec == ONEDIGIT12HOUR ||
1249 fieldSpec == TWODIGIT12HOUR ||
1250 fieldSpec == ONEDIGIT24HOUR ||
1251 fieldSpec == TWODIGIT24HOUR) &&
1252 (infoPtr->nCharsEntered == 1))
1253 {
1254 if (vkCode >= '3')
1255 maxChars = 1;
1256 }
1257
1258 if (maxChars == infoPtr->nCharsEntered)
1259 DATETIME_ApplySelectedField(infoPtr);
1260 }
1261
1262 return 0;
1263 }
1264
1265
1266 static LRESULT
1267 DATETIME_VScroll (DATETIME_INFO *infoPtr, WORD wScroll)
1268 {
1269 int fieldNum = infoPtr->select & DTHT_DATEFIELD;
1270
1271 if ((SHORT)LOWORD(wScroll) != SB_THUMBPOSITION) return 0;
1272 if (!(infoPtr->haveFocus)) return 0;
1273 if ((fieldNum==0) && (infoPtr->select)) return 0;
1274
1275 if (infoPtr->pendingUpdown >= 0) {
1276 DATETIME_IncreaseField (infoPtr, fieldNum, 1);
1277 DATETIME_SendDateTimeChangeNotify (infoPtr);
1278 }
1279 else {
1280 DATETIME_IncreaseField (infoPtr, fieldNum, -1);
1281 DATETIME_SendDateTimeChangeNotify (infoPtr);
1282 }
1283
1284 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1285
1286 return 0;
1287 }
1288
1289
1290 static LRESULT
1291 DATETIME_KillFocus (DATETIME_INFO *infoPtr, HWND lostFocus)
1292 {
1293 TRACE("lost focus to %p\n", lostFocus);
1294
1295 if (infoPtr->haveFocus) {
1296 DATETIME_SendSimpleNotify (infoPtr, NM_KILLFOCUS);
1297 infoPtr->haveFocus = 0;
1298 DATETIME_SetSelectedField (infoPtr, -1);
1299 }
1300
1301 InvalidateRect (infoPtr->hwndSelf, NULL, TRUE);
1302
1303 return 0;
1304 }
1305
1306
1307 static LRESULT
1308 DATETIME_NCCreate (HWND hwnd, const CREATESTRUCTW *lpcs)
1309 {
1310 DWORD dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
1311 /* force control to have client edge */
1312 dwExStyle |= WS_EX_CLIENTEDGE;
1313 SetWindowLongW(hwnd, GWL_EXSTYLE, dwExStyle);
1314
1315 return DefWindowProcW(hwnd, WM_NCCREATE, 0, (LPARAM)lpcs);
1316 }
1317
1318
1319 static LRESULT
1320 DATETIME_SetFocus (DATETIME_INFO *infoPtr, HWND lostFocus)
1321 {
1322 TRACE("got focus from %p\n", lostFocus);
1323
1324 /* if monthcal is open and it loses focus, close monthcal */
1325 if (infoPtr->hMonthCal && (lostFocus == infoPtr->hMonthCal) &&
1326 IsWindowVisible(infoPtr->hMonthCal))
1327 {
1328 ShowWindow(infoPtr->hMonthCal, SW_HIDE);
1329 DATETIME_SendSimpleNotify(infoPtr, DTN_CLOSEUP);
1330 /* note: this get triggered even if monthcal loses focus to a dropdown
1331 * box click, which occurs without an intermediate WM_PAINT call
1332 */
1333 infoPtr->bDropdownEnabled = FALSE;
1334 return 0;
1335 }
1336
1337 if (infoPtr->haveFocus == 0) {
1338 DATETIME_SendSimpleNotify (infoPtr, NM_SETFOCUS);
1339 infoPtr->haveFocus = DTHT_GOTFOCUS;
1340 }
1341
1342 InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1343
1344 return 0;
1345 }
1346
1347
1348 static BOOL
1349 DATETIME_SendDateTimeChangeNotify (const DATETIME_INFO *infoPtr)
1350 {
1351 NMDATETIMECHANGE dtdtc;
1352
1353 dtdtc.nmhdr.hwndFrom = infoPtr->hwndSelf;
1354 dtdtc.nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
1355 dtdtc.nmhdr.code = DTN_DATETIMECHANGE;
1356
1357 dtdtc.dwFlags = infoPtr->dateValid ? GDT_VALID : GDT_NONE;
1358
1359 dtdtc.st = infoPtr->date;
1360 return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
1361 dtdtc.nmhdr.idFrom, (LPARAM)&dtdtc);
1362 }
1363
1364
1365 static BOOL
1366 DATETIME_SendSimpleNotify (const DATETIME_INFO *infoPtr, UINT code)
1367 {
1368 NMHDR nmhdr;
1369
1370 TRACE("%x\n", code);
1371 nmhdr.hwndFrom = infoPtr->hwndSelf;
1372 nmhdr.idFrom = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
1373 nmhdr.code = code;
1374
1375 return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
1376 nmhdr.idFrom, (LPARAM)&nmhdr);
1377 }
1378
1379 static LRESULT
1380 DATETIME_Size (DATETIME_INFO *infoPtr, INT width, INT height)
1381 {
1382 /* set size */
1383 infoPtr->rcClient.bottom = height;
1384 infoPtr->rcClient.right = width;
1385
1386 TRACE("Height=%d, Width=%d\n", infoPtr->rcClient.bottom, infoPtr->rcClient.right);
1387
1388 infoPtr->rcDraw = infoPtr->rcClient;
1389
1390 if (infoPtr->dwStyle & DTS_UPDOWN) {
1391 SetWindowPos(infoPtr->hUpdown, NULL,
1392 infoPtr->rcClient.right-14, 0,
1393 15, infoPtr->rcClient.bottom - infoPtr->rcClient.top,
1394 SWP_NOACTIVATE | SWP_NOZORDER);
1395 }
1396 else {
1397 /* set the size of the button that drops the calendar down */
1398 /* FIXME: account for style that allows button on left side */
1399 infoPtr->calbutton.top = infoPtr->rcDraw.top;
1400 infoPtr->calbutton.bottom= infoPtr->rcDraw.bottom;
1401 infoPtr->calbutton.left = infoPtr->rcDraw.right-15;
1402 infoPtr->calbutton.right = infoPtr->rcDraw.right;
1403 }
1404
1405 /* set enable/disable button size for show none style being enabled */
1406 /* FIXME: these dimensions are completely incorrect */
1407 infoPtr->checkbox.top = infoPtr->rcDraw.top;
1408 infoPtr->checkbox.bottom = infoPtr->rcDraw.bottom;
1409 infoPtr->checkbox.left = infoPtr->rcDraw.left;
1410 infoPtr->checkbox.right = infoPtr->rcDraw.left + 10;
1411
1412 InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1413
1414 return 0;
1415 }
1416
1417 static LRESULT
1418 DATETIME_StyleChanging(DATETIME_INFO *infoPtr, WPARAM wStyleType, STYLESTRUCT *lpss)
1419 {
1420 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
1421 wStyleType, lpss->styleOld, lpss->styleNew);
1422
1423 /* block DTS_SHOWNONE change */
1424 if ((lpss->styleNew ^ lpss->styleOld) & DTS_SHOWNONE)
1425 {
1426 if (lpss->styleOld & DTS_SHOWNONE)
1427 lpss->styleNew |= DTS_SHOWNONE;
1428 else
1429 lpss->styleNew &= ~DTS_SHOWNONE;
1430 }
1431
1432 return 0;
1433 }
1434
1435 static LRESULT
1436 DATETIME_StyleChanged(DATETIME_INFO *infoPtr, WPARAM wStyleType, const STYLESTRUCT *lpss)
1437 {
1438 TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
1439 wStyleType, lpss->styleOld, lpss->styleNew);
1440
1441 if (wStyleType != GWL_STYLE) return 0;
1442
1443 infoPtr->dwStyle = lpss->styleNew;
1444
1445 if ( !(lpss->styleOld & DTS_SHOWNONE) && (lpss->styleNew & DTS_SHOWNONE) ) {
1446 infoPtr->hwndCheckbut = CreateWindowExW (0, WC_BUTTONW, 0, WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
1447 2, 2, 13, 13, infoPtr->hwndSelf, 0,
1448 (HINSTANCE)GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_HINSTANCE), 0);
1449 SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, infoPtr->dateValid ? 1 : 0, 0);
1450 }
1451 if ( (lpss->styleOld & DTS_SHOWNONE) && !(lpss->styleNew & DTS_SHOWNONE) ) {
1452 DestroyWindow(infoPtr->hwndCheckbut);
1453 infoPtr->hwndCheckbut = 0;
1454 }
1455 if ( !(lpss->styleOld & DTS_UPDOWN) && (lpss->styleNew & DTS_UPDOWN) ) {
1456 infoPtr->hUpdown = CreateUpDownControl (WS_CHILD | WS_BORDER | WS_VISIBLE, 120, 1, 20, 20,
1457 infoPtr->hwndSelf, 1, 0, 0, UD_MAXVAL, UD_MINVAL, 0);
1458 }
1459 if ( (lpss->styleOld & DTS_UPDOWN) && !(lpss->styleNew & DTS_UPDOWN) ) {
1460 DestroyWindow(infoPtr->hUpdown);
1461 infoPtr->hUpdown = 0;
1462 }
1463
1464 InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1465 return 0;
1466 }
1467
1468
1469 static LRESULT
1470 DATETIME_SetFont (DATETIME_INFO *infoPtr, HFONT font, BOOL repaint)
1471 {
1472 infoPtr->hFont = font;
1473 if (repaint) InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1474 return 0;
1475 }
1476
1477
1478 static LRESULT
1479 DATETIME_Create (HWND hwnd, const CREATESTRUCTW *lpcs)
1480 {
1481 DATETIME_INFO *infoPtr = Alloc (sizeof(DATETIME_INFO));
1482 STYLESTRUCT ss = { 0, lpcs->style };
1483
1484 if (!infoPtr) return -1;
1485
1486 infoPtr->hwndSelf = hwnd;
1487 infoPtr->dwStyle = lpcs->style;
1488
1489 infoPtr->nrFieldsAllocated = 32;
1490 infoPtr->fieldspec = Alloc (infoPtr->nrFieldsAllocated * sizeof(int));
1491 infoPtr->fieldRect = Alloc (infoPtr->nrFieldsAllocated * sizeof(RECT));
1492 infoPtr->buflen = Alloc (infoPtr->nrFieldsAllocated * sizeof(int));
1493 infoPtr->hwndNotify = lpcs->hwndParent;
1494 infoPtr->select = -1; /* initially, nothing is selected */
1495 infoPtr->bDropdownEnabled = TRUE;
1496
1497 DATETIME_StyleChanged(infoPtr, GWL_STYLE, &ss);
1498 DATETIME_SetFormatW (infoPtr, 0);
1499
1500 /* create the monthcal control */
1501 infoPtr->hMonthCal = CreateWindowExW (0, MONTHCAL_CLASSW, 0, WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
1502 0, 0, 0, 0, infoPtr->hwndSelf, 0, 0, 0);
1503
1504 /* initialize info structure */
1505 GetLocalTime (&infoPtr->date);
1506 infoPtr->dateValid = TRUE;
1507 infoPtr->hFont = GetStockObject(DEFAULT_GUI_FONT);
1508
1509 SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
1510
1511 return 0;
1512 }
1513
1514
1515
1516 static LRESULT
1517 DATETIME_Destroy (DATETIME_INFO *infoPtr)
1518 {
1519 if (infoPtr->hwndCheckbut)
1520 DestroyWindow(infoPtr->hwndCheckbut);
1521 if (infoPtr->hUpdown)
1522 DestroyWindow(infoPtr->hUpdown);
1523 if (infoPtr->hMonthCal)
1524 DestroyWindow(infoPtr->hMonthCal);
1525 SetWindowLongPtrW( infoPtr->hwndSelf, 0, 0 ); /* clear infoPtr */
1526 Free (infoPtr->buflen);
1527 Free (infoPtr->fieldRect);
1528 Free (infoPtr->fieldspec);
1529 Free (infoPtr);
1530 return 0;
1531 }
1532
1533
1534 static INT
1535 DATETIME_GetText (const DATETIME_INFO *infoPtr, INT count, LPWSTR dst)
1536 {
1537 WCHAR buf[80];
1538 int i;
1539
1540 if (!dst || (count <= 0)) return 0;
1541
1542 dst[0] = 0;
1543 for (i = 0; i < infoPtr->nrFields; i++)
1544 {
1545 DATETIME_ReturnTxt(infoPtr, i, buf, sizeof(buf)/sizeof(buf[0]));
1546 if ((strlenW(dst) + strlenW(buf)) < count)
1547 strcatW(dst, buf);
1548 else break;
1549 }
1550 return strlenW(dst);
1551 }
1552
1553
1554 static LRESULT WINAPI
1555 DATETIME_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1556 {
1557 DATETIME_INFO *infoPtr = ((DATETIME_INFO *)GetWindowLongPtrW (hwnd, 0));
1558 LRESULT ret;
1559
1560 TRACE ("%x, %lx, %lx\n", uMsg, wParam, lParam);
1561
1562 if (!infoPtr && (uMsg != WM_CREATE) && (uMsg != WM_NCCREATE))
1563 return DefWindowProcW( hwnd, uMsg, wParam, lParam );
1564
1565 switch (uMsg) {
1566
1567 case DTM_GETSYSTEMTIME:
1568 return DATETIME_GetSystemTime (infoPtr, (SYSTEMTIME *) lParam);
1569
1570 case DTM_SETSYSTEMTIME:
1571 return DATETIME_SetSystemTime (infoPtr, wParam, (SYSTEMTIME *) lParam);
1572
1573 case DTM_GETRANGE:
1574 ret = SendMessageW (infoPtr->hMonthCal, MCM_GETRANGE, wParam, lParam);
1575 return ret ? ret : 1; /* bug emulation */
1576
1577 case DTM_SETRANGE:
1578 return SendMessageW (infoPtr->hMonthCal, MCM_SETRANGE, wParam, lParam);
1579
1580 case DTM_SETFORMATA:
1581 return DATETIME_SetFormatA (infoPtr, (LPCSTR)lParam);
1582
1583 case DTM_SETFORMATW:
1584 return DATETIME_SetFormatW (infoPtr, (LPCWSTR)lParam);
1585
1586 case DTM_GETMONTHCAL:
1587 return (LRESULT)infoPtr->hMonthCal;
1588
1589 case DTM_SETMCCOLOR:
1590 return SendMessageW (infoPtr->hMonthCal, MCM_SETCOLOR, wParam, lParam);
1591
1592 case DTM_GETMCCOLOR:
1593 return SendMessageW (infoPtr->hMonthCal, MCM_GETCOLOR, wParam, 0);
1594
1595 case DTM_SETMCFONT:
1596 return SendMessageW (infoPtr->hMonthCal, WM_SETFONT, wParam, lParam);
1597
1598 case DTM_GETMCFONT:
1599 return SendMessageW (infoPtr->hMonthCal, WM_GETFONT, wParam, lParam);
1600
1601 case WM_NOTIFY:
1602 return DATETIME_Notify (infoPtr, (LPNMHDR)lParam);
1603
1604 case WM_ENABLE:
1605 return DATETIME_Enable (infoPtr, (BOOL)wParam);
1606
1607 case WM_ERASEBKGND:
1608 return DATETIME_EraseBackground (infoPtr, (HDC)wParam);
1609
1610 case WM_GETDLGCODE:
1611 return DLGC_WANTARROWS | DLGC_WANTCHARS;
1612
1613 case WM_PRINTCLIENT:
1614 case WM_PAINT:
1615 return DATETIME_Paint (infoPtr, (HDC)wParam);
1616
1617 case WM_KEYDOWN:
1618 return DATETIME_KeyDown (infoPtr, wParam);
1619
1620 case WM_CHAR:
1621 return DATETIME_Char (infoPtr, wParam);
1622
1623 case WM_KILLFOCUS:
1624 return DATETIME_KillFocus (infoPtr, (HWND)wParam);
1625
1626 case WM_NCCREATE:
1627 return DATETIME_NCCreate (hwnd, (LPCREATESTRUCTW)lParam);
1628
1629 case WM_SETFOCUS:
1630 return DATETIME_SetFocus (infoPtr, (HWND)wParam);
1631
1632 case WM_SIZE:
1633 return DATETIME_Size (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
1634
1635 case WM_LBUTTONDOWN:
1636 return DATETIME_LButtonDown (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
1637
1638 case WM_LBUTTONUP:
1639 return DATETIME_LButtonUp (infoPtr);
1640
1641 case WM_VSCROLL:
1642 return DATETIME_VScroll (infoPtr, (WORD)wParam);
1643
1644 case WM_CREATE:
1645 return DATETIME_Create (hwnd, (LPCREATESTRUCTW)lParam);
1646
1647 case WM_DESTROY:
1648 return DATETIME_Destroy (infoPtr);
1649
1650 case WM_COMMAND:
1651 return DATETIME_Command (infoPtr, wParam, lParam);
1652
1653 case WM_STYLECHANGING:
1654 return DATETIME_StyleChanging(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
1655
1656 case WM_STYLECHANGED:
1657 return DATETIME_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
1658
1659 case WM_SETFONT:
1660 return DATETIME_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
1661
1662 case WM_GETFONT:
1663 return (LRESULT) infoPtr->hFont;
1664
1665 case WM_GETTEXT:
1666 return (LRESULT) DATETIME_GetText(infoPtr, wParam, (LPWSTR)lParam);
1667
1668 case WM_SETTEXT:
1669 return CB_ERR;
1670
1671 default:
1672 if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
1673 ERR("unknown msg %04x wp=%08lx lp=%08lx\n",
1674 uMsg, wParam, lParam);
1675 return DefWindowProcW (hwnd, uMsg, wParam, lParam);
1676 }
1677 }
1678
1679
1680 void
1681 DATETIME_Register (void)
1682 {
1683 WNDCLASSW wndClass;
1684
1685 ZeroMemory (&wndClass, sizeof(WNDCLASSW));
1686 wndClass.style = CS_GLOBALCLASS;
1687 wndClass.lpfnWndProc = DATETIME_WindowProc;
1688 wndClass.cbClsExtra = 0;
1689 wndClass.cbWndExtra = sizeof(DATETIME_INFO *);
1690 wndClass.hCursor = LoadCursorW (0, (LPCWSTR)IDC_ARROW);
1691 wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
1692 wndClass.lpszClassName = DATETIMEPICK_CLASSW;
1693
1694 RegisterClassW (&wndClass);
1695 }
1696
1697
1698 void
1699 DATETIME_Unregister (void)
1700 {
1701 UnregisterClassW (DATETIMEPICK_CLASSW, NULL);
1702 }
Maarten's multimedia branch