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