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