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