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