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  * Copyright 2012 Owen Rudge for CodeWeavers
   8  *
   9  * This library is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this library; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  22  *
  23  * TODO:
  24  *    -- DTS_APPCANPARSE
  25  *    -- DTS_SHORTDATECENTURYFORMAT
  26  *    -- DTN_FORMAT
  27  *    -- DTN_FORMATQUERY
  28  *    -- DTN_USERSTRING
  29  *    -- DTN_WMKEYDOWN
  30  *    -- FORMATCALLBACK
  31  */
  32
  33 #include <math.h>
  34 #include <string.h>
  35 #include <stdarg.h>
  36 #include <stdio.h>
  37 #include <limits.h>
  38
  39 #include "windef.h"
  40 #include "winbase.h"
  41 #include "wingdi.h"
  42 #include "winuser.h"
  43 #include "winnls.h"
  44 #include "commctrl.h"
  45 #include "comctl32.h"
  46 #include "uxtheme.h"
  47 #include "vsstyle.h"
  48 #include "wine/debug.h"
  49
  50 WINE_DEFAULT_DEBUG_CHANNEL(datetime);
  51
  52 typedef struct
  53 {
  54     HWND hwndSelf;
  55     HWND hMonthCal;
  56     HWND hwndNotify;
  57     HWND hUpdown;
  58     DWORD dwStyle;
  59     SYSTEMTIME date;
  60     BOOL dateValid;
  61     HWND hwndCheckbut;
  62     RECT rcClient; /* rect around the edge of the window */
  63     RECT rcDraw; /* rect inside of the border */
  64     RECT checkbox;  /* checkbox allowing the control to be enabled/disabled */
  65     RECT calbutton; /* button that toggles the dropdown of the monthcal control */
  66     BOOL bCalDepressed; /* TRUE = cal button is depressed */
  67     BOOL bCalHot; /* TRUE if calendar button is hovered */
  68     BOOL bDropdownEnabled;
  69     int  select;
  70     WCHAR charsEntered[4];
  71     int nCharsEntered;
  72     HFONT hFont;
  73     int nrFieldsAllocated;
  74     int nrFields;
  75     int haveFocus;
  76     int *fieldspec;
  77     RECT *fieldRect;
  78     int  *buflen;
  79     WCHAR textbuf[256];
  80     POINT monthcal_pos;
  81     int pendingUpdown;
  82 } DATETIME_INFO, *LPDATETIME_INFO;
  83
  84 /* in monthcal.c */
  85 extern int MONTHCAL_MonthLength(int month, int year);
  86 extern int MONTHCAL_CalculateDayOfWeek(SYSTEMTIME *date, BOOL inplace);
  87
  88 /* this list of defines is closely related to `allowedformatchars' defined
  89  * in datetime.c; the high nibble indicates the `base type' of the format
  90  * specifier.
  91  * Do not change without first reading DATETIME_UseFormat.
  92  *
  93  */
  94
  95 #define DT_END_FORMAT      0
  96 #define ONEDIGITDAY     0x01
  97 #define TWODIGITDAY     0x02
  98 #define THREECHARDAY    0x03
  99 #define FULLDAY         0x04
 100 #define ONEDIGIT12HOUR  0x11
 101 #define TWODIGIT12HOUR  0x12
 102 #define ONEDIGIT24HOUR  0x21
 103 #define TWODIGIT24HOUR  0x22
 104 #define ONEDIGITMINUTE  0x31
 105 #define TWODIGITMINUTE  0x32
 106 #define ONEDIGITMONTH   0x41
 107 #define TWODIGITMONTH   0x42
 108 #define THREECHARMONTH  0x43
 109 #define FULLMONTH       0x44
 110 #define ONEDIGITSECOND  0x51
 111 #define TWODIGITSECOND  0x52
 112 #define ONELETTERAMPM   0x61
 113 #define TWOLETTERAMPM   0x62
 114 #define ONEDIGITYEAR    0x71
 115 #define TWODIGITYEAR    0x72
 116 #define INVALIDFULLYEAR 0x73      /* FIXME - yyy is not valid - we'll treat it as yyyy */
 117 #define FULLYEAR        0x74
 118 #define FORMATCALLBACK  0x81      /* -> maximum of 0x80 callbacks possible */
 119 #define FORMATCALLMASK  0x80
 120 #define DT_STRING       0x0100
 121
 122 #define DTHT_DATEFIELD  0xff      /* for hit-testing */
 123
 124 #define DTHT_NONE       0x1000
 125 #define DTHT_CHECKBOX   0x2000  /* these should end at '00' , to make */
 126 #define DTHT_MCPOPUP    0x3000  /* & DTHT_DATEFIELD 0 when DATETIME_KeyDown */
 127 #define DTHT_GOTFOCUS   0x4000  /* tests for date-fields */
 128 #define DTHT_NODATEMASK 0xf000  /* to mask check and drop down from others */
 129
 130 static BOOL DATETIME_SendSimpleNotify (const DATETIME_INFO *infoPtr, UINT code);
 131 static BOOL DATETIME_SendDateTimeChangeNotify (const DATETIME_INFO *infoPtr);
 132 static const WCHAR allowedformatchars[] = L"dhHmMstyX";
 133 static const int maxrepetition [] = {4,2,2,2,4,2,2,4,-1};
 134 static const WCHAR *themeClass = WC_SCROLLBARW;
 135
 136 /* valid date limits */
 137 static const SYSTEMTIME max_allowed_date = { .wYear = 9999, .wMonth = 12, .wDayOfWeek = 0, .wDay = 31 };
 138 static const SYSTEMTIME min_allowed_date = { .wYear = 1752, .wMonth = 9, .wDayOfWeek = 0, .wDay = 14 };
 139
 140 static DWORD
 141 DATETIME_GetSystemTime (const DATETIME_INFO *infoPtr, SYSTEMTIME *systime)
 142 {
 143     if (!systime) return GDT_NONE;
 144
 145     if ((infoPtr->dwStyle & DTS_SHOWNONE) &&
 146         (SendMessageW (infoPtr->hwndCheckbut, BM_GETCHECK, 0, 0) == BST_UNCHECKED))
 147         return GDT_NONE;
 148
 149     *systime = infoPtr->date;
 150
 151     return GDT_VALID;
 152 }
 153
 154 /* Checks value is within configured date range
 155  *
 156  * PARAMETERS
 157  *
 158  *  [I] infoPtr : valid pointer to control data
 159  *  [I] date    : pointer to valid date data to check
 160  *
 161  * RETURN VALUE
 162  *
 163  *  TRUE  - date within configured range
 164  *  FALSE - date is outside configured range
 165  */
 166 static BOOL DATETIME_IsDateInValidRange(const DATETIME_INFO *infoPtr, const SYSTEMTIME *date)
 167 {
 168     SYSTEMTIME range[2];
 169     DWORD limits;
 170
 171     if ((MONTHCAL_CompareSystemTime(date, &max_allowed_date) == 1) ||
 172         (MONTHCAL_CompareSystemTime(date, &min_allowed_date) == -1))
 173         return FALSE;
 174
 175     limits = SendMessageW (infoPtr->hMonthCal, MCM_GETRANGE, 0, (LPARAM)range);
 176
 177     if (limits & GDTR_MAX)
 178     {
 179         if (MONTHCAL_CompareSystemTime(date, &range[1]) == 1)
 180            return FALSE;
 181     }
 182
 183     if (limits & GDTR_MIN)
 184     {
 185         if (MONTHCAL_CompareSystemTime(date, &range[0]) == -1)
 186            return FALSE;
 187     }
 188
 189     return TRUE;
 190 }
 191
 192 static BOOL
 193 DATETIME_SetSystemTime (DATETIME_INFO *infoPtr, DWORD flag, const SYSTEMTIME *systime)
 194 {
 195     if (!systime) return FALSE;
 196
 197     TRACE("%04d/%02d/%02d %02d:%02d:%02d\n",
 198           systime->wYear, systime->wMonth, systime->wDay,
 199           systime->wHour, systime->wMinute, systime->wSecond);
 200
 201     if (flag == GDT_VALID) {
 202         if (systime->wYear == 0 ||
 203             systime->wMonth < 1 || systime->wMonth > 12 ||
 204             systime->wDay < 1 ||
 205             systime->wDay > MONTHCAL_MonthLength(systime->wMonth, systime->wYear) ||
 206             systime->wHour > 23 ||
 207             systime->wMinute > 59 ||
 208             systime->wSecond > 59 ||
 209             systime->wMilliseconds > 999
 210            )
 211             return FALSE;
 212
 213         /* Windows returns true if the date is valid but outside the limits set */
 214         if (!DATETIME_IsDateInValidRange(infoPtr, systime))
 215             return TRUE;
 216
 217         infoPtr->dateValid = TRUE;
 218         infoPtr->date = *systime;
 219         /* always store a valid day of week */
 220         MONTHCAL_CalculateDayOfWeek(&infoPtr->date, TRUE);
 221
 222         SendMessageW (infoPtr->hMonthCal, MCM_SETCURSEL, 0, (LPARAM)(&infoPtr->date));
 223         SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, BST_CHECKED, 0);
 224     } else if ((infoPtr->dwStyle & DTS_SHOWNONE) && (flag == GDT_NONE)) {
 225         infoPtr->dateValid = FALSE;
 226         SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, BST_UNCHECKED, 0);
 227     }
 228     else
 229         return FALSE;
 230
 231     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
 232     return TRUE;
 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 up as '<show seconds>tring'.
 245  *
 246  */
 247 static void
 248 DATETIME_UseFormat (DATETIME_INFO *infoPtr, LPCWSTR formattxt)
 249 {
 250     unsigned int i;
 251     int j, k, len;
 252     BOOL inside_literal = FALSE; /* inside '...' */
 253     int *nrFields = &infoPtr->nrFields;
 254
 255     *nrFields = 0;
 256     infoPtr->fieldspec[*nrFields] = 0;
 257     len = lstrlenW(allowedformatchars);
 258     k = 0;
 259
 260     for (i = 0; formattxt[i]; i++)  {
 261         TRACE ("\n%d %c:", i, formattxt[i]);
 262         if (!inside_literal) {
 263             for (j = 0; j < len; j++) {
 264                 if (allowedformatchars[j]==formattxt[i]) {
 265                     TRACE ("%c[%d,%x]", allowedformatchars[j], *nrFields, infoPtr->fieldspec[*nrFields]);
 266                     if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
 267                         infoPtr->fieldspec[*nrFields] = (j<<4) + 1;
 268                         break;
 269                     }
 270                     if (infoPtr->fieldspec[*nrFields] >> 4 != j) {
 271                         (*nrFields)++;
 272                         infoPtr->fieldspec[*nrFields] = (j<<4) + 1;
 273                         break;
 274                     }
 275                     if ((infoPtr->fieldspec[*nrFields] & 0x0f) == maxrepetition[j]) {
 276                         (*nrFields)++;
 277                         infoPtr->fieldspec[*nrFields] = (j<<4) + 1;
 278                         break;
 279                     }
 280                     infoPtr->fieldspec[*nrFields]++;
 281                     break;
 282                 }   /* if allowedformatchar */
 283             } /* for j */
 284         }
 285         else
 286             j = len;
 287
 288         if (formattxt[i] == '\'')
 289         {
 290             inside_literal = !inside_literal;
 291             continue;
 292         }
 293
 294         /* char is not a specifier: handle char like a string */
 295         if (j == len) {
 296             if ((*nrFields==0) && (infoPtr->fieldspec[*nrFields]==0)) {
 297                 infoPtr->fieldspec[*nrFields] = DT_STRING + k;
 298                 infoPtr->buflen[*nrFields] = 0;
 299             } else if ((infoPtr->fieldspec[*nrFields] & DT_STRING) != DT_STRING)  {
 300                 (*nrFields)++;
 301                 infoPtr->fieldspec[*nrFields] = DT_STRING + k;
 302                 infoPtr->buflen[*nrFields] = 0;
 303             }
 304             infoPtr->textbuf[k] = formattxt[i];
 305             k++;
 306             infoPtr->buflen[*nrFields]++;
 307         }   /* if j=len */
 308
 309         if (*nrFields == infoPtr->nrFieldsAllocated) {
 310             FIXME ("out of memory; should reallocate. crash ahead.\n");
 311         }
 312     } /* for i */
 313
 314     TRACE("\n");
 315
 316     if (infoPtr->fieldspec[*nrFields] != 0) (*nrFields)++;
 317 }
 318
 319
 320 static BOOL
 321 DATETIME_SetFormatW (DATETIME_INFO *infoPtr, LPCWSTR format)
 322 {
 323     WCHAR format_buf[80];
 324
 325     if (!format) {
 326         DWORD format_item;
 327
 328         if ((infoPtr->dwStyle & DTS_SHORTDATECENTURYFORMAT) == DTS_SHORTDATECENTURYFORMAT)
 329             format_item = LOCALE_SSHORTDATE;
 330         else if ((infoPtr->dwStyle & DTS_LONGDATEFORMAT) == DTS_LONGDATEFORMAT)
 331             format_item = LOCALE_SLONGDATE;
 332         else if ((infoPtr->dwStyle & DTS_TIMEFORMAT) == DTS_TIMEFORMAT)
 333             format_item = LOCALE_STIMEFORMAT;
 334         else /* DTS_SHORTDATEFORMAT */
 335             format_item = LOCALE_SSHORTDATE;
 336         GetLocaleInfoW(LOCALE_USER_DEFAULT, format_item, format_buf, ARRAY_SIZE(format_buf));
 337         format = format_buf;
 338     }
 339
 340     DATETIME_UseFormat (infoPtr, format);
 341     InvalidateRect (infoPtr->hwndSelf, NULL, TRUE);
 342
 343     return TRUE;
 344 }
 345
 346
 347 static BOOL
 348 DATETIME_SetFormatA (DATETIME_INFO *infoPtr, LPCSTR lpszFormat)
 349 {
 350     if (lpszFormat) {
 351         BOOL retval;
 352         INT len = MultiByteToWideChar(CP_ACP, 0, lpszFormat, -1, NULL, 0);
 353         LPWSTR wstr = Alloc(len * sizeof(WCHAR));
 354         if (wstr) MultiByteToWideChar(CP_ACP, 0, lpszFormat, -1, wstr, len);
 355         retval = DATETIME_SetFormatW (infoPtr, wstr);
 356         Free (wstr);
 357         return retval;
 358     }
 359     else
 360         return DATETIME_SetFormatW (infoPtr, 0);
 361
 362 }
 363
 364
 365 static void
 366 DATETIME_ReturnTxt (const DATETIME_INFO *infoPtr, int count, LPWSTR result, int resultSize)
 367 {
 368     SYSTEMTIME date = infoPtr->date;
 369     int spec;
 370     WCHAR buffer[80];
 371
 372     *result=0;
 373     TRACE ("%d,%d\n", infoPtr->nrFields, count);
 374     if (count>infoPtr->nrFields || count < 0) {
 375         WARN ("buffer overrun, have %d want %d\n", infoPtr->nrFields, count);
 376         return;
 377     }
 378
 379     if (!infoPtr->fieldspec) return;
 380
 381     spec = infoPtr->fieldspec[count];
 382     if (spec & DT_STRING) {
 383         int txtlen = infoPtr->buflen[count];
 384
 385         if (txtlen > resultSize)
 386             txtlen = resultSize - 1;
 387         memcpy (result, infoPtr->textbuf + (spec &~ DT_STRING), txtlen * sizeof(WCHAR));
 388         result[txtlen] = 0;
 389         TRACE ("arg%d=%x->[%s]\n", count, infoPtr->fieldspec[count], debugstr_w(result));
 390         return;
 391     }
 392
 393
 394     switch (spec) {
 395         case DT_END_FORMAT:
 396             *result = 0;
 397             break;
 398         case ONEDIGITDAY:
 399             wsprintfW (result, L"%d", date.wDay);
 400             break;
 401         case TWODIGITDAY:
 402             wsprintfW (result, L"%.2d", date.wDay);
 403             break;
 404         case THREECHARDAY:
 405             GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1+(date.wDayOfWeek+6)%7, result, 4);
 406             /*wsprintfW (result,"%.3s",days[date.wDayOfWeek]);*/
 407             break;
 408         case FULLDAY:
 409             GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SDAYNAME1+(date.wDayOfWeek+6)%7, result, resultSize);
 410             break;
 411         case ONEDIGIT12HOUR:
 412             if (date.wHour == 0) {
 413                 result[0] = '1';
 414                 result[1] = '2';
 415                 result[2] = 0;
 416             }
 417             else
 418                 wsprintfW (result, L"%d", date.wHour - (date.wHour > 12 ? 12 : 0));
 419             break;
 420         case TWODIGIT12HOUR:
 421             if (date.wHour == 0) {
 422                 result[0] = '1';
 423                 result[1] = '2';
 424                 result[2] = 0;
 425             }
 426             else
 427                 wsprintfW (result, L"%.2d", date.wHour - (date.wHour > 12 ? 12 : 0));
 428             break;
 429         case ONEDIGIT24HOUR:
 430             wsprintfW (result, L"%d", date.wHour);
 431             break;
 432         case TWODIGIT24HOUR:
 433             wsprintfW (result, L"%.2d", date.wHour);
 434             break;
 435         case ONEDIGITSECOND:
 436             wsprintfW (result, L"%d", date.wSecond);
 437             break;
 438         case TWODIGITSECOND:
 439             wsprintfW (result, L"%.2d", date.wSecond);
 440             break;
 441         case ONEDIGITMINUTE:
 442             wsprintfW (result, L"%d", date.wMinute);
 443             break;
 444         case TWODIGITMINUTE:
 445             wsprintfW (result, L"%.2d", date.wMinute);
 446             break;
 447         case ONEDIGITMONTH:
 448             wsprintfW (result, L"%d", date.wMonth);
 449             break;
 450         case TWODIGITMONTH:
 451             wsprintfW (result, L"%.2d", date.wMonth);
 452             break;
 453         case THREECHARMONTH:
 454             GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME1+date.wMonth -1, buffer, ARRAY_SIZE(buffer));
 455             wsprintfW (result, L"%s.3s", buffer);
 456             break;
 457         case FULLMONTH:
 458             GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME1+date.wMonth -1,
 459                            result, resultSize);
 460             break;
 461         case ONELETTERAMPM:
 462             result[0] = (date.wHour < 12 ? 'A' : 'P');
 463             result[1] = 0;
 464             break;
 465         case TWOLETTERAMPM:
 466             result[0] = (date.wHour < 12 ? 'A' : 'P');
 467             result[1] = 'M';
 468             result[2] = 0;
 469             break;
 470         case FORMATCALLBACK:
 471             FIXME ("Not implemented\n");
 472             result[0] = 'x';
 473             result[1] = 0;
 474             break;
 475         case ONEDIGITYEAR:
 476             wsprintfW (result, L"%d", date.wYear % 10);
 477             break;
 478         case TWODIGITYEAR:
 479             wsprintfW (result, L"%.2d", date.wYear % 100);
 480             break;
 481         case INVALIDFULLYEAR:
 482         case FULLYEAR:
 483             wsprintfW (result, L"%d", date.wYear);
 484             break;
 485     }
 486
 487     TRACE ("arg%d=%x->[%s]\n", count, infoPtr->fieldspec[count], debugstr_w(result));
 488 }
 489
 490 static int wrap(int val, int delta, int minVal, int maxVal)
 491 {
 492     val += delta;
 493     if (delta == INT_MIN || val < minVal) return maxVal;
 494     if (delta == INT_MAX || val > maxVal) return minVal;
 495     return val;
 496 }
 497
 498 static void
 499 DATETIME_IncreaseField (DATETIME_INFO *infoPtr, int number, int delta)
 500 {
 501     SYSTEMTIME *date = &infoPtr->date;
 502     SYSTEMTIME range[2];
 503     DWORD limits;
 504     BOOL min;
 505
 506     TRACE ("%d\n", number);
 507     if ((number > infoPtr->nrFields) || (number < 0)) return;
 508
 509     if ((infoPtr->fieldspec[number] & DTHT_DATEFIELD) == 0) return;
 510
 511     switch (infoPtr->fieldspec[number]) {
 512         case ONEDIGITYEAR:
 513         case TWODIGITYEAR:
 514         case FULLYEAR:
 515             if (delta == INT_MIN)
 516                 date->wYear = 1752;
 517             else if (delta == INT_MAX)
 518                 date->wYear = 9999;
 519             else
 520                 date->wYear = max(min(date->wYear + delta, 9999), 1752);
 521
 522             if (date->wDay > MONTHCAL_MonthLength(date->wMonth, date->wYear))
 523                 /* This can happen when moving away from a leap year. */
 524                 date->wDay = MONTHCAL_MonthLength(date->wMonth, date->wYear);
 525             MONTHCAL_CalculateDayOfWeek(date, TRUE);
 526             break;
 527         case ONEDIGITMONTH:
 528         case TWODIGITMONTH:
 529         case THREECHARMONTH:
 530         case FULLMONTH:
 531             date->wMonth = wrap(date->wMonth, delta, 1, 12);
 532             MONTHCAL_CalculateDayOfWeek(date, TRUE);
 533             delta = 0;
 534             /* fall through */
 535         case ONEDIGITDAY:
 536         case TWODIGITDAY:
 537         case THREECHARDAY:
 538         case FULLDAY:
 539             date->wDay = wrap(date->wDay, delta, 1, MONTHCAL_MonthLength(date->wMonth, date->wYear));
 540             MONTHCAL_CalculateDayOfWeek(date, TRUE);
 541             break;
 542         case ONELETTERAMPM:
 543         case TWOLETTERAMPM:
 544             delta *= 12;
 545             /* fall through */
 546         case ONEDIGIT12HOUR:
 547         case TWODIGIT12HOUR:
 548         case ONEDIGIT24HOUR:
 549         case TWODIGIT24HOUR:
 550             date->wHour = wrap(date->wHour, delta, 0, 23);
 551             break;
 552         case ONEDIGITMINUTE:
 553         case TWODIGITMINUTE:
 554             date->wMinute = wrap(date->wMinute, delta, 0, 59);
 555             break;
 556         case ONEDIGITSECOND:
 557         case TWODIGITSECOND:
 558             date->wSecond = wrap(date->wSecond, delta, 0, 59);
 559             break;
 560         case FORMATCALLBACK:
 561             FIXME ("Not implemented\n");
 562             break;
 563     }
 564
 565     /* FYI: On 1752/9/14 the calendar changed and England and the
 566      * American colonies changed to the Gregorian calendar. This change
 567      * involved having September 14th follow September 2nd. So no date
 568      * algorithm works before that date.
 569      */
 570     if (10000 * date->wYear + 100 * date->wMonth + date->wDay < 17520914) {
 571         date->wYear = 1752;
 572         date->wMonth = 9;
 573         date->wDay = 14;
 574         date->wSecond = 0;
 575         date->wMinute = 0;
 576         date->wHour = 0;
 577     }
 578
 579     /* Ensure time is within bounds */
 580     limits = SendMessageW (infoPtr->hMonthCal, MCM_GETRANGE, 0, (LPARAM)range);
 581     min = delta < 0;
 582
 583     if (limits & (min ? GDTR_MIN : GDTR_MAX))
 584     {
 585         int i = (min ? 0 : 1);
 586
 587         if (MONTHCAL_CompareSystemTime(date, &range[i]) == (min ? -1 : 1))
 588         {
 589             date->wYear = range[i].wYear;
 590             date->wMonth = range[i].wMonth;
 591             date->wDayOfWeek = range[i].wDayOfWeek;
 592             date->wDay = range[i].wDay;
 593             date->wHour = range[i].wHour;
 594             date->wMinute = range[i].wMinute;
 595             date->wSecond = range[i].wSecond;
 596             date->wMilliseconds = range[i].wMilliseconds;
 597         }
 598     }
 599 }
 600
 601 static int DATETIME_GetFieldWidth (const DATETIME_INFO *infoPtr, HDC hdc, int count)
 602 {
 603     /* fields are a fixed width, determined by the largest possible string */
 604     /* presumably, these widths should be language dependent */
 605     int spec;
 606     WCHAR buffer[80];
 607     LPCWSTR bufptr;
 608     SIZE size;
 609
 610     if (!infoPtr->fieldspec) return 0;
 611
 612     spec = infoPtr->fieldspec[count];
 613     if (spec & DT_STRING) {
 614         int txtlen = infoPtr->buflen[count];
 615
 616         if (txtlen > 79)
 617             txtlen = 79;
 618         memcpy (buffer, infoPtr->textbuf + (spec &~ DT_STRING), txtlen * sizeof(WCHAR));
 619         buffer[txtlen] = 0;
 620         bufptr = buffer;
 621     }
 622     else {
 623         switch (spec) {
 624             case ONEDIGITDAY:
 625             case ONEDIGIT12HOUR:
 626             case ONEDIGIT24HOUR:
 627             case ONEDIGITSECOND:
 628             case ONEDIGITMINUTE:
 629             case ONEDIGITMONTH:
 630             case ONEDIGITYEAR:
 631                 /* these seem to use a two byte field */
 632             case TWODIGITDAY:
 633             case TWODIGIT12HOUR:
 634             case TWODIGIT24HOUR:
 635             case TWODIGITSECOND:
 636             case TWODIGITMINUTE:
 637             case TWODIGITMONTH:
 638             case TWODIGITYEAR:
 639                 bufptr = L"22";
 640                 break;
 641             case INVALIDFULLYEAR:
 642             case FULLYEAR:
 643                 bufptr = L"2222";
 644                 break;
 645             case THREECHARMONTH:
 646             case FULLMONTH:
 647             case THREECHARDAY:
 648             case FULLDAY:
 649             {
 650                 const WCHAR *fall;
 651                 LCTYPE lctype;
 652                 INT i, max_count;
 653                 LONG cx;
 654
 655                 /* choose locale data type and fallback string */
 656                 switch (spec) {
 657                 case THREECHARDAY:
 658                     fall   = L"Wed";
 659                     lctype = LOCALE_SABBREVDAYNAME1;
 660                     max_count = 7;
 661                     break;
 662                 case FULLDAY:
 663                     fall   = L"Wednesday";
 664                     lctype = LOCALE_SDAYNAME1;
 665                     max_count = 7;
 666                     break;
 667                 case THREECHARMONTH:
 668                     fall   = L"Dec";
 669                     lctype = LOCALE_SABBREVMONTHNAME1;
 670                     max_count = 12;
 671                     break;
 672                 default: /* FULLMONTH */
 673                     fall   = L"September";
 674                     lctype = LOCALE_SMONTHNAME1;
 675                     max_count = 12;
 676                     break;
 677                 }
 678
 679                 cx = 0;
 680                 for (i = 0; i < max_count; i++)
 681                 {
 682                     if(GetLocaleInfoW(LOCALE_USER_DEFAULT, lctype + i,
 683                         buffer, ARRAY_SIZE(buffer)))
 684                     {
 685                         GetTextExtentPoint32W(hdc, buffer, lstrlenW(buffer), &size);
 686                         if (size.cx > cx) cx = size.cx;
 687                     }
 688                     else /* locale independent fallback on failure */
 689                     {
 690                         GetTextExtentPoint32W(hdc, fall, lstrlenW(fall), &size);
 691                         cx = size.cx;
 692                         break;
 693                     }
 694                 }
 695                 return cx;
 696             }
 697             case ONELETTERAMPM:
 698                 bufptr = L"A";
 699                 break;
 700             case TWOLETTERAMPM:
 701                 bufptr = L"AM";
 702                 break;
 703             default:
 704                 bufptr = L"2";
 705                 break;
 706         }
 707     }
 708     GetTextExtentPoint32W (hdc, bufptr, lstrlenW(bufptr), &size);
 709     return size.cx;
 710 }
 711
 712 static void
 713 DATETIME_Refresh (DATETIME_INFO *infoPtr, HDC hdc)
 714 {
 715     HTHEME theme;
 716     int state;
 717
 718     TRACE("\n");
 719
 720     if (infoPtr->dateValid) {
 721         int i, prevright;
 722         RECT *field;
 723         RECT *rcDraw = &infoPtr->rcDraw;
 724         SIZE size;
 725         COLORREF oldTextColor;
 726         HFONT oldFont = SelectObject (hdc, infoPtr->hFont);
 727         INT oldBkMode = SetBkMode (hdc, TRANSPARENT);
 728         WCHAR txt[80];
 729
 730         DATETIME_ReturnTxt (infoPtr, 0, txt, ARRAY_SIZE(txt));
 731         GetTextExtentPoint32W (hdc, txt, lstrlenW(txt), &size);
 732         rcDraw->bottom = size.cy + 2;
 733
 734         prevright = infoPtr->checkbox.right = ((infoPtr->dwStyle & DTS_SHOWNONE) ? 18 : 2);
 735
 736         for (i = 0; i < infoPtr->nrFields; i++) {
 737             DATETIME_ReturnTxt (infoPtr, i, txt, ARRAY_SIZE(txt));
 738             GetTextExtentPoint32W (hdc, txt, lstrlenW(txt), &size);
 739             field = &infoPtr->fieldRect[i];
 740             field->left   = prevright;
 741             field->right  = prevright + DATETIME_GetFieldWidth (infoPtr, hdc, i);
 742             field->top    = rcDraw->top;
 743             field->bottom = rcDraw->bottom;
 744             prevright = field->right;
 745
 746             if (infoPtr->dwStyle & WS_DISABLED)
 747                 oldTextColor = SetTextColor (hdc, comctl32_color.clrGrayText);
 748             else if ((infoPtr->haveFocus) && (i == infoPtr->select)) {
 749                 RECT selection;
 750
 751                 /* fill if focused */
 752                 HBRUSH hbr = CreateSolidBrush (comctl32_color.clrActiveCaption);
 753
 754                 if (infoPtr->nCharsEntered)
 755                 {
 756                     memcpy(txt, infoPtr->charsEntered, infoPtr->nCharsEntered * sizeof(WCHAR));
 757                     txt[infoPtr->nCharsEntered] = 0;
 758                     GetTextExtentPoint32W (hdc, txt, lstrlenW(txt), &size);
 759                 }
 760
 761                 SetRect(&selection, 0, 0, size.cx, size.cy);
 762                 /* center rectangle */
 763                 OffsetRect(&selection, (field->right  + field->left - size.cx)/2,
 764                                        (field->bottom - size.cy)/2);
 765
 766                 FillRect(hdc, &selection, hbr);
 767                 DeleteObject (hbr);
 768                 oldTextColor = SetTextColor (hdc, comctl32_color.clrWindow);
 769             }
 770             else
 771                 oldTextColor = SetTextColor (hdc, comctl32_color.clrWindowText);
 772
 773             /* draw the date text using the colour set above */
 774             DrawTextW (hdc, txt, lstrlenW(txt), field, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
 775             SetTextColor (hdc, oldTextColor);
 776         }
 777         SetBkMode (hdc, oldBkMode);
 778         SelectObject (hdc, oldFont);
 779     }
 780
 781     if (infoPtr->dwStyle & DTS_UPDOWN)
 782         return;
 783
 784     theme = GetWindowTheme(infoPtr->hwndSelf);
 785     if (theme)
 786     {
 787         if (infoPtr->dwStyle & WS_DISABLED)
 788             state = ABS_DOWNDISABLED;
 789         else if (infoPtr->bCalDepressed)
 790             state = ABS_DOWNPRESSED;
 791         else if (infoPtr->bCalHot)
 792             state = ABS_DOWNHOT;
 793         else
 794             state = ABS_DOWNNORMAL;
 795
 796         if (IsThemeBackgroundPartiallyTransparent(theme, SBP_ARROWBTN, state))
 797             DrawThemeParentBackground(infoPtr->hwndSelf, hdc, &infoPtr->calbutton);
 798         DrawThemeBackground(theme, hdc, SBP_ARROWBTN, state, &infoPtr->calbutton, NULL);
 799     }
 800     else
 801     {
 802         DrawFrameControl(hdc, &infoPtr->calbutton, DFC_SCROLL,
 803                          DFCS_SCROLLDOWN | (infoPtr->bCalDepressed ? DFCS_PUSHED : 0) |
 804                          (infoPtr->dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0) );
 805     }
 806 }
 807
 808
 809 static INT
 810 DATETIME_HitTest (const DATETIME_INFO *infoPtr, POINT pt)
 811 {
 812     int i;
 813
 814     TRACE ("%s\n", wine_dbgstr_point(&pt));
 815
 816     if (PtInRect (&infoPtr->calbutton, pt)) return DTHT_MCPOPUP;
 817     if (PtInRect (&infoPtr->checkbox, pt)) return DTHT_CHECKBOX;
 818
 819     for (i = 0; i < infoPtr->nrFields; i++) {
 820         if (PtInRect (&infoPtr->fieldRect[i], pt)) return i;
 821     }
 822
 823     return DTHT_NONE;
 824 }
 825
 826 /* Returns index of the nearest preceding date field from given,
 827    or -1 if none was found */
 828 static int DATETIME_GetPrevDateField(const DATETIME_INFO *infoPtr, int i)
 829 {
 830     for(--i; i >= 0; i--)
 831     {
 832         if (infoPtr->fieldspec[i] & DTHT_DATEFIELD) return i;
 833     }
 834     return -1;
 835 }
 836
 837 static void
 838 DATETIME_ApplySelectedField (DATETIME_INFO *infoPtr)
 839 {
 840     int fieldNum = infoPtr->select & DTHT_DATEFIELD;
 841     int i, val = 0;
 842     BOOL clamp_day = FALSE;
 843     SYSTEMTIME date = infoPtr->date;
 844     int oldyear;
 845
 846     if (infoPtr->select == -1 || infoPtr->nCharsEntered == 0)
 847         return;
 848
 849     if ((infoPtr->fieldspec[fieldNum] == ONELETTERAMPM) ||
 850         (infoPtr->fieldspec[fieldNum] == TWOLETTERAMPM))
 851         val = infoPtr->charsEntered[0];
 852     else {
 853         for (i=0; i<infoPtr->nCharsEntered; i++)
 854             val = val * 10 + infoPtr->charsEntered[i] - '0';
 855     }
 856
 857     infoPtr->nCharsEntered = 0;
 858
 859     switch (infoPtr->fieldspec[fieldNum]) {
 860         case ONEDIGITYEAR:
 861         case TWODIGITYEAR:
 862             oldyear = date.wYear;
 863             date.wYear = date.wYear - (date.wYear%100) + val;
 864
 865             if (DATETIME_IsDateInValidRange(infoPtr, &date))
 866                 clamp_day = TRUE;
 867             else
 868                 date.wYear = oldyear;
 869
 870             break;
 871         case INVALIDFULLYEAR:
 872         case FULLYEAR:
 873             oldyear = date.wYear;
 874             date.wYear = val;
 875
 876             if (DATETIME_IsDateInValidRange(infoPtr, &date))
 877                 clamp_day = TRUE;
 878             else
 879                 date.wYear = oldyear;
 880
 881             break;
 882         case ONEDIGITMONTH:
 883         case TWODIGITMONTH:
 884             date.wMonth = val;
 885             clamp_day = TRUE;
 886             break;
 887         case ONEDIGITDAY:
 888         case TWODIGITDAY:
 889             date.wDay = val;
 890             break;
 891         case ONEDIGIT12HOUR:
 892         case TWODIGIT12HOUR:
 893             if (val >= 24)
 894                 val -= 20;
 895
 896             if (val >= 13)
 897                 date.wHour = val;
 898             else if (val != 0) {
 899                 if (date.wHour >= 12) /* preserve current AM/PM state */
 900                     date.wHour = (val == 12 ? 12 : val + 12);
 901                 else
 902                     date.wHour = (val == 12 ? 0 : val);
 903             }
 904             break;
 905         case ONEDIGIT24HOUR:
 906         case TWODIGIT24HOUR:
 907             date.wHour = val;
 908             break;
 909         case ONEDIGITMINUTE:
 910         case TWODIGITMINUTE:
 911             date.wMinute = val;
 912             break;
 913         case ONEDIGITSECOND:
 914         case TWODIGITSECOND:
 915             date.wSecond = val;
 916             break;
 917         case ONELETTERAMPM:
 918         case TWOLETTERAMPM:
 919             if (val == 'a' || val == 'A') {
 920                 if (date.wHour >= 12)
 921                     date.wHour -= 12;
 922             } else if (val == 'p' || val == 'P') {
 923                 if (date.wHour < 12)
 924                     date.wHour += 12;
 925             }
 926             break;
 927     }
 928
 929     if (clamp_day && date.wDay > MONTHCAL_MonthLength(date.wMonth, date.wYear))
 930         date.wDay = MONTHCAL_MonthLength(date.wMonth, date.wYear);
 931
 932     if (DATETIME_SetSystemTime(infoPtr, GDT_VALID, &date))
 933         DATETIME_SendDateTimeChangeNotify (infoPtr);
 934 }
 935
 936 static void
 937 DATETIME_SetSelectedField (DATETIME_INFO *infoPtr, int select)
 938 {
 939     DATETIME_ApplySelectedField(infoPtr);
 940
 941     infoPtr->select = select;
 942     infoPtr->nCharsEntered = 0;
 943 }
 944
 945 static LRESULT
 946 DATETIME_LButtonDown (DATETIME_INFO *infoPtr, INT x, INT y)
 947 {
 948     POINT pt;
 949     int new;
 950
 951     pt.x = x;
 952     pt.y = y;
 953     new = DATETIME_HitTest (infoPtr, pt);
 954
 955     SetFocus(infoPtr->hwndSelf);
 956
 957     if (!(new & DTHT_NODATEMASK) || (new == DTHT_NONE))
 958     {
 959         if (new == DTHT_NONE)
 960             new = infoPtr->nrFields - 1;
 961         else
 962         {
 963             /* hitting string part moves selection to next date field to left */
 964             if (infoPtr->fieldspec[new] & DT_STRING)
 965             {
 966                 new = DATETIME_GetPrevDateField(infoPtr, new);
 967                 if (new == -1) return 0;
 968             }
 969             /* never select full day of week */
 970             if (infoPtr->fieldspec[new] == FULLDAY) return 0;
 971         }
 972     }
 973
 974     DATETIME_SetSelectedField(infoPtr, new);
 975
 976     if (infoPtr->select == DTHT_MCPOPUP) {
 977         RECT rcMonthCal;
 978         POINT pos;
 979         SendMessageW(infoPtr->hMonthCal, MCM_GETMINREQRECT, 0, (LPARAM)&rcMonthCal);
 980
 981         /* FIXME: button actually is only depressed during dropdown of the */
 982         /* calendar control and when the mouse is over the button window */
 983         infoPtr->bCalDepressed = TRUE;
 984
 985         /* recalculate the position of the monthcal popup */
 986         if(infoPtr->dwStyle & DTS_RIGHTALIGN)
 987             pos.x = infoPtr->calbutton.left - (rcMonthCal.right - rcMonthCal.left);
 988         else
 989             /* FIXME: this should be after the area reserved for the checkbox */
 990             pos.x = infoPtr->rcDraw.left;
 991
 992         pos.y = infoPtr->rcClient.bottom;
 993         OffsetRect( &rcMonthCal, pos.x, pos.y );
 994         MapWindowPoints( infoPtr->hwndSelf, 0, (POINT *)&rcMonthCal, 2 );
 995         SetWindowPos(infoPtr->hMonthCal, 0, rcMonthCal.left, rcMonthCal.top,
 996                      rcMonthCal.right - rcMonthCal.left, rcMonthCal.bottom - rcMonthCal.top, 0);
 997
 998         if(IsWindowVisible(infoPtr->hMonthCal)) {
 999             ShowWindow(infoPtr->hMonthCal, SW_HIDE);
1000             infoPtr->bDropdownEnabled = FALSE;
1001             DATETIME_SendSimpleNotify (infoPtr, DTN_CLOSEUP);
1002         } else {
1003             const SYSTEMTIME *lprgSysTimeArray = &infoPtr->date;
1004             TRACE("update calendar %04d/%02d/%02d\n",
1005             lprgSysTimeArray->wYear, lprgSysTimeArray->wMonth, lprgSysTimeArray->wDay);
1006             SendMessageW(infoPtr->hMonthCal, MCM_SETCURSEL, 0, (LPARAM)(&infoPtr->date));
1007
1008             if (infoPtr->bDropdownEnabled) {
1009                 ShowWindow(infoPtr->hMonthCal, SW_SHOW);
1010                 DATETIME_SendSimpleNotify (infoPtr, DTN_DROPDOWN);
1011             }
1012             infoPtr->bDropdownEnabled = TRUE;
1013         }
1014
1015         TRACE ("dt:%p mc:%p mc parent:%p, desktop:%p\n",
1016                infoPtr->hwndSelf, infoPtr->hMonthCal, infoPtr->hwndNotify, GetDesktopWindow ());
1017     }
1018
1019     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1020
1021     return 0;
1022 }
1023
1024
1025 static LRESULT
1026 DATETIME_LButtonUp (DATETIME_INFO *infoPtr)
1027 {
1028     if(infoPtr->bCalDepressed) {
1029         infoPtr->bCalDepressed = FALSE;
1030         InvalidateRect(infoPtr->hwndSelf, &(infoPtr->calbutton), TRUE);
1031     }
1032
1033     return 0;
1034 }
1035
1036
1037 static LRESULT
1038 DATETIME_Paint (DATETIME_INFO *infoPtr, HDC hdc)
1039 {
1040     if (!hdc) {
1041         PAINTSTRUCT ps;
1042         hdc = BeginPaint (infoPtr->hwndSelf, &ps);
1043         DATETIME_Refresh (infoPtr, hdc);
1044         EndPaint (infoPtr->hwndSelf, &ps);
1045     } else {
1046         DATETIME_Refresh (infoPtr, hdc);
1047     }
1048
1049     /* Not a click on the dropdown box, enabled it */
1050     infoPtr->bDropdownEnabled = TRUE;
1051
1052     return 0;
1053 }
1054
1055
1056 static LRESULT
1057 DATETIME_Button_Command (DATETIME_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
1058 {
1059     if( HIWORD(wParam) == BN_CLICKED) {
1060         DWORD state = SendMessageW((HWND)lParam, BM_GETCHECK, 0, 0);
1061         infoPtr->dateValid = (state == BST_CHECKED);
1062         InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1063         DATETIME_SendDateTimeChangeNotify(infoPtr);
1064     }
1065     return 0;
1066 }
1067
1068
1069
1070 static LRESULT
1071 DATETIME_Command (DATETIME_INFO *infoPtr, WPARAM wParam, LPARAM lParam)
1072 {
1073     TRACE("hwndbutton = %p\n", infoPtr->hwndCheckbut);
1074     if(infoPtr->hwndCheckbut == (HWND)lParam)
1075         return DATETIME_Button_Command(infoPtr, wParam, lParam);
1076     return 0;
1077 }
1078
1079
1080 static LRESULT
1081 DATETIME_Enable (DATETIME_INFO *infoPtr, BOOL bEnable)
1082 {
1083     TRACE("%p %s\n", infoPtr, bEnable ? "TRUE" : "FALSE");
1084     if (bEnable)
1085         infoPtr->dwStyle &= ~WS_DISABLED;
1086     else
1087         infoPtr->dwStyle |= WS_DISABLED;
1088
1089     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1090
1091     return 0;
1092 }
1093
1094
1095 static LRESULT
1096 DATETIME_EraseBackground (const DATETIME_INFO *infoPtr, HDC hdc)
1097 {
1098     HBRUSH hBrush, hSolidBrush = NULL;
1099     RECT   rc;
1100
1101     if (infoPtr->dwStyle & WS_DISABLED)
1102         hBrush = hSolidBrush = CreateSolidBrush(comctl32_color.clrBtnFace);
1103     else
1104     {
1105         hBrush = (HBRUSH)SendMessageW(infoPtr->hwndNotify, WM_CTLCOLOREDIT,
1106                                       (WPARAM)hdc, (LPARAM)infoPtr->hwndSelf);
1107         if (!hBrush)
1108             hBrush = hSolidBrush = CreateSolidBrush(comctl32_color.clrWindow);
1109     }
1110
1111     GetClientRect (infoPtr->hwndSelf, &rc);
1112
1113     FillRect (hdc, &rc, hBrush);
1114
1115     if (hSolidBrush)
1116         DeleteObject(hSolidBrush);
1117
1118     return -1;
1119 }
1120
1121
1122 static LRESULT
1123 DATETIME_Notify (DATETIME_INFO *infoPtr, const NMHDR *lpnmh)
1124 {
1125     TRACE ("Got notification %x from %p\n", lpnmh->code, lpnmh->hwndFrom);
1126     TRACE ("info: %p %p %p\n", infoPtr->hwndSelf, infoPtr->hMonthCal, infoPtr->hUpdown);
1127
1128     if (lpnmh->code == MCN_SELECT) {
1129         ShowWindow(infoPtr->hMonthCal, SW_HIDE);
1130         infoPtr->dateValid = TRUE;
1131         SendMessageW (infoPtr->hMonthCal, MCM_GETCURSEL, 0, (LPARAM)&infoPtr->date);
1132         TRACE("got from calendar %04d/%02d/%02d day of week %d\n",
1133         infoPtr->date.wYear, infoPtr->date.wMonth, infoPtr->date.wDay, infoPtr->date.wDayOfWeek);
1134         SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, BST_CHECKED, 0);
1135         InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1136         DATETIME_SendDateTimeChangeNotify (infoPtr);
1137         DATETIME_SendSimpleNotify(infoPtr, DTN_CLOSEUP);
1138     }
1139     if ((lpnmh->hwndFrom == infoPtr->hUpdown) && (lpnmh->code == UDN_DELTAPOS)) {
1140         const NM_UPDOWN *lpnmud = (const NM_UPDOWN*)lpnmh;
1141         TRACE("Delta pos %d\n", lpnmud->iDelta);
1142         infoPtr->pendingUpdown = lpnmud->iDelta;
1143     }
1144     return 0;
1145 }
1146
1147
1148 static LRESULT
1149 DATETIME_KeyDown (DATETIME_INFO *infoPtr, DWORD vkCode)
1150 {
1151     int fieldNum = infoPtr->select & DTHT_DATEFIELD;
1152     int wrap = 0;
1153     int new;
1154
1155     if (!(infoPtr->haveFocus)) return 0;
1156     if ((fieldNum==0) && (infoPtr->select)) return 0;
1157
1158     if (infoPtr->select & FORMATCALLMASK) {
1159         FIXME ("Callbacks not implemented yet\n");
1160     }
1161
1162     switch (vkCode) {
1163         case VK_ADD:
1164         case VK_UP:
1165             infoPtr->nCharsEntered = 0;
1166             DATETIME_IncreaseField (infoPtr, fieldNum, 1);
1167             DATETIME_SendDateTimeChangeNotify (infoPtr);
1168             break;
1169         case VK_SUBTRACT:
1170         case VK_DOWN:
1171             infoPtr->nCharsEntered = 0;
1172             DATETIME_IncreaseField (infoPtr, fieldNum, -1);
1173             DATETIME_SendDateTimeChangeNotify (infoPtr);
1174             break;
1175         case VK_HOME:
1176             infoPtr->nCharsEntered = 0;
1177             DATETIME_IncreaseField (infoPtr, fieldNum, INT_MIN);
1178             DATETIME_SendDateTimeChangeNotify (infoPtr);
1179             break;
1180         case VK_END:
1181             infoPtr->nCharsEntered = 0;
1182             DATETIME_IncreaseField (infoPtr, fieldNum, INT_MAX);
1183             DATETIME_SendDateTimeChangeNotify (infoPtr);
1184             break;
1185         case VK_LEFT:
1186             new = infoPtr->select;
1187             do {
1188                 if (new == 0) {
1189                     new = new - 1;
1190                     wrap++;
1191                 } else {
1192                     new--;
1193                 }
1194             } while ((infoPtr->fieldspec[new] & DT_STRING) && (wrap<2));
1195             if (new != infoPtr->select)
1196                 DATETIME_SetSelectedField(infoPtr, new);
1197             break;
1198         case VK_RIGHT:
1199             new = infoPtr->select;
1200             do {
1201                 new++;
1202                 if (new==infoPtr->nrFields) {
1203                     new = 0;
1204                     wrap++;
1205                 }
1206             } while ((infoPtr->fieldspec[new] & DT_STRING) && (wrap<2));
1207             if (new != infoPtr->select)
1208                 DATETIME_SetSelectedField(infoPtr, new);
1209             break;
1210     }
1211
1212     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1213
1214     return 0;
1215 }
1216
1217
1218 static LRESULT
1219 DATETIME_Char (DATETIME_INFO *infoPtr, WPARAM vkCode)
1220 {
1221     int fieldNum, fieldSpec;
1222
1223     fieldNum = infoPtr->select & DTHT_DATEFIELD;
1224     fieldSpec = infoPtr->fieldspec[fieldNum];
1225
1226     if (fieldSpec == ONELETTERAMPM || fieldSpec == TWOLETTERAMPM) {
1227         infoPtr->charsEntered[0] = vkCode;
1228         infoPtr->nCharsEntered = 1;
1229
1230         DATETIME_ApplySelectedField(infoPtr);
1231     } else if (vkCode >= '0' && vkCode <= '9') {
1232         int maxChars;
1233
1234         infoPtr->charsEntered[infoPtr->nCharsEntered++] = vkCode;
1235
1236         if (fieldSpec == INVALIDFULLYEAR || fieldSpec == FULLYEAR)
1237             maxChars = 4;
1238         else
1239             maxChars = 2;
1240
1241         if ((fieldSpec == ONEDIGIT12HOUR ||
1242              fieldSpec == TWODIGIT12HOUR ||
1243              fieldSpec == ONEDIGIT24HOUR ||
1244              fieldSpec == TWODIGIT24HOUR) &&
1245             (infoPtr->nCharsEntered == 1))
1246         {
1247             if (vkCode >= '3')
1248                  maxChars = 1;
1249         }
1250
1251         if (maxChars == infoPtr->nCharsEntered)
1252             DATETIME_ApplySelectedField(infoPtr);
1253     }
1254
1255     return 0;
1256 }
1257
1258
1259 static LRESULT
1260 DATETIME_VScroll (DATETIME_INFO *infoPtr, WORD wScroll)
1261 {
1262     int fieldNum = infoPtr->select & DTHT_DATEFIELD;
1263
1264     if ((SHORT)LOWORD(wScroll) != SB_THUMBPOSITION) return 0;
1265     if (!(infoPtr->haveFocus)) return 0;
1266     if ((fieldNum==0) && (infoPtr->select)) return 0;
1267
1268     if (infoPtr->pendingUpdown >= 0) {
1269         DATETIME_IncreaseField (infoPtr, fieldNum, 1);
1270         DATETIME_SendDateTimeChangeNotify (infoPtr);
1271     }
1272     else {
1273         DATETIME_IncreaseField (infoPtr, fieldNum, -1);
1274         DATETIME_SendDateTimeChangeNotify (infoPtr);
1275     }
1276
1277     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1278
1279     return 0;
1280 }
1281
1282
1283 static LRESULT
1284 DATETIME_KillFocus (DATETIME_INFO *infoPtr, HWND lostFocus)
1285 {
1286     TRACE("lost focus to %p\n", lostFocus);
1287
1288     if (infoPtr->haveFocus) {
1289         DATETIME_SendSimpleNotify (infoPtr, NM_KILLFOCUS);
1290         infoPtr->haveFocus = 0;
1291         DATETIME_SetSelectedField (infoPtr, -1);
1292     }
1293
1294     InvalidateRect (infoPtr->hwndSelf, NULL, TRUE);
1295
1296     return 0;
1297 }
1298
1299
1300 static LRESULT
1301 DATETIME_NCCreate (HWND hwnd, const CREATESTRUCTW *lpcs)
1302 {
1303     DWORD dwExStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
1304     /* force control to have client edge */
1305     dwExStyle |= WS_EX_CLIENTEDGE;
1306     SetWindowLongW(hwnd, GWL_EXSTYLE, dwExStyle);
1307
1308     return 1;
1309 }
1310
1311 static LRESULT DATETIME_NCPaint (HWND hwnd, HRGN region)
1312 {
1313     INT cxEdge, cyEdge;
1314     HRGN clipRgn;
1315     HTHEME theme;
1316     LONG exStyle;
1317     RECT r;
1318     HDC dc;
1319
1320     theme = OpenThemeDataForDpi(NULL, WC_EDITW, GetDpiForWindow(hwnd));
1321     if (!theme)
1322         return DefWindowProcW(hwnd, WM_NCPAINT, (WPARAM)region, 0);
1323
1324     exStyle = GetWindowLongW(hwnd, GWL_EXSTYLE);
1325     if (!(exStyle & WS_EX_CLIENTEDGE))
1326     {
1327         CloseThemeData(theme);
1328         return DefWindowProcW(hwnd, WM_NCPAINT, (WPARAM)region, 0);
1329     }
1330
1331     cxEdge = GetSystemMetrics(SM_CXEDGE);
1332     cyEdge = GetSystemMetrics(SM_CYEDGE);
1333     GetWindowRect(hwnd, &r);
1334
1335     /* New clipping region passed to default proc to exclude border */
1336     clipRgn = CreateRectRgn(r.left + cxEdge, r.top + cyEdge, r.right - cxEdge, r.bottom - cyEdge);
1337     if (region != (HRGN)1)
1338         CombineRgn(clipRgn, clipRgn, region, RGN_AND);
1339     OffsetRect(&r, -r.left, -r.top);
1340
1341     dc = GetDCEx(hwnd, region, DCX_WINDOW | DCX_INTERSECTRGN);
1342     if (IsThemeBackgroundPartiallyTransparent(theme, 0, 0))
1343         DrawThemeParentBackground(hwnd, dc, &r);
1344     DrawThemeBackground(theme, dc, 0, 0, &r, 0);
1345     ReleaseDC(hwnd, dc);
1346     CloseThemeData(theme);
1347
1348     /* Call default proc to get the scrollbars etc. also painted */
1349     DefWindowProcW(hwnd, WM_NCPAINT, (WPARAM)clipRgn, 0);
1350     DeleteObject(clipRgn);
1351     return 0;
1352 }
1353
1354 static LRESULT DATETIME_MouseMove (DATETIME_INFO *infoPtr, LONG x, LONG y)
1355 {
1356     TRACKMOUSEEVENT event;
1357     POINT point;
1358     BOOL hot;
1359
1360     point.x = x;
1361     point.y = y;
1362     hot = PtInRect(&infoPtr->calbutton, point);
1363     if (hot != infoPtr->bCalHot)
1364     {
1365         infoPtr->bCalHot = hot;
1366         RedrawWindow(infoPtr->hwndSelf, &infoPtr->calbutton, 0, RDW_INVALIDATE | RDW_UPDATENOW);
1367     }
1368
1369     if (!hot)
1370         return 0;
1371
1372     event.cbSize = sizeof(TRACKMOUSEEVENT);
1373     event.dwFlags = TME_QUERY;
1374     if (!TrackMouseEvent(&event) || event.hwndTrack != infoPtr->hwndSelf || !(event.dwFlags & TME_LEAVE))
1375     {
1376         event.hwndTrack = infoPtr->hwndSelf;
1377         event.dwFlags = TME_LEAVE;
1378         TrackMouseEvent(&event);
1379     }
1380
1381     return 0;
1382 }
1383
1384 static LRESULT DATETIME_MouseLeave (DATETIME_INFO *infoPtr)
1385 {
1386     infoPtr->bCalHot = FALSE;
1387     RedrawWindow(infoPtr->hwndSelf, &infoPtr->calbutton, 0, RDW_INVALIDATE | RDW_UPDATENOW);
1388     return 0;
1389 }
1390
1391 static LRESULT
1392 DATETIME_SetFocus (DATETIME_INFO *infoPtr, HWND lostFocus)
1393 {
1394     TRACE("got focus from %p\n", lostFocus);
1395
1396     /* if monthcal is open and it loses focus, close monthcal */
1397     if (infoPtr->hMonthCal && (lostFocus == infoPtr->hMonthCal) &&
1398         IsWindowVisible(infoPtr->hMonthCal))
1399     {
1400         ShowWindow(infoPtr->hMonthCal, SW_HIDE);
1401         DATETIME_SendSimpleNotify(infoPtr, DTN_CLOSEUP);
1402         /* note: this get triggered even if monthcal loses focus to a dropdown
1403          * box click, which occurs without an intermediate WM_PAINT call
1404          */
1405         infoPtr->bDropdownEnabled = FALSE;
1406         return 0;
1407     }
1408
1409     if (infoPtr->haveFocus == 0) {
1410         DATETIME_SendSimpleNotify (infoPtr, NM_SETFOCUS);
1411         infoPtr->haveFocus = DTHT_GOTFOCUS;
1412     }
1413
1414     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1415
1416     return 0;
1417 }
1418
1419
1420 static BOOL
1421 DATETIME_SendDateTimeChangeNotify (const DATETIME_INFO *infoPtr)
1422 {
1423     NMDATETIMECHANGE dtdtc;
1424
1425     dtdtc.nmhdr.hwndFrom = infoPtr->hwndSelf;
1426     dtdtc.nmhdr.idFrom   = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
1427     dtdtc.nmhdr.code     = DTN_DATETIMECHANGE;
1428
1429     dtdtc.dwFlags = infoPtr->dateValid ? GDT_VALID : GDT_NONE;
1430
1431     dtdtc.st = infoPtr->date;
1432     return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
1433                                 dtdtc.nmhdr.idFrom, (LPARAM)&dtdtc);
1434 }
1435
1436
1437 static BOOL
1438 DATETIME_SendSimpleNotify (const DATETIME_INFO *infoPtr, UINT code)
1439 {
1440     NMHDR nmhdr;
1441
1442     TRACE("%x\n", code);
1443     nmhdr.hwndFrom = infoPtr->hwndSelf;
1444     nmhdr.idFrom   = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
1445     nmhdr.code     = code;
1446
1447     return (BOOL) SendMessageW (infoPtr->hwndNotify, WM_NOTIFY,
1448                                 nmhdr.idFrom, (LPARAM)&nmhdr);
1449 }
1450
1451 static LRESULT
1452 DATETIME_Size (DATETIME_INFO *infoPtr, INT width, INT height)
1453 {
1454     /* set size */
1455     infoPtr->rcClient.bottom = height;
1456     infoPtr->rcClient.right = width;
1457
1458     TRACE("Height %ld, Width %ld\n", infoPtr->rcClient.bottom, infoPtr->rcClient.right);
1459
1460     infoPtr->rcDraw = infoPtr->rcClient;
1461
1462     if (infoPtr->dwStyle & DTS_UPDOWN) {
1463         SetWindowPos(infoPtr->hUpdown, NULL,
1464             infoPtr->rcClient.right-14, 0,
1465             15, infoPtr->rcClient.bottom - infoPtr->rcClient.top,
1466             SWP_NOACTIVATE | SWP_NOZORDER);
1467     }
1468     else {
1469         /* set the size of the button that drops the calendar down */
1470         /* FIXME: account for style that allows button on left side */
1471         infoPtr->calbutton.top   = infoPtr->rcDraw.top;
1472         infoPtr->calbutton.bottom= infoPtr->rcDraw.bottom;
1473         infoPtr->calbutton.left  = infoPtr->rcDraw.right-15;
1474         infoPtr->calbutton.right = infoPtr->rcDraw.right;
1475     }
1476
1477     /* set enable/disable button size for show none style being enabled */
1478     /* FIXME: these dimensions are completely incorrect */
1479     infoPtr->checkbox.top = infoPtr->rcDraw.top;
1480     infoPtr->checkbox.bottom = infoPtr->rcDraw.bottom;
1481     infoPtr->checkbox.left = infoPtr->rcDraw.left;
1482     infoPtr->checkbox.right = infoPtr->rcDraw.left + 10;
1483
1484     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1485
1486     return 0;
1487 }
1488
1489 static LRESULT
1490 DATETIME_StyleChanging(DATETIME_INFO *infoPtr, WPARAM wStyleType, STYLESTRUCT *lpss)
1491 {
1492     TRACE("styletype %Ix, styleOld %#lx, styleNew %#lx\n", wStyleType, lpss->styleOld, lpss->styleNew);
1493
1494     /* block DTS_SHOWNONE change */
1495     if ((lpss->styleNew ^ lpss->styleOld) & DTS_SHOWNONE)
1496     {
1497         if (lpss->styleOld & DTS_SHOWNONE)
1498             lpss->styleNew |= DTS_SHOWNONE;
1499         else
1500             lpss->styleNew &= ~DTS_SHOWNONE;
1501     }
1502
1503     return 0;
1504 }
1505
1506 static LRESULT
1507 DATETIME_StyleChanged(DATETIME_INFO *infoPtr, WPARAM wStyleType, const STYLESTRUCT *lpss)
1508 {
1509     TRACE("styletype %Ix, styleOld %#lx, styleNew %#lx\n", wStyleType, lpss->styleOld, lpss->styleNew);
1510
1511     if (wStyleType != GWL_STYLE) return 0;
1512
1513     infoPtr->dwStyle = lpss->styleNew;
1514
1515     if ( !(lpss->styleOld & DTS_SHOWNONE) && (lpss->styleNew & DTS_SHOWNONE) ) {
1516         infoPtr->hwndCheckbut = CreateWindowExW (0, WC_BUTTONW, 0, WS_CHILD | WS_VISIBLE | BS_AUTOCHECKBOX,
1517                                                  2, 2, 13, 13, infoPtr->hwndSelf, 0,
1518                                                 (HINSTANCE)GetWindowLongPtrW (infoPtr->hwndSelf, GWLP_HINSTANCE), 0);
1519         SendMessageW (infoPtr->hwndCheckbut, BM_SETCHECK, infoPtr->dateValid ? 1 : 0, 0);
1520     }
1521     if ( (lpss->styleOld & DTS_SHOWNONE) && !(lpss->styleNew & DTS_SHOWNONE) ) {
1522         DestroyWindow(infoPtr->hwndCheckbut);
1523         infoPtr->hwndCheckbut = 0;
1524     }
1525     if ( !(lpss->styleOld & DTS_UPDOWN) && (lpss->styleNew & DTS_UPDOWN) ) {
1526         infoPtr->hUpdown = CreateUpDownControl (WS_CHILD | WS_BORDER | WS_VISIBLE, 120, 1, 20, 20,
1527                                                 infoPtr->hwndSelf, 1, 0, 0, UD_MAXVAL, UD_MINVAL, 0);
1528     }
1529     if ( (lpss->styleOld & DTS_UPDOWN) && !(lpss->styleNew & DTS_UPDOWN) ) {
1530         DestroyWindow(infoPtr->hUpdown);
1531         infoPtr->hUpdown = 0;
1532     }
1533
1534     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1535     return 0;
1536 }
1537
1538 static LRESULT DATETIME_ThemeChanged (DATETIME_INFO *infoPtr)
1539 {
1540     HTHEME theme;
1541
1542     theme = GetWindowTheme(infoPtr->hwndSelf);
1543     CloseThemeData(theme);
1544     OpenThemeData(infoPtr->hwndSelf, themeClass);
1545     InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1546     return 0;
1547 }
1548
1549 static BOOL DATETIME_GetIdealSize(DATETIME_INFO *infoPtr, SIZE *size)
1550 {
1551     SIZE field_size;
1552     RECT rect;
1553     WCHAR txt[80];
1554     HDC hdc;
1555     HFONT oldFont;
1556     int i;
1557
1558     size->cx = size->cy = 0;
1559
1560     hdc = GetDC(infoPtr->hwndSelf);
1561     oldFont = SelectObject(hdc, infoPtr->hFont);
1562
1563     /* Get text font height */
1564     DATETIME_ReturnTxt(infoPtr, 0, txt, ARRAY_SIZE(txt));
1565     GetTextExtentPoint32W(hdc, txt, lstrlenW(txt), &field_size);
1566     size->cy = field_size.cy;
1567
1568     /* Get text font width */
1569     for (i = 0; i < infoPtr->nrFields; i++)
1570     {
1571         size->cx += DATETIME_GetFieldWidth(infoPtr, hdc, i);
1572     }
1573
1574     SelectObject(hdc, oldFont);
1575     ReleaseDC(infoPtr->hwndSelf, hdc);
1576
1577     if (infoPtr->dwStyle & DTS_UPDOWN)
1578     {
1579         GetWindowRect(infoPtr->hUpdown, &rect);
1580         size->cx += rect.right - rect.left;
1581     }
1582     else
1583     {
1584         size->cx += infoPtr->calbutton.right - infoPtr->calbutton.left;
1585     }
1586
1587     if (infoPtr->dwStyle & DTS_SHOWNONE)
1588     {
1589         size->cx += infoPtr->checkbox.right - infoPtr->checkbox.left;
1590     }
1591
1592     /* Add space between controls for them not to get too close */
1593     size->cx += 12;
1594     size->cy += 4;
1595
1596     TRACE("cx %ld, cy %ld\n", size->cx, size->cy);
1597     return TRUE;
1598 }
1599
1600 static LRESULT
1601 DATETIME_SetFont (DATETIME_INFO *infoPtr, HFONT font, BOOL repaint)
1602 {
1603     infoPtr->hFont = font;
1604     if (repaint) InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
1605     return 0;
1606 }
1607
1608
1609 static LRESULT
1610 DATETIME_Create (HWND hwnd, const CREATESTRUCTW *lpcs)
1611 {
1612     DATETIME_INFO *infoPtr = Alloc (sizeof(DATETIME_INFO));
1613     STYLESTRUCT ss = { 0, lpcs->style };
1614
1615     if (!infoPtr) return -1;
1616
1617     infoPtr->hwndSelf = hwnd;
1618     infoPtr->dwStyle = lpcs->style;
1619
1620     infoPtr->nrFieldsAllocated = 32;
1621     infoPtr->fieldspec = Alloc (infoPtr->nrFieldsAllocated * sizeof(int));
1622     infoPtr->fieldRect = Alloc (infoPtr->nrFieldsAllocated * sizeof(RECT));
1623     infoPtr->buflen = Alloc (infoPtr->nrFieldsAllocated * sizeof(int));
1624     infoPtr->hwndNotify = lpcs->hwndParent;
1625     infoPtr->select = -1; /* initially, nothing is selected */
1626     infoPtr->bDropdownEnabled = TRUE;
1627     infoPtr->bCalHot = FALSE;
1628
1629     DATETIME_StyleChanged(infoPtr, GWL_STYLE, &ss);
1630     DATETIME_SetFormatW (infoPtr, 0);
1631
1632     /* create the monthcal control */
1633     infoPtr->hMonthCal = CreateWindowExW (0, MONTHCAL_CLASSW, 0, WS_BORDER | WS_POPUP | WS_CLIPSIBLINGS,
1634                                           0, 0, 0, 0, infoPtr->hwndSelf, 0, 0, 0);
1635
1636     /* initialize info structure */
1637     GetLocalTime (&infoPtr->date);
1638     infoPtr->dateValid = TRUE;
1639     infoPtr->hFont = GetStockObject(DEFAULT_GUI_FONT);
1640
1641     SetWindowLongPtrW (hwnd, 0, (DWORD_PTR)infoPtr);
1642     OpenThemeData(hwnd, themeClass);
1643
1644     return 0;
1645 }
1646
1647
1648
1649 static LRESULT
1650 DATETIME_Destroy (DATETIME_INFO *infoPtr)
1651 {
1652     HTHEME theme;
1653
1654     theme = GetWindowTheme(infoPtr->hwndSelf);
1655     CloseThemeData(theme);
1656
1657     if (infoPtr->hwndCheckbut)
1658         DestroyWindow(infoPtr->hwndCheckbut);
1659     if (infoPtr->hUpdown)
1660         DestroyWindow(infoPtr->hUpdown);
1661     if (infoPtr->hMonthCal)
1662         DestroyWindow(infoPtr->hMonthCal);
1663     SetWindowLongPtrW( infoPtr->hwndSelf, 0, 0 ); /* clear infoPtr */
1664     Free (infoPtr->buflen);
1665     Free (infoPtr->fieldRect);
1666     Free (infoPtr->fieldspec);
1667     Free (infoPtr);
1668     return 0;
1669 }
1670
1671
1672 static INT
1673 DATETIME_GetText (const DATETIME_INFO *infoPtr, INT count, LPWSTR dst)
1674 {
1675     WCHAR buf[80];
1676     int i;
1677
1678     if (!dst || (count <= 0)) return 0;
1679
1680     dst[0] = 0;
1681     for (i = 0; i < infoPtr->nrFields; i++)
1682     {
1683         DATETIME_ReturnTxt(infoPtr, i, buf, ARRAY_SIZE(buf));
1684         if ((lstrlenW(dst) + lstrlenW(buf)) < count)
1685             lstrcatW(dst, buf);
1686         else break;
1687     }
1688     return lstrlenW(dst);
1689 }
1690
1691 static int DATETIME_GetTextLength(const DATETIME_INFO *info)
1692 {
1693     int i, length = 0;
1694     WCHAR buffer[80];
1695
1696     TRACE("%p.\n", info);
1697
1698     for (i = 0; i < info->nrFields; i++)
1699     {
1700         DATETIME_ReturnTxt(info, i, buffer, ARRAY_SIZE(buffer));
1701         length += lstrlenW(buffer);
1702     }
1703     return length;
1704 }
1705
1706 static LRESULT WINAPI
1707 DATETIME_WindowProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1708 {
1709     DATETIME_INFO *infoPtr = ((DATETIME_INFO *)GetWindowLongPtrW (hwnd, 0));
1710
1711     TRACE("%x, %Ix, %Ix\n", uMsg, wParam, lParam);
1712
1713     if (!infoPtr && (uMsg != WM_CREATE) && (uMsg != WM_NCCREATE))
1714         return DefWindowProcW( hwnd, uMsg, wParam, lParam );
1715
1716     switch (uMsg) {
1717
1718     case DTM_GETSYSTEMTIME:
1719         return DATETIME_GetSystemTime (infoPtr, (SYSTEMTIME *) lParam);
1720
1721     case DTM_SETSYSTEMTIME:
1722         return DATETIME_SetSystemTime (infoPtr, wParam, (SYSTEMTIME *) lParam);
1723
1724     case DTM_GETRANGE:
1725         return SendMessageW (infoPtr->hMonthCal, MCM_GETRANGE, wParam, lParam);
1726
1727     case DTM_SETRANGE:
1728         return SendMessageW (infoPtr->hMonthCal, MCM_SETRANGE, wParam, lParam);
1729
1730     case DTM_SETFORMATA:
1731         return DATETIME_SetFormatA (infoPtr, (LPCSTR)lParam);
1732
1733     case DTM_SETFORMATW:
1734         return DATETIME_SetFormatW (infoPtr, (LPCWSTR)lParam);
1735
1736     case DTM_GETMONTHCAL:
1737         return (LRESULT)infoPtr->hMonthCal;
1738
1739     case DTM_SETMCCOLOR:
1740         return SendMessageW (infoPtr->hMonthCal, MCM_SETCOLOR, wParam, lParam);
1741
1742     case DTM_GETMCCOLOR:
1743         return SendMessageW (infoPtr->hMonthCal, MCM_GETCOLOR, wParam, 0);
1744
1745     case DTM_SETMCFONT:
1746         return SendMessageW (infoPtr->hMonthCal, WM_SETFONT, wParam, lParam);
1747
1748     case DTM_GETMCFONT:
1749         return SendMessageW (infoPtr->hMonthCal, WM_GETFONT, wParam, lParam);
1750
1751     case DTM_GETIDEALSIZE:
1752         return DATETIME_GetIdealSize(infoPtr, (SIZE *)lParam);
1753
1754     case WM_NOTIFY:
1755         return DATETIME_Notify (infoPtr, (LPNMHDR)lParam);
1756
1757     case WM_ENABLE:
1758         return DATETIME_Enable (infoPtr, (BOOL)wParam);
1759
1760     case WM_ERASEBKGND:
1761         return DATETIME_EraseBackground (infoPtr, (HDC)wParam);
1762
1763     case WM_GETDLGCODE:
1764         return DLGC_WANTARROWS | DLGC_WANTCHARS;
1765
1766     case WM_PRINTCLIENT:
1767     case WM_PAINT:
1768         return DATETIME_Paint (infoPtr, (HDC)wParam);
1769
1770     case WM_KEYDOWN:
1771         return DATETIME_KeyDown (infoPtr, wParam);
1772
1773     case WM_CHAR:
1774         return DATETIME_Char (infoPtr, wParam);
1775
1776     case WM_KILLFOCUS:
1777         return DATETIME_KillFocus (infoPtr, (HWND)wParam);
1778
1779     case WM_NCCREATE:
1780         return DATETIME_NCCreate (hwnd, (LPCREATESTRUCTW)lParam);
1781
1782     case WM_NCPAINT:
1783         return DATETIME_NCPaint(hwnd, (HRGN)wParam);
1784
1785     case WM_MOUSEMOVE:
1786         return DATETIME_MouseMove(infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
1787
1788     case WM_MOUSELEAVE:
1789         return DATETIME_MouseLeave(infoPtr);
1790
1791     case WM_SETFOCUS:
1792         return DATETIME_SetFocus (infoPtr, (HWND)wParam);
1793
1794     case WM_SIZE:
1795         return DATETIME_Size (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
1796
1797     case WM_LBUTTONDOWN:
1798         return DATETIME_LButtonDown (infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
1799
1800     case WM_LBUTTONUP:
1801         return DATETIME_LButtonUp (infoPtr);
1802
1803     case WM_VSCROLL:
1804         return DATETIME_VScroll (infoPtr, (WORD)wParam);
1805
1806     case WM_CREATE:
1807         return DATETIME_Create (hwnd, (LPCREATESTRUCTW)lParam);
1808
1809     case WM_DESTROY:
1810         return DATETIME_Destroy (infoPtr);
1811
1812     case WM_COMMAND:
1813         return DATETIME_Command (infoPtr, wParam, lParam);
1814
1815     case WM_STYLECHANGING:
1816         return DATETIME_StyleChanging(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
1817
1818     case WM_STYLECHANGED:
1819         return DATETIME_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
1820
1821     case WM_THEMECHANGED:
1822         return DATETIME_ThemeChanged(infoPtr);
1823
1824     case WM_SETFONT:
1825         return DATETIME_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
1826
1827     case WM_GETFONT:
1828         return (LRESULT) infoPtr->hFont;
1829
1830     case WM_GETTEXT:
1831         return (LRESULT) DATETIME_GetText(infoPtr, wParam, (LPWSTR)lParam);
1832
1833     case WM_GETTEXTLENGTH:
1834         return (LRESULT)DATETIME_GetTextLength(infoPtr);
1835
1836     case WM_SETTEXT:
1837         return CB_ERR;
1838
1839     default:
1840         if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
1841             ERR("unknown msg %04x, wp %Ix, lp %Ix\n", uMsg, wParam, lParam);
1842         return DefWindowProcW (hwnd, uMsg, wParam, lParam);
1843     }
1844 }
1845
1846
1847 void
1848 DATETIME_Register (void)
1849 {
1850     WNDCLASSW wndClass;
1851
1852     ZeroMemory (&wndClass, sizeof(WNDCLASSW));
1853     wndClass.style         = CS_GLOBALCLASS;
1854     wndClass.lpfnWndProc   = DATETIME_WindowProc;
1855     wndClass.cbClsExtra    = 0;
1856     wndClass.cbWndExtra    = sizeof(DATETIME_INFO *);
1857     wndClass.hCursor       = LoadCursorW (0, (LPCWSTR)IDC_ARROW);
1858     wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
1859     wndClass.lpszClassName = DATETIMEPICK_CLASSW;
1860
1861     RegisterClassW (&wndClass);
1862 }
1863
1864
1865 void
1866 DATETIME_Unregister (void)
1867 {
1868     UnregisterClassW (DATETIMEPICK_CLASSW, NULL);
1869 }