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_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 }