?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implemented DTM_GET/SETRANGE.
[wine/multimedia.git] / dlls / comctl32 / datetime.c
blob422877463e533773146abbf2ccadf3bef527fa81
1 /*
2 * Date and time picker control
3 *
4 * Copyright 1998, 1999 Eric Kohl
5 * Copyright 1999, 2000 Alex Priem <alexp@sci.kun.nl>
6 * Copyright 2000 Chris Morgan <cmorgan@wpi.edu>
7 *
8 *
9 * TODO:
10 * - All messages.
11 * - All notifications.
12 *
13 */
14
15 #include <math.h>
16 #include <string.h>
17 #include <stdio.h>
18
19 #include "winbase.h"
20 #include "wingdi.h"
21 #include "commctrl.h"
22 #include "debugtools.h"
23
24 DEFAULT_DEBUG_CHANNEL(datetime);
25
26 typedef struct
27 {
28 HWND hMonthCal;
29 HWND hUpdown;
30 SYSTEMTIME date;
31 BOOL dateValid;
32 HWND hwndCheckbut;
33 RECT rcClient; /* rect around the edge of the window */
34 RECT rcDraw; /* rect inside of the border */
35 RECT checkbox; /* checkbox allowing the control to be enabled/disabled */
36 RECT calbutton; /* button that toggles the dropdown of the monthcal control */
37 BOOL bCalDepressed; /* TRUE = cal button is depressed */
38 int select;
39 HFONT hFont;
40 int nrFieldsAllocated;
41 int nrFields;
42 int haveFocus;
43 int *fieldspec;
44 RECT *fieldRect;
45 int *buflen;
46 char textbuf[256];
47 POINT monthcal_pos;
48 } DATETIME_INFO, *LPDATETIME_INFO;
49
50 /* in monthcal.c */
51 extern int MONTHCAL_MonthLength(int month, int year);
52
53 /* this list of defines is closely related to `allowedformatchars' defined
54 * in datetime.c; the high nibble indicates the `base type' of the format
55 * specifier.
56 * Do not change without first reading DATETIME_UseFormat.
57 *
58 */
59
60 #define DT_END_FORMAT 0
61 #define ONEDIGITDAY 0x01
62 #define TWODIGITDAY 0x02
63 #define THREECHARDAY 0x03
64 #define FULLDAY 0x04
65 #define ONEDIGIT12HOUR 0x11
66 #define TWODIGIT12HOUR 0x12
67 #define ONEDIGIT24HOUR 0x21
68 #define TWODIGIT24HOUR 0x22
69 #define ONEDIGITMINUTE 0x31
70 #define TWODIGITMINUTE 0x32
71 #define ONEDIGITMONTH 0x41
72 #define TWODIGITMONTH 0x42
73 #define THREECHARMONTH 0x43
74 #define FULLMONTH 0x44
75 #define ONEDIGITSECOND 0x51
76 #define TWODIGITSECOND 0x52
77 #define ONELETTERAMPM 0x61
78 #define TWOLETTERAMPM 0x62
79 #define ONEDIGITYEAR 0x71
80 #define TWODIGITYEAR 0x72
81 #define FULLYEAR 0x73
82 #define FORMATCALLBACK 0x81 /* -> maximum of 0x80 callbacks possible */
83 #define FORMATCALLMASK 0x80
84 #define DT_STRING 0x0100
85
86 #define DTHT_DATEFIELD 0xff /* for hit-testing */
87
88 #define DTHT_NONE 0
89 #define DTHT_CHECKBOX 0x200 /* these should end at '00' , to make */
90 #define DTHT_MCPOPUP 0x300 /* & DTHT_DATEFIELD 0 when DATETIME_KeyDown */
91 #define DTHT_GOTFOCUS 0x400 /* tests for date-fields */
92
93 #define DATETIME_GetInfoPtr(hwnd) ((DATETIME_INFO *)GetWindowLongA (hwnd, 0))
94
95 static BOOL DATETIME_SendSimpleNotify (HWND hwnd, UINT code);
96 static BOOL DATETIME_SendDateTimeChangeNotify (HWND hwnd);
97 extern void MONTHCAL_CopyTime(const SYSTEMTIME *from, SYSTEMTIME *to);
98 static const char *allowedformatchars = {"dhHmMstyX'"};
99 static const int maxrepetition [] = {4,2,2,2,4,2,2,3,-1,-1};
100
101
102 static LRESULT
103 DATETIME_GetSystemTime (HWND hwnd, WPARAM wParam, LPARAM lParam )
104 {
105 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
106 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
107 SYSTEMTIME *lprgSysTimeArray=(SYSTEMTIME *) lParam;
108
109 TRACE("%04x %08lx\n",wParam,lParam);
110 if (!lParam) return GDT_NONE;
111
112 if ((dwStyle & DTS_SHOWNONE) &&
113 (SendMessageA (infoPtr->hwndCheckbut, BM_GETCHECK, 0, 0)))
114 return GDT_NONE;
115
116 MONTHCAL_CopyTime (&infoPtr->date, lprgSysTimeArray);
117
118 return GDT_VALID;
119 }
120
121
122 static LRESULT
123 DATETIME_SetSystemTime (HWND hwnd, WPARAM wParam, LPARAM lParam )
124 {
125 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
126 SYSTEMTIME *lprgSysTimeArray=(SYSTEMTIME *) lParam;
127
128 TRACE("%04x %08lx\n",wParam,lParam);
129 if (!lParam) return 0;
130
131 if (lParam==GDT_VALID)
132 MONTHCAL_CopyTime (lprgSysTimeArray, &infoPtr->date);
133 if (lParam==GDT_NONE) {
134 infoPtr->dateValid=FALSE;
135 SendMessageA (infoPtr->hwndCheckbut, BM_SETCHECK, 0, 0);
136 }
137 return 1;
138 }
139
140
141 static LRESULT
142 DATETIME_GetRange (HWND hwnd, LPARAM lParam )
143 {
144 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
145 LRESULT ret;
146
147 TRACE("%08lx\n", lParam);
148 ret = SendMessageA (infoPtr->hMonthCal, MCM_GETRANGE, 0, lParam);
149 if (!ret) ret = 1; /* bug emulation... */
150 return ret;
151 }
152
153 static LRESULT
154 DATETIME_SetRange (HWND hwnd, WPARAM wParam, LPARAM lParam )
155 {
156 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
157
158 TRACE("%04x %08lx\n",wParam,lParam);
159
160 return SendMessageA (infoPtr->hMonthCal, MCM_SETRANGE, wParam, lParam);
161 }
162
163 static LRESULT
164 DATETIME_GetMonthCalColor (HWND hwnd, WPARAM wParam)
165 {
166 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
167
168 TRACE("%04x\n",wParam);
169 return SendMessageA (infoPtr->hMonthCal, MCM_GETCOLOR, wParam, 0);
170 }
171
172
173 static LRESULT
174 DATETIME_SetMonthCalColor (HWND hwnd, WPARAM wParam, LPARAM lParam)
175 {
176 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
177
178 TRACE("%04x %08lx\n",wParam,lParam);
179 return SendMessageA (infoPtr->hMonthCal, MCM_SETCOLOR, wParam, lParam);
180 }
181
182
183 /* FIXME: need to get way to force font into monthcal structure */
184 static LRESULT
185 DATETIME_GetMonthCal (HWND hwnd)
186 {
187 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
188
189 TRACE("\n");
190 return infoPtr->hMonthCal;
191 }
192
193
194
195 /* FIXME: need to get way to force font into monthcal structure */
196
197 static LRESULT
198 DATETIME_GetMonthCalFont (HWND hwnd)
199 {
200
201 TRACE("\n");
202 return 0;
203 }
204
205
206 static LRESULT
207 DATETIME_SetMonthCalFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
208 {
209
210 TRACE("%04x %08lx\n",wParam,lParam);
211 return 0;
212 }
213
214
215 /*
216 Split up a formattxt in actions.
217 See ms documentation for the meaning of the letter codes/'specifiers'.
218
219 Notes:
220 *'dddddd' is handled as 'dddd' plus 'dd'.
221 *unrecognized formats are strings (here given the type DT_STRING;
222 start of the string is encoded in lower bits of DT_STRING.
223 Therefore, 'string' ends finally up as '<show seconds>tring'.
224
225 */
226
227
228 static void
229 DATETIME_UseFormat (DATETIME_INFO *infoPtr, const char *formattxt)
230 {
231 int i,j,k,len;
232 int *nrFields=& infoPtr->nrFields;
233
234 TRACE ("%s\n",formattxt);
235
236
237 *nrFields=0;
238 infoPtr->fieldspec[*nrFields]=0;
239 len=strlen(allowedformatchars);
240 k=0;
241
242 for (i=0; i<strlen (formattxt); i++) {
243 TRACE ("\n%d %c:",i, formattxt[i]);
244 for (j=0; j<len; j++) {
245 if (allowedformatchars[j]==formattxt[i]) {
246 TRACE ("%c[%d,%x]",allowedformatchars[j], *nrFields,
247 infoPtr->fieldspec[*nrFields]);
248 if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
249 infoPtr->fieldspec[*nrFields]=(j<<4) +1;
250 break;
251 }
252 if (infoPtr->fieldspec[*nrFields]>>4!=j) {
253 (*nrFields)++;
254 infoPtr->fieldspec[*nrFields]=(j<<4) +1;
255 break;
256 }
257 if ((infoPtr->fieldspec[*nrFields] & 0x0f)==maxrepetition[j]) {
258 (*nrFields)++;
259 infoPtr->fieldspec[*nrFields]=(j<<4) +1;
260 break;
261 }
262 infoPtr->fieldspec[*nrFields]++;
263 break;
264 } /* if allowedformatchar */
265 } /* for j */
266
267
268 /* char is not a specifier: handle char like a string */
269 if (j==len) {
270 if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
271 infoPtr->fieldspec[*nrFields]=DT_STRING+k;
272 infoPtr->buflen[*nrFields]=0;
273 } else
274 if ((infoPtr->fieldspec[*nrFields] & DT_STRING)!=DT_STRING) {
275 (*nrFields)++;
276 infoPtr->fieldspec[*nrFields]=DT_STRING+k;
277 infoPtr->buflen[*nrFields]=0;
278 }
279 infoPtr->textbuf[k]=formattxt[i];
280 k++;
281 infoPtr->buflen[*nrFields]++;
282 } /* if j=len */
283
284 if (*nrFields==infoPtr->nrFieldsAllocated) {
285 FIXME ("out of memory; should reallocate. crash ahead.\n");
286 }
287
288 } /* for i */
289
290 TRACE("\n");
291
292 if (infoPtr->fieldspec[*nrFields]!=0) (*nrFields)++;
293 }
294
295
296 static LRESULT
297 DATETIME_SetFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
298 {
299 DATETIME_INFO *infoPtr= DATETIME_GetInfoPtr (hwnd);
300 char format_buf[80];
301 DWORD format_item;
302
303 TRACE("%04x %08lx\n",wParam,lParam);
304 if (!lParam) {
305 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
306
307 if (dwStyle & DTS_LONGDATEFORMAT)
308 format_item=LOCALE_SLONGDATE;
309 else if (dwStyle & DTS_TIMEFORMAT)
310 format_item=LOCALE_STIMEFORMAT;
311 else /* DTS_SHORTDATEFORMAT */
312 format_item=LOCALE_SSHORTDATE;
313 GetLocaleInfoA( GetSystemDefaultLCID(), format_item,format_buf,sizeof(format_buf));
314 DATETIME_UseFormat (infoPtr, format_buf);
315 }
316 else
317 DATETIME_UseFormat (infoPtr, (char *) lParam);
318
319 return infoPtr->nrFields;
320 }
321
322
323 static LRESULT
324 DATETIME_SetFormatW (HWND hwnd, WPARAM wParam, LPARAM lParam)
325
326 {
327 TRACE("%04x %08lx\n",wParam,lParam);
328 if (lParam) {
329 LPSTR buf;
330 int retval;
331 int len = WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, NULL, 0, NULL, NULL );
332
333 buf = (LPSTR) COMCTL32_Alloc (len);
334 WideCharToMultiByte( CP_ACP, 0, (LPWSTR)lParam, -1, buf, len, NULL, NULL );
335 retval=DATETIME_SetFormat (hwnd, 0, (LPARAM) buf);
336 COMCTL32_Free (buf);
337 return retval;
338 }
339 else
340 return DATETIME_SetFormat (hwnd, 0, 0);
341
342 }
343
344
345 static void
346 DATETIME_ReturnTxt (DATETIME_INFO *infoPtr, int count, char *result)
347 {
348 SYSTEMTIME date = infoPtr->date;
349 int spec;
350 char buffer[80];
351
352 *result=0;
353 TRACE ("%d,%d\n", infoPtr->nrFields, count);
354 if ((count>infoPtr->nrFields) || (count<0)) {
355 WARN ("buffer overrun, have %d want %d\n", infoPtr->nrFields, count);
356 return;
357 }
358
359 if (!infoPtr->fieldspec) return;
360
361 spec=infoPtr->fieldspec[count];
362 if (spec & DT_STRING) {
363 int txtlen=infoPtr->buflen[count];
364
365 strncpy (result, infoPtr->textbuf + (spec &~ DT_STRING), txtlen);
366 result[txtlen]=0;
367 TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
368 return;
369 }
370
371
372 switch (spec) {
373 case DT_END_FORMAT:
374 *result=0;
375 break;
376 case ONEDIGITDAY:
377 sprintf (result,"%d",date.wDay);
378 break;
379 case TWODIGITDAY:
380 sprintf (result,"%.2d",date.wDay);
381 break;
382 case THREECHARDAY:
383 GetLocaleInfoA( LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1+(date.wDayOfWeek+6)%7,
384 result,4);
385 /*sprintf (result,"%.3s",days[date.wDayOfWeek]);*/
386 break;
387 case FULLDAY:
388 GetLocaleInfoA( LOCALE_USER_DEFAULT,LOCALE_SDAYNAME1+ (date.wDayOfWeek+6)%7,
389 buffer,sizeof(buffer));
390 strcpy (result,buffer);
391 break;
392 case ONEDIGIT12HOUR:
393 if (date.wHour>12)
394 sprintf (result,"%d",date.wHour-12);
395 else
396 sprintf (result,"%d",date.wHour);
397 break;
398 case TWODIGIT12HOUR:
399 if (date.wHour>12)
400 sprintf (result,"%.2d",date.wHour-12);
401 else
402 sprintf (result,"%.2d",date.wHour);
403 break;
404 case ONEDIGIT24HOUR:
405 sprintf (result,"%d",date.wHour);
406 break;
407 case TWODIGIT24HOUR:
408 sprintf (result,"%.2d",date.wHour);
409 break;
410 case ONEDIGITSECOND:
411 sprintf (result,"%d",date.wSecond);
412 break;
413 case TWODIGITSECOND:
414 sprintf (result,"%.2d",date.wSecond);
415 break;
416 case ONEDIGITMINUTE:
417 sprintf (result,"%d",date.wMinute);
418 break;
419 case TWODIGITMINUTE:
420 sprintf (result,"%.2d",date.wMinute);
421 break;
422 case ONEDIGITMONTH:
423 sprintf (result,"%d",date.wMonth);
424 break;
425 case TWODIGITMONTH:
426 sprintf (result,"%.2d",date.wMonth);
427 break;
428 case THREECHARMONTH:
429 GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
430 buffer,sizeof(buffer));
431 sprintf (result,"%.3s",buffer);
432 break;
433 case FULLMONTH:
434 GetLocaleInfoA( GetSystemDefaultLCID(),LOCALE_SMONTHNAME1+date.wMonth -1,
435 result,sizeof(result));
436 break;
437 case ONELETTERAMPM:
438 if (date.wHour<12)
439 strcpy (result,"A");
440 else
441 strcpy (result,"P");
442 break;
443 case TWOLETTERAMPM:
444 if (date.wHour<12)
445 strcpy (result,"AM");
446 else
447 strcpy (result,"PM");
448 break;
449 case FORMATCALLBACK:
450 FIXME ("Not implemented\n");
451 strcpy (result,"xxx");
452 break;
453 case ONEDIGITYEAR:
454 sprintf (result,"%d",date.wYear-10* (int) floor(date.wYear/10));
455 break;
456 case TWODIGITYEAR:
457 sprintf (result,"%.2d",date.wYear-100* (int) floor(date.wYear/100));
458 break;
459 case FULLYEAR:
460 sprintf (result,"%d",date.wYear);
461 break;
462 }
463
464 TRACE ("arg%d=%x->[%s]\n",count,infoPtr->fieldspec[count],result);
465 }
466
467
468 static void
469 DATETIME_IncreaseField (DATETIME_INFO *infoPtr, int number)
470 {
471 SYSTEMTIME *date = &infoPtr->date;
472 int spec;
473
474 TRACE ("%d\n",number);
475 if ((number>infoPtr->nrFields) || (number<0)) return;
476
477 spec=infoPtr->fieldspec[number];
478 if ((spec & DTHT_DATEFIELD)==0) return;
479
480 switch (spec) {
481 case ONEDIGITDAY:
482 case TWODIGITDAY:
483 case THREECHARDAY:
484 case FULLDAY:
485 date->wDay++;
486 if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
487 date->wDay=1;
488 break;
489 case ONEDIGIT12HOUR:
490 case TWODIGIT12HOUR:
491 case ONEDIGIT24HOUR:
492 case TWODIGIT24HOUR:
493 date->wHour++;
494 if (date->wHour>23) date->wHour=0;
495 break;
496 case ONEDIGITSECOND:
497 case TWODIGITSECOND:
498 date->wSecond++;
499 if (date->wSecond>59) date->wSecond=0;
500 break;
501 case ONEDIGITMINUTE:
502 case TWODIGITMINUTE:
503 date->wMinute++;
504 if (date->wMinute>59) date->wMinute=0;
505 break;
506 case ONEDIGITMONTH:
507 case TWODIGITMONTH:
508 case THREECHARMONTH:
509 case FULLMONTH:
510 date->wMonth++;
511 if (date->wMonth>12) date->wMonth=1;
512 if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
513 date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
514 break;
515 case ONELETTERAMPM:
516 case TWOLETTERAMPM:
517 date->wHour+=12;
518 if (date->wHour>23) date->wHour-=24;
519 break;
520 case FORMATCALLBACK:
521 FIXME ("Not implemented\n");
522 break;
523 case ONEDIGITYEAR:
524 case TWODIGITYEAR:
525 case FULLYEAR:
526 date->wYear++;
527 break;
528 }
529
530 }
531
532
533 static void
534 DATETIME_DecreaseField (DATETIME_INFO *infoPtr, int number)
535 {
536 SYSTEMTIME *date = & infoPtr->date;
537 int spec;
538
539 TRACE ("%d\n",number);
540 if ((number>infoPtr->nrFields) || (number<0)) return;
541
542 spec = infoPtr->fieldspec[number];
543 if ((spec & DTHT_DATEFIELD)==0) return;
544
545 TRACE ("%x\n",spec);
546
547 switch (spec) {
548 case ONEDIGITDAY:
549 case TWODIGITDAY:
550 case THREECHARDAY:
551 case FULLDAY:
552 date->wDay--;
553 if (date->wDay<1)
554 date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
555 break;
556 case ONEDIGIT12HOUR:
557 case TWODIGIT12HOUR:
558 case ONEDIGIT24HOUR:
559 case TWODIGIT24HOUR:
560 if (date->wHour)
561 date->wHour--;
562 else
563 date->wHour=23;
564 break;
565 case ONEDIGITSECOND:
566 case TWODIGITSECOND:
567 if (date->wHour)
568 date->wSecond--;
569 else
570 date->wHour=59;
571 break;
572 case ONEDIGITMINUTE:
573 case TWODIGITMINUTE:
574 if (date->wMinute)
575 date->wMinute--;
576 else
577 date->wMinute=59;
578 break;
579 case ONEDIGITMONTH:
580 case TWODIGITMONTH:
581 case THREECHARMONTH:
582 case FULLMONTH:
583 if (date->wMonth>1)
584 date->wMonth--;
585 else
586 date->wMonth=12;
587 if (date->wDay>MONTHCAL_MonthLength(date->wMonth,date->wYear))
588 date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
589 break;
590 case ONELETTERAMPM:
591 case TWOLETTERAMPM:
592 if (date->wHour<12)
593 date->wHour+=12;
594 else
595 date->wHour-=12;
596 break;
597 case FORMATCALLBACK:
598 FIXME ("Not implemented\n");
599 break;
600 case ONEDIGITYEAR:
601 case TWODIGITYEAR:
602 case FULLYEAR:
603 date->wYear--;
604 break;
605 }
606
607 }
608
609
610 static void
611 DATETIME_ResetFieldDown (DATETIME_INFO *infoPtr, int number)
612 {
613 SYSTEMTIME *date = &infoPtr->date;
614 int spec;
615
616 TRACE ("%d\n",number);
617 if ((number>infoPtr->nrFields) || (number<0)) return;
618
619 spec = infoPtr->fieldspec[number];
620 if ((spec & DTHT_DATEFIELD)==0) return;
621
622
623 switch (spec) {
624 case ONEDIGITDAY:
625 case TWODIGITDAY:
626 case THREECHARDAY:
627 case FULLDAY:
628 date->wDay = 1;
629 break;
630 case ONEDIGIT12HOUR:
631 case TWODIGIT12HOUR:
632 case ONEDIGIT24HOUR:
633 case TWODIGIT24HOUR:
634 case ONELETTERAMPM:
635 case TWOLETTERAMPM:
636 date->wHour = 0;
637 break;
638 case ONEDIGITSECOND:
639 case TWODIGITSECOND:
640 date->wSecond = 0;
641 break;
642 case ONEDIGITMINUTE:
643 case TWODIGITMINUTE:
644 date->wMinute = 0;
645 break;
646 case ONEDIGITMONTH:
647 case TWODIGITMONTH:
648 case THREECHARMONTH:
649 case FULLMONTH:
650 date->wMonth = 1;
651 case FORMATCALLBACK:
652 FIXME ("Not implemented\n");
653 break;
654 case ONEDIGITYEAR:
655 case TWODIGITYEAR:
656 /* FYI: On 9/14/1752 the calender changed and England and the American */
657 /* colonies changed to the Gregorian calender. This change involved */
658 /* having September 14th following September 2nd. So no date algorithms */
659 /* work before that date. */
660 case FULLYEAR:
661 date->wSecond = 0;
662 date->wMinute = 0;
663 date->wHour = 0;
664 date->wDay = 14; /* overactive ms-programmers..*/
665 date->wMonth = 9;
666 date->wYear = 1752;
667 break;
668 }
669
670 }
671
672
673 static void
674 DATETIME_ResetFieldUp (DATETIME_INFO *infoPtr, int number)
675 {
676 SYSTEMTIME *date = & infoPtr->date;
677 int spec;
678
679 TRACE("%d \n",number);
680 if ((number>infoPtr->nrFields) || (number<0)) return;
681
682 spec=infoPtr->fieldspec[number];
683 if ((spec & DTHT_DATEFIELD)==0) return;
684
685 switch (spec) {
686 case ONEDIGITDAY:
687 case TWODIGITDAY:
688 case THREECHARDAY:
689 case FULLDAY:
690 date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
691 break;
692 case ONEDIGIT12HOUR:
693 case TWODIGIT12HOUR:
694 case ONEDIGIT24HOUR:
695 case TWODIGIT24HOUR:
696 case ONELETTERAMPM:
697 case TWOLETTERAMPM:
698 date->wHour=23;
699 break;
700 case ONEDIGITSECOND:
701 case TWODIGITSECOND:
702 date->wSecond=59;
703 break;
704 case ONEDIGITMINUTE:
705 case TWODIGITMINUTE:
706 date->wMinute=59;
707 break;
708 case ONEDIGITMONTH:
709 case TWODIGITMONTH:
710 case THREECHARMONTH:
711 case FULLMONTH:
712 date->wMonth=12;
713 case FORMATCALLBACK:
714 FIXME ("Not implemented\n");
715 break;
716 case ONEDIGITYEAR:
717 case TWODIGITYEAR:
718 case FULLYEAR:
719 date->wYear=9999; /* Y10K problem? naaah. */
720 break;
721 }
722
723 }
724
725
726 static void DATETIME_Refresh (HWND hwnd, HDC hdc)
727
728 {
729 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
730 int i,prevright;
731 RECT *field;
732 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
733 RECT *rcDraw = &infoPtr->rcDraw;
734 RECT *rcClient = &infoPtr->rcClient;
735 RECT *calbutton = &infoPtr->calbutton;
736 RECT *checkbox = &infoPtr->checkbox;
737 HBRUSH hbr;
738 SIZE size;
739 COLORREF oldBk, oldTextColor;
740
741 /* draw control edge */
742 TRACE("\n");
743 hbr = CreateSolidBrush(RGB(255, 255, 255));
744 FillRect(hdc, rcClient, hbr);
745 DrawEdge(hdc, rcClient, EDGE_SUNKEN, BF_RECT);
746 DeleteObject(hbr);
747
748 if (infoPtr->dateValid) {
749 char txt[80];
750 HFONT oldFont;
751 oldFont = SelectObject (hdc, infoPtr->hFont);
752
753 DATETIME_ReturnTxt (infoPtr, 0, txt);
754 GetTextExtentPoint32A (hdc, txt, strlen (txt), &size);
755 rcDraw->bottom = size.cy+2;
756
757 if (dwStyle & DTS_SHOWNONE) checkbox->right = 18;
758
759 prevright = checkbox->right;
760
761 for (i=0; i<infoPtr->nrFields; i++) {
762 DATETIME_ReturnTxt (infoPtr, i, txt);
763 GetTextExtentPoint32A (hdc, txt, strlen (txt), &size);
764 field = & infoPtr->fieldRect[i];
765 field->left = prevright;
766 field->right = prevright+size.cx;
767 field->top = rcDraw->top;
768 field->bottom = rcDraw->bottom;
769 prevright = field->right;
770
771 if ((infoPtr->haveFocus) && (i==infoPtr->select)) {
772 hbr = CreateSolidBrush (GetSysColor (COLOR_ACTIVECAPTION));
773 FillRect(hdc, field, hbr);
774 oldBk = SetBkColor (hdc, GetSysColor(COLOR_ACTIVECAPTION));
775 oldTextColor = SetTextColor (hdc, GetSysColor(COLOR_WINDOW));
776 DeleteObject (hbr);
777 DrawTextA ( hdc, txt, strlen(txt), field,
778 DT_RIGHT | DT_VCENTER | DT_SINGLELINE );
779 SetBkColor (hdc, oldBk);
780 SetTextColor (hdc, oldTextColor);
781 }
782 else
783 DrawTextA ( hdc, txt, strlen(txt), field,
784 DT_RIGHT | DT_VCENTER | DT_SINGLELINE );
785 }
786
787 SelectObject (hdc, oldFont);
788 }
789
790 if (!(dwStyle & DTS_UPDOWN)) {
791 DrawFrameControl(hdc, calbutton, DFC_SCROLL,
792 DFCS_SCROLLDOWN | (infoPtr->bCalDepressed ? DFCS_PUSHED : 0) |
793 (dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0) );
794 }
795 }
796
797
798 static LRESULT
799 DATETIME_HitTest (HWND hwnd, DATETIME_INFO *infoPtr, POINT pt)
800 {
801 int i, retval;
802
803 TRACE ("%ld, %ld\n",pt.x,pt.y);
804
805 retval = DTHT_NONE;
806 if (PtInRect (&infoPtr->calbutton, pt))
807 {retval = DTHT_MCPOPUP; TRACE("Hit in calbutton(DTHT_MCPOPUP)\n"); goto done; }
808 if (PtInRect (&infoPtr->checkbox, pt))
809 {retval = DTHT_CHECKBOX; TRACE("Hit in checkbox(DTHT_CHECKBOX)\n"); goto done; }
810
811 for (i=0; i<infoPtr->nrFields; i++) {
812 if (PtInRect (&infoPtr->fieldRect[i], pt)) {
813 retval = i;
814 TRACE("Hit in date text in field %d\n", i);
815 break;
816 }
817 }
818
819 done:
820 return retval;
821 }
822
823
824 static LRESULT
825 DATETIME_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
826 {
827 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
828 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
829 int old, new;
830 POINT pt;
831
832 TRACE ("\n");
833
834 old = infoPtr->select;
835 pt.x = (INT)LOWORD(lParam);
836 pt.y = (INT)HIWORD(lParam);
837
838 new = DATETIME_HitTest (hwnd, infoPtr, pt);
839
840 /* FIXME: might be conditions where we don't want to update infoPtr->select */
841 infoPtr->select = new;
842
843 if (infoPtr->select != old) {
844 infoPtr->haveFocus = DTHT_GOTFOCUS;
845 }
846
847 if (infoPtr->select == DTHT_MCPOPUP) {
848 /* FIXME: button actually is only depressed during dropdown of the */
849 /* calender control and when the mouse is over the button window */
850 infoPtr->bCalDepressed = TRUE;
851
852 /* recalculate the position of the monthcal popup */
853 if(dwStyle & DTS_RIGHTALIGN)
854 infoPtr->monthcal_pos.x = infoPtr->rcClient.right - ((infoPtr->calbutton.right -
855 infoPtr->calbutton.left) + 145);
856 else
857 infoPtr->monthcal_pos.x = 8;
858
859 infoPtr->monthcal_pos.y = infoPtr->rcClient.bottom;
860 ClientToScreen (hwnd, &(infoPtr->monthcal_pos));
861 SetWindowPos(infoPtr->hMonthCal, 0, infoPtr->monthcal_pos.x,
862 infoPtr->monthcal_pos.y, 145, 150, 0);
863
864 if(IsWindowVisible(infoPtr->hMonthCal))
865 ShowWindow(infoPtr->hMonthCal, SW_HIDE);
866 else
867 ShowWindow(infoPtr->hMonthCal, SW_SHOW);
868
869 TRACE ("dt:%x mc:%x mc parent:%x, desktop:%x, mcpp:%x\n",
870 hwnd,infoPtr->hMonthCal,
871 GetParent (infoPtr->hMonthCal),
872 GetDesktopWindow (),
873 GetParent (GetParent (infoPtr->hMonthCal)));
874 DATETIME_SendSimpleNotify (hwnd, DTN_DROPDOWN);
875 }
876
877 InvalidateRect(hwnd, NULL, FALSE);
878
879 return 0;
880 }
881
882
883 static LRESULT
884 DATETIME_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
885 {
886 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
887
888 TRACE("\n");
889
890 if(infoPtr->bCalDepressed == TRUE) {
891 infoPtr->bCalDepressed = FALSE;
892 InvalidateRect(hwnd, &(infoPtr->calbutton), TRUE);
893 }
894
895 return 0;
896 }
897
898
899 static LRESULT
900 DATETIME_Paint (HWND hwnd, WPARAM wParam)
901 {
902 HDC hdc;
903 PAINTSTRUCT ps;
904
905 hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
906 DATETIME_Refresh (hwnd, hdc);
907 if(!wParam)
908 EndPaint (hwnd, &ps);
909 return 0;
910 }
911
912
913 static LRESULT
914 DATETIME_ParentNotify (HWND hwnd, WPARAM wParam, LPARAM lParam)
915 {
916 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
917 LPNMHDR lpnmh = (LPNMHDR) lParam;
918
919 TRACE ("%x,%lx\n",wParam, lParam);
920 TRACE ("Got notification %x from %x\n", lpnmh->code, lpnmh->hwndFrom);
921 TRACE ("info: %x %x %x\n",hwnd,infoPtr->hMonthCal,infoPtr->hUpdown);
922 return 0;
923 }
924
925
926 static LRESULT
927 DATETIME_Notify (HWND hwnd, WPARAM wParam, LPARAM lParam)
928
929 {
930 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
931 LPNMHDR lpnmh = (LPNMHDR) lParam;
932
933 TRACE ("%x,%lx\n",wParam, lParam);
934 TRACE ("Got notification %x from %x\n", lpnmh->code, lpnmh->hwndFrom);
935 TRACE ("info: %x %x %x\n",hwnd,infoPtr->hMonthCal,infoPtr->hUpdown);
936 return 0;
937 }
938
939
940 static LRESULT
941 DATETIME_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
942 {
943 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
944 int FieldNum,wrap=0;
945
946 TRACE("%x %lx %x\n",wParam, lParam, infoPtr->select);
947
948 FieldNum = infoPtr->select & DTHT_DATEFIELD;
949
950 if (!(infoPtr->haveFocus)) return 0;
951 if ((FieldNum==0) && (infoPtr->select)) return 0;
952
953 if (infoPtr->select & FORMATCALLMASK) {
954 FIXME ("Callbacks not implemented yet\n");
955 }
956
957 switch (wParam) {
958 case VK_ADD:
959 case VK_UP:
960 DATETIME_IncreaseField (infoPtr,FieldNum);
961 DATETIME_SendDateTimeChangeNotify (hwnd);
962 break;
963 case VK_SUBTRACT:
964 case VK_DOWN:
965 DATETIME_DecreaseField (infoPtr,FieldNum);
966 DATETIME_SendDateTimeChangeNotify (hwnd);
967 break;
968 case VK_HOME:
969 DATETIME_ResetFieldDown (infoPtr,FieldNum);
970 DATETIME_SendDateTimeChangeNotify (hwnd);
971 break;
972 case VK_END:
973 DATETIME_ResetFieldUp(infoPtr,FieldNum);
974 DATETIME_SendDateTimeChangeNotify (hwnd);
975 break;
976 case VK_LEFT:
977 do {
978 if (infoPtr->select==0) {
979 infoPtr->select = infoPtr->nrFields - 1;
980 wrap++;
981 } else
982 infoPtr->select--;
983 }
984 while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
985 break;
986 case VK_RIGHT:
987 do {
988 infoPtr->select++;
989 if (infoPtr->select==infoPtr->nrFields) {
990 infoPtr->select = 0;
991 wrap++;
992 }
993 }
994 while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
995 break;
996 }
997
998 InvalidateRect(hwnd, NULL, FALSE);
999
1000 return 0;
1001 }
1002
1003
1004 static LRESULT
1005 DATETIME_KillFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
1006 {
1007 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
1008
1009 TRACE ("\n");
1010
1011 if (infoPtr->haveFocus) {
1012 DATETIME_SendSimpleNotify (hwnd, NM_KILLFOCUS);
1013 infoPtr->haveFocus = 0;
1014 }
1015
1016 InvalidateRect (hwnd, NULL, TRUE);
1017
1018 return 0;
1019 }
1020
1021
1022 static LRESULT
1023 DATETIME_SetFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
1024 {
1025 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
1026
1027 TRACE ("\n");
1028
1029 if (infoPtr->haveFocus==0) {
1030 DATETIME_SendSimpleNotify (hwnd, NM_SETFOCUS);
1031 infoPtr->haveFocus = DTHT_GOTFOCUS;
1032 }
1033
1034 InvalidateRect(hwnd, NULL, FALSE);
1035
1036 return 0;
1037 }
1038
1039
1040 static BOOL
1041 DATETIME_SendDateTimeChangeNotify (HWND hwnd)
1042
1043 {
1044 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
1045 NMDATETIMECHANGE dtdtc;
1046
1047 TRACE ("\n");
1048 dtdtc.nmhdr.hwndFrom = hwnd;
1049 dtdtc.nmhdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
1050 dtdtc.nmhdr.code = DTN_DATETIMECHANGE;
1051
1052 if ((GetWindowLongA (hwnd, GWL_STYLE) & DTS_SHOWNONE))
1053 dtdtc.dwFlags = GDT_NONE;
1054 else
1055 dtdtc.dwFlags = GDT_VALID;
1056
1057 MONTHCAL_CopyTime (&infoPtr->date, &dtdtc.st);
1058 return (BOOL) SendMessageA (GetParent (hwnd), WM_NOTIFY,
1059 (WPARAM)dtdtc.nmhdr.idFrom, (LPARAM)&dtdtc);
1060 }
1061
1062
1063 static BOOL
1064 DATETIME_SendSimpleNotify (HWND hwnd, UINT code)
1065 {
1066 NMHDR nmhdr;
1067
1068 TRACE("%x\n",code);
1069 nmhdr.hwndFrom = hwnd;
1070 nmhdr.idFrom = GetWindowLongA( hwnd, GWL_ID);
1071 nmhdr.code = code;
1072
1073 return (BOOL) SendMessageA (GetParent (hwnd), WM_NOTIFY,
1074 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
1075 }
1076
1077 static LRESULT
1078 DATETIME_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
1079 {
1080 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr(hwnd);
1081 DWORD dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
1082
1083 /* set size */
1084 infoPtr->rcClient.bottom = HIWORD(lParam);
1085 infoPtr->rcClient.right = LOWORD(lParam);
1086
1087 TRACE("Height=%d, Width=%d\n", infoPtr->rcClient.bottom, infoPtr->rcClient.right);
1088
1089 /* use DrawEdge to adjust the size of rcEdge to get rcDraw */
1090 memcpy((&infoPtr->rcDraw), (&infoPtr->rcClient), sizeof(infoPtr->rcDraw));
1091
1092 DrawEdge((HDC)NULL, &(infoPtr->rcDraw), EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1093
1094 /* set the size of the button that drops the calender down */
1095 /* FIXME: account for style that allows button on left side */
1096 infoPtr->calbutton.top = infoPtr->rcDraw.top;
1097 infoPtr->calbutton.bottom= infoPtr->rcDraw.bottom;
1098 infoPtr->calbutton.left = infoPtr->rcDraw.right-15;
1099 infoPtr->calbutton.right = infoPtr->rcDraw.right;
1100
1101 /* set enable/disable button size for show none style being enabled */
1102 /* FIXME: these dimensions are completely incorrect */
1103 infoPtr->checkbox.top = infoPtr->rcDraw.top;
1104 infoPtr->checkbox.bottom = infoPtr->rcDraw.bottom;
1105 infoPtr->checkbox.left = infoPtr->rcDraw.left;
1106 infoPtr->checkbox.right = infoPtr->rcDraw.left + 10;
1107
1108 /* update the position of the monthcal control */
1109 if(dwStyle & DTS_RIGHTALIGN)
1110 infoPtr->monthcal_pos.x = infoPtr->rcClient.right - ((infoPtr->calbutton.right -
1111 infoPtr->calbutton.left) + 145);
1112 else
1113 infoPtr->monthcal_pos.x = 8;
1114
1115 infoPtr->monthcal_pos.y = infoPtr->rcClient.bottom;
1116 ClientToScreen (hwnd, &(infoPtr->monthcal_pos));
1117 SetWindowPos(infoPtr->hMonthCal, 0, infoPtr->monthcal_pos.x,
1118 infoPtr->monthcal_pos.y,
1119 145, 150, 0);
1120
1121 InvalidateRect(hwnd, NULL, FALSE);
1122
1123 return 0;
1124 }
1125
1126
1127 static LRESULT
1128 DATETIME_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
1129 {
1130 DATETIME_INFO *infoPtr;
1131 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1132
1133 /* allocate memory for info structure */
1134 TRACE("%04x %08lx\n",wParam,lParam);
1135 infoPtr = (DATETIME_INFO *)COMCTL32_Alloc (sizeof(DATETIME_INFO));
1136 if (infoPtr == NULL) {
1137 ERR("could not allocate info memory!\n");
1138 return 0;
1139 }
1140
1141 SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
1142
1143 if (dwStyle & DTS_SHOWNONE) {
1144 infoPtr->hwndCheckbut=CreateWindowExA (0,"button", 0,
1145 WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
1146 2,2,13,13,
1147 hwnd,
1148 0, GetWindowLongA (hwnd, GWL_HINSTANCE), 0);
1149 SendMessageA (infoPtr->hwndCheckbut, BM_SETCHECK, 1, 0);
1150 }
1151
1152 if (dwStyle & DTS_UPDOWN) {
1153 infoPtr->hUpdown=CreateUpDownControl (
1154 WS_CHILD | WS_BORDER | WS_VISIBLE,
1155 120,1,20,20,
1156 hwnd,1,0,0,
1157 UD_MAXVAL, UD_MINVAL, 0);
1158 }
1159
1160 infoPtr->fieldspec = (int *) COMCTL32_Alloc (32*sizeof(int));
1161 infoPtr->fieldRect = (RECT *) COMCTL32_Alloc (32*sizeof(RECT));
1162 infoPtr->buflen = (int *) COMCTL32_Alloc (32*sizeof(int));
1163 infoPtr->nrFieldsAllocated = 32;
1164
1165 DATETIME_SetFormat (hwnd, 0, 0);
1166
1167 /* create the monthcal control */
1168 infoPtr->hMonthCal = CreateWindowExA (0,"SysMonthCal32", 0,
1169 WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
1170 0, 0, 0, 0,
1171 GetParent(hwnd),
1172 0, 0, 0);
1173
1174 /* initialize info structure */
1175 GetSystemTime (&infoPtr->date);
1176 infoPtr->dateValid = TRUE;
1177 infoPtr->hFont = GetStockObject(DEFAULT_GUI_FONT);
1178 return 0;
1179 }
1180
1181
1182 static LRESULT
1183 DATETIME_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
1184 {
1185 DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
1186
1187 TRACE("\n");
1188 COMCTL32_Free (infoPtr);
1189 SetWindowLongA( hwnd, 0, 0 );
1190 return 0;
1191 }
1192
1193
1194 static LRESULT WINAPI
1195 DATETIME_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1196 {
1197 if (!DATETIME_GetInfoPtr(hwnd) && (uMsg != WM_CREATE))
1198 return DefWindowProcA( hwnd, uMsg, wParam, lParam );
1199
1200 switch (uMsg)
1201 {
1202
1203 case DTM_GETSYSTEMTIME:
1204 return DATETIME_GetSystemTime (hwnd, wParam, lParam);
1205
1206 case DTM_SETSYSTEMTIME:
1207 return DATETIME_SetSystemTime (hwnd, wParam, lParam);
1208
1209 case DTM_GETRANGE:
1210 return DATETIME_GetRange(hwnd, lParam);
1211
1212 case DTM_SETRANGE:
1213 return DATETIME_SetRange(hwnd, wParam, lParam);
1214
1215 case DTM_SETFORMATA:
1216 return DATETIME_SetFormat (hwnd, wParam, lParam);
1217
1218 case DTM_SETFORMATW:
1219 return DATETIME_SetFormatW (hwnd, wParam, lParam);
1220
1221 case DTM_SETMCCOLOR:
1222 return DATETIME_SetMonthCalColor (hwnd, wParam, lParam);
1223
1224 case DTM_GETMCCOLOR:
1225 return DATETIME_GetMonthCalColor (hwnd, wParam);
1226
1227 case DTM_GETMONTHCAL:
1228 return DATETIME_GetMonthCal (hwnd);
1229
1230 case DTM_SETMCFONT:
1231 return DATETIME_SetMonthCalFont (hwnd, wParam, lParam);
1232
1233 case DTM_GETMCFONT:
1234 return DATETIME_GetMonthCalFont (hwnd);
1235
1236 case WM_PARENTNOTIFY:
1237 return DATETIME_ParentNotify (hwnd, wParam, lParam);
1238
1239 case WM_NOTIFY:
1240 return DATETIME_Notify (hwnd, wParam, lParam);
1241
1242 case WM_GETDLGCODE:
1243 return DLGC_WANTARROWS | DLGC_WANTCHARS;
1244
1245 case WM_PAINT:
1246 return DATETIME_Paint (hwnd, wParam);
1247
1248 case WM_KEYDOWN:
1249 return DATETIME_KeyDown (hwnd, wParam, lParam);
1250
1251 case WM_KILLFOCUS:
1252 return DATETIME_KillFocus (hwnd, wParam, lParam);
1253
1254 case WM_SETFOCUS:
1255 return DATETIME_SetFocus (hwnd, wParam, lParam);
1256
1257 case WM_SIZE:
1258 return DATETIME_Size (hwnd, wParam, lParam);
1259
1260 case WM_LBUTTONDOWN:
1261 return DATETIME_LButtonDown (hwnd, wParam, lParam);
1262
1263 case WM_LBUTTONUP:
1264 return DATETIME_LButtonUp (hwnd, wParam, lParam);
1265
1266 case WM_CREATE:
1267 return DATETIME_Create (hwnd, wParam, lParam);
1268
1269 case WM_DESTROY:
1270 return DATETIME_Destroy (hwnd, wParam, lParam);
1271
1272 default:
1273 if (uMsg >= WM_USER)
1274 ERR("unknown msg %04x wp=%08x lp=%08lx\n",
1275 uMsg, wParam, lParam);
1276 return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1277 }
1278 return 0;
1279 }
1280
1281
1282 VOID
1283 DATETIME_Register (void)
1284 {
1285 WNDCLASSA wndClass;
1286
1287 TRACE("\n");
1288 ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1289 wndClass.style = CS_GLOBALCLASS;
1290 wndClass.lpfnWndProc = (WNDPROC)DATETIME_WindowProc;
1291 wndClass.cbClsExtra = 0;
1292 wndClass.cbWndExtra = sizeof(DATETIME_INFO *);
1293 wndClass.hCursor = LoadCursorA (0, IDC_ARROWA);
1294 wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
1295 wndClass.lpszClassName = DATETIMEPICK_CLASSA;
1296
1297 RegisterClassA (&wndClass);
1298 }
1299
1300
1301 VOID
1302 DATETIME_Unregister (void)
1303 {
1304 TRACE("\n");
1305 UnregisterClassA (DATETIMEPICK_CLASSA, (HINSTANCE)NULL);
1306 }
Maarten's multimedia branch