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