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