source: trunk/src/comctl32/datetime.c@ 5806

Last change on this file since 5806 was 5806, checked in by sandervl, 24 years ago

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