git.oblomov.eu Git - wine/blob - dlls/comctl32/monthcal.c

   1 /* Month calendar control
   2
   3  *
   4  * Copyright 1998, 1999 Eric Kohl (ekohl@abo.rhein-zeitung.de)
   5  * Copyright 1999 Alex Priem (alexp@sci.kun.nl)
   6  * Copyright 1999 Chris Morgan <cmorgan@wpi.edu> and
   7  *                James Abbatiello <abbeyj@wpi.edu>
   8  *
   9  * TODO:
  10  *   - Notifications.
  11  *
  12  *
  13  *  FIXME: refresh should ask for rect of required length. (?)
  14  *  FIXME: handle resources better (doesn't work now); also take care
  15            of internationalization.
  16  *  FIXME: keyboard handling.
  17  */
  18
  19 #include <math.h>
  20
  21 #include "winbase.h"
  22 #include "winuser.h"
  23 #include "wingdi.h"
  24 #include "win.h"
  25 #include "winnls.h"
  26 #include "commctrl.h"
  27 #include "comctl32.h"
  28 #include "monthcal.h"
  29 #include "debugtools.h"
  30
  31 DEFAULT_DEBUG_CHANNEL(monthcal)
  32
  33 /* take #days/month from ole/parsedt.c;
  34  * we want full month-names, and abbreviated weekdays, so these are
  35  * defined here */
  36
  37 extern int mdays[];
  38
  39 char *monthtxt[] = {"January", "February", "March", "April", "May",
  40                       "June", "July", "August", "September", "October",
  41                       "November", "December"};
  42 char *daytxt[] = {"Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  43 int DayOfWeekTable[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
  44
  45
  46 #define MONTHCAL_GetInfoPtr(hwnd) ((MONTHCAL_INFO *)GetWindowLongA(hwnd, 0))
  47
  48 /* helper functions  */
  49
  50 /* returns the number of days in any given month */
  51 /* january is 1, december is 12 */
  52 static int MONTHCAL_MonthLength(int month, int year)
  53 {
  54   /* if we have a leap year add 1 day to February */
  55   /* a leap year is a year either divisible by 400 */
  56   /* or divisible by 4 and not by 100 */
  57   if(month == 2) { /* February */
  58     return mdays[month - 1] + ((year%400 == 0) ? 1 : ((year%100 != 0) &&
  59      (year%4 == 0)) ? 1 : 0);
  60   }
  61   else {
  62     return mdays[month - 1];
  63   }
  64 }
  65
  66
  67 /* make sure that time is valid */
  68 static int MONTHCAL_ValidateTime(SYSTEMTIME time)
  69 {
  70   if(time.wMonth > 12) return FALSE;
  71   if(time.wDayOfWeek > 6) return FALSE;
  72   if(time.wDay > MONTHCAL_MonthLength(time.wMonth, time.wYear))
  73           return FALSE;
  74   if(time.wHour > 23) return FALSE;
  75   if(time.wMinute > 59) return FALSE;
  76   if(time.wSecond > 59) return FALSE;
  77   if(time.wMilliseconds > 999) return FALSE;
  78
  79   return TRUE;
  80 }
  81
  82
  83 void MONTHCAL_CopyTime(const SYSTEMTIME *from, SYSTEMTIME *to)
  84 {
  85   to->wYear = from->wYear;
  86   to->wMonth = from->wMonth;
  87   to->wDayOfWeek = from->wDayOfWeek;
  88   to->wDay = from->wDay;
  89   to->wHour = from->wHour;
  90   to->wMinute = from->wMinute;
  91   to->wSecond = from->wSecond;
  92   to->wMilliseconds = from->wMilliseconds;
  93 }
  94
  95
  96 /* Note:Depending on DST, this may be offset by a day.
  97    Need to find out if we're on a DST place & adjust the clock accordingly.
  98    Above function assumes we have a valid data.
  99    Valid for year>1752;  1 <= d <= 31, 1 <= m <= 12.
 100    0 = Monday.
 101 */
 102
 103 /* returns the day in the week(0 == sunday, 6 == saturday) */
 104 /* day(1 == 1st, 2 == 2nd... etc), year is the  year value */
 105 int MONTHCAL_CalculateDayOfWeek(DWORD day, DWORD month, DWORD year)
 106 {
 107   year-=(month < 3);
 108
 109   return((year + year/4 - year/100 + year/400 +
 110          DayOfWeekTable[month-1] + day - 1 ) % 7);
 111 }
 112
 113
 114 static int MONTHCAL_CalcDayFromPos(MONTHCAL_INFO *infoPtr, int x, int y)
 115 {
 116   int daypos, weekpos, retval, firstDay;
 117
 118   /* if the point is outside the x bounds of the window put
 119   it at the boundry */
 120   if(x > (infoPtr->width_increment * 7.0)) {
 121     x = infoPtr->rcClient.right - infoPtr->rcClient.left - infoPtr->left_offset;
 122   }
 123
 124   daypos = (x -(infoPtr->prevmonth.left + infoPtr->left_offset)) / infoPtr->width_increment;
 125   weekpos = (y - infoPtr->days.bottom - infoPtr->rcClient.top) / infoPtr->height_increment;
 126
 127   firstDay = MONTHCAL_CalculateDayOfWeek(1, infoPtr->currentMonth, infoPtr->currentYear);
 128   retval = daypos + (7 * weekpos) - firstDay;
 129   TRACE("%d %d %d\n", daypos, weekpos, retval);
 130   return retval;
 131 }
 132
 133 /* day is the day of the month, 1 == 1st day of the month */
 134 /* sets x and y to be the position of the day */
 135 /* x == day, y == week where(0,0) == sunday, 1st week */
 136 static void MONTHCAL_CalcDayXY(MONTHCAL_INFO *infoPtr, int day, int month,
 137                                  int *x, int *y)
 138 {
 139   int firstDay, prevMonth;
 140
 141   firstDay = MONTHCAL_CalculateDayOfWeek(1, infoPtr->currentMonth, infoPtr->currentYear);
 142
 143   if(month==infoPtr->currentMonth) {
 144     *x = (day + firstDay) % 7;
 145     *y = (day + firstDay - *x) / 7;
 146     return;
 147   }
 148   if(month < infoPtr->currentMonth) {
 149     prevMonth = month - 1;
 150     if(prevMonth==0)
 151        prevMonth = 12;
 152
 153     *x = (MONTHCAL_MonthLength(prevMonth, infoPtr->currentYear) - firstDay) % 7;
 154     *y = 0;
 155     return;
 156   }
 157
 158   *y = MONTHCAL_MonthLength(month, infoPtr->currentYear - 1) / 7;
 159   *x = (day + firstDay + MONTHCAL_MonthLength(month,
 160        infoPtr->currentYear)) % 7;
 161 }
 162
 163
 164 /* x: column(day), y: row(week) */
 165 static void MONTHCAL_CalcDayRect(MONTHCAL_INFO *infoPtr, RECT *r, int x, int y)
 166 {
 167   r->left = infoPtr->prevmonth.left + x * infoPtr->width_increment + infoPtr->left_offset;
 168   r->right = r->left + infoPtr->width_increment;
 169   r->top = infoPtr->height_increment * y  + infoPtr->days.bottom + infoPtr->top_offset;
 170   r->bottom = r->top + infoPtr->textHeight;
 171 }
 172
 173
 174 /* sets the RECT struct r to the rectangle around the day and month */
 175 /* day is the day value of the month(1 == 1st), month is the month */
 176 /* value(january == 1, december == 12) */
 177 static inline void MONTHCAL_CalcPosFromDay(MONTHCAL_INFO *infoPtr,
 178                                             int day, int month, RECT *r)
 179 {
 180   int x, y;
 181
 182   MONTHCAL_CalcDayXY(infoPtr, day, month, &x, &y);
 183   MONTHCAL_CalcDayRect(infoPtr, r, x, y);
 184 }
 185
 186
 187 /* day is the day in the month(1 == 1st of the month) */
 188 /* month is the month value(1 == january, 12 == december) */
 189 static void MONTHCAL_CircleDay(HDC hdc, MONTHCAL_INFO *infoPtr, int day,
 190 int month)
 191 {
 192   HPEN hRedPen = CreatePen(PS_SOLID, 2, RGB(255, 0, 0));
 193   HPEN hOldPen2 = SelectObject(hdc, hRedPen);
 194   POINT points[13];
 195   int x, y;
 196   RECT day_rect;
 197
 198  /* use prevmonth to calculate position because it contains the extra width
 199   * from MCS_WEEKNUMBERS
 200   */
 201
 202   MONTHCAL_CalcPosFromDay(infoPtr, day, month, &day_rect);
 203
 204   x = day_rect.left;
 205   y = day_rect.top;
 206
 207   points[0].x = x;
 208   points[0].y = y - 1;
 209   points[1].x = x + 0.8 * infoPtr->width_increment;
 210   points[1].y = y - 1;
 211   points[2].x = x + 0.9 * infoPtr->width_increment;
 212   points[2].y = y;
 213   points[3].x = x + infoPtr->width_increment;
 214   points[3].y = y + 0.5 * infoPtr->textHeight;
 215
 216   points[4].x = x + infoPtr->width_increment;
 217   points[4].y = y + 0.9 * infoPtr->textHeight;
 218   points[5].x = x + 0.6 * infoPtr->width_increment;
 219   points[5].y = y + 0.9 * infoPtr->textHeight;
 220   points[6].x = x + 0.5 * infoPtr->width_increment;
 221   points[6].y = y + 0.9 * infoPtr->textHeight; /* bring the bottom up just
 222                                 a hair to fit inside the day rectangle */
 223
 224   points[7].x = x + 0.2 * infoPtr->width_increment;
 225   points[7].y = y + 0.8 * infoPtr->textHeight;
 226   points[8].x = x + 0.1 * infoPtr->width_increment;
 227   points[8].y = y + 0.8 * infoPtr->textHeight;
 228   points[9].x = x;
 229   points[9].y = y + 0.5 * infoPtr->textHeight;
 230
 231   points[10].x = x + 0.1 * infoPtr->width_increment;
 232   points[10].y = y + 0.2 * infoPtr->textHeight;
 233   points[11].x = x + 0.2 * infoPtr->width_increment;
 234   points[11].y = y + 0.3 * infoPtr->textHeight;
 235   points[12].x = x + 0.5 * infoPtr->width_increment;
 236   points[12].y = y + 0.3 * infoPtr->textHeight;
 237
 238   PolyBezier(hdc, points, 13);
 239   DeleteObject(hRedPen);
 240   SelectObject(hdc, hOldPen2);
 241 }
 242
 243
 244 static void MONTHCAL_DrawDay(HDC hdc, MONTHCAL_INFO *infoPtr,
 245                                                         int day, int month, int x, int y, int bold)
 246 {
 247   char buf[10];
 248   RECT r;
 249   static int haveBoldFont, haveSelectedDay = FALSE;
 250   HBRUSH hbr;
 251   HPEN hNewPen, hOldPen = 0;
 252   COLORREF oldCol = 0;
 253   COLORREF oldBk = 0;
 254
 255   sprintf(buf, "%d", day);
 256
 257 /* No need to check styles: when selection is not valid, it is set to zero.
 258  * 1<day<31, so evertyhing's OK.
 259  */
 260
 261   MONTHCAL_CalcDayRect(infoPtr, &r, x, y);
 262
 263   if((day>=infoPtr->minSel.wDay) && (day<=infoPtr->maxSel.wDay)
 264        && (month==infoPtr->currentMonth)) {
 265     HRGN hrgn;
 266     RECT r2;
 267
 268     TRACE("%d %d %d\n",day, infoPtr->minSel.wDay, infoPtr->maxSel.wDay);
 269     TRACE("%d %d %d %d\n", r.left, r.top, r.right, r.bottom);
 270     oldCol = SetTextColor(hdc, infoPtr->monthbk);
 271     oldBk = SetBkColor(hdc, infoPtr->trailingtxt);
 272     hbr = GetSysColorBrush(COLOR_GRAYTEXT);
 273     hrgn = CreateEllipticRgn(r.left, r.top, r.right, r.bottom);
 274     FillRgn(hdc, hrgn, hbr);
 275
 276     /* FIXME: this may need to be changed now b/c of the other
 277         drawing changes 11/3/99 CMM */
 278     r2.left   = r.left - 0.25 * infoPtr->textWidth;
 279     r2.top    = r.top;
 280     r2.right  = r.left + 0.5 * infoPtr->textWidth;
 281     r2.bottom = r.bottom;
 282     if(haveSelectedDay) FillRect(hdc, &r2, hbr);
 283       haveSelectedDay = TRUE;
 284   } else {
 285     haveSelectedDay = FALSE;
 286   }
 287
 288   /* need to add some code for multiple selections */
 289
 290   if((bold) &&(!haveBoldFont)) {
 291     SelectObject(hdc, infoPtr->hBoldFont);
 292     haveBoldFont = TRUE;
 293   }
 294   if((!bold) &&(haveBoldFont)) {
 295     SelectObject(hdc, infoPtr->hFont);
 296     haveBoldFont = FALSE;
 297   }
 298
 299   if(haveSelectedDay) {
 300     SetTextColor(hdc, oldCol);
 301     SetBkColor(hdc, oldBk);
 302   }
 303
 304   DrawTextA(hdc, buf, lstrlenA(buf), &r,
 305                          DT_CENTER | DT_VCENTER | DT_SINGLELINE );
 306
 307   /* draw a rectangle around the currently selected days text */
 308   if((day==infoPtr->curSelDay) && (month==infoPtr->currentMonth)) {
 309     hNewPen = CreatePen(PS_DOT, 0, GetSysColor(COLOR_WINDOWTEXT) );
 310     hbr = GetSysColorBrush(COLOR_WINDOWTEXT);
 311     FrameRect(hdc, &r, hbr);
 312     SelectObject(hdc, hOldPen);
 313   }
 314 }
 315
 316
 317 /* CHECKME: For `todays date', do we need to check the locale?*/
 318 static void MONTHCAL_Refresh(HWND hwnd, HDC hdc)
 319 {
 320   MONTHCAL_INFO *infoPtr=MONTHCAL_GetInfoPtr(hwnd);
 321   RECT *rcClient=&infoPtr->rcClient;
 322   RECT *rcDraw=&infoPtr->rcDraw;
 323   RECT *title=&infoPtr->title;
 324   RECT *prev=&infoPtr->titlebtnprev;
 325   RECT *next=&infoPtr->titlebtnnext;
 326   RECT *titlemonth=&infoPtr->titlemonth;
 327   RECT *titleyear=&infoPtr->titleyear;
 328   RECT *prevmonth=&infoPtr->prevmonth;
 329   RECT *nextmonth=&infoPtr->nextmonth;
 330   RECT dayrect;
 331   RECT *days=&dayrect;
 332   RECT *weeknums=&infoPtr->weeknums;
 333   RECT *rtoday=&infoPtr->today;
 334   int i, j, m, mask, day, firstDay, weeknum, prevMonth;
 335   int textHeight = infoPtr->textHeight, textWidth = infoPtr->textWidth;
 336   SIZE size;
 337   HBRUSH hbr;
 338   HFONT currentFont;
 339   /* LOGFONTA logFont; */
 340   char buf[20], *thisMonthtxt;
 341   COLORREF oldTextColor, oldBkColor;
 342   DWORD dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
 343   BOOL prssed;
 344
 345   oldTextColor = SetTextColor(hdc, GetSysColor(COLOR_WINDOWTEXT));
 346
 347   /* draw control edge */
 348   hbr =  CreateSolidBrush(RGB(255, 255, 255));
 349   FillRect(hdc, rcClient, hbr);
 350   DrawEdge(hdc, rcClient, EDGE_SUNKEN, BF_RECT);
 351   DeleteObject(hbr);
 352   prssed = FALSE;
 353
 354   /* draw header */
 355   hbr =  CreateSolidBrush(infoPtr->titlebk);
 356   FillRect(hdc, title, hbr);
 357
 358   /* if the previous button is pressed draw it depressed */
 359   if((infoPtr->status & MC_PREVPRESSED))
 360       DrawFrameControl(hdc, prev, DFC_SCROLL,
 361            DFCS_SCROLLLEFT | DFCS_PUSHED |
 362         (dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0));
 363   else /* if the previous button is pressed draw it depressed */
 364     DrawFrameControl(hdc, prev, DFC_SCROLL,
 365            DFCS_SCROLLLEFT |(dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0));
 366
 367   /* if next button is depressed draw it depressed */
 368   if((infoPtr->status & MC_NEXTPRESSED))
 369     DrawFrameControl(hdc, next, DFC_SCROLL,
 370            DFCS_SCROLLRIGHT | DFCS_PUSHED |
 371         (dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0));
 372   else /* if the next button is pressed draw it depressed */
 373     DrawFrameControl(hdc, next, DFC_SCROLL,
 374            DFCS_SCROLLRIGHT |(dwStyle & WS_DISABLED ? DFCS_INACTIVE : 0));
 375
 376   oldBkColor = SetBkColor(hdc, infoPtr->titlebk);
 377   SetTextColor(hdc, infoPtr->titletxt);
 378   currentFont = SelectObject(hdc, infoPtr->hBoldFont);
 379
 380   /* titlemonth->left and right are set in MONTHCAL_UpdateSize */
 381   titlemonth->left   = title->left;
 382   titlemonth->right  = title->right;
 383
 384   thisMonthtxt = monthtxt[infoPtr->currentMonth - 1];
 385   sprintf(buf, "%s %ld", thisMonthtxt, infoPtr->currentYear);
 386   DrawTextA(hdc, buf, strlen(buf), titlemonth,
 387                         DT_CENTER | DT_VCENTER | DT_SINGLELINE);
 388   SelectObject(hdc, infoPtr->hFont);
 389
 390 /* titlemonth left/right contained rect for whole titletxt('June  1999')
 391   * MCM_HitTestInfo wants month & year rects, so prepare these now.
 392   *(no, we can't draw them separately; the whole text is centered)
 393   */
 394   GetTextExtentPoint32A(hdc, buf, lstrlenA(buf), &size);
 395   titlemonth->left = title->right / 2 - size.cx / 2;
 396   titleyear->right = title->right / 2 + size.cx / 2;
 397   GetTextExtentPoint32A(hdc, thisMonthtxt, lstrlenA(thisMonthtxt), &size);
 398   titlemonth->right = titlemonth->left + size.cx;
 399   titleyear->right = titlemonth->right;
 400
 401
 402 /* draw line under day abbreviatons */
 403
 404    if(dwStyle & MCS_WEEKNUMBERS)
 405      MoveToEx(hdc, rcDraw->left + textWidth + 3, title->bottom + textHeight + 2, NULL);
 406    else
 407      MoveToEx(hdc, rcDraw->left + 3, title->bottom + textHeight + 2, NULL);
 408
 409   LineTo(hdc, rcDraw->right - 3, title->bottom + textHeight + 2);
 410
 411 /* draw day abbreviations */
 412
 413   SetBkColor(hdc, infoPtr->monthbk);
 414   SetTextColor(hdc, infoPtr->trailingtxt);
 415
 416   /* copy this rect so we can change the values without changing */
 417   /* the original version */
 418   days->left = infoPtr->days.left;
 419   days->right = infoPtr->days.right;
 420   days->top = infoPtr->days.top;
 421   days->bottom = infoPtr->days.bottom;
 422
 423   i = infoPtr->firstDay;
 424
 425   for(j=0; j<7; j++) {
 426     DrawTextA(hdc, daytxt[i], strlen(daytxt[i]), days,
 427                          DT_CENTER | DT_VCENTER | DT_SINGLELINE );
 428     i = (i + 1) % 7;
 429     days->left+=infoPtr->width_increment;
 430     days->right+=infoPtr->width_increment;
 431   }
 432
 433   days->left = rcDraw->left + j;
 434   if(dwStyle & MCS_WEEKNUMBERS) days->left+=textWidth;
 435   /* FIXME: this may need to be changed now 11/10/99 CMM */
 436   days->right = rcDraw->left + (j+1) * textWidth - 2;
 437
 438 /* draw day numbers; first, the previous month */
 439
 440   firstDay = MONTHCAL_CalculateDayOfWeek(1, infoPtr->currentMonth, infoPtr->currentYear);
 441
 442   prevMonth = infoPtr->currentMonth - 1;
 443   if(prevMonth == 0) /* if currentMonth is january(1) prevMonth is */
 444     prevMonth = 12;    /* december(12) of the previous year */
 445
 446   day = MONTHCAL_MonthLength(prevMonth, infoPtr->currentYear) - firstDay;
 447   mask = 1<<(day-1);
 448
 449   i = 0;
 450   m = 0;
 451   while(day <= MONTHCAL_MonthLength(prevMonth, infoPtr->currentYear)) {
 452     MONTHCAL_DrawDay(hdc, infoPtr, day, prevMonth, i, 0,
 453           infoPtr->monthdayState[m] & mask);
 454     mask<<=1;
 455     day++;
 456     i++;
 457   }
 458
 459   prevmonth->left = 0;
 460   if(dwStyle & MCS_WEEKNUMBERS) prevmonth->left = textWidth;
 461   prevmonth->right  = prevmonth->left + i * textWidth;
 462   prevmonth->top    = days->bottom;
 463   prevmonth->bottom = prevmonth->top + textHeight;
 464
 465 /* draw `current' month  */
 466
 467   day = 1; /* start at the beginning of the current month */
 468
 469   infoPtr->firstDayplace = i;
 470   SetTextColor(hdc, infoPtr->txt);
 471   m++;
 472   mask = 1;
 473
 474   /* draw the first week of the current month */
 475   while(i<7) {
 476     MONTHCAL_DrawDay(hdc, infoPtr, day, infoPtr->currentMonth, i, 0,
 477         infoPtr->monthdayState[m] & mask);
 478
 479     if((infoPtr->currentMonth==infoPtr->todaysDate.wMonth) &&
 480         (day==infoPtr->todaysDate.wDay) &&
 481         (infoPtr->currentYear == infoPtr->todaysDate.wYear)) {
 482       MONTHCAL_CircleDay(hdc, infoPtr, day, infoPtr->currentMonth);
 483     }
 484
 485     mask<<=1;
 486     day++;
 487     i++;
 488   }
 489
 490   j = 1; /* move to the 2nd week of the current month */
 491   i = 0; /* move back to sunday */
 492   while(day <= MONTHCAL_MonthLength(infoPtr->currentMonth, infoPtr->currentYear)) {
 493     MONTHCAL_DrawDay(hdc, infoPtr, day, infoPtr->currentMonth, i, j,
 494           infoPtr->monthdayState[m] & mask);
 495
 496     if((infoPtr->currentMonth==infoPtr->todaysDate.wMonth) &&
 497     (day==infoPtr->todaysDate.wDay) &&
 498     (infoPtr->currentYear == infoPtr->todaysDate.wYear))
 499       MONTHCAL_CircleDay(hdc, infoPtr, day, infoPtr->currentMonth);
 500
 501     mask<<=1;
 502     day++;
 503     i++;
 504     if(i>6) { /* past saturday, goto the next weeks sunday */
 505       i = 0;
 506       j++;
 507     }
 508   }
 509
 510 /*  draw `next' month */
 511
 512 /* note: the nextmonth rect only hints for the `half-week' that needs to be
 513  * drawn to complete the current week. An eventual next week that needs to
 514  * be drawn to complete the month calendar is not taken into account in
 515  * this rect -- HitTest knows about this.*/
 516
 517   nextmonth->left   = prevmonth->left + i * textWidth;
 518   nextmonth->right  = rcDraw->right;
 519   nextmonth->top    = days->bottom + (j+1) * textHeight;
 520   nextmonth->bottom = nextmonth->top + textHeight;
 521
 522   day = 1; /* start at the first day of the next month */
 523   m++;
 524   mask = 1;
 525
 526   SetTextColor(hdc, infoPtr->trailingtxt);
 527   while((i<7) &&(j<6)) {
 528     MONTHCAL_DrawDay(hdc, infoPtr, day, infoPtr->currentMonth + 1, i, j,
 529                 infoPtr->monthdayState[m] & mask);
 530
 531     mask<<=1;
 532     day++;
 533     i++;
 534     if(i==7) { /* past saturday, go to next week's sunday */
 535       i = 0;
 536       j++;
 537     }
 538   }
 539   SetTextColor(hdc, infoPtr->txt);
 540
 541
 542 /* draw `today' date if style allows it, and draw a circle before today's
 543  * date if necessary */
 544
 545   if(!(dwStyle & MCS_NOTODAY))  {
 546     int offset = 0;
 547     if(!(dwStyle & MCS_NOTODAYCIRCLE))  {
 548       MONTHCAL_CircleDay(hdc, infoPtr, day, infoPtr->currentMonth + 1);
 549       offset+=textWidth;
 550     }
 551     MONTHCAL_CalcDayRect(infoPtr, rtoday, offset==textWidth, 6);
 552     sprintf(buf, "Today: %d/%d/%d", infoPtr->todaysDate.wMonth,
 553              infoPtr->todaysDate.wDay, infoPtr->todaysDate.wYear % 100);
 554     rtoday->right = rcDraw->right;
 555     SelectObject(hdc, infoPtr->hBoldFont);
 556     DrawTextA(hdc, buf, lstrlenA(buf), rtoday,
 557                          DT_LEFT | DT_VCENTER | DT_SINGLELINE);
 558     SelectObject(hdc, infoPtr->hFont);
 559   }
 560
 561   if(dwStyle & MCS_WEEKNUMBERS)  {
 562     /* display weeknumbers*/
 563     weeknums->left   = 0;
 564     weeknums->right  = textWidth;
 565     weeknums->top    = days->bottom + 2;
 566     weeknums->bottom = days->bottom + 2 + textHeight;
 567
 568     weeknum = 0;
 569     for(i=0; i<infoPtr->currentMonth-1; i++)
 570       weeknum+=MONTHCAL_MonthLength(i, infoPtr->currentYear);
 571
 572     weeknum/=7;
 573     for(i=0; i<6; i++) {
 574       sprintf(buf, "%d", weeknum + i);
 575       DrawTextA(hdc, buf, lstrlenA(buf), weeknums,
 576                          DT_CENTER | DT_BOTTOM | DT_SINGLELINE );
 577       weeknums->top+=textHeight * 1.25;
 578       weeknums->bottom+=textHeight * 1.25;
 579     }
 580
 581     MoveToEx(hdc, weeknums->right, days->bottom + 5 , NULL);
 582     LineTo(hdc, weeknums->right, weeknums->bottom - 1.25 * textHeight - 5);
 583
 584   }
 585
 586   /* currentFont was font at entering Refresh */
 587
 588   SetBkColor(hdc, oldBkColor);
 589   SelectObject(hdc, currentFont);
 590   SetTextColor(hdc, oldTextColor);
 591 }
 592
 593
 594 static LRESULT
 595 MONTHCAL_GetMinReqRect(HWND hwnd, WPARAM wParam, LPARAM lParam)
 596 {
 597   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 598   LPRECT lpRect = (LPRECT) lParam;
 599   TRACE("%x %lx\n", wParam, lParam);
 600
 601   /* validate parameters */
 602
 603   if((infoPtr==NULL) ||(lpRect == NULL) ) return FALSE;
 604
 605   lpRect->left = infoPtr->rcClient.left;
 606   lpRect->right = infoPtr->rcClient.right;
 607   lpRect->top = infoPtr->rcClient.top;
 608   lpRect->bottom = infoPtr->rcClient.bottom;
 609   return TRUE;
 610 }
 611
 612 static LRESULT
 613 MONTHCAL_GetColor(HWND hwnd, WPARAM wParam, LPARAM lParam)
 614 {
 615   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 616
 617   TRACE("%x %lx\n", wParam, lParam);
 618
 619   switch((int)wParam) {
 620     case MCSC_BACKGROUND:
 621       return infoPtr->bk;
 622     case MCSC_TEXT:
 623       return infoPtr->txt;
 624     case MCSC_TITLEBK:
 625       return infoPtr->titlebk;
 626     case MCSC_TITLETEXT:
 627       return infoPtr->titletxt;
 628     case MCSC_MONTHBK:
 629       return infoPtr->monthbk;
 630     case MCSC_TRAILINGTEXT:
 631       return infoPtr->trailingtxt;
 632   }
 633
 634   return -1;
 635 }
 636
 637 static LRESULT
 638 MONTHCAL_SetColor(HWND hwnd, WPARAM wParam, LPARAM lParam)
 639 {
 640   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 641   int prev = -1;
 642
 643   TRACE("%x %lx\n", wParam, lParam);
 644
 645   switch((int)wParam) {
 646     case MCSC_BACKGROUND:
 647       prev = infoPtr->bk;
 648       infoPtr->bk = (COLORREF)lParam;
 649       break;
 650     case MCSC_TEXT:
 651       prev = infoPtr->txt;
 652       infoPtr->txt = (COLORREF)lParam;
 653       break;
 654     case MCSC_TITLEBK:
 655       prev = infoPtr->titlebk;
 656       infoPtr->titlebk = (COLORREF)lParam;
 657       break;
 658     case MCSC_TITLETEXT:
 659       prev=infoPtr->titletxt;
 660       infoPtr->titletxt = (COLORREF)lParam;
 661       break;
 662     case MCSC_MONTHBK:
 663       prev = infoPtr->monthbk;
 664       infoPtr->monthbk = (COLORREF)lParam;
 665       break;
 666     case MCSC_TRAILINGTEXT:
 667       prev = infoPtr->trailingtxt;
 668       infoPtr->trailingtxt = (COLORREF)lParam;
 669       break;
 670   }
 671
 672   return prev;
 673 }
 674
 675 static LRESULT
 676 MONTHCAL_GetMonthDelta(HWND hwnd, WPARAM wParam, LPARAM lParam)
 677 {
 678   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 679
 680   TRACE("%x %lx\n", wParam, lParam);
 681
 682   if(infoPtr->delta)
 683     return infoPtr->delta;
 684   else
 685     return infoPtr->visible;
 686 }
 687
 688 static LRESULT
 689 MONTHCAL_SetMonthDelta(HWND hwnd, WPARAM wParam, LPARAM lParam)
 690 {
 691   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 692   int prev = infoPtr->delta;
 693
 694   TRACE("%x %lx\n", wParam, lParam);
 695
 696   infoPtr->delta = (int)wParam;
 697   return prev;
 698 }
 699
 700
 701 static LRESULT
 702 MONTHCAL_GetFirstDayOfWeek(HWND hwnd, WPARAM wParam, LPARAM lParam)
 703 {
 704   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 705
 706   return infoPtr->firstDay;
 707 }
 708
 709
 710 /* sets the first day of the week that will appear in the control */
 711 /* 0 == Monday, 6 == Sunday */
 712 /* FIXME: this needs to be implemented properly in MONTHCAL_Refresh() */
 713 /* FIXME: we need more error checking here */
 714 static LRESULT
 715 MONTHCAL_SetFirstDayOfWeek(HWND hwnd, WPARAM wParam, LPARAM lParam)
 716 {
 717   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 718   int prev = infoPtr->firstDay;
 719   char buf[40];
 720   int day;
 721
 722   TRACE("%x %lx\n", wParam, lParam);
 723
 724   if((lParam >= 0) && (lParam < 7)) {
 725     infoPtr->firstDay = (int)lParam;
 726     GetLocaleInfoA(LOCALE_USER_DEFAULT, LOCALE_IFIRSTDAYOFWEEK,
 727                 buf, sizeof(buf));
 728     TRACE("%s %d\n", buf, strlen(buf));
 729     if((sscanf(buf, "%d", &day) == 1) &&(infoPtr->firstDay != day))
 730       infoPtr->firstDay = day;
 731   }
 732   return prev;
 733 }
 734
 735
 736 /* FIXME: fill this in */
 737 static LRESULT
 738 MONTHCAL_GetMonthRange(HWND hwnd, WPARAM wParam, LPARAM lParam)
 739 {
 740   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 741
 742   TRACE("%x %lx\n", wParam, lParam);
 743   FIXME("stub\n");
 744
 745   return infoPtr->monthRange;
 746 }
 747
 748
 749 static LRESULT
 750 MONTHCAL_GetMaxTodayWidth(HWND hwnd)
 751 {
 752   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 753
 754   return(infoPtr->today.right - infoPtr->today.left);
 755 }
 756
 757
 758 /* FIXME: are validated times taken from current date/time or simply
 759  * copied?
 760  * FIXME:    check whether MCM_GETMONTHRANGE shows correct result after
 761  *            adjusting range with MCM_SETRANGE
 762  */
 763
 764 static LRESULT
 765 MONTHCAL_SetRange(HWND hwnd, WPARAM wParam, LPARAM lParam)
 766 {
 767   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 768   SYSTEMTIME lprgSysTimeArray[1];
 769   int prev;
 770
 771   TRACE("%x %lx\n", wParam, lParam);
 772
 773   if(wParam & GDTR_MAX) {
 774     if(MONTHCAL_ValidateTime(lprgSysTimeArray[1])){
 775       MONTHCAL_CopyTime(&lprgSysTimeArray[1], &infoPtr->maxDate);
 776       infoPtr->rangeValid|=GDTR_MAX;
 777     } else  {
 778       GetSystemTime(&infoPtr->todaysDate);
 779       MONTHCAL_CopyTime(&infoPtr->todaysDate, &infoPtr->maxDate);
 780     }
 781   }
 782   if(wParam & GDTR_MIN) {
 783     if(MONTHCAL_ValidateTime(lprgSysTimeArray[0])) {
 784       MONTHCAL_CopyTime(&lprgSysTimeArray[0], &infoPtr->maxDate);
 785       infoPtr->rangeValid|=GDTR_MIN;
 786     } else {
 787       GetSystemTime(&infoPtr->todaysDate);
 788       MONTHCAL_CopyTime(&infoPtr->todaysDate, &infoPtr->maxDate);
 789     }
 790   }
 791
 792   prev = infoPtr->monthRange;
 793   infoPtr->monthRange = infoPtr->maxDate.wMonth - infoPtr->minDate.wMonth;
 794
 795   if(infoPtr->monthRange!=prev) {
 796         COMCTL32_ReAlloc(infoPtr->monthdayState,
 797                 infoPtr->monthRange * sizeof(MONTHDAYSTATE));
 798   }
 799
 800   return 1;
 801 }
 802
 803
 804 /* CHECKME: At the moment, we copy ranges anyway,regardless of
 805  * infoPtr->rangeValid; a invalid range is simply filled with zeros in
 806  * SetRange.  Is this the right behavior?
 807 */
 808
 809 static LRESULT
 810 MONTHCAL_GetRange(HWND hwnd, WPARAM wParam, LPARAM lParam)
 811 {
 812   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 813   SYSTEMTIME *lprgSysTimeArray = (SYSTEMTIME *)lParam;
 814
 815   /* validate parameters */
 816
 817   if((infoPtr==NULL) || (lprgSysTimeArray==NULL)) return FALSE;
 818
 819   MONTHCAL_CopyTime(&infoPtr->maxDate, &lprgSysTimeArray[1]);
 820   MONTHCAL_CopyTime(&infoPtr->minDate, &lprgSysTimeArray[0]);
 821
 822   return infoPtr->rangeValid;
 823 }
 824
 825
 826 static LRESULT
 827 MONTHCAL_SetDayState(HWND hwnd, WPARAM wParam, LPARAM lParam)
 828
 829 {
 830   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 831   int i, iMonths = (int)wParam;
 832   MONTHDAYSTATE *dayStates = (LPMONTHDAYSTATE)lParam;
 833
 834   TRACE("%x %lx\n", wParam, lParam);
 835   if(iMonths!=infoPtr->monthRange) return 0;
 836
 837   for(i=0; i<iMonths; i++)
 838     infoPtr->monthdayState[i] = dayStates[i];
 839   return 1;
 840 }
 841
 842
 843 static LRESULT
 844 MONTHCAL_GetCurSel(HWND hwnd, WPARAM wParam, LPARAM lParam)
 845 {
 846   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 847   SYSTEMTIME *lpSel = (SYSTEMTIME *) lParam;
 848
 849   TRACE("%x %lx\n", wParam, lParam);
 850   if((infoPtr==NULL) ||(lpSel==NULL)) return FALSE;
 851   if(GetWindowLongA(hwnd, GWL_STYLE) & MCS_MULTISELECT) return FALSE;
 852
 853   MONTHCAL_CopyTime(&infoPtr->minSel, lpSel);
 854   return TRUE;
 855 }
 856
 857
 858 /* FIXME: if the specified date is not visible, make it visible */
 859 /* FIXME: redraw? */
 860 static LRESULT
 861 MONTHCAL_SetCurSel(HWND hwnd, WPARAM wParam, LPARAM lParam)
 862 {
 863   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 864   SYSTEMTIME *lpSel = (SYSTEMTIME *)lParam;
 865
 866   TRACE("%x %lx\n", wParam, lParam);
 867   if((infoPtr==NULL) ||(lpSel==NULL)) return FALSE;
 868   if(GetWindowLongA(hwnd, GWL_STYLE) & MCS_MULTISELECT) return FALSE;
 869
 870   TRACE("%d %d\n", lpSel->wMonth, lpSel->wDay);
 871
 872   MONTHCAL_CopyTime(lpSel, &infoPtr->minSel);
 873   MONTHCAL_CopyTime(lpSel, &infoPtr->maxSel);
 874
 875   return TRUE;
 876 }
 877
 878
 879 static LRESULT
 880 MONTHCAL_GetMaxSelCount(HWND hwnd, WPARAM wParam, LPARAM lParam)
 881 {
 882   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 883
 884   TRACE("%x %lx\n", wParam, lParam);
 885   return infoPtr->maxSelCount;
 886 }
 887
 888
 889 static LRESULT
 890 MONTHCAL_SetMaxSelCount(HWND hwnd, WPARAM wParam, LPARAM lParam)
 891 {
 892   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 893
 894   TRACE("%x %lx\n", wParam, lParam);
 895   if(GetWindowLongA(hwnd, GWL_STYLE) & MCS_MULTISELECT)  {
 896     infoPtr->maxSelCount = wParam;
 897   }
 898
 899   return TRUE;
 900 }
 901
 902
 903 static LRESULT
 904 MONTHCAL_GetSelRange(HWND hwnd, WPARAM wParam, LPARAM lParam)
 905 {
 906   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 907   SYSTEMTIME *lprgSysTimeArray = (SYSTEMTIME *) lParam;
 908
 909   TRACE("%x %lx\n", wParam, lParam);
 910
 911   /* validate parameters */
 912
 913   if((infoPtr==NULL) ||(lprgSysTimeArray==NULL)) return FALSE;
 914
 915   if(GetWindowLongA(hwnd, GWL_STYLE) & MCS_MULTISELECT)
 916   {
 917     MONTHCAL_CopyTime(&infoPtr->maxSel, &lprgSysTimeArray[1]);
 918     MONTHCAL_CopyTime(&infoPtr->minSel, &lprgSysTimeArray[0]);
 919     TRACE("[min,max]=[%d %d]\n", infoPtr->minSel.wDay, infoPtr->maxSel.wDay);
 920     return TRUE;
 921   }
 922
 923   return FALSE;
 924 }
 925
 926
 927 static LRESULT
 928 MONTHCAL_SetSelRange(HWND hwnd, WPARAM wParam, LPARAM lParam)
 929 {
 930   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 931   SYSTEMTIME *lprgSysTimeArray = (SYSTEMTIME *) lParam;
 932
 933   TRACE("%x %lx\n", wParam, lParam);
 934
 935   /* validate parameters */
 936
 937   if((infoPtr==NULL) ||(lprgSysTimeArray==NULL)) return FALSE;
 938
 939   if(GetWindowLongA( hwnd, GWL_STYLE) & MCS_MULTISELECT)
 940   {
 941     MONTHCAL_CopyTime(&lprgSysTimeArray[1], &infoPtr->maxSel);
 942     MONTHCAL_CopyTime(&lprgSysTimeArray[0], &infoPtr->minSel);
 943     TRACE("[min,max]=[%d %d]\n", infoPtr->minSel.wDay, infoPtr->maxSel.wDay);
 944     return TRUE;
 945   }
 946
 947   return FALSE;
 948 }
 949
 950
 951 static LRESULT
 952 MONTHCAL_GetToday(HWND hwnd, WPARAM wParam, LPARAM lParam)
 953 {
 954   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 955   SYSTEMTIME *lpToday = (SYSTEMTIME *) lParam;
 956
 957   TRACE("%x %lx\n", wParam, lParam);
 958
 959   /* validate parameters */
 960
 961   if((infoPtr==NULL) || (lpToday==NULL)) return FALSE;
 962   MONTHCAL_CopyTime(&infoPtr->todaysDate, lpToday);
 963   return TRUE;
 964 }
 965
 966
 967 static LRESULT
 968 MONTHCAL_SetToday(HWND hwnd, WPARAM wParam, LPARAM lParam)
 969 {
 970   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 971   SYSTEMTIME *lpToday = (SYSTEMTIME *) lParam;
 972
 973   TRACE("%x %lx\n", wParam, lParam);
 974
 975   /* validate parameters */
 976
 977   if((infoPtr==NULL) ||(lpToday==NULL)) return FALSE;
 978   MONTHCAL_CopyTime(lpToday, &infoPtr->todaysDate);
 979   return TRUE;
 980 }
 981
 982
 983 static LRESULT
 984 MONTHCAL_HitTest(HWND hwnd, LPARAM lParam)
 985 {
 986  MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
 987  PMCHITTESTINFO lpht = (PMCHITTESTINFO)lParam;
 988  UINT x,y;
 989  DWORD retval;
 990
 991  x = lpht->pt.x;
 992  y = lpht->pt.y;
 993  retval = MCHT_NOWHERE;
 994
 995
 996   /* are we in the header? */
 997
 998   if(PtInRect(&infoPtr->title, lpht->pt)) {
 999     if(PtInRect(&infoPtr->titlebtnprev, lpht->pt)) {
1000       retval = MCHT_TITLEBTNPREV;
1001       goto done;
1002     }
1003     if(PtInRect(&infoPtr->titlebtnnext, lpht->pt)) {
1004       retval = MCHT_TITLEBTNNEXT;
1005       goto done;
1006     }
1007     if(PtInRect(&infoPtr->titlemonth, lpht->pt)) {
1008       retval = MCHT_TITLEMONTH;
1009       goto done;
1010     }
1011     if(PtInRect(&infoPtr->titleyear, lpht->pt)) {
1012       retval = MCHT_TITLEYEAR;
1013       goto done;
1014     }
1015
1016     retval = MCHT_TITLE;
1017     goto done;
1018   }
1019
1020   if(PtInRect(&infoPtr->days, lpht->pt)) {
1021     retval = MCHT_CALENDARDAY;  /* FIXME: find out which day we're on */
1022     goto done;
1023   }
1024   if(PtInRect(&infoPtr->weeknums, lpht->pt)) {
1025     retval = MCHT_CALENDARWEEKNUM; /* FIXME: find out which day we're on */
1026     goto done;
1027   }
1028   if(PtInRect(&infoPtr->prevmonth, lpht->pt)) {
1029     retval = MCHT_CALENDARDATEPREV;
1030     goto done;
1031   }
1032
1033   if(PtInRect(&infoPtr->nextmonth, lpht->pt) ||
1034  ((x>infoPtr->nextmonth.left) &&(x<infoPtr->nextmonth.right) &&
1035   (y>infoPtr->nextmonth.bottom) &&(y<infoPtr->today.top ))) {
1036     retval = MCHT_CALENDARDATENEXT;
1037     goto done;
1038   }
1039
1040   if(PtInRect(&infoPtr->today, lpht->pt)) {
1041     retval = MCHT_TODAYLINK;
1042     goto done;
1043   }
1044
1045 /* MCHT_CALENDARDATE determination: since the next & previous month have
1046  * been handled already(MCHT_CALENDARDATEPREV/NEXT), we only have to check
1047  * whether we're in the calendar area. infoPtr->prevMonth.left handles the
1048  * MCS_WEEKNUMBERS style nicely.
1049  */
1050
1051
1052  TRACE("%d %d [%d %d %d %d] [%d %d %d %d]\n", x, y,
1053         infoPtr->prevmonth.left, infoPtr->prevmonth.right,
1054         infoPtr->prevmonth.top, infoPtr->prevmonth.bottom,
1055         infoPtr->nextmonth.left, infoPtr->nextmonth.right,
1056         infoPtr->nextmonth.top, infoPtr->nextmonth.bottom);
1057   if((x>infoPtr->prevmonth.left) &&(x<infoPtr->nextmonth.right) &&
1058    (y>infoPtr->prevmonth.top) &&(y<infoPtr->nextmonth.bottom))  {
1059     lpht->st.wYear = infoPtr->currentYear;
1060     lpht->st.wMonth = infoPtr->currentMonth;
1061
1062     lpht->st.wDay = MONTHCAL_CalcDayFromPos(infoPtr, x, y);
1063
1064     TRACE("day hit: %d\n", lpht->st.wDay);
1065     retval = MCHT_CALENDARDATE;
1066     goto done;
1067
1068   }
1069
1070   /* Hit nothing special? What's left must be background :-) */
1071
1072   retval = MCHT_CALENDARBK;
1073  done:
1074   lpht->uHit = retval;
1075   return retval;
1076 }
1077
1078
1079 static void MONTHCAL_GoToNextMonth(HWND hwnd, MONTHCAL_INFO *infoPtr)
1080 {
1081   DWORD dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
1082
1083   TRACE("MONTHCAL_GoToNextMonth\n");
1084
1085   infoPtr->currentMonth++;
1086   if(infoPtr->currentMonth > 12) {
1087     infoPtr->currentYear++;
1088     infoPtr->currentMonth = 1;
1089   }
1090
1091   if(dwStyle & MCS_DAYSTATE) {
1092     NMDAYSTATE nmds;
1093     int i;
1094
1095     nmds.nmhdr.hwndFrom = hwnd;
1096     nmds.nmhdr.idFrom   = GetWindowLongA(hwnd, GWL_ID);
1097     nmds.nmhdr.code     = MCN_GETDAYSTATE;
1098     nmds.cDayState      = infoPtr->monthRange;
1099     nmds.prgDayState    = COMCTL32_Alloc(infoPtr->monthRange * sizeof(MONTHDAYSTATE));
1100
1101     SendMessageA(GetParent(hwnd), WM_NOTIFY,
1102     (WPARAM)nmds.nmhdr.idFrom, (LPARAM)&nmds);
1103     for(i=0; i<infoPtr->monthRange; i++)
1104       infoPtr->monthdayState[i] = nmds.prgDayState[i];
1105   }
1106 }
1107
1108
1109 static void MONTHCAL_GoToPrevMonth(HWND hwnd,  MONTHCAL_INFO *infoPtr)
1110 {
1111   DWORD dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
1112
1113   TRACE("MONTHCAL_GoToPrevMonth\n");
1114
1115   infoPtr->currentMonth--;
1116   if(infoPtr->currentMonth < 1) {
1117     infoPtr->currentYear--;
1118     infoPtr->currentMonth = 12;
1119   }
1120
1121   if(dwStyle & MCS_DAYSTATE) {
1122     NMDAYSTATE nmds;
1123     int i;
1124
1125     nmds.nmhdr.hwndFrom = hwnd;
1126     nmds.nmhdr.idFrom   = GetWindowLongA(hwnd, GWL_ID);
1127     nmds.nmhdr.code     = MCN_GETDAYSTATE;
1128     nmds.cDayState      = infoPtr->monthRange;
1129     nmds.prgDayState    = COMCTL32_Alloc
1130                         (infoPtr->monthRange * sizeof(MONTHDAYSTATE));
1131
1132     SendMessageA(GetParent(hwnd), WM_NOTIFY,
1133         (WPARAM)nmds.nmhdr.idFrom, (LPARAM)&nmds);
1134     for(i=0; i<infoPtr->monthRange; i++)
1135        infoPtr->monthdayState[i] = nmds.prgDayState[i];
1136   }
1137 }
1138
1139
1140 static LRESULT
1141 MONTHCAL_LButtonDown(HWND hwnd, WPARAM wParam, LPARAM lParam)
1142 {
1143   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
1144   MCHITTESTINFO ht;
1145   HDC hdc;
1146   DWORD hit;
1147   HMENU hMenu;
1148   HWND retval;
1149   BOOL redraw = FALSE;
1150
1151
1152   TRACE("%x %lx\n", wParam, lParam);
1153
1154   ht.pt.x = (INT)LOWORD(lParam);
1155   ht.pt.y = (INT)HIWORD(lParam);
1156   hit = MONTHCAL_HitTest(hwnd, (LPARAM)&ht);
1157
1158   /* FIXME: these flags should be checked by */
1159   /*((hit & MCHT_XXX) == MCHT_XXX) b/c some of the flags are */
1160   /* multi-bit */
1161   if(hit & MCHT_NEXT) {
1162     redraw = TRUE;
1163     MONTHCAL_GoToNextMonth(hwnd, infoPtr);
1164     infoPtr->status = MC_NEXTPRESSED;
1165     SetTimer(hwnd, MC_NEXTMONTHTIMER, MC_NEXTMONTHDELAY, 0);
1166   }
1167   if(hit & MCHT_PREV) {
1168     redraw = TRUE;
1169     MONTHCAL_GoToPrevMonth(hwnd, infoPtr);
1170     infoPtr->status = MC_PREVPRESSED;
1171     SetTimer(hwnd, MC_PREVMONTHTIMER, MC_NEXTMONTHDELAY, 0);
1172   }
1173
1174   if(hit == MCHT_TITLEMONTH) {
1175 /*
1176     HRSRC hrsrc = FindResourceA( COMCTL32_hModule, MAKEINTRESOURCEA(IDD_MCMONTHMENU), RT_MENUA );
1177     if(!hrsrc) {
1178       TRACE("returning zero\n");
1179       return 0;
1180     }
1181     TRACE("resource is:%x\n",hrsrc);
1182     hMenu = LoadMenuIndirectA((LPCVOID)LoadResource( COMCTL32_hModule, hrsrc ));
1183
1184     TRACE("menu is:%x\n",hMenu);
1185 */
1186
1187     hMenu = CreateMenu();
1188     AppendMenuA(hMenu, MF_STRING,IDM_JAN, "January");
1189     AppendMenuA(hMenu, MF_STRING,IDM_FEB, "February");
1190     AppendMenuA(hMenu, MF_STRING,IDM_MAR, "March");
1191
1192     retval = CreateWindowA(POPUPMENU_CLASS_ATOM, NULL,
1193               WS_CHILD | WS_VISIBLE, 0, 0 ,100 , 220,
1194               hwnd, hMenu, GetWindowLongA(hwnd, GWL_HINSTANCE), NULL);
1195     TRACE("hwnd returned:%x\n", retval);
1196
1197   }
1198   if(hit == MCHT_TITLEYEAR) {
1199     FIXME("create updown for yearselection\n");
1200   }
1201   if(hit == MCHT_TODAYLINK) {
1202     FIXME("set currentday\n");
1203   }
1204   if(hit == MCHT_CALENDARDATE) {
1205     SYSTEMTIME selArray[2];
1206     NMSELCHANGE nmsc;
1207
1208     TRACE("\n");
1209     nmsc.nmhdr.hwndFrom = hwnd;
1210     nmsc.nmhdr.idFrom   = GetWindowLongA(hwnd, GWL_ID);
1211     nmsc.nmhdr.code     = MCN_SELCHANGE;
1212     MONTHCAL_CopyTime(&nmsc.stSelStart, &infoPtr->minSel);
1213     MONTHCAL_CopyTime(&nmsc.stSelEnd, &infoPtr->maxSel);
1214
1215     SendMessageA(GetParent(hwnd), WM_NOTIFY,
1216            (WPARAM)nmsc.nmhdr.idFrom,(LPARAM)&nmsc);
1217
1218     MONTHCAL_CopyTime(&ht.st, &selArray[0]);
1219     MONTHCAL_CopyTime(&ht.st, &selArray[1]);
1220     MONTHCAL_SetSelRange(hwnd,0,(LPARAM) &selArray);
1221
1222     /* redraw if the selected day changed */
1223     if(infoPtr->curSelDay != ht.st.wDay) {
1224       redraw = TRUE;
1225     }
1226
1227     infoPtr->firstSelDay = ht.st.wDay;
1228     infoPtr->curSelDay = ht.st.wDay;
1229     infoPtr->status = MC_SEL_LBUTDOWN;
1230   }
1231
1232   /* redraw only if the control changed */
1233   if(redraw) {
1234     hdc = GetDC(hwnd);
1235           MONTHCAL_Refresh(hwnd, hdc);
1236     ReleaseDC(hwnd, hdc);
1237   }
1238
1239   return 0;
1240 }
1241
1242
1243 static LRESULT
1244 MONTHCAL_LButtonUp(HWND hwnd, WPARAM wParam, LPARAM lParam)
1245 {
1246   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
1247   NMSELCHANGE nmsc;
1248   NMHDR nmhdr;
1249   HDC hdc;
1250   BOOL redraw = FALSE;
1251
1252   TRACE("\n");
1253
1254   if(infoPtr->status & MC_NEXTPRESSED) {
1255     KillTimer(hwnd, MC_NEXTMONTHTIMER);
1256     redraw = TRUE;
1257   }
1258   if(infoPtr->status & MC_PREVPRESSED) {
1259     KillTimer(hwnd, MC_PREVMONTHTIMER);
1260     redraw = TRUE;
1261   }
1262
1263   infoPtr->status = MC_SEL_LBUTUP;
1264
1265   nmhdr.hwndFrom = hwnd;
1266   nmhdr.idFrom   = GetWindowLongA( hwnd, GWL_ID);
1267   nmhdr.code     = NM_RELEASEDCAPTURE;
1268   TRACE("Sent notification from %x to %x\n", hwnd, GetParent(hwnd));
1269
1270   SendMessageA(GetParent(hwnd), WM_NOTIFY,
1271                                 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
1272
1273   nmsc.nmhdr.hwndFrom = hwnd;
1274   nmsc.nmhdr.idFrom   = GetWindowLongA(hwnd, GWL_ID);
1275   nmsc.nmhdr.code     = MCN_SELECT;
1276   MONTHCAL_CopyTime(&nmsc.stSelStart, &infoPtr->minSel);
1277   MONTHCAL_CopyTime(&nmsc.stSelEnd, &infoPtr->maxSel);
1278
1279   SendMessageA(GetParent(hwnd), WM_NOTIFY,
1280            (WPARAM)nmsc.nmhdr.idFrom, (LPARAM)&nmsc);
1281
1282   /* redraw if necessary */
1283   if(redraw) {
1284     hdc = GetDC(hwnd);
1285     MONTHCAL_Refresh(hwnd, hdc);
1286     ReleaseDC(hwnd, hdc);
1287   }
1288
1289   return 0;
1290 }
1291
1292
1293 static LRESULT
1294 MONTHCAL_Timer(HWND hwnd, WPARAM wParam, LPARAM lParam)
1295 {
1296   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
1297   HDC hdc;
1298   BOOL redraw = FALSE;
1299
1300   TRACE(" %d\n", wParam);
1301   if(!infoPtr) return 0;
1302
1303   switch(wParam) {
1304   case MC_NEXTMONTHTIMER:
1305     redraw = TRUE;
1306     MONTHCAL_GoToNextMonth(hwnd, infoPtr);
1307     break;
1308   case MC_PREVMONTHTIMER:
1309     redraw = TRUE;
1310     MONTHCAL_GoToPrevMonth(hwnd, infoPtr);
1311     break;
1312   default:
1313     ERR("got unknown timer\n");
1314   }
1315
1316   /* redraw only if necessary */
1317   if(redraw) {
1318     hdc = GetDC(hwnd);
1319     MONTHCAL_Refresh(hwnd, hdc);
1320     ReleaseDC(hwnd, hdc);
1321   }
1322
1323   return 0;
1324 }
1325
1326
1327 static LRESULT
1328 MONTHCAL_MouseMove(HWND hwnd, WPARAM wParam, LPARAM lParam)
1329 {
1330   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
1331   MCHITTESTINFO ht;
1332   HDC hdc;
1333   int oldselday, selday, hit;
1334   RECT r;
1335
1336   if(!(infoPtr->status & MC_SEL_LBUTDOWN)) return 0;
1337
1338   ht.pt.x = LOWORD(lParam);
1339   ht.pt.y = HIWORD(lParam);
1340
1341   hit = MONTHCAL_HitTest(hwnd, (LPARAM)&ht);
1342
1343   /* not on the calendar date numbers? bail out */
1344   TRACE("hit:%x\n",hit);
1345   if((hit & MCHT_CALENDARDATE) != MCHT_CALENDARDATE) return 0;
1346
1347   selday = ht.st.wDay;
1348   oldselday = infoPtr->curSelDay;
1349   infoPtr->curSelDay = selday;
1350   MONTHCAL_CalcPosFromDay(infoPtr, selday, ht.st. wMonth, &r);
1351
1352   if(GetWindowLongA(hwnd, GWL_STYLE) & MCS_MULTISELECT)  {
1353     SYSTEMTIME selArray[2];
1354     int i;
1355
1356     MONTHCAL_GetSelRange(hwnd, 0, (LPARAM)&selArray);
1357     i = 0;
1358     if(infoPtr->firstSelDay==selArray[0].wDay) i=1;
1359     TRACE("oldRange:%d %d %d %d\n", infoPtr->firstSelDay, selArray[0].wDay, selArray[1].wDay, i);
1360     if(infoPtr->firstSelDay==selArray[1].wDay) {
1361       /* 1st time we get here: selArray[0]=selArray[1])  */
1362       /* if we're still at the first selected date, return */
1363       if(infoPtr->firstSelDay==selday) goto done;
1364       if(selday<infoPtr->firstSelDay) i = 0;
1365     }
1366
1367     if(abs(infoPtr->firstSelDay - selday) >= infoPtr->maxSelCount) {
1368       if(selday>infoPtr->firstSelDay)
1369         selday = infoPtr->firstSelDay + infoPtr->maxSelCount;
1370       else
1371         selday = infoPtr->firstSelDay - infoPtr->maxSelCount;
1372     }
1373
1374     if(selArray[i].wDay!=selday) {
1375       TRACE("newRange:%d %d %d %d\n", infoPtr->firstSelDay, selArray[0].wDay, selArray[1].wDay, i);
1376
1377       selArray[i].wDay = selday;
1378
1379       if(selArray[0].wDay>selArray[1].wDay) {
1380         DWORD tempday;
1381         tempday = selArray[1].wDay;
1382         selArray[1].wDay = selArray[0].wDay;
1383         selArray[0].wDay = tempday;
1384       }
1385
1386       MONTHCAL_SetSelRange(hwnd, 0, (LPARAM)&selArray);
1387     }
1388   }
1389
1390 done:
1391
1392   /* only redraw if the currently selected day changed */
1393   if(oldselday != infoPtr->curSelDay) {
1394     hdc = GetDC(hwnd);
1395     MONTHCAL_Refresh(hwnd, hdc);
1396     ReleaseDC(hwnd, hdc);
1397   }
1398
1399   return 0;
1400 }
1401
1402
1403 static LRESULT
1404 MONTHCAL_Paint(HWND hwnd, WPARAM wParam)
1405 {
1406   HDC hdc;
1407   PAINTSTRUCT ps;
1408
1409   hdc = (wParam==0 ? BeginPaint(hwnd, &ps) : (HDC)wParam);
1410   MONTHCAL_Refresh(hwnd, hdc);
1411   if(!wParam) EndPaint(hwnd, &ps);
1412   return 0;
1413 }
1414
1415
1416 static LRESULT
1417 MONTHCAL_KillFocus(HWND hwnd, WPARAM wParam, LPARAM lParam)
1418 {
1419   HDC hdc;
1420
1421   TRACE("\n");
1422
1423   hdc = GetDC(hwnd);
1424   MONTHCAL_Refresh(hwnd, hdc);
1425   ReleaseDC(hwnd, hdc);
1426   InvalidateRect(hwnd, NULL, TRUE);
1427
1428   return 0;
1429 }
1430
1431
1432 static LRESULT
1433 MONTHCAL_SetFocus(HWND hwnd, WPARAM wParam, LPARAM lParam)
1434 {
1435   HDC hdc;
1436
1437   TRACE("\n");
1438
1439   hdc = GetDC(hwnd);
1440   MONTHCAL_Refresh(hwnd, hdc);
1441   ReleaseDC(hwnd, hdc);
1442
1443   return 0;
1444 }
1445
1446 /* sets the size information */
1447 static void MONTHCAL_UpdateSize(HWND hwnd)
1448 {
1449   HDC hdc = GetDC(hwnd);
1450   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
1451   RECT *rcClient=&infoPtr->rcClient;
1452   RECT *rcDraw=&infoPtr->rcDraw;
1453   RECT *title=&infoPtr->title;
1454   RECT *prev=&infoPtr->titlebtnprev;
1455   RECT *next=&infoPtr->titlebtnnext;
1456   RECT *titlemonth=&infoPtr->titlemonth;
1457   RECT *titleyear=&infoPtr->titleyear;
1458   RECT *days=&infoPtr->days;
1459   SIZE size;
1460   TEXTMETRICA tm;
1461   DWORD dwStyle = GetWindowLongA(hwnd, GWL_STYLE);
1462   HFONT currentFont;
1463
1464   currentFont = SelectObject(hdc, infoPtr->hFont);
1465
1466   /* FIXME: need a way to determine current font, without setting it */
1467   /*
1468   if(infoPtr->hFont!=currentFont) {
1469     SelectObject(hdc, currentFont);
1470     infoPtr->hFont=currentFont;
1471     GetObjectA(currentFont, sizeof(LOGFONTA), &logFont);
1472     logFont.lfWeight=FW_BOLD;
1473     infoPtr->hBoldFont = CreateFontIndirectA(&logFont);
1474   }
1475   */
1476
1477   /* get the height and width of each day's text */
1478   GetTextMetricsA(hdc, &tm);
1479   infoPtr->textHeight = tm.tmHeight + tm.tmExternalLeading;
1480   GetTextExtentPoint32A(hdc, "Sun", 3, &size);
1481   infoPtr->textWidth = size.cx + 2;
1482
1483   /* retrieve the controls client rectangle info infoPtr->rcClient */
1484   GetClientRect(hwnd, rcClient);
1485
1486   if(dwStyle & MCS_WEEKNUMBERS)
1487     infoPtr->rcClient.right+=infoPtr->textWidth;
1488
1489   /* rcDraw is the rectangle the control is drawn in */
1490   rcDraw->left = rcClient->left;
1491   rcDraw->right = rcClient->right;
1492   rcDraw->top = rcClient->top;
1493   rcDraw->bottom = rcClient->bottom;
1494
1495   /* use DrawEdge to adjust the size of rcClient such that we */
1496   /* do not overwrite the border when drawing the control */
1497   DrawEdge((HDC)NULL, rcDraw, EDGE_SUNKEN, BF_RECT | BF_ADJUST);
1498
1499
1500   /* this is correct, the control does NOT expand vertically */
1501   /* like it does horizontally */
1502   /* make sure we don't move the controls bottom out of the client */
1503   /* area */
1504   if((rcDraw->top + 8 * infoPtr->textHeight + 5) < rcDraw->bottom) {
1505     rcDraw->bottom = rcDraw->top + 8 * infoPtr->textHeight + 5;
1506   }
1507
1508   /* calculate title area */
1509   title->top    = rcClient->top + 1;
1510   title->bottom = title->top + 2 * infoPtr->textHeight + 4;
1511   title->left   = rcClient->left + 1;
1512   title->right  = rcClient->right - 1;
1513
1514   /* recalculate the height and width increments and offsets */
1515   infoPtr->width_increment = (infoPtr->rcDraw.right - infoPtr->rcDraw.left) / 7.0;
1516   infoPtr->height_increment = (infoPtr->rcDraw.bottom - infoPtr->rcDraw.top) / 7.0;
1517   infoPtr->left_offset = (infoPtr->rcDraw.right - infoPtr->rcDraw.left) - (infoPtr->width_increment * 7.0);
1518   infoPtr->top_offset = (infoPtr->rcDraw.bottom - infoPtr->rcDraw.top) - (infoPtr->height_increment * 7.0);
1519
1520   /* set the dimensions of the next and previous buttons and center */
1521   /* the month text vertically */
1522   prev->top        = next->top    = title->top + 6;
1523   prev->bottom = next->bottom = title->top + 2 * infoPtr->textHeight - 3;
1524   prev->right  = title->left  + 28;
1525   prev->left   = title->left  + 4;
1526   next->left   = title->right - 28;
1527   next->right  = title->right - 4;
1528
1529   /* titlemonth->left and right change based upon the current month */
1530   /* and are recalculated in refresh as the current month may change */
1531   /* without the control being resized */
1532   titlemonth->bottom = titleyear->bottom = prev->top + 2 * infoPtr->textHeight - 3;
1533   titlemonth->top    = titleyear->top    = title->top;
1534
1535   /* setup the dimensions of the rectangle we draw the names of the */
1536   /* days of the week in */
1537   days->left = infoPtr->left_offset;
1538   if(dwStyle & MCS_WEEKNUMBERS) days->left+=infoPtr->textWidth;
1539   days->right  = days->left + infoPtr->width_increment;
1540   days->top    = title->bottom + 2;
1541   days->bottom = title->bottom + infoPtr->textHeight + 2;
1542
1543   /* restore the originally selected font */
1544   SelectObject(hdc, currentFont);
1545
1546   ReleaseDC(hwnd, hdc);
1547 }
1548
1549 static LRESULT MONTHCAL_Size(HWND hwnd, int Width, int Height)
1550 {
1551   TRACE("(hwnd=%x, width=%d, height=%d)\n", hwnd, Width, Height);
1552
1553   MONTHCAL_UpdateSize(hwnd);
1554
1555   /* invalidate client area and erase background */
1556   InvalidateRect(hwnd, NULL, TRUE);
1557
1558   return 0;
1559 }
1560
1561 /* FIXME: check whether dateMin/dateMax need to be adjusted. */
1562 static LRESULT
1563 MONTHCAL_Create(HWND hwnd, WPARAM wParam, LPARAM lParam)
1564 {
1565   MONTHCAL_INFO *infoPtr;
1566   LOGFONTA      logFont;
1567
1568   /* allocate memory for info structure */
1569   infoPtr =(MONTHCAL_INFO*)COMCTL32_Alloc(sizeof(MONTHCAL_INFO));
1570   SetWindowLongA(hwnd, 0, (DWORD)infoPtr);
1571
1572   if(infoPtr == NULL) {
1573     ERR( "could not allocate info memory!\n");
1574     return 0;
1575   }
1576   if((MONTHCAL_INFO*)GetWindowLongA(hwnd, 0) != infoPtr) {
1577     ERR( "pointer assignment error!\n");
1578     return 0;
1579   }
1580
1581   infoPtr->hFont = GetStockObject(DEFAULT_GUI_FONT);
1582   GetObjectA(infoPtr->hFont, sizeof(LOGFONTA), &logFont);
1583   logFont.lfWeight = FW_BOLD;
1584   infoPtr->hBoldFont = CreateFontIndirectA(&logFont);
1585
1586   /* initialize info structure */
1587   /* FIXME: calculate systemtime ->> localtime(substract timezoneinfo) */
1588
1589   GetSystemTime(&infoPtr->todaysDate);
1590   infoPtr->firstDay = 0;
1591   infoPtr->currentMonth = infoPtr->todaysDate.wMonth;
1592   infoPtr->currentYear = infoPtr->todaysDate.wYear;
1593   MONTHCAL_CopyTime(&infoPtr->todaysDate, &infoPtr->minDate);
1594   MONTHCAL_CopyTime(&infoPtr->todaysDate, &infoPtr->maxDate);
1595   infoPtr->maxSelCount  = 6;
1596   infoPtr->monthRange = 3;
1597   infoPtr->monthdayState = COMCTL32_Alloc
1598                          (infoPtr->monthRange * sizeof(MONTHDAYSTATE));
1599   infoPtr->titlebk     = GetSysColor(COLOR_ACTIVECAPTION);
1600   infoPtr->titletxt    = GetSysColor(COLOR_WINDOW);
1601   infoPtr->monthbk     = GetSysColor(COLOR_WINDOW);
1602   infoPtr->trailingtxt = GetSysColor(COLOR_GRAYTEXT);
1603   infoPtr->bk          = GetSysColor(COLOR_WINDOW);
1604   infoPtr->txt         = GetSysColor(COLOR_WINDOWTEXT);
1605
1606   /* call MONTHCAL_UpdateSize to set all of the dimensions */
1607   /* of the control */
1608   MONTHCAL_UpdateSize(hwnd);
1609
1610   return 0;
1611 }
1612
1613
1614 static LRESULT
1615 MONTHCAL_Destroy(HWND hwnd, WPARAM wParam, LPARAM lParam)
1616 {
1617   MONTHCAL_INFO *infoPtr = MONTHCAL_GetInfoPtr(hwnd);
1618
1619   /* free month calendar info data */
1620   COMCTL32_Free(infoPtr);
1621
1622   return 0;
1623 }
1624
1625
1626 static LRESULT WINAPI
1627 MONTHCAL_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1628 {
1629   switch(uMsg)
1630   {
1631   case MCM_GETCURSEL:
1632     return MONTHCAL_GetCurSel(hwnd, wParam, lParam);
1633
1634   case MCM_SETCURSEL:
1635     return MONTHCAL_SetCurSel(hwnd, wParam, lParam);
1636
1637   case MCM_GETMAXSELCOUNT:
1638     return MONTHCAL_GetMaxSelCount(hwnd, wParam, lParam);
1639
1640   case MCM_SETMAXSELCOUNT:
1641     return MONTHCAL_SetMaxSelCount(hwnd, wParam, lParam);
1642
1643   case MCM_GETSELRANGE:
1644     return MONTHCAL_GetSelRange(hwnd, wParam, lParam);
1645
1646   case MCM_SETSELRANGE:
1647     return MONTHCAL_SetSelRange(hwnd, wParam, lParam);
1648
1649   case MCM_GETMONTHRANGE:
1650     return MONTHCAL_GetMonthRange(hwnd, wParam, lParam);
1651
1652   case MCM_SETDAYSTATE:
1653     return MONTHCAL_SetDayState(hwnd, wParam, lParam);
1654
1655   case MCM_GETMINREQRECT:
1656     return MONTHCAL_GetMinReqRect(hwnd, wParam, lParam);
1657
1658   case MCM_GETCOLOR:
1659     return MONTHCAL_GetColor(hwnd, wParam, lParam);
1660
1661   case MCM_SETCOLOR:
1662     return MONTHCAL_SetColor(hwnd, wParam, lParam);
1663
1664   case MCM_GETTODAY:
1665     return MONTHCAL_GetToday(hwnd, wParam, lParam);
1666
1667   case MCM_SETTODAY:
1668     return MONTHCAL_SetToday(hwnd, wParam, lParam);
1669
1670   case MCM_HITTEST:
1671     return MONTHCAL_HitTest(hwnd,lParam);
1672
1673   case MCM_GETFIRSTDAYOFWEEK:
1674     return MONTHCAL_GetFirstDayOfWeek(hwnd, wParam, lParam);
1675
1676   case MCM_SETFIRSTDAYOFWEEK:
1677     return MONTHCAL_SetFirstDayOfWeek(hwnd, wParam, lParam);
1678
1679   case MCM_GETRANGE:
1680     return MONTHCAL_GetRange(hwnd, wParam, lParam);
1681
1682   case MCM_SETRANGE:
1683     return MONTHCAL_SetRange(hwnd, wParam, lParam);
1684
1685   case MCM_GETMONTHDELTA:
1686     return MONTHCAL_GetMonthDelta(hwnd, wParam, lParam);
1687
1688   case MCM_SETMONTHDELTA:
1689     return MONTHCAL_SetMonthDelta(hwnd, wParam, lParam);
1690
1691   case MCM_GETMAXTODAYWIDTH:
1692     return MONTHCAL_GetMaxTodayWidth(hwnd);
1693
1694   case WM_GETDLGCODE:
1695     return DLGC_WANTARROWS | DLGC_WANTCHARS;
1696
1697   case WM_KILLFOCUS:
1698     return MONTHCAL_KillFocus(hwnd, wParam, lParam);
1699
1700   case WM_LBUTTONDOWN:
1701     return MONTHCAL_LButtonDown(hwnd, wParam, lParam);
1702
1703   case WM_MOUSEMOVE:
1704     return MONTHCAL_MouseMove(hwnd, wParam, lParam);
1705
1706   case WM_LBUTTONUP:
1707     return MONTHCAL_LButtonUp(hwnd, wParam, lParam);
1708
1709   case WM_PAINT:
1710     return MONTHCAL_Paint(hwnd, wParam);
1711
1712   case WM_SETFOCUS:
1713     return MONTHCAL_SetFocus(hwnd, wParam, lParam);
1714
1715   case WM_SIZE:
1716     return MONTHCAL_Size(hwnd, (int)SLOWORD(lParam), (int)SHIWORD(lParam));
1717
1718   case WM_CREATE:
1719     return MONTHCAL_Create(hwnd, wParam, lParam);
1720
1721   case WM_TIMER:
1722     return MONTHCAL_Timer(hwnd, wParam, lParam);
1723
1724   case WM_DESTROY:
1725     return MONTHCAL_Destroy(hwnd, wParam, lParam);
1726
1727   default:
1728     if(uMsg >= WM_USER)
1729       ERR( "unknown msg %04x wp=%08x lp=%08lx\n", uMsg, wParam, lParam);
1730     return DefWindowProcA(hwnd, uMsg, wParam, lParam);
1731   }
1732   return 0;
1733 }
1734
1735
1736 void
1737 MONTHCAL_Register(void)
1738 {
1739   WNDCLASSA wndClass;
1740
1741   if(GlobalFindAtomA(MONTHCAL_CLASSA)) return;
1742
1743   ZeroMemory(&wndClass, sizeof(WNDCLASSA));
1744   wndClass.style         = CS_GLOBALCLASS;
1745   wndClass.lpfnWndProc   = (WNDPROC)MONTHCAL_WindowProc;
1746   wndClass.cbClsExtra    = 0;
1747   wndClass.cbWndExtra    = sizeof(MONTHCAL_INFO *);
1748   wndClass.hCursor       = LoadCursorA(0, IDC_ARROWA);
1749   wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
1750   wndClass.lpszClassName = MONTHCAL_CLASSA;
1751
1752   RegisterClassA(&wndClass);
1753 }
1754
1755
1756 void
1757 MONTHCAL_Unregister(void)
1758 {
1759   if(GlobalFindAtomA(MONTHCAL_CLASSA))
1760     UnregisterClassA(MONTHCAL_CLASSA, (HINSTANCE)NULL);
1761 }