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 1752/9/14 the calendar changed and England and the
 657          * American colonies changed to the Gregorian calendar. This change
 658          * involved having September 14th follow September 2nd. So no date
 659          * algorithm works before that date.
 660          */
 661         case FULLYEAR:
 662                 date->wSecond = 0;
 663                 date->wMinute = 0;
 664                 date->wHour = 0;
 665                 date->wDay = 14;                /* overactive ms-programmers..*/
 666                 date->wMonth = 9;
 667                 date->wYear = 1752;
 668                 break;
 669         }
 670
 671 }
 672
 673
 674 static void
 675 DATETIME_ResetFieldUp (DATETIME_INFO *infoPtr, int number)
 676 {
 677  SYSTEMTIME *date = & infoPtr->date;
 678  int spec;
 679
 680  TRACE("%d \n",number);
 681  if ((number>infoPtr->nrFields) || (number<0)) return;
 682
 683  spec=infoPtr->fieldspec[number];
 684  if ((spec & DTHT_DATEFIELD)==0) return;
 685
 686  switch (spec) {
 687         case ONEDIGITDAY:
 688         case TWODIGITDAY:
 689         case THREECHARDAY:
 690         case FULLDAY:
 691                 date->wDay=MONTHCAL_MonthLength(date->wMonth,date->wYear);
 692                 break;
 693         case ONEDIGIT12HOUR:
 694         case TWODIGIT12HOUR:
 695         case ONEDIGIT24HOUR:
 696         case TWODIGIT24HOUR:
 697         case ONELETTERAMPM:
 698         case TWOLETTERAMPM:
 699                 date->wHour=23;
 700                 break;
 701         case ONEDIGITSECOND:
 702         case TWODIGITSECOND:
 703                 date->wSecond=59;
 704                 break;
 705         case ONEDIGITMINUTE:
 706         case TWODIGITMINUTE:
 707                 date->wMinute=59;
 708                 break;
 709         case ONEDIGITMONTH:
 710         case TWODIGITMONTH:
 711         case THREECHARMONTH:
 712         case FULLMONTH:
 713                 date->wMonth=12;
 714         case FORMATCALLBACK:
 715                 FIXME ("Not implemented\n");
 716                 break;
 717         case ONEDIGITYEAR:
 718         case TWODIGITYEAR:
 719         case FULLYEAR:
 720                 date->wYear=9999;    /* Y10K problem? naaah. */
 721                 break;
 722         }
 723
 724 }
 725
 726
 727 static void DATETIME_Refresh (HWND hwnd, HDC hdc)
 728
 729 {
 730   DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 731   int i,prevright;
 732   RECT *field;
 733   DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
 734   RECT *rcDraw = &infoPtr->rcDraw;
 735   RECT *rcClient = &infoPtr->rcClient;
 736   RECT *calbutton = &infoPtr->calbutton;
 737   RECT *checkbox = &infoPtr->checkbox;
 738   HBRUSH hbr;
 739   SIZE size;
 740   COLORREF oldBk, oldTextColor;
 741
 742   /* draw control edge */
 743   TRACE("\n");
 744   hbr = CreateSolidBrush(RGB(255, 255, 255));
 745   FillRect(hdc, rcClient, hbr);
 746   DrawEdge(hdc, rcClient, EDGE_SUNKEN, BF_RECT);
 747   DeleteObject(hbr);
 748
 749   if (infoPtr->dateValid) {
 750     char txt[80];
 751     HFONT oldFont;
 752     oldFont = SelectObject (hdc, infoPtr->hFont);
 753
 754     DATETIME_ReturnTxt (infoPtr, 0, txt);
 755     GetTextExtentPoint32A (hdc, txt, strlen (txt), &size);
 756     rcDraw->bottom = size.cy+2;
 757
 758     if (dwStyle & DTS_SHOWNONE) checkbox->right = 18;
 759
 760     prevright = checkbox->right;
 761
 762     for (i=0; i<infoPtr->nrFields; i++) {
 763       DATETIME_ReturnTxt (infoPtr, i, txt);
 764       GetTextExtentPoint32A (hdc, txt, strlen (txt), &size);
 765       field = & infoPtr->fieldRect[i];
 766       field->left  = prevright;
 767       field->right = prevright+size.cx;
 768       field->top   = rcDraw->top;
 769       field->bottom = rcDraw->bottom;
 770       prevright = field->right;
 771
 772       if ((infoPtr->haveFocus) && (i==infoPtr->select)) {
 773         hbr = CreateSolidBrush (GetSysColor (COLOR_ACTIVECAPTION));
 774         FillRect(hdc, field, hbr);
 775         oldBk = SetBkColor (hdc, GetSysColor(COLOR_ACTIVECAPTION));
 776         oldTextColor = SetTextColor (hdc, GetSysColor(COLOR_WINDOW));
 777         DeleteObject (hbr);
 778         DrawTextA ( hdc, txt, strlen(txt), field,
 779               DT_RIGHT | DT_VCENTER | DT_SINGLELINE );
 780         SetBkColor (hdc, oldBk);
 781                 SetTextColor (hdc, oldTextColor);
 782       }
 783       else
 784         DrawTextA ( hdc, txt, strlen(txt), field,
 785                          DT_RIGHT | DT_VCENTER | DT_SINGLELINE );
 786     }
 787
 788     SelectObject (hdc, oldFont);
 789   }
 790
 791   if (!(dwStyle & DTS_UPDOWN)) {
 792     DrawFrameControl(hdc, calbutton, DFC_SCROLL,
 793         DFCS_SCROLLDOWN | (infoPtr->bCalDepressed ? DFCS_PUSHED : 0) |
 794         (dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0) );
 795   }
 796 }
 797
 798
 799 static LRESULT
 800 DATETIME_HitTest (HWND hwnd, DATETIME_INFO *infoPtr, POINT pt)
 801 {
 802   int i, retval;
 803
 804   TRACE ("%ld, %ld\n",pt.x,pt.y);
 805
 806   retval = DTHT_NONE;
 807   if (PtInRect (&infoPtr->calbutton, pt))
 808     {retval = DTHT_MCPOPUP; TRACE("Hit in calbutton(DTHT_MCPOPUP)\n"); goto done; }
 809   if (PtInRect (&infoPtr->checkbox, pt))
 810     {retval = DTHT_CHECKBOX; TRACE("Hit in checkbox(DTHT_CHECKBOX)\n"); goto done; }
 811
 812   for (i=0; i<infoPtr->nrFields; i++) {
 813     if (PtInRect (&infoPtr->fieldRect[i], pt)) {
 814       retval = i;
 815       TRACE("Hit in date text in field %d\n", i);
 816       break;
 817     }
 818  }
 819
 820 done:
 821   return retval;
 822 }
 823
 824
 825 static LRESULT
 826 DATETIME_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 827 {
 828   DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 829   DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
 830   int old, new;
 831   POINT pt;
 832
 833   TRACE ("\n");
 834
 835   old = infoPtr->select;
 836   pt.x = (INT)LOWORD(lParam);
 837   pt.y = (INT)HIWORD(lParam);
 838
 839   new = DATETIME_HitTest (hwnd, infoPtr, pt);
 840
 841   /* FIXME: might be conditions where we don't want to update infoPtr->select */
 842   infoPtr->select = new;
 843
 844   if (infoPtr->select != old) {
 845     infoPtr->haveFocus = DTHT_GOTFOCUS;
 846    }
 847
 848   if (infoPtr->select == DTHT_MCPOPUP) {
 849     /* FIXME: button actually is only depressed during dropdown of the */
 850     /* calendar control and when the mouse is over the button window */
 851     infoPtr->bCalDepressed = TRUE;
 852
 853     /* recalculate the position of the monthcal popup */
 854     if(dwStyle & DTS_RIGHTALIGN)
 855       infoPtr->monthcal_pos.x = infoPtr->rcClient.right - ((infoPtr->calbutton.right -
 856                                 infoPtr->calbutton.left) + 145);
 857     else
 858       infoPtr->monthcal_pos.x = 8;
 859
 860     infoPtr->monthcal_pos.y = infoPtr->rcClient.bottom;
 861     ClientToScreen (hwnd, &(infoPtr->monthcal_pos));
 862     SetWindowPos(infoPtr->hMonthCal, 0, infoPtr->monthcal_pos.x,
 863         infoPtr->monthcal_pos.y, 145, 150, 0);
 864
 865     if(IsWindowVisible(infoPtr->hMonthCal))
 866         ShowWindow(infoPtr->hMonthCal, SW_HIDE);
 867     else
 868         ShowWindow(infoPtr->hMonthCal, SW_SHOW);
 869
 870     TRACE ("dt:%x mc:%x mc parent:%x, desktop:%x, mcpp:%x\n",
 871               hwnd,infoPtr->hMonthCal,
 872               GetParent (infoPtr->hMonthCal),
 873               GetDesktopWindow (),
 874               GetParent (GetParent (infoPtr->hMonthCal)));
 875     DATETIME_SendSimpleNotify (hwnd, DTN_DROPDOWN);
 876   }
 877
 878   InvalidateRect(hwnd, NULL, FALSE);
 879
 880   return 0;
 881 }
 882
 883
 884 static LRESULT
 885 DATETIME_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
 886 {
 887   DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 888
 889   TRACE("\n");
 890
 891   if(infoPtr->bCalDepressed == TRUE) {
 892     infoPtr->bCalDepressed = FALSE;
 893     InvalidateRect(hwnd, &(infoPtr->calbutton), TRUE);
 894   }
 895
 896   return 0;
 897 }
 898
 899
 900 static LRESULT
 901 DATETIME_Paint (HWND hwnd, WPARAM wParam)
 902 {
 903     HDC hdc;
 904     PAINTSTRUCT ps;
 905
 906     hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
 907     DATETIME_Refresh (hwnd, hdc);
 908     if(!wParam)
 909     EndPaint (hwnd, &ps);
 910     return 0;
 911 }
 912
 913
 914 static LRESULT
 915 DATETIME_ParentNotify (HWND hwnd, WPARAM wParam, LPARAM lParam)
 916 {
 917  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 918  LPNMHDR lpnmh = (LPNMHDR) lParam;
 919
 920  TRACE ("%x,%lx\n",wParam, lParam);
 921  TRACE ("Got notification %x from %x\n", lpnmh->code, lpnmh->hwndFrom);
 922  TRACE ("info: %x %x %x\n",hwnd,infoPtr->hMonthCal,infoPtr->hUpdown);
 923  return 0;
 924 }
 925
 926
 927 static LRESULT
 928 DATETIME_Notify (HWND hwnd, WPARAM wParam, LPARAM lParam)
 929
 930 {
 931  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 932  LPNMHDR lpnmh = (LPNMHDR) lParam;
 933
 934  TRACE ("%x,%lx\n",wParam, lParam);
 935  TRACE ("Got notification %x from %x\n", lpnmh->code, lpnmh->hwndFrom);
 936  TRACE ("info: %x %x %x\n",hwnd,infoPtr->hMonthCal,infoPtr->hUpdown);
 937  return 0;
 938 }
 939
 940
 941 static LRESULT
 942 DATETIME_KeyDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
 943 {
 944  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
 945  int FieldNum,wrap=0;
 946
 947  TRACE("%x %lx %x\n",wParam, lParam, infoPtr->select);
 948
 949  FieldNum = infoPtr->select & DTHT_DATEFIELD;
 950
 951  if (!(infoPtr->haveFocus)) return 0;
 952  if ((FieldNum==0) && (infoPtr->select)) return 0;
 953
 954  if (infoPtr->select & FORMATCALLMASK) {
 955         FIXME ("Callbacks not implemented yet\n");
 956  }
 957
 958  switch (wParam) {
 959         case VK_ADD:
 960         case VK_UP:
 961                 DATETIME_IncreaseField (infoPtr,FieldNum);
 962                 DATETIME_SendDateTimeChangeNotify (hwnd);
 963                 break;
 964         case VK_SUBTRACT:
 965         case VK_DOWN:
 966                 DATETIME_DecreaseField (infoPtr,FieldNum);
 967                 DATETIME_SendDateTimeChangeNotify (hwnd);
 968                 break;
 969         case VK_HOME:
 970                 DATETIME_ResetFieldDown (infoPtr,FieldNum);
 971                 DATETIME_SendDateTimeChangeNotify (hwnd);
 972                 break;
 973         case VK_END:
 974                 DATETIME_ResetFieldUp(infoPtr,FieldNum);
 975                 DATETIME_SendDateTimeChangeNotify (hwnd);
 976                 break;
 977         case VK_LEFT:
 978                 do {
 979                         if (infoPtr->select==0) {
 980                                 infoPtr->select = infoPtr->nrFields - 1;
 981                                 wrap++;
 982                         } else
 983                         infoPtr->select--;
 984                 }
 985                 while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
 986                 break;
 987         case VK_RIGHT:
 988                 do {
 989                         infoPtr->select++;
 990                         if (infoPtr->select==infoPtr->nrFields) {
 991                                 infoPtr->select = 0;
 992                                 wrap++;
 993                         }
 994                         }
 995                 while ((infoPtr->fieldspec[infoPtr->select] & DT_STRING) && (wrap<2));
 996                 break;
 997         }
 998
 999   InvalidateRect(hwnd, NULL, FALSE);
1000
1001   return 0;
1002 }
1003
1004
1005 static LRESULT
1006 DATETIME_KillFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
1007 {
1008     DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
1009
1010     TRACE ("\n");
1011
1012     if (infoPtr->haveFocus) {
1013         DATETIME_SendSimpleNotify (hwnd, NM_KILLFOCUS);
1014         infoPtr->haveFocus = 0;
1015     }
1016
1017     InvalidateRect (hwnd, NULL, TRUE);
1018
1019     return 0;
1020 }
1021
1022
1023 static LRESULT
1024 DATETIME_SetFocus (HWND hwnd, WPARAM wParam, LPARAM lParam)
1025 {
1026     DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
1027
1028     TRACE ("\n");
1029
1030     if (infoPtr->haveFocus==0) {
1031         DATETIME_SendSimpleNotify (hwnd, NM_SETFOCUS);
1032         infoPtr->haveFocus = DTHT_GOTFOCUS;
1033     }
1034
1035     InvalidateRect(hwnd, NULL, FALSE);
1036
1037     return 0;
1038 }
1039
1040
1041 static BOOL
1042 DATETIME_SendDateTimeChangeNotify (HWND hwnd)
1043
1044 {
1045  DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
1046  NMDATETIMECHANGE dtdtc;
1047
1048  TRACE ("\n");
1049  dtdtc.nmhdr.hwndFrom = hwnd;
1050  dtdtc.nmhdr.idFrom   = GetWindowLongA( hwnd, GWL_ID);
1051  dtdtc.nmhdr.code     = DTN_DATETIMECHANGE;
1052
1053  if ((GetWindowLongA (hwnd, GWL_STYLE) & DTS_SHOWNONE))
1054    dtdtc.dwFlags = GDT_NONE;
1055  else
1056    dtdtc.dwFlags = GDT_VALID;
1057
1058  MONTHCAL_CopyTime (&infoPtr->date, &dtdtc.st);
1059  return (BOOL) SendMessageA (GetParent (hwnd), WM_NOTIFY,
1060                               (WPARAM)dtdtc.nmhdr.idFrom, (LPARAM)&dtdtc);
1061 }
1062
1063
1064 static BOOL
1065 DATETIME_SendSimpleNotify (HWND hwnd, UINT code)
1066 {
1067     NMHDR nmhdr;
1068
1069     TRACE("%x\n",code);
1070     nmhdr.hwndFrom = hwnd;
1071     nmhdr.idFrom   = GetWindowLongA( hwnd, GWL_ID);
1072     nmhdr.code     = code;
1073
1074     return (BOOL) SendMessageA (GetParent (hwnd), WM_NOTIFY,
1075                                 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
1076 }
1077
1078 static LRESULT
1079 DATETIME_Size (HWND hwnd, WPARAM wParam, LPARAM lParam)
1080 {
1081   DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr(hwnd);
1082   DWORD dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
1083
1084   /* set size */
1085   infoPtr->rcClient.bottom = HIWORD(lParam);
1086   infoPtr->rcClient.right = LOWORD(lParam);
1087
1088   TRACE("Height=%d, Width=%d\n", infoPtr->rcClient.bottom, infoPtr->rcClient.right);
1089
1090   /* use DrawEdge to adjust the size of rcEdge to get rcDraw */
1091   memcpy((&infoPtr->rcDraw), (&infoPtr->rcClient), sizeof(infoPtr->rcDraw));
1092
1093   DrawEdge((HDC)NULL, &(infoPtr->rcDraw), EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1094
1095   /* set the size of the button that drops the calendar down */
1096   /* FIXME: account for style that allows button on left side */
1097   infoPtr->calbutton.top   = infoPtr->rcDraw.top;
1098   infoPtr->calbutton.bottom= infoPtr->rcDraw.bottom;
1099   infoPtr->calbutton.left  = infoPtr->rcDraw.right-15;
1100   infoPtr->calbutton.right = infoPtr->rcDraw.right;
1101
1102   /* set enable/disable button size for show none style being enabled */
1103   /* FIXME: these dimensions are completely incorrect */
1104   infoPtr->checkbox.top = infoPtr->rcDraw.top;
1105   infoPtr->checkbox.bottom = infoPtr->rcDraw.bottom;
1106   infoPtr->checkbox.left = infoPtr->rcDraw.left;
1107   infoPtr->checkbox.right = infoPtr->rcDraw.left + 10;
1108
1109   /* update the position of the monthcal control */
1110   if(dwStyle & DTS_RIGHTALIGN)
1111     infoPtr->monthcal_pos.x = infoPtr->rcClient.right - ((infoPtr->calbutton.right -
1112                                 infoPtr->calbutton.left) + 145);
1113   else
1114     infoPtr->monthcal_pos.x = 8;
1115
1116   infoPtr->monthcal_pos.y = infoPtr->rcClient.bottom;
1117   ClientToScreen (hwnd, &(infoPtr->monthcal_pos));
1118   SetWindowPos(infoPtr->hMonthCal, 0, infoPtr->monthcal_pos.x,
1119     infoPtr->monthcal_pos.y,
1120     145, 150, 0);
1121
1122   InvalidateRect(hwnd, NULL, FALSE);
1123
1124   return 0;
1125 }
1126
1127
1128 static LRESULT
1129 DATETIME_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
1130 {
1131   DATETIME_INFO *infoPtr;
1132   DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1133
1134   /* allocate memory for info structure */
1135   TRACE("%04x %08lx\n",wParam,lParam);
1136   infoPtr = (DATETIME_INFO *)COMCTL32_Alloc (sizeof(DATETIME_INFO));
1137   if (infoPtr == NULL) {
1138     ERR("could not allocate info memory!\n");
1139     return 0;
1140   }
1141
1142   SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
1143
1144   if (dwStyle & DTS_SHOWNONE) {
1145     infoPtr->hwndCheckbut=CreateWindowExA (0,"button", 0,
1146          WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
1147          2,2,13,13,
1148          hwnd,
1149          0, GetWindowLongA  (hwnd, GWL_HINSTANCE), 0);
1150          SendMessageA (infoPtr->hwndCheckbut, BM_SETCHECK, 1, 0);
1151   }
1152
1153   if (dwStyle & DTS_UPDOWN) {
1154     infoPtr->hUpdown=CreateUpDownControl (
1155         WS_CHILD | WS_BORDER | WS_VISIBLE,
1156         120,1,20,20,
1157         hwnd,1,0,0,
1158         UD_MAXVAL, UD_MINVAL, 0);
1159   }
1160
1161   infoPtr->fieldspec = (int *) COMCTL32_Alloc (32*sizeof(int));
1162   infoPtr->fieldRect = (RECT *) COMCTL32_Alloc (32*sizeof(RECT));
1163   infoPtr->buflen = (int *) COMCTL32_Alloc (32*sizeof(int));
1164   infoPtr->nrFieldsAllocated = 32;
1165
1166   DATETIME_SetFormat (hwnd, 0, 0);
1167
1168   /* create the monthcal control */
1169     infoPtr->hMonthCal = CreateWindowExA (0,"SysMonthCal32", 0,
1170         WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
1171         0, 0, 0, 0,
1172         GetParent(hwnd),
1173         0, 0, 0);
1174
1175   /* initialize info structure */
1176   GetSystemTime (&infoPtr->date);
1177   infoPtr->dateValid = TRUE;
1178   infoPtr->hFont = GetStockObject(DEFAULT_GUI_FONT);
1179   return 0;
1180 }
1181
1182
1183 static LRESULT
1184 DATETIME_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
1185 {
1186     DATETIME_INFO *infoPtr = DATETIME_GetInfoPtr (hwnd);
1187
1188     TRACE("\n");
1189     COMCTL32_Free (infoPtr);
1190     SetWindowLongA( hwnd, 0, 0 );
1191     return 0;
1192 }
1193
1194
1195 static LRESULT WINAPI
1196 DATETIME_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1197 {
1198     if (!DATETIME_GetInfoPtr(hwnd) && (uMsg != WM_CREATE))
1199         return DefWindowProcA( hwnd, uMsg, wParam, lParam );
1200
1201     switch (uMsg)
1202     {
1203
1204     case DTM_GETSYSTEMTIME:
1205         return DATETIME_GetSystemTime (hwnd, wParam, lParam);
1206
1207     case DTM_SETSYSTEMTIME:
1208         return DATETIME_SetSystemTime (hwnd, wParam, lParam);
1209
1210     case DTM_GETRANGE:
1211         return DATETIME_GetRange(hwnd, lParam);
1212
1213     case DTM_SETRANGE:
1214         return DATETIME_SetRange(hwnd, wParam, lParam);
1215
1216     case DTM_SETFORMATA:
1217         return DATETIME_SetFormat (hwnd, wParam, lParam);
1218
1219     case DTM_SETFORMATW:
1220         return DATETIME_SetFormatW (hwnd, wParam, lParam);
1221
1222     case DTM_SETMCCOLOR:
1223         return DATETIME_SetMonthCalColor (hwnd, wParam, lParam);
1224
1225     case DTM_GETMCCOLOR:
1226         return DATETIME_GetMonthCalColor (hwnd, wParam);
1227
1228     case DTM_GETMONTHCAL:
1229         return DATETIME_GetMonthCal (hwnd);
1230
1231     case DTM_SETMCFONT:
1232         return DATETIME_SetMonthCalFont (hwnd, wParam, lParam);
1233
1234     case DTM_GETMCFONT:
1235         return DATETIME_GetMonthCalFont (hwnd);
1236
1237     case WM_PARENTNOTIFY:
1238         return DATETIME_ParentNotify (hwnd, wParam, lParam);
1239
1240     case WM_NOTIFY:
1241         return DATETIME_Notify (hwnd, wParam, lParam);
1242
1243     case WM_GETDLGCODE:
1244         return DLGC_WANTARROWS | DLGC_WANTCHARS;
1245
1246     case WM_PAINT:
1247         return DATETIME_Paint (hwnd, wParam);
1248
1249     case WM_KEYDOWN:
1250         return DATETIME_KeyDown (hwnd, wParam, lParam);
1251
1252     case WM_KILLFOCUS:
1253         return DATETIME_KillFocus (hwnd, wParam, lParam);
1254
1255     case WM_SETFOCUS:
1256         return DATETIME_SetFocus (hwnd, wParam, lParam);
1257
1258     case WM_SIZE:
1259         return DATETIME_Size (hwnd, wParam, lParam);
1260
1261     case WM_LBUTTONDOWN:
1262         return DATETIME_LButtonDown (hwnd, wParam, lParam);
1263
1264     case WM_LBUTTONUP:
1265         return DATETIME_LButtonUp (hwnd, wParam, lParam);
1266
1267     case WM_CREATE:
1268         return DATETIME_Create (hwnd, wParam, lParam);
1269
1270     case WM_DESTROY:
1271         return DATETIME_Destroy (hwnd, wParam, lParam);
1272
1273     default:
1274         if (uMsg >= WM_USER)
1275                 ERR("unknown msg %04x wp=%08x lp=%08lx\n",
1276                      uMsg, wParam, lParam);
1277         return DefWindowProcA (hwnd, uMsg, wParam, lParam);
1278     }
1279     return 0;
1280 }
1281
1282
1283 VOID
1284 DATETIME_Register (void)
1285 {
1286     WNDCLASSA wndClass;
1287
1288     TRACE("\n");
1289     ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1290     wndClass.style         = CS_GLOBALCLASS;
1291     wndClass.lpfnWndProc   = (WNDPROC)DATETIME_WindowProc;
1292     wndClass.cbClsExtra    = 0;
1293     wndClass.cbWndExtra    = sizeof(DATETIME_INFO *);
1294     wndClass.hCursor       = LoadCursorA (0, IDC_ARROWA);
1295     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
1296     wndClass.lpszClassName = DATETIMEPICK_CLASSA;
1297
1298     RegisterClassA (&wndClass);
1299 }
1300
1301
1302 VOID
1303 DATETIME_Unregister (void)
1304 {
1305     TRACE("\n");
1306     UnregisterClassA (DATETIMEPICK_CLASSA, (HINSTANCE)NULL);
1307 }