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