git.oblomov.eu Git - wine/blob - dlls/comctl32/datetime.c

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