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

   1 /*
   2  * Month calendar control
   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  * Copyright 2000 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>
   9  * Copyright 2009-2011 Nikolay Sivov
  10  *
  11  * This library is free software; you can redistribute it and/or
  12  * modify it under the terms of the GNU Lesser General Public
  13  * License as published by the Free Software Foundation; either
  14  * version 2.1 of the License, or (at your option) any later version.
  15  *
  16  * This library is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * Lesser General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU Lesser General Public
  22  * License along with this library; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  24  *
  25  * NOTE
  26  *
  27  * This code was audited for completeness against the documented features
  28  * of Comctl32.dll version 6.0 on Oct. 20, 2004, by Dimitrie O. Paun.
  29  *
  30  * Unless otherwise noted, we believe this code to be complete, as per
  31  * the specification mentioned above.
  32  * If you discover missing features, or bugs, please note them below.
  33  *
  34  * TODO:
  35  *    -- MCM_[GS]ETUNICODEFORMAT
  36  *    -- handle resources better (doesn't work now);
  37  *    -- take care of internationalization.
  38  *    -- keyboard handling.
  39  *    -- search for FIXME
  40  */
  41
  42 #include <math.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <stdlib.h>
  46 #include <string.h>
  47
  48 #include "windef.h"
  49 #include "winbase.h"
  50 #include "wingdi.h"
  51 #include "winuser.h"
  52 #include "winnls.h"
  53 #include "commctrl.h"
  54 #include "comctl32.h"
  55 #include "uxtheme.h"
  56 #include "tmschema.h"
  57 #include "wine/unicode.h"
  58 #include "wine/debug.h"
  59
  60 WINE_DEFAULT_DEBUG_CHANNEL(monthcal);
  61
  62 #define MC_SEL_LBUTUP       1   /* Left button released */
  63 #define MC_SEL_LBUTDOWN     2   /* Left button pressed in calendar */
  64 #define MC_PREVPRESSED      4   /* Prev month button pressed */
  65 #define MC_NEXTPRESSED      8   /* Next month button pressed */
  66 #define MC_PREVNEXTMONTHDELAY   350     /* when continuously pressing `next/prev
  67                                            month', wait 350 ms before going
  68                                            to the next/prev month */
  69 #define MC_TODAYUPDATEDELAY 120000 /* time between today check for update (2 min) */
  70
  71 #define MC_PREVNEXTMONTHTIMER   1       /* Timer ID's */
  72 #define MC_TODAYUPDATETIMER     2
  73
  74 #define countof(arr) (sizeof(arr)/sizeof(arr[0]))
  75
  76 /* convert from days to 100 nanoseconds unit - used as FILETIME unit */
  77 #define DAYSTO100NSECS(days) (((ULONGLONG)(days))*24*60*60*10000000)
  78
  79 /* single calendar data */
  80 typedef struct _CALENDAR_INFO
  81 {
  82     RECT title;      /* rect for the header above the calendar */
  83     RECT titlemonth; /* the 'month name' text in the header */
  84     RECT titleyear;  /* the 'year number' text in the header */
  85     RECT wdays;      /* week days at top */
  86     RECT days;       /* calendar area */
  87     RECT weeknums;   /* week numbers at left side */
  88
  89     SYSTEMTIME month;/* contains calendar main month/year */
  90 } CALENDAR_INFO;
  91
  92 typedef struct
  93 {
  94     HWND        hwndSelf;
  95     DWORD       dwStyle; /* cached GWL_STYLE */
  96
  97     COLORREF    colors[MCSC_TRAILINGTEXT+1];
  98     HBRUSH      brushes[MCSC_MONTHBK+1];
  99
 100     HFONT       hFont;
 101     HFONT       hBoldFont;
 102     int         textHeight;
 103     int         textWidth;
 104     int         height_increment;
 105     int         width_increment;
 106     INT         delta;  /* scroll rate; # of months that the */
 107                         /* control moves when user clicks a scroll button */
 108     int         visible;        /* # of months visible */
 109     int         firstDay;       /* Start month calendar with firstDay's day,
 110                                    stored in SYSTEMTIME format */
 111     BOOL        firstDaySet;    /* first week day differs from locale defined */
 112
 113     BOOL        isUnicode;      /* value set with MCM_SETUNICODE format */
 114
 115     int         monthRange;
 116     MONTHDAYSTATE *monthdayState;
 117     SYSTEMTIME  todaysDate;
 118     BOOL        todaySet;       /* Today was forced with MCM_SETTODAY */
 119     int         status;         /* See MC_SEL flags */
 120     SYSTEMTIME  firstSel;       /* first selected day */
 121     INT         maxSelCount;
 122     SYSTEMTIME  minSel;         /* contains single selection when used without MCS_MULTISELECT */
 123     SYSTEMTIME  maxSel;
 124     SYSTEMTIME  focusedSel;     /* date currently focused with mouse movement */
 125     DWORD       rangeValid;
 126     SYSTEMTIME  minDate;
 127     SYSTEMTIME  maxDate;
 128
 129     RECT titlebtnnext;  /* the `next month' button in the header */
 130     RECT titlebtnprev;  /* the `prev month' button in the header */
 131     RECT todayrect;     /* `today: xx/xx/xx' text rect */
 132     HWND hwndNotify;    /* Window to receive the notifications */
 133     HWND hWndYearEdit;  /* Window Handle of edit box to handle years */
 134     HWND hWndYearUpDown;/* Window Handle of updown box to handle years */
 135     WNDPROC EditWndProc;  /* original Edit window procedure */
 136
 137     CALENDAR_INFO *calendars;
 138     INT            cal_num;
 139 } MONTHCAL_INFO, *LPMONTHCAL_INFO;
 140
 141 static const WCHAR themeClass[] = { 'S','c','r','o','l','l','b','a','r',0 };
 142
 143 /* empty SYSTEMTIME const */
 144 static const SYSTEMTIME st_null;
 145 /* valid date limits */
 146 static const SYSTEMTIME max_allowed_date = { .wYear = 9999, .wMonth = 12, .wDay = 31 };
 147 static const SYSTEMTIME min_allowed_date = { .wYear = 1752, .wMonth = 9,  .wDay = 14 };
 148
 149 /* Prev/Next buttons */
 150 enum nav_direction
 151 {
 152     DIRECTION_BACKWARD,
 153     DIRECTION_FORWARD
 154 };
 155
 156 /* helper functions  */
 157
 158 /* send a single MCN_SELCHANGE notification */
 159 static inline void MONTHCAL_NotifySelectionChange(const MONTHCAL_INFO *infoPtr)
 160 {
 161     NMSELCHANGE nmsc;
 162
 163     nmsc.nmhdr.hwndFrom = infoPtr->hwndSelf;
 164     nmsc.nmhdr.idFrom   = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
 165     nmsc.nmhdr.code     = MCN_SELCHANGE;
 166     nmsc.stSelStart     = infoPtr->minSel;
 167     nmsc.stSelEnd       = infoPtr->maxSel;
 168     SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, nmsc.nmhdr.idFrom, (LPARAM)&nmsc);
 169 }
 170
 171 /* send a single MCN_SELECT notification */
 172 static inline void MONTHCAL_NotifySelect(const MONTHCAL_INFO *infoPtr)
 173 {
 174     NMSELCHANGE nmsc;
 175
 176     nmsc.nmhdr.hwndFrom = infoPtr->hwndSelf;
 177     nmsc.nmhdr.idFrom   = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
 178     nmsc.nmhdr.code     = MCN_SELECT;
 179     nmsc.stSelStart     = infoPtr->minSel;
 180     nmsc.stSelEnd       = infoPtr->maxSel;
 181
 182     SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, nmsc.nmhdr.idFrom, (LPARAM)&nmsc);
 183 }
 184
 185 /* returns the number of days in any given month, checking for leap days */
 186 /* january is 1, december is 12 */
 187 int MONTHCAL_MonthLength(int month, int year)
 188 {
 189   const int mdays[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
 190   /* Wrap around, this eases handling. Getting length only we shouldn't care
 191      about year change here cause January and December have
 192      the same day quantity */
 193   if(month == 0)
 194     month = 12;
 195   else if(month == 13)
 196     month = 1;
 197
 198   /* special case for calendar transition year */
 199   if(month == min_allowed_date.wMonth && year == min_allowed_date.wYear) return 19;
 200
 201   /* if we have a leap year add 1 day to February */
 202   /* a leap year is a year either divisible by 400 */
 203   /* or divisible by 4 and not by 100 */
 204   if(month == 2) { /* February */
 205     return mdays[month - 1] + ((year%400 == 0) ? 1 : ((year%100 != 0) &&
 206      (year%4 == 0)) ? 1 : 0);
 207   }
 208   else {
 209     return mdays[month - 1];
 210   }
 211 }
 212
 213 /* compares timestamps using date part only */
 214 static inline BOOL MONTHCAL_IsDateEqual(const SYSTEMTIME *first, const SYSTEMTIME *second)
 215 {
 216   return (first->wYear == second->wYear) && (first->wMonth == second->wMonth) &&
 217          (first->wDay  == second->wDay);
 218 }
 219
 220 /* make sure that date fields are valid */
 221 static BOOL MONTHCAL_ValidateDate(const SYSTEMTIME *time)
 222 {
 223   if(time->wMonth < 1 || time->wMonth > 12 ) return FALSE;
 224   if(time->wDayOfWeek > 6) return FALSE;
 225   if(time->wDay > MONTHCAL_MonthLength(time->wMonth, time->wYear))
 226           return FALSE;
 227
 228   return TRUE;
 229 }
 230
 231 /* Copies timestamp part only.
 232  *
 233  * PARAMETERS
 234  *
 235  *  [I] from : source date
 236  *  [O] to   : dest date
 237  */
 238 static void MONTHCAL_CopyTime(const SYSTEMTIME *from, SYSTEMTIME *to)
 239 {
 240   to->wHour   = from->wHour;
 241   to->wMinute = from->wMinute;
 242   to->wSecond = from->wSecond;
 243 }
 244
 245 /* Copies date part only.
 246  *
 247  * PARAMETERS
 248  *
 249  *  [I] from : source date
 250  *  [O] to   : dest date
 251  */
 252 static void MONTHCAL_CopyDate(const SYSTEMTIME *from, SYSTEMTIME *to)
 253 {
 254   to->wYear  = from->wYear;
 255   to->wMonth = from->wMonth;
 256   to->wDay   = from->wDay;
 257   to->wDayOfWeek = from->wDayOfWeek;
 258 }
 259
 260 /* Compares two dates in SYSTEMTIME format
 261  *
 262  * PARAMETERS
 263  *
 264  *  [I] first  : pointer to valid first date data to compare
 265  *  [I] second : pointer to valid second date data to compare
 266  *
 267  * RETURN VALUE
 268  *
 269  *  -1 : first <  second
 270  *   0 : first == second
 271  *   1 : first >  second
 272  *
 273  *  Note that no date validation performed, alreadt validated values expected.
 274  */
 275 static LONG MONTHCAL_CompareSystemTime(const SYSTEMTIME *first, const SYSTEMTIME *second)
 276 {
 277   FILETIME ft_first, ft_second;
 278
 279   SystemTimeToFileTime(first, &ft_first);
 280   SystemTimeToFileTime(second, &ft_second);
 281
 282   return CompareFileTime(&ft_first, &ft_second);
 283 }
 284
 285 static LONG MONTHCAL_CompareMonths(const SYSTEMTIME *first, const SYSTEMTIME *second)
 286 {
 287   SYSTEMTIME st_first, st_second;
 288
 289   st_first = st_second = st_null;
 290   MONTHCAL_CopyDate(first, &st_first);
 291   MONTHCAL_CopyDate(second, &st_second);
 292   st_first.wDay = st_second.wDay = 1;
 293
 294   return MONTHCAL_CompareSystemTime(&st_first, &st_second);
 295 }
 296
 297 static LONG MONTHCAL_CompareDate(const SYSTEMTIME *first, const SYSTEMTIME *second)
 298 {
 299   SYSTEMTIME st_first, st_second;
 300
 301   st_first = st_second = st_null;
 302   MONTHCAL_CopyDate(first, &st_first);
 303   MONTHCAL_CopyDate(second, &st_second);
 304
 305   return MONTHCAL_CompareSystemTime(&st_first, &st_second);
 306 }
 307
 308 /* Checks largest possible date range and configured one
 309  *
 310  * PARAMETERS
 311  *
 312  *  [I] infoPtr : valid pointer to control data
 313  *  [I] date    : pointer to valid date data to check
 314  *  [I] fix     : make date fit valid range
 315  *
 316  * RETURN VALUE
 317  *
 318  *  TRUE  - date whithin largest and configured range
 319  *  FALSE - date is outside largest or configured range
 320  */
 321 static BOOL MONTHCAL_IsDateInValidRange(const MONTHCAL_INFO *infoPtr,
 322                                         SYSTEMTIME *date, BOOL fix)
 323 {
 324   const SYSTEMTIME *fix_st = NULL;
 325
 326   if(MONTHCAL_CompareSystemTime(date, &max_allowed_date) == 1) {
 327      fix_st = &max_allowed_date;
 328   }
 329   else if(MONTHCAL_CompareSystemTime(date, &min_allowed_date) == -1) {
 330      fix_st = &min_allowed_date;
 331   }
 332   else if(infoPtr->rangeValid & GDTR_MAX) {
 333      if((MONTHCAL_CompareSystemTime(date, &infoPtr->maxDate) == 1)) {
 334        fix_st = &infoPtr->maxDate;
 335      }
 336   }
 337   else if(infoPtr->rangeValid & GDTR_MIN) {
 338      if((MONTHCAL_CompareSystemTime(date, &infoPtr->minDate) == -1)) {
 339        fix_st = &infoPtr->minDate;
 340      }
 341   }
 342
 343   if (fix && fix_st) {
 344     date->wYear  = fix_st->wYear;
 345     date->wMonth = fix_st->wMonth;
 346   }
 347
 348   return fix_st ? FALSE : TRUE;
 349 }
 350
 351 /* Checks passed range width with configured maximum selection count
 352  *
 353  * PARAMETERS
 354  *
 355  *  [I] infoPtr : valid pointer to control data
 356  *  [I] range0  : pointer to valid date data (requested bound)
 357  *  [I] range1  : pointer to valid date data (primary bound)
 358  *  [O] adjust  : returns adjusted range bound to fit maximum range (optional)
 359  *
 360  *  Adjust value computed basing on primary bound and current maximum selection
 361  *  count. For simple range check (without adjusted value required) (range0, range1)
 362  *  relation means nothing.
 363  *
 364  * RETURN VALUE
 365  *
 366  *  TRUE  - range is shorter or equal to maximum
 367  *  FALSE - range is larger than maximum
 368  */
 369 static BOOL MONTHCAL_IsSelRangeValid(const MONTHCAL_INFO *infoPtr,
 370                                      const SYSTEMTIME *range0,
 371                                      const SYSTEMTIME *range1,
 372                                      SYSTEMTIME *adjust)
 373 {
 374   ULARGE_INTEGER ul_range0, ul_range1, ul_diff;
 375   FILETIME ft_range0, ft_range1;
 376   LONG cmp;
 377
 378   SystemTimeToFileTime(range0, &ft_range0);
 379   SystemTimeToFileTime(range1, &ft_range1);
 380
 381   ul_range0.u.LowPart  = ft_range0.dwLowDateTime;
 382   ul_range0.u.HighPart = ft_range0.dwHighDateTime;
 383   ul_range1.u.LowPart  = ft_range1.dwLowDateTime;
 384   ul_range1.u.HighPart = ft_range1.dwHighDateTime;
 385
 386   cmp = CompareFileTime(&ft_range0, &ft_range1);
 387
 388   if(cmp == 1)
 389      ul_diff.QuadPart = ul_range0.QuadPart - ul_range1.QuadPart;
 390   else
 391      ul_diff.QuadPart = -ul_range0.QuadPart + ul_range1.QuadPart;
 392
 393   if(ul_diff.QuadPart >= DAYSTO100NSECS(infoPtr->maxSelCount)) {
 394
 395      if(adjust) {
 396        if(cmp == 1)
 397           ul_range0.QuadPart = ul_range1.QuadPart + DAYSTO100NSECS(infoPtr->maxSelCount - 1);
 398        else
 399           ul_range0.QuadPart = ul_range1.QuadPart - DAYSTO100NSECS(infoPtr->maxSelCount - 1);
 400
 401        ft_range0.dwLowDateTime  = ul_range0.u.LowPart;
 402        ft_range0.dwHighDateTime = ul_range0.u.HighPart;
 403        FileTimeToSystemTime(&ft_range0, adjust);
 404      }
 405
 406      return FALSE;
 407   }
 408   else return TRUE;
 409 }
 410
 411 /* Used in MCM_SETRANGE/MCM_SETSELRANGE to determine resulting time part.
 412    Milliseconds are intentionally not validated. */
 413 static BOOL MONTHCAL_ValidateTime(const SYSTEMTIME *time)
 414 {
 415   if((time->wHour > 24) || (time->wMinute > 59) || (time->wSecond > 59))
 416     return FALSE;
 417   else
 418     return TRUE;
 419 }
 420
 421 /* Note:Depending on DST, this may be offset by a day.
 422    Need to find out if we're on a DST place & adjust the clock accordingly.
 423    Above function assumes we have a valid data.
 424    Valid for year>1752;  1 <= d <= 31, 1 <= m <= 12.
 425    0 = Sunday.
 426 */
 427
 428 /* Returns the day in the week
 429  *
 430  * PARAMETERS
 431  *  [i] date    : input date
 432  *  [I] inplace : set calculated value back to date structure
 433  *
 434  * RETURN VALUE
 435  *   day of week in SYSTEMTIME format: (0 == sunday,..., 6 == saturday)
 436  */
 437 int MONTHCAL_CalculateDayOfWeek(SYSTEMTIME *date, BOOL inplace)
 438 {
 439   SYSTEMTIME st = st_null;
 440   FILETIME ft;
 441
 442   MONTHCAL_CopyDate(date, &st);
 443
 444   SystemTimeToFileTime(&st, &ft);
 445   FileTimeToSystemTime(&ft, &st);
 446
 447   if (inplace) date->wDayOfWeek = st.wDayOfWeek;
 448
 449   return st.wDayOfWeek;
 450 }
 451
 452 /* add/substract 'months' from date */
 453 static inline void MONTHCAL_GetMonth(SYSTEMTIME *date, INT months)
 454 {
 455   INT length, m = date->wMonth + months;
 456
 457   date->wYear += m > 0 ? (m - 1) / 12 : m / 12 - 1;
 458   date->wMonth = m > 0 ? (m - 1) % 12 + 1 : 12 + m % 12;
 459   /* fix moving from last day in a month */
 460   length = MONTHCAL_MonthLength(date->wMonth, date->wYear);
 461   if(date->wDay > length) date->wDay = length;
 462   MONTHCAL_CalculateDayOfWeek(date, TRUE);
 463 }
 464
 465 /* properly updates date to point on next month */
 466 static inline void MONTHCAL_GetNextMonth(SYSTEMTIME *date)
 467 {
 468   return MONTHCAL_GetMonth(date, 1);
 469 }
 470
 471 /* properly updates date to point on prev month */
 472 static inline void MONTHCAL_GetPrevMonth(SYSTEMTIME *date)
 473 {
 474   return MONTHCAL_GetMonth(date, -1);
 475 }
 476
 477 /* Returns full date for a first currently visible day */
 478 static void MONTHCAL_GetMinDate(const MONTHCAL_INFO *infoPtr, SYSTEMTIME *date)
 479 {
 480   /* zero indexed calendar has the earliest date */
 481   SYSTEMTIME st_first = infoPtr->calendars[0].month;
 482   INT firstDay;
 483
 484   st_first.wDay = 1;
 485   firstDay = MONTHCAL_CalculateDayOfWeek(&st_first, FALSE);
 486
 487   *date = infoPtr->calendars[0].month;
 488   MONTHCAL_GetPrevMonth(date);
 489
 490   date->wDay = MONTHCAL_MonthLength(date->wMonth, date->wYear) +
 491                (infoPtr->firstDay - firstDay) % 7 + 1;
 492
 493   if(date->wDay > MONTHCAL_MonthLength(date->wMonth, date->wYear))
 494     date->wDay -= 7;
 495
 496   /* fix day of week */
 497   MONTHCAL_CalculateDayOfWeek(date, TRUE);
 498 }
 499
 500 /* Returns full date for a last currently visible day */
 501 static void MONTHCAL_GetMaxDate(const MONTHCAL_INFO *infoPtr, SYSTEMTIME *date)
 502 {
 503   /* the latest date is in latest calendar */
 504   SYSTEMTIME st, lt_month = infoPtr->calendars[infoPtr->cal_num-1].month;
 505
 506   *date = lt_month;
 507   MONTHCAL_GetNextMonth(date);
 508
 509   MONTHCAL_GetMinDate(infoPtr, &st);
 510   /* Use month length to get max day. 42 means max day count in calendar area */
 511   date->wDay = 42 - (MONTHCAL_MonthLength(st.wMonth, st.wYear) - st.wDay + 1) -
 512                      MONTHCAL_MonthLength(lt_month.wMonth, lt_month.wYear);
 513
 514   /* fix day of week */
 515   MONTHCAL_CalculateDayOfWeek(date, TRUE);
 516 }
 517
 518 /* From a given point, calculate the row (weekpos), column(daypos)
 519    and day in the calendar. day== 0 mean the last day of tha last month
 520 */
 521 static int MONTHCAL_CalcDayFromPos(const MONTHCAL_INFO *infoPtr, int x, int y,
 522                                    int *daypos, int *weekpos)
 523 {
 524   int retval, firstDay;
 525   RECT rcClient;
 526   SYSTEMTIME st = infoPtr->minSel;
 527
 528   GetClientRect(infoPtr->hwndSelf, &rcClient);
 529
 530   /* if the point is outside the x bounds of the window put
 531   it at the boundary */
 532   if (x > rcClient.right)
 533     x = rcClient.right;
 534
 535   *daypos  = (x - infoPtr->calendars[0].days.left ) / infoPtr->width_increment;
 536   *weekpos = (y - infoPtr->calendars[0].days.top ) / infoPtr->height_increment;
 537
 538   st.wDay = 1;
 539   firstDay = (MONTHCAL_CalculateDayOfWeek(&st, FALSE) + 6 - infoPtr->firstDay) % 7;
 540   retval = *daypos + (7 * *weekpos) - firstDay;
 541   return retval;
 542 }
 543
 544 /* Sets the RECT struct r to the rectangle around the date
 545  *
 546  * PARAMETERS
 547  *
 548  *  [I] infoPtr : pointer to control data
 549  *  [I] date : date value
 550  *  [O] x : day column (zero based)
 551  *  [O] y : week column (zero based)
 552  */
 553 static void MONTHCAL_CalcDayXY(const MONTHCAL_INFO *infoPtr,
 554                                const SYSTEMTIME *date, INT *x, INT *y)
 555 {
 556   SYSTEMTIME st = infoPtr->minSel;
 557   LONG cmp;
 558   int first;
 559
 560   st.wDay = 1;
 561   first = (MONTHCAL_CalculateDayOfWeek(&st, FALSE) + 6 - infoPtr->firstDay) % 7;
 562
 563   cmp = MONTHCAL_CompareMonths(date, &infoPtr->minSel);
 564
 565   /* previous month */
 566   if(cmp == -1) {
 567     *x = (first - MONTHCAL_MonthLength(date->wMonth, infoPtr->minSel.wYear) + date->wDay) % 7;
 568     *y = 0;
 569     return;
 570   }
 571
 572   /* next month calculation is same as for current,
 573      just add current month length */
 574   if(cmp == 1) {
 575     first += MONTHCAL_MonthLength(infoPtr->minSel.wMonth, infoPtr->minSel.wYear);
 576   }
 577
 578   *x = (date->wDay + first) % 7;
 579   *y = (date->wDay + first - *x) / 7;
 580 }
 581
 582
 583 /* x: column(day), y: row(week) */
 584 static inline void MONTHCAL_CalcDayRect(const MONTHCAL_INFO *infoPtr, RECT *r, int x, int y)
 585 {
 586   r->left = infoPtr->calendars[0].days.left + x * infoPtr->width_increment;
 587   r->right = r->left + infoPtr->width_increment;
 588   r->top  = infoPtr->calendars[0].days.top  + y * infoPtr->height_increment;
 589   r->bottom = r->top + infoPtr->textHeight;
 590 }
 591
 592
 593 /* Sets the RECT struct r to the rectangle around the date */
 594 static inline void MONTHCAL_CalcPosFromDay(const MONTHCAL_INFO *infoPtr,
 595                                            const SYSTEMTIME *date, RECT *r)
 596 {
 597   int x, y;
 598
 599   MONTHCAL_CalcDayXY(infoPtr, date, &x, &y);
 600   MONTHCAL_CalcDayRect(infoPtr, r, x, y);
 601 }
 602
 603 /* Focused day helper:
 604
 605    - set focused date to given value;
 606    - reset to zero value if NULL passed;
 607    - invalidate previous and new day rectangle only if needed.
 608
 609    Returns TRUE if focused day changed, FALSE otherwise.
 610 */
 611 static BOOL MONTHCAL_SetDayFocus(MONTHCAL_INFO *infoPtr, const SYSTEMTIME *st)
 612 {
 613   RECT r;
 614
 615   if(st)
 616   {
 617     /* there's nothing to do if it's the same date,
 618        mouse move within same date rectangle case */
 619     if(MONTHCAL_IsDateEqual(&infoPtr->focusedSel, st)) return FALSE;
 620
 621     /* invalidate old focused day */
 622     MONTHCAL_CalcPosFromDay(infoPtr, &infoPtr->focusedSel, &r);
 623     InvalidateRect(infoPtr->hwndSelf, &r, FALSE);
 624
 625     infoPtr->focusedSel = *st;
 626   }
 627
 628   MONTHCAL_CalcPosFromDay(infoPtr, &infoPtr->focusedSel, &r);
 629
 630   if(!st && MONTHCAL_ValidateDate(&infoPtr->focusedSel))
 631     infoPtr->focusedSel = st_null;
 632
 633   /* on set invalidates new day, on reset clears previous focused day */
 634   InvalidateRect(infoPtr->hwndSelf, &r, FALSE);
 635
 636   return TRUE;
 637 }
 638
 639 /* Draw today day mark rectangle
 640  *
 641  * [I] hdc : context to draw in
 642  * [I] day : day to mark with rectangle
 643  *
 644  */
 645 static void MONTHCAL_CircleDay(const MONTHCAL_INFO *infoPtr, HDC hdc,
 646                                const SYSTEMTIME *date)
 647 {
 648   HPEN hRedPen = CreatePen(PS_SOLID, 1, RGB(255, 0, 0));
 649   HPEN hOldPen2 = SelectObject(hdc, hRedPen);
 650   HBRUSH hOldBrush;
 651   RECT day_rect;
 652
 653   MONTHCAL_CalcPosFromDay(infoPtr, date, &day_rect);
 654
 655   hOldBrush = SelectObject(hdc, GetStockObject(NULL_BRUSH));
 656   Rectangle(hdc, day_rect.left, day_rect.top, day_rect.right, day_rect.bottom);
 657
 658   SelectObject(hdc, hOldBrush);
 659   DeleteObject(hRedPen);
 660   SelectObject(hdc, hOldPen2);
 661 }
 662
 663 static void MONTHCAL_DrawDay(const MONTHCAL_INFO *infoPtr, HDC hdc, const SYSTEMTIME *st,
 664                              int bold, const PAINTSTRUCT *ps)
 665 {
 666   static const WCHAR fmtW[] = { '%','d',0 };
 667   WCHAR buf[10];
 668   RECT r, r_temp;
 669   COLORREF oldCol = 0;
 670   COLORREF oldBk  = 0;
 671   INT old_bkmode, selection;
 672
 673   /* no need to check styles: when selection is not valid, it is set to zero.
 674      1 < day < 31, so everything is OK */
 675   MONTHCAL_CalcPosFromDay(infoPtr, st, &r);
 676   if(!IntersectRect(&r_temp, &(ps->rcPaint), &r)) return;
 677
 678   if ((MONTHCAL_CompareDate(st, &infoPtr->minSel) >= 0) &&
 679       (MONTHCAL_CompareDate(st, &infoPtr->maxSel) <= 0))
 680   {
 681
 682     TRACE("%d %d %d\n", st->wDay, infoPtr->minSel.wDay, infoPtr->maxSel.wDay);
 683     TRACE("%s\n", wine_dbgstr_rect(&r));
 684     oldCol = SetTextColor(hdc, infoPtr->colors[MCSC_MONTHBK]);
 685     oldBk = SetBkColor(hdc, infoPtr->colors[MCSC_TRAILINGTEXT]);
 686     FillRect(hdc, &r, infoPtr->brushes[MCSC_TITLEBK]);
 687
 688     selection = 1;
 689   }
 690   else
 691     selection = 0;
 692
 693   SelectObject(hdc, bold ? infoPtr->hBoldFont : infoPtr->hFont);
 694
 695   old_bkmode = SetBkMode(hdc, TRANSPARENT);
 696   wsprintfW(buf, fmtW, st->wDay);
 697   DrawTextW(hdc, buf, -1, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE );
 698   SetBkMode(hdc, old_bkmode);
 699
 700   if (selection)
 701   {
 702     SetTextColor(hdc, oldCol);
 703     SetBkColor(hdc, oldBk);
 704   }
 705 }
 706
 707
 708 static void MONTHCAL_PaintButton(MONTHCAL_INFO *infoPtr, HDC hdc, enum nav_direction button)
 709 {
 710     HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
 711     RECT *r = button == DIRECTION_FORWARD ? &infoPtr->titlebtnnext : &infoPtr->titlebtnprev;
 712     BOOL pressed = button == DIRECTION_FORWARD ? infoPtr->status & MC_NEXTPRESSED :
 713                                                  infoPtr->status & MC_PREVPRESSED;
 714     if (theme)
 715     {
 716         static const int states[] = {
 717             /* Prev button */
 718             ABS_LEFTNORMAL,  ABS_LEFTPRESSED,  ABS_LEFTDISABLED,
 719             /* Next button */
 720             ABS_RIGHTNORMAL, ABS_RIGHTPRESSED, ABS_RIGHTDISABLED
 721         };
 722         int stateNum = button == DIRECTION_FORWARD ? 3 : 0;
 723         if (pressed)
 724             stateNum += 1;
 725         else
 726         {
 727             if (infoPtr->dwStyle & WS_DISABLED) stateNum += 2;
 728         }
 729         DrawThemeBackground (theme, hdc, SBP_ARROWBTN, states[stateNum], r, NULL);
 730     }
 731     else
 732     {
 733         int style = button == DIRECTION_FORWARD ? DFCS_SCROLLRIGHT : DFCS_SCROLLLEFT;
 734         if (pressed)
 735             style |= DFCS_PUSHED;
 736         else
 737         {
 738             if (infoPtr->dwStyle & WS_DISABLED) style |= DFCS_INACTIVE;
 739         }
 740
 741         DrawFrameControl(hdc, r, DFC_SCROLL, style);
 742     }
 743 }
 744 /* paint a title with buttons and month/year string */
 745 static void MONTHCAL_PaintTitle(MONTHCAL_INFO *infoPtr, HDC hdc, const PAINTSTRUCT *ps, INT calIdx)
 746 {
 747   static const WCHAR fmt_monthW[] = { '%','s',' ','%','l','d',0 };
 748   RECT *title = &infoPtr->calendars[calIdx].title;
 749   const SYSTEMTIME *st = &infoPtr->calendars[calIdx].month;
 750   WCHAR buf_month[80], buf_fmt[80];
 751   SIZE sz;
 752
 753   /* fill header box */
 754   FillRect(hdc, title, infoPtr->brushes[MCSC_TITLEBK]);
 755
 756   /* month/year string */
 757   SetBkColor(hdc, infoPtr->colors[MCSC_TITLEBK]);
 758   SetTextColor(hdc, infoPtr->colors[MCSC_TITLETEXT]);
 759   SelectObject(hdc, infoPtr->hBoldFont);
 760
 761   GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME1 + st->wMonth - 1,
 762                  buf_month, countof(buf_month));
 763
 764   wsprintfW(buf_fmt, fmt_monthW, buf_month, st->wYear);
 765   DrawTextW(hdc, buf_fmt, strlenW(buf_fmt), title,
 766                       DT_CENTER | DT_VCENTER | DT_SINGLELINE);
 767
 768   /* update title rectangles with current month - used while testing hits */
 769   GetTextExtentPoint32W(hdc, buf_fmt, strlenW(buf_fmt), &sz);
 770   infoPtr->calendars[calIdx].titlemonth.left = title->right / 2 + title->left / 2 - sz.cx / 2;
 771   infoPtr->calendars[calIdx].titleyear.right = title->right / 2 + title->left / 2 + sz.cx / 2;
 772
 773   GetTextExtentPoint32W(hdc, buf_month, strlenW(buf_month), &sz);
 774   infoPtr->calendars[calIdx].titlemonth.right = infoPtr->calendars[calIdx].titlemonth.left + sz.cx;
 775   infoPtr->calendars[calIdx].titleyear.left   = infoPtr->calendars[calIdx].titlemonth.right;
 776 }
 777
 778 static void MONTHCAL_PaintWeeknumbers(const MONTHCAL_INFO *infoPtr, HDC hdc, const PAINTSTRUCT *ps, INT calIdx)
 779 {
 780   const SYSTEMTIME *date = &infoPtr->calendars[calIdx].month;
 781   static const WCHAR fmt_weekW[] = { '%','d',0 };
 782   INT mindays, weeknum, weeknum1, startofprescal;
 783   INT i, prev_month;
 784   SYSTEMTIME st;
 785   WCHAR buf[80];
 786   RECT r;
 787
 788   if (!(infoPtr->dwStyle & MCS_WEEKNUMBERS)) return;
 789
 790   MONTHCAL_GetMinDate(infoPtr, &st);
 791   startofprescal = st.wDay;
 792   st = *date;
 793
 794   prev_month = date->wMonth - 1;
 795   if(prev_month == 0) prev_month = 12;
 796
 797   /*
 798      Rules what week to call the first week of a new year:
 799      LOCALE_IFIRSTWEEKOFYEAR == 0 (e.g US?):
 800      The week containing Jan 1 is the first week of year
 801      LOCALE_IFIRSTWEEKOFYEAR == 2 (e.g. Germany):
 802      First week of year must contain 4 days of the new year
 803      LOCALE_IFIRSTWEEKOFYEAR == 1  (what contries?)
 804      The first week of the year must contain only days of the new year
 805   */
 806   GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IFIRSTWEEKOFYEAR, buf, countof(buf));
 807   weeknum = atoiW(buf);
 808   switch (weeknum)
 809   {
 810     case 1: mindays = 6;
 811         break;
 812     case 2: mindays = 3;
 813         break;
 814     case 0: mindays = 0;
 815         break;
 816     default:
 817         WARN("Unknown LOCALE_IFIRSTWEEKOFYEAR value %d, defaulting to 0\n", weeknum);
 818         mindays = 0;
 819   }
 820
 821   if (date->wMonth == 1)
 822   {
 823     /* calculate all those exceptions for january */
 824     st.wDay = st.wMonth = 1;
 825     weeknum1 = MONTHCAL_CalculateDayOfWeek(&st, FALSE);
 826     if ((infoPtr->firstDay - weeknum1) % 7 > mindays)
 827         weeknum = 1;
 828     else
 829     {
 830         weeknum = 0;
 831         for(i = 0; i < 11; i++)
 832            weeknum += MONTHCAL_MonthLength(i+1, date->wYear - 1);
 833
 834         weeknum  += startofprescal + 7;
 835         weeknum  /= 7;
 836         st.wYear -= 1;
 837         weeknum1  = MONTHCAL_CalculateDayOfWeek(&st, FALSE);
 838         if ((infoPtr->firstDay - weeknum1) % 7 > mindays) weeknum++;
 839     }
 840   }
 841   else
 842   {
 843     weeknum = 0;
 844     for(i = 0; i < prev_month - 1; i++)
 845         weeknum += MONTHCAL_MonthLength(i+1, date->wYear);
 846
 847     weeknum += startofprescal + 7;
 848     weeknum /= 7;
 849     st.wDay = st.wMonth = 1;
 850     weeknum1 = MONTHCAL_CalculateDayOfWeek(&st, FALSE);
 851     if ((infoPtr->firstDay - weeknum1) % 7 > mindays) weeknum++;
 852   }
 853
 854   r = infoPtr->calendars[calIdx].weeknums;
 855
 856   /* erase whole week numbers area */
 857   FillRect(hdc, &r, infoPtr->brushes[MCSC_MONTHBK]);
 858   SetTextColor(hdc, infoPtr->colors[MCSC_TITLEBK]);
 859
 860   /* reduce rectangle to one week number */
 861   r.bottom = r.top + infoPtr->height_increment;
 862
 863   for(i = 0; i < 6; i++) {
 864     if((i == 0) && (weeknum > 50))
 865     {
 866         wsprintfW(buf, fmt_weekW, weeknum);
 867         weeknum = 0;
 868     }
 869     else if((i == 5) && (weeknum > 47))
 870     {
 871         wsprintfW(buf, fmt_weekW, 1);
 872     }
 873     else
 874         wsprintfW(buf, fmt_weekW, weeknum + i);
 875
 876     DrawTextW(hdc, buf, -1, &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
 877     OffsetRect(&r, 0, infoPtr->height_increment);
 878   }
 879
 880   /* line separator for week numbers column */
 881   MoveToEx(hdc, infoPtr->calendars[calIdx].weeknums.right, infoPtr->calendars[calIdx].weeknums.top + 3 , NULL);
 882   LineTo(hdc,   infoPtr->calendars[calIdx].weeknums.right, infoPtr->calendars[calIdx].weeknums.bottom);
 883 }
 884
 885 /* bottom today date */
 886 static void MONTHCAL_PaintTodayTitle(const MONTHCAL_INFO *infoPtr, HDC hdc, const PAINTSTRUCT *ps)
 887 {
 888   if(!(infoPtr->dwStyle & MCS_NOTODAY))  {
 889     static const WCHAR todayW[] = { 'T','o','d','a','y',':',0 };
 890     static const WCHAR fmt_todayW[] = { '%','s',' ','%','s',0 };
 891     WCHAR buf_todayW[30], buf_dateW[20], buf[80];
 892     RECT rtoday;
 893
 894     if(!(infoPtr->dwStyle & MCS_NOTODAYCIRCLE)) {
 895       SYSTEMTIME fake_st;
 896
 897       MONTHCAL_GetMaxDate(infoPtr, &fake_st);
 898       /* this is always safe cause next month will never fully fit calendar */
 899       fake_st.wDay += 1;
 900       MONTHCAL_CircleDay(infoPtr, hdc, &fake_st);
 901     }
 902     if (!LoadStringW(COMCTL32_hModule, IDM_TODAY, buf_todayW, countof(buf_todayW)))
 903     {
 904         WARN("Can't load resource\n");
 905         strcpyW(buf_todayW, todayW);
 906     }
 907     MONTHCAL_CalcDayRect(infoPtr, &rtoday, 1, 6);
 908     GetDateFormatW(LOCALE_USER_DEFAULT, DATE_SHORTDATE, &infoPtr->todaysDate, NULL,
 909                                                         buf_dateW, countof(buf_dateW));
 910     SelectObject(hdc, infoPtr->hBoldFont);
 911
 912     wsprintfW(buf, fmt_todayW, buf_todayW, buf_dateW);
 913     DrawTextW(hdc, buf, -1, &rtoday, DT_CALCRECT | DT_LEFT | DT_VCENTER | DT_SINGLELINE);
 914     DrawTextW(hdc, buf, -1, &rtoday, DT_LEFT | DT_VCENTER | DT_SINGLELINE);
 915
 916     SelectObject(hdc, infoPtr->hFont);
 917   }
 918 }
 919
 920 /* today mark + focus */
 921 static void MONTHCAL_PaintFocusAndCircle(const MONTHCAL_INFO *infoPtr, HDC hdc, const PAINTSTRUCT *ps)
 922 {
 923   if((infoPtr->minSel.wMonth == infoPtr->todaysDate.wMonth) &&
 924      (infoPtr->minSel.wYear  == infoPtr->todaysDate.wYear) &&
 925     !(infoPtr->dwStyle & MCS_NOTODAYCIRCLE))
 926   {
 927     MONTHCAL_CircleDay(infoPtr, hdc, &infoPtr->todaysDate);
 928   }
 929
 930   if(!MONTHCAL_IsDateEqual(&infoPtr->focusedSel, &st_null))
 931   {
 932     RECT r;
 933     MONTHCAL_CalcPosFromDay(infoPtr, &infoPtr->focusedSel, &r);
 934     DrawFocusRect(hdc, &r);
 935   }
 936 }
 937
 938 /* months before first calendar month and after last calendar month */
 939 static void MONTHCAL_PaintLeadTrailMonths(const MONTHCAL_INFO *infoPtr, HDC hdc, const PAINTSTRUCT *ps)
 940 {
 941   INT mask, length;
 942   SYSTEMTIME st_max, st;
 943
 944   if (infoPtr->dwStyle & MCS_NOTRAILINGDATES) return;
 945
 946   SetTextColor(hdc, infoPtr->colors[MCSC_TRAILINGTEXT]);
 947
 948   /* draw prev month */
 949   MONTHCAL_GetMinDate(infoPtr, &st);
 950   mask = 1 << (st.wDay-1);
 951   /* December and January both 31 days long, so no worries if wrapped */
 952   length = MONTHCAL_MonthLength(infoPtr->calendars[0].month.wMonth - 1,
 953                                 infoPtr->calendars[0].month.wYear);
 954   while(st.wDay <= length)
 955   {
 956       MONTHCAL_DrawDay(infoPtr, hdc, &st, infoPtr->monthdayState[0] & mask, ps);
 957       mask <<= 1;
 958       st.wDay++;
 959   }
 960
 961   /* draw next month */
 962   st = infoPtr->calendars[infoPtr->cal_num-1].month;
 963   st.wDay = 1;
 964   MONTHCAL_GetNextMonth(&st);
 965   MONTHCAL_GetMaxDate(infoPtr, &st_max);
 966   mask = 1;
 967
 968   while(st.wDay <= st_max.wDay)
 969   {
 970       MONTHCAL_DrawDay(infoPtr, hdc, &st, infoPtr->monthdayState[2] & mask, ps);
 971       mask <<= 1;
 972       st.wDay++;
 973   }
 974 }
 975
 976 /* paint a calendar area */
 977 static void MONTHCAL_PaintCalendar(const MONTHCAL_INFO *infoPtr, HDC hdc, const PAINTSTRUCT *ps, INT calIdx)
 978 {
 979   const SYSTEMTIME *date = &infoPtr->calendars[calIdx].month;
 980   INT prev_month, i, j, length;
 981   RECT r, fill_bk_rect;
 982   SYSTEMTIME st;
 983   WCHAR buf[80];
 984   int mask;
 985
 986   /* fill whole days area - from week days area to today note rectangle */
 987   fill_bk_rect = infoPtr->calendars[calIdx].wdays;
 988   fill_bk_rect.bottom = infoPtr->calendars[calIdx].days.bottom +
 989                           (infoPtr->todayrect.bottom - infoPtr->todayrect.top);
 990
 991   FillRect(hdc, &fill_bk_rect, infoPtr->brushes[MCSC_MONTHBK]);
 992
 993   /* draw line under day abbreviations */
 994   MoveToEx(hdc, infoPtr->calendars[calIdx].days.left + 3,
 995                 infoPtr->calendars[calIdx].title.bottom + infoPtr->textHeight + 1, NULL);
 996   LineTo(hdc, infoPtr->calendars[calIdx].days.right - 3,
 997               infoPtr->calendars[calIdx].title.bottom + infoPtr->textHeight + 1);
 998
 999   prev_month = date->wMonth - 1;
1000   if (prev_month == 0) prev_month = 12;
1001
1002   infoPtr->calendars[calIdx].wdays.left = infoPtr->calendars[calIdx].days.left =
1003       infoPtr->calendars[calIdx].weeknums.right;
1004
1005   /* draw day abbreviations */
1006   SelectObject(hdc, infoPtr->hFont);
1007   SetBkColor(hdc, infoPtr->colors[MCSC_MONTHBK]);
1008   SetTextColor(hdc, infoPtr->colors[MCSC_TITLEBK]);
1009   /* rectangle to draw a single day abbreviation within */
1010   r = infoPtr->calendars[calIdx].wdays;
1011   r.right = r.left + infoPtr->width_increment;
1012
1013   i = infoPtr->firstDay;
1014   for(j = 0; j < 7; j++) {
1015     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1 + (i+j+6)%7, buf, countof(buf));
1016     DrawTextW(hdc, buf, strlenW(buf), &r, DT_CENTER | DT_VCENTER | DT_SINGLELINE);
1017     OffsetRect(&r, infoPtr->width_increment, 0);
1018   }
1019
1020   /* draw current month */
1021   SetTextColor(hdc, infoPtr->colors[MCSC_TEXT]);
1022   st = *date;
1023   st.wDay = 1;
1024   mask = 1;
1025   length = MONTHCAL_MonthLength(date->wMonth, date->wYear);
1026   while(st.wDay <= length)
1027   {
1028     MONTHCAL_DrawDay(infoPtr, hdc, &st, infoPtr->monthdayState[1] & mask, ps);
1029     mask <<= 1;
1030     st.wDay++;
1031   }
1032 }
1033
1034 static void MONTHCAL_Refresh(MONTHCAL_INFO *infoPtr, HDC hdc, const PAINTSTRUCT *ps)
1035 {
1036   COLORREF old_text_clr, old_bk_clr;
1037   HFONT old_font;
1038   INT i;
1039
1040   old_text_clr = SetTextColor(hdc, comctl32_color.clrWindowText);
1041   old_bk_clr   = GetBkColor(hdc);
1042   old_font     = GetCurrentObject(hdc, OBJ_FONT);
1043
1044   for (i = 0; i < infoPtr->cal_num; i++)
1045   {
1046     RECT *title = &infoPtr->calendars[i].title;
1047     RECT r;
1048
1049     /* draw title, redraw all its elements */
1050     if (IntersectRect(&r, &(ps->rcPaint), title))
1051         MONTHCAL_PaintTitle(infoPtr, hdc, ps, i);
1052
1053     /* draw calendar area */
1054     UnionRect(&r, &infoPtr->calendars[i].wdays, &infoPtr->todayrect);
1055     if (IntersectRect(&r, &(ps->rcPaint), &r))
1056         MONTHCAL_PaintCalendar(infoPtr, hdc, ps, i);
1057
1058     /* week numbers */
1059     MONTHCAL_PaintWeeknumbers(infoPtr, hdc, ps, i);
1060   }
1061
1062   /* partially visible months */
1063   MONTHCAL_PaintLeadTrailMonths(infoPtr, hdc, ps);
1064
1065   /* focus and today rectangle */
1066   MONTHCAL_PaintFocusAndCircle(infoPtr, hdc, ps);
1067
1068   /* today at the bottom left */
1069   MONTHCAL_PaintTodayTitle(infoPtr, hdc, ps);
1070
1071   /* navigation buttons */
1072   MONTHCAL_PaintButton(infoPtr, hdc, DIRECTION_BACKWARD);
1073   MONTHCAL_PaintButton(infoPtr, hdc, DIRECTION_FORWARD);
1074
1075   /* restore context */
1076   SetBkColor(hdc, old_bk_clr);
1077   SelectObject(hdc, old_font);
1078   SetTextColor(hdc, old_text_clr);
1079 }
1080
1081 static LRESULT
1082 MONTHCAL_GetMinReqRect(const MONTHCAL_INFO *infoPtr, RECT *rect)
1083 {
1084   TRACE("rect %p\n", rect);
1085
1086   if(!rect) return FALSE;
1087
1088   *rect = infoPtr->calendars[0].title;
1089   rect->bottom = infoPtr->calendars[0].days.bottom + infoPtr->todayrect.bottom -
1090                  infoPtr->todayrect.top;
1091
1092   AdjustWindowRect(rect, infoPtr->dwStyle, FALSE);
1093
1094   /* minimal rectangle is zero based */
1095   OffsetRect(rect, -rect->left, -rect->top);
1096
1097   TRACE("%s\n", wine_dbgstr_rect(rect));
1098
1099   return TRUE;
1100 }
1101
1102 static COLORREF
1103 MONTHCAL_GetColor(const MONTHCAL_INFO *infoPtr, UINT index)
1104 {
1105   TRACE("%p, %d\n", infoPtr, index);
1106
1107   if (index > MCSC_TRAILINGTEXT) return -1;
1108   return infoPtr->colors[index];
1109 }
1110
1111 static LRESULT
1112 MONTHCAL_SetColor(MONTHCAL_INFO *infoPtr, UINT index, COLORREF color)
1113 {
1114   COLORREF prev;
1115
1116   TRACE("%p, %d: color %08x\n", infoPtr, index, color);
1117
1118   if (index > MCSC_TRAILINGTEXT) return -1;
1119
1120   prev = infoPtr->colors[index];
1121   infoPtr->colors[index] = color;
1122
1123   /* update cached brush */
1124   if (index == MCSC_BACKGROUND || index == MCSC_TITLEBK || index == MCSC_MONTHBK)
1125   {
1126     DeleteObject(infoPtr->brushes[index]);
1127     infoPtr->brushes[index] = CreateSolidBrush(color);
1128   }
1129
1130   InvalidateRect(infoPtr->hwndSelf, NULL, index == MCSC_BACKGROUND ? TRUE : FALSE);
1131   return prev;
1132 }
1133
1134 static LRESULT
1135 MONTHCAL_GetMonthDelta(const MONTHCAL_INFO *infoPtr)
1136 {
1137   TRACE("\n");
1138
1139   if(infoPtr->delta)
1140     return infoPtr->delta;
1141   else
1142     return infoPtr->visible;
1143 }
1144
1145
1146 static LRESULT
1147 MONTHCAL_SetMonthDelta(MONTHCAL_INFO *infoPtr, INT delta)
1148 {
1149   INT prev = infoPtr->delta;
1150
1151   TRACE("delta %d\n", delta);
1152
1153   infoPtr->delta = delta;
1154   return prev;
1155 }
1156
1157
1158 static inline LRESULT
1159 MONTHCAL_GetFirstDayOfWeek(const MONTHCAL_INFO *infoPtr)
1160 {
1161   int day;
1162
1163   /* convert from SYSTEMTIME to locale format */
1164   day = (infoPtr->firstDay >= 0) ? (infoPtr->firstDay+6)%7 : infoPtr->firstDay;
1165
1166   return MAKELONG(day, infoPtr->firstDaySet);
1167 }
1168
1169
1170 /* Sets the first day of the week that will appear in the control
1171  *
1172  *
1173  * PARAMETERS:
1174  *  [I] infoPtr : valid pointer to control data
1175  *  [I] day : day number to set as new first day (0 == Monday,...,6 == Sunday)
1176  *
1177  *
1178  * RETURN VALUE:
1179  *  Low word contains previous first day,
1180  *  high word indicates was first day forced with this message before or is
1181  *  locale difined (TRUE - was forced, FALSE - wasn't).
1182  *
1183  * FIXME: this needs to be implemented properly in MONTHCAL_Refresh()
1184  * FIXME: we need more error checking here
1185  */
1186 static LRESULT
1187 MONTHCAL_SetFirstDayOfWeek(MONTHCAL_INFO *infoPtr, INT day)
1188 {
1189   LRESULT prev = MONTHCAL_GetFirstDayOfWeek(infoPtr);
1190   int new_day;
1191
1192   TRACE("%d\n", day);
1193
1194   if(day == -1)
1195   {
1196     WCHAR buf[80];
1197
1198     GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_IFIRSTDAYOFWEEK, buf, countof(buf));
1199     TRACE("%s %d\n", debugstr_w(buf), strlenW(buf));
1200
1201     new_day = atoiW(buf);
1202
1203     infoPtr->firstDaySet = FALSE;
1204   }
1205   else if(day >= 7)
1206   {
1207     new_day = 6; /* max first day allowed */
1208     infoPtr->firstDaySet = TRUE;
1209   }
1210   else
1211   {
1212     /* Native behaviour for that case is broken: invalid date number >31
1213        got displayed at (0,0) position, current month starts always from
1214        (1,0) position. Should be implemented here as well only if there's
1215        nothing else to do. */
1216     if (day < -1)
1217       FIXME("No bug compatibility for day=%d\n", day);
1218
1219     new_day = day;
1220     infoPtr->firstDaySet = TRUE;
1221   }
1222
1223   /* convert from locale to SYSTEMTIME format */
1224   infoPtr->firstDay = (new_day >= 0) ? (++new_day) % 7 : new_day;
1225
1226   InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1227
1228   return prev;
1229 }
1230
1231
1232 static LRESULT
1233 MONTHCAL_GetMonthRange(const MONTHCAL_INFO *infoPtr, DWORD flag, SYSTEMTIME *st)
1234 {
1235   TRACE("flag=%d, st=%p\n", flag, st);
1236
1237   if(st)
1238   {
1239     switch (flag) {
1240     case GMR_VISIBLE:
1241     {
1242         st[0] = infoPtr->calendars[0].month;
1243         st[1] = infoPtr->calendars[infoPtr->cal_num-1].month;
1244
1245         if (st[0].wMonth == min_allowed_date.wMonth &&
1246             st[0].wYear  == min_allowed_date.wYear)
1247         {
1248             st[0].wDay = min_allowed_date.wDay;
1249         }
1250         else
1251             st[0].wDay = 1;
1252         MONTHCAL_CalculateDayOfWeek(&st[0], TRUE);
1253
1254         st[1].wDay = MONTHCAL_MonthLength(st[1].wMonth, st[1].wYear);
1255         MONTHCAL_CalculateDayOfWeek(&st[1], TRUE);
1256
1257         return infoPtr->cal_num;
1258     }
1259     case GMR_DAYSTATE:
1260     {
1261         MONTHCAL_GetMinDate(infoPtr, &st[0]);
1262         MONTHCAL_GetMaxDate(infoPtr, &st[1]);
1263         break;
1264     }
1265     default:
1266         WARN("Unknown flag value, got %d\n", flag);
1267     }
1268   }
1269
1270   return infoPtr->monthRange;
1271 }
1272
1273
1274 static LRESULT
1275 MONTHCAL_GetMaxTodayWidth(const MONTHCAL_INFO *infoPtr)
1276 {
1277   return(infoPtr->todayrect.right - infoPtr->todayrect.left);
1278 }
1279
1280
1281 static LRESULT
1282 MONTHCAL_SetRange(MONTHCAL_INFO *infoPtr, SHORT limits, SYSTEMTIME *range)
1283 {
1284     FILETIME ft_min, ft_max;
1285
1286     TRACE("%x %p\n", limits, range);
1287
1288     if ((limits & GDTR_MIN && !MONTHCAL_ValidateDate(&range[0])) ||
1289         (limits & GDTR_MAX && !MONTHCAL_ValidateDate(&range[1])))
1290         return FALSE;
1291
1292     if (limits & GDTR_MIN)
1293     {
1294         if (!MONTHCAL_ValidateTime(&range[0]))
1295             MONTHCAL_CopyTime(&infoPtr->todaysDate, &range[0]);
1296
1297         infoPtr->minDate = range[0];
1298         infoPtr->rangeValid |= GDTR_MIN;
1299     }
1300     if (limits & GDTR_MAX)
1301     {
1302         if (!MONTHCAL_ValidateTime(&range[1]))
1303             MONTHCAL_CopyTime(&infoPtr->todaysDate, &range[1]);
1304
1305         infoPtr->maxDate = range[1];
1306         infoPtr->rangeValid |= GDTR_MAX;
1307     }
1308
1309     /* Only one limit set - we are done */
1310     if ((infoPtr->rangeValid & (GDTR_MIN | GDTR_MAX)) != (GDTR_MIN | GDTR_MAX))
1311         return TRUE;
1312
1313     SystemTimeToFileTime(&infoPtr->maxDate, &ft_max);
1314     SystemTimeToFileTime(&infoPtr->minDate, &ft_min);
1315
1316     if (CompareFileTime(&ft_min, &ft_max) >= 0)
1317     {
1318         if ((limits & (GDTR_MIN | GDTR_MAX)) == (GDTR_MIN | GDTR_MAX))
1319         {
1320             /* Native swaps limits only when both limits are being set. */
1321             SYSTEMTIME st_tmp = infoPtr->minDate;
1322             infoPtr->minDate  = infoPtr->maxDate;
1323             infoPtr->maxDate  = st_tmp;
1324         }
1325         else
1326         {
1327             /* reset the other limit */
1328             if (limits & GDTR_MIN) infoPtr->maxDate = st_null;
1329             if (limits & GDTR_MAX) infoPtr->minDate = st_null;
1330             infoPtr->rangeValid &= limits & GDTR_MIN ? ~GDTR_MAX : ~GDTR_MIN;
1331         }
1332     }
1333
1334     return TRUE;
1335 }
1336
1337
1338 static LRESULT
1339 MONTHCAL_GetRange(const MONTHCAL_INFO *infoPtr, SYSTEMTIME *range)
1340 {
1341   TRACE("%p\n", range);
1342
1343   if(!range) return FALSE;
1344
1345   range[1] = infoPtr->maxDate;
1346   range[0] = infoPtr->minDate;
1347
1348   return infoPtr->rangeValid;
1349 }
1350
1351
1352 static LRESULT
1353 MONTHCAL_SetDayState(const MONTHCAL_INFO *infoPtr, INT months, MONTHDAYSTATE *states)
1354 {
1355   TRACE("%p %d %p\n", infoPtr, months, states);
1356   if(months != infoPtr->monthRange) return 0;
1357
1358   memcpy(infoPtr->monthdayState, states, months*sizeof(MONTHDAYSTATE));
1359
1360   return 1;
1361 }
1362
1363 static LRESULT
1364 MONTHCAL_GetCurSel(const MONTHCAL_INFO *infoPtr, SYSTEMTIME *curSel)
1365 {
1366   TRACE("%p\n", curSel);
1367   if(!curSel) return FALSE;
1368   if(infoPtr->dwStyle & MCS_MULTISELECT) return FALSE;
1369
1370   *curSel = infoPtr->minSel;
1371   TRACE("%d/%d/%d\n", curSel->wYear, curSel->wMonth, curSel->wDay);
1372   return TRUE;
1373 }
1374
1375 static LRESULT
1376 MONTHCAL_SetCurSel(MONTHCAL_INFO *infoPtr, SYSTEMTIME *curSel)
1377 {
1378   SYSTEMTIME prev = infoPtr->minSel;
1379   WORD day;
1380
1381   TRACE("%p\n", curSel);
1382   if(!curSel) return FALSE;
1383   if(infoPtr->dwStyle & MCS_MULTISELECT) return FALSE;
1384
1385   if(!MONTHCAL_ValidateDate(curSel)) return FALSE;
1386   /* exit earlier if selection equals current */
1387   if (MONTHCAL_IsDateEqual(&infoPtr->minSel, curSel)) return TRUE;
1388
1389   if(!MONTHCAL_IsDateInValidRange(infoPtr, curSel, FALSE)) return FALSE;
1390
1391   infoPtr->calendars[0].month = *curSel;
1392   infoPtr->minSel = *curSel;
1393   infoPtr->maxSel = *curSel;
1394
1395   /* if selection is still in current month, reduce rectangle */
1396   day = prev.wDay;
1397   prev.wDay = curSel->wDay;
1398   if (MONTHCAL_IsDateEqual(&prev, curSel))
1399   {
1400     RECT r_prev, r_new;
1401
1402     prev.wDay = day;
1403     MONTHCAL_CalcPosFromDay(infoPtr, &prev, &r_prev);
1404     MONTHCAL_CalcPosFromDay(infoPtr, curSel, &r_new);
1405
1406     InvalidateRect(infoPtr->hwndSelf, &r_prev, FALSE);
1407     InvalidateRect(infoPtr->hwndSelf, &r_new,  FALSE);
1408   }
1409   else
1410     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1411
1412   return TRUE;
1413 }
1414
1415
1416 static LRESULT
1417 MONTHCAL_GetMaxSelCount(const MONTHCAL_INFO *infoPtr)
1418 {
1419   return infoPtr->maxSelCount;
1420 }
1421
1422
1423 static LRESULT
1424 MONTHCAL_SetMaxSelCount(MONTHCAL_INFO *infoPtr, INT max)
1425 {
1426   TRACE("%d\n", max);
1427
1428   if(!(infoPtr->dwStyle & MCS_MULTISELECT)) return FALSE;
1429   if(max <= 0) return FALSE;
1430
1431   infoPtr->maxSelCount = max;
1432
1433   return TRUE;
1434 }
1435
1436
1437 static LRESULT
1438 MONTHCAL_GetSelRange(const MONTHCAL_INFO *infoPtr, SYSTEMTIME *range)
1439 {
1440   TRACE("%p\n", range);
1441
1442   if(!range) return FALSE;
1443
1444   if(infoPtr->dwStyle & MCS_MULTISELECT)
1445   {
1446     range[1] = infoPtr->maxSel;
1447     range[0] = infoPtr->minSel;
1448     TRACE("[min,max]=[%d %d]\n", infoPtr->minSel.wDay, infoPtr->maxSel.wDay);
1449     return TRUE;
1450   }
1451
1452   return FALSE;
1453 }
1454
1455
1456 static LRESULT
1457 MONTHCAL_SetSelRange(MONTHCAL_INFO *infoPtr, SYSTEMTIME *range)
1458 {
1459   TRACE("%p\n", range);
1460
1461   if(!range) return FALSE;
1462
1463   if(infoPtr->dwStyle & MCS_MULTISELECT)
1464   {
1465     SYSTEMTIME old_range[2];
1466
1467     /* adjust timestamps */
1468     if(!MONTHCAL_ValidateTime(&range[0]))
1469       MONTHCAL_CopyTime(&infoPtr->todaysDate, &range[0]);
1470     if(!MONTHCAL_ValidateTime(&range[1]))
1471       MONTHCAL_CopyTime(&infoPtr->todaysDate, &range[1]);
1472
1473     /* maximum range exceeded */
1474     if(!MONTHCAL_IsSelRangeValid(infoPtr, &range[0], &range[1], NULL)) return FALSE;
1475
1476     old_range[0] = infoPtr->minSel;
1477     old_range[1] = infoPtr->maxSel;
1478
1479     /* swap if min > max */
1480     if(MONTHCAL_CompareSystemTime(&range[0], &range[1]) <= 0)
1481     {
1482       infoPtr->minSel = range[0];
1483       infoPtr->maxSel = range[1];
1484     }
1485     else
1486     {
1487       infoPtr->minSel = range[1];
1488       infoPtr->maxSel = range[0];
1489     }
1490     infoPtr->calendars[0].month = infoPtr->minSel;
1491
1492     /* update day of week */
1493     MONTHCAL_CalculateDayOfWeek(&infoPtr->minSel, TRUE);
1494     MONTHCAL_CalculateDayOfWeek(&infoPtr->maxSel, TRUE);
1495
1496     /* redraw if bounds changed */
1497     /* FIXME: no actual need to redraw everything */
1498     if(!MONTHCAL_IsDateEqual(&old_range[0], &range[0]) ||
1499        !MONTHCAL_IsDateEqual(&old_range[1], &range[1]))
1500     {
1501        InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1502     }
1503
1504     TRACE("[min,max]=[%d %d]\n", infoPtr->minSel.wDay, infoPtr->maxSel.wDay);
1505     return TRUE;
1506   }
1507
1508   return FALSE;
1509 }
1510
1511
1512 static LRESULT
1513 MONTHCAL_GetToday(const MONTHCAL_INFO *infoPtr, SYSTEMTIME *today)
1514 {
1515   TRACE("%p\n", today);
1516
1517   if(!today) return FALSE;
1518   *today = infoPtr->todaysDate;
1519   return TRUE;
1520 }
1521
1522 /* Internal helper for MCM_SETTODAY handler and auto update timer handler
1523  *
1524  * RETURN VALUE
1525  *
1526  *  TRUE  - today date changed
1527  *  FALSE - today date isn't changed
1528  */
1529 static BOOL
1530 MONTHCAL_UpdateToday(MONTHCAL_INFO *infoPtr, const SYSTEMTIME *today)
1531 {
1532   RECT new_r, old_r;
1533
1534   if(MONTHCAL_IsDateEqual(today, &infoPtr->todaysDate)) return FALSE;
1535
1536   MONTHCAL_CalcPosFromDay(infoPtr, &infoPtr->todaysDate, &old_r);
1537   MONTHCAL_CalcPosFromDay(infoPtr, today, &new_r);
1538
1539   infoPtr->todaysDate = *today;
1540
1541   /* only two days need redrawing */
1542   InvalidateRect(infoPtr->hwndSelf, &old_r, FALSE);
1543   InvalidateRect(infoPtr->hwndSelf, &new_r, FALSE);
1544   return TRUE;
1545 }
1546
1547 /* MCM_SETTODAT handler */
1548 static LRESULT
1549 MONTHCAL_SetToday(MONTHCAL_INFO *infoPtr, const SYSTEMTIME *today)
1550 {
1551   TRACE("%p\n", today);
1552
1553   if(!today) return FALSE;
1554
1555   /* remember if date was set successfully */
1556   if(MONTHCAL_UpdateToday(infoPtr, today)) infoPtr->todaySet = TRUE;
1557
1558   return TRUE;
1559 }
1560
1561 /* returns calendar index containing specified point, or -1 if it's background */
1562 static INT MONTHCAL_GetCalendarFromPoint(const MONTHCAL_INFO *infoPtr, const POINT *pt)
1563 {
1564   RECT r;
1565   INT i;
1566
1567   for (i = 0; i < infoPtr->cal_num; i++)
1568   {
1569      /* whole bounding rectangle allows some optimization to compute */
1570      r.left   = infoPtr->calendars[i].title.left;
1571      r.top    = infoPtr->calendars[i].title.top;
1572      r.bottom = infoPtr->calendars[i].days.bottom;
1573      r.right  = infoPtr->calendars[i].days.right;
1574
1575      if (PtInRect(&r, *pt)) return i;
1576   }
1577
1578   return -1;
1579 }
1580
1581 static inline UINT fill_hittest_info(const MCHITTESTINFO *src, MCHITTESTINFO *dest)
1582 {
1583   dest->uHit = src->uHit;
1584   dest->st = src->st;
1585
1586   if (dest->cbSize == sizeof(MCHITTESTINFO))
1587     memcpy(&dest->rc, &src->rc, sizeof(MCHITTESTINFO) - MCHITTESTINFO_V1_SIZE);
1588
1589   return src->uHit;
1590 }
1591
1592 static LRESULT
1593 MONTHCAL_HitTest(const MONTHCAL_INFO *infoPtr, MCHITTESTINFO *lpht)
1594 {
1595   INT day, wday, wnum, calIdx;
1596   MCHITTESTINFO htinfo;
1597   SYSTEMTIME ht_month;
1598   UINT x, y;
1599
1600   if(!lpht || lpht->cbSize < MCHITTESTINFO_V1_SIZE) return -1;
1601
1602   x = lpht->pt.x;
1603   y = lpht->pt.y;
1604
1605   htinfo.st = st_null;
1606
1607   /* we should preserve passed fields if hit area doesn't need them */
1608   if (lpht->cbSize == sizeof(MCHITTESTINFO))
1609     memcpy(&htinfo.rc, &lpht->rc, sizeof(MCHITTESTINFO) - MCHITTESTINFO_V1_SIZE);
1610
1611   /* Comment in for debugging...
1612   TRACE("%d %d wd[%d %d %d %d] d[%d %d %d %d] t[%d %d %d %d] wn[%d %d %d %d]\n", x, y,
1613         infoPtr->wdays.left, infoPtr->wdays.right,
1614         infoPtr->wdays.top, infoPtr->wdays.bottom,
1615         infoPtr->days.left, infoPtr->days.right,
1616         infoPtr->days.top, infoPtr->days.bottom,
1617         infoPtr->todayrect.left, infoPtr->todayrect.right,
1618         infoPtr->todayrect.top, infoPtr->todayrect.bottom,
1619         infoPtr->weeknums.left, infoPtr->weeknums.right,
1620         infoPtr->weeknums.top, infoPtr->weeknums.bottom);
1621   */
1622
1623   /* guess in what calendar we are */
1624   calIdx = MONTHCAL_GetCalendarFromPoint(infoPtr, &lpht->pt);
1625   if (calIdx == -1)
1626   {
1627     if (PtInRect(&infoPtr->todayrect, lpht->pt))
1628     {
1629       htinfo.uHit = MCHT_TODAYLINK;
1630       htinfo.rc = infoPtr->todayrect;
1631     }
1632     else
1633       /* outside of calendar area? What's left must be background :-) */
1634       htinfo.uHit = MCHT_CALENDARBK;
1635
1636     return fill_hittest_info(&htinfo, lpht);
1637   }
1638
1639   ht_month = infoPtr->calendars[calIdx].month;
1640
1641   /* are we in the header? */
1642   if (PtInRect(&infoPtr->calendars[calIdx].title, lpht->pt)) {
1643     /* FIXME: buttons hittesting could be optimized cause maximum
1644               two calendars have buttons */
1645     if (calIdx == 0 && PtInRect(&infoPtr->titlebtnprev, lpht->pt))
1646     {
1647       htinfo.uHit = MCHT_TITLEBTNPREV;
1648       htinfo.rc = infoPtr->titlebtnprev;
1649     }
1650     else if (PtInRect(&infoPtr->titlebtnnext, lpht->pt))
1651     {
1652       htinfo.uHit = MCHT_TITLEBTNNEXT;
1653       htinfo.rc = infoPtr->titlebtnnext;
1654     }
1655     else if (PtInRect(&infoPtr->calendars[calIdx].titlemonth, lpht->pt))
1656     {
1657       htinfo.uHit = MCHT_TITLEMONTH;
1658       htinfo.rc = infoPtr->calendars[calIdx].titlemonth;
1659       htinfo.iOffset = calIdx;
1660     }
1661     else if (PtInRect(&infoPtr->calendars[calIdx].titleyear, lpht->pt))
1662     {
1663       htinfo.uHit = MCHT_TITLEYEAR;
1664       htinfo.rc = infoPtr->calendars[calIdx].titleyear;
1665       htinfo.iOffset = calIdx;
1666     }
1667     else
1668     {
1669       htinfo.uHit = MCHT_TITLE;
1670       htinfo.rc = infoPtr->calendars[calIdx].title;
1671       htinfo.iOffset = calIdx;
1672     }
1673
1674     return fill_hittest_info(&htinfo, lpht);
1675   }
1676
1677   /* days area (including week days and week numbers */
1678   day = MONTHCAL_CalcDayFromPos(infoPtr, x, y, &wday, &wnum);
1679   if (PtInRect(&infoPtr->calendars[calIdx].wdays, lpht->pt))
1680   {
1681     htinfo.uHit = MCHT_CALENDARDAY;
1682     htinfo.iOffset = calIdx;
1683     htinfo.st.wYear  = ht_month.wYear;
1684     htinfo.st.wMonth = (day < 1) ? ht_month.wMonth -1 : ht_month.wMonth;
1685     htinfo.st.wDay   = (day < 1) ?
1686       MONTHCAL_MonthLength(ht_month.wMonth-1, ht_month.wYear) - day : day;
1687
1688     MONTHCAL_CalcDayXY(infoPtr, &htinfo.st, &htinfo.iCol, &htinfo.iRow);
1689   }
1690   else if(PtInRect(&infoPtr->calendars[calIdx].weeknums, lpht->pt))
1691   {
1692     htinfo.uHit = MCHT_CALENDARWEEKNUM;
1693     htinfo.st.wYear  = ht_month.wYear;
1694     htinfo.iOffset = calIdx;
1695
1696     if (day < 1)
1697     {
1698       htinfo.st.wMonth = ht_month.wMonth - 1;
1699       htinfo.st.wDay = MONTHCAL_MonthLength(ht_month.wMonth-1, ht_month.wYear) - day;
1700     }
1701     else if (day > MONTHCAL_MonthLength(ht_month.wMonth, ht_month.wYear))
1702     {
1703       htinfo.st.wMonth = ht_month.wMonth + 1;
1704       htinfo.st.wDay = day - MONTHCAL_MonthLength(ht_month.wMonth, ht_month.wYear);
1705     }
1706     else
1707     {
1708       htinfo.st.wMonth = ht_month.wMonth;
1709       htinfo.st.wDay = day;
1710     }
1711   }
1712   else if(PtInRect(&infoPtr->calendars[calIdx].days, lpht->pt))
1713   {
1714       htinfo.iOffset = calIdx;
1715       htinfo.st.wYear  = ht_month.wYear;
1716       htinfo.st.wMonth = ht_month.wMonth;
1717       if (day < 1)
1718       {
1719           htinfo.uHit = MCHT_CALENDARDATEPREV;
1720           MONTHCAL_GetPrevMonth(&htinfo.st);
1721           htinfo.st.wDay = MONTHCAL_MonthLength(htinfo.st.wMonth, htinfo.st.wYear) + day;
1722       }
1723       else if (day > MONTHCAL_MonthLength(ht_month.wMonth, ht_month.wYear))
1724       {
1725           htinfo.uHit = MCHT_CALENDARDATENEXT;
1726           MONTHCAL_GetNextMonth(&htinfo.st);
1727           htinfo.st.wDay = day - MONTHCAL_MonthLength(ht_month.wMonth, ht_month.wYear);
1728       }
1729       else
1730       {
1731         htinfo.uHit = MCHT_CALENDARDATE;
1732         htinfo.st.wDay = day;
1733       }
1734
1735       MONTHCAL_CalcDayXY(infoPtr, &htinfo.st, &htinfo.iCol, &htinfo.iRow);
1736       MONTHCAL_CalcDayRect(infoPtr, &htinfo.rc, htinfo.iCol, htinfo.iRow);
1737       /* always update day of week */
1738       MONTHCAL_CalculateDayOfWeek(&htinfo.st, TRUE);
1739   }
1740
1741   return fill_hittest_info(&htinfo, lpht);
1742 }
1743
1744 /* MCN_GETDAYSTATE notification helper */
1745 static void MONTHCAL_NotifyDayState(MONTHCAL_INFO *infoPtr)
1746 {
1747   if(infoPtr->dwStyle & MCS_DAYSTATE) {
1748     NMDAYSTATE nmds;
1749
1750     nmds.nmhdr.hwndFrom = infoPtr->hwndSelf;
1751     nmds.nmhdr.idFrom   = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
1752     nmds.nmhdr.code     = MCN_GETDAYSTATE;
1753     nmds.cDayState      = infoPtr->monthRange;
1754     nmds.prgDayState    = Alloc(infoPtr->monthRange * sizeof(MONTHDAYSTATE));
1755
1756     nmds.stStart = infoPtr->todaysDate;
1757     nmds.stStart.wYear  = infoPtr->minSel.wYear;
1758     nmds.stStart.wMonth = infoPtr->minSel.wMonth;
1759     nmds.stStart.wDay = 1;
1760
1761     SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, nmds.nmhdr.idFrom, (LPARAM)&nmds);
1762     memcpy(infoPtr->monthdayState, nmds.prgDayState, infoPtr->monthRange*sizeof(MONTHDAYSTATE));
1763
1764     Free(nmds.prgDayState);
1765   }
1766 }
1767
1768 /* no valid range check performed */
1769 static void MONTHCAL_Scroll(MONTHCAL_INFO *infoPtr, INT delta)
1770 {
1771   INT i, selIdx = -1;
1772
1773   for(i = 0; i < infoPtr->cal_num; i++)
1774   {
1775     /* save selection position to shift it later */
1776     if (selIdx == -1 && MONTHCAL_CompareMonths(&infoPtr->minSel, &infoPtr->calendars[i].month) == 0)
1777       selIdx = i;
1778
1779     MONTHCAL_GetMonth(&infoPtr->calendars[i].month, delta);
1780   }
1781
1782   /* selection is always shifted to first calendar */
1783   if(infoPtr->dwStyle & MCS_MULTISELECT)
1784   {
1785     SYSTEMTIME range[2];
1786
1787     MONTHCAL_GetSelRange(infoPtr, range);
1788     MONTHCAL_GetMonth(&range[0], delta - selIdx);
1789     MONTHCAL_GetMonth(&range[1], delta - selIdx);
1790     MONTHCAL_SetSelRange(infoPtr, range);
1791   }
1792   else
1793   {
1794     SYSTEMTIME st = infoPtr->minSel;
1795
1796     MONTHCAL_GetMonth(&st, delta - selIdx);
1797     MONTHCAL_SetCurSel(infoPtr, &st);
1798   }
1799 }
1800
1801 static void MONTHCAL_GoToMonth(MONTHCAL_INFO *infoPtr, enum nav_direction direction)
1802 {
1803   INT delta = infoPtr->delta ? infoPtr->delta : infoPtr->cal_num;
1804   SYSTEMTIME st;
1805
1806   TRACE("%s\n", direction == DIRECTION_BACKWARD ? "back" : "fwd");
1807
1808   /* check if change allowed by range set */
1809   if(direction == DIRECTION_BACKWARD)
1810   {
1811     st = infoPtr->calendars[0].month;
1812     MONTHCAL_GetMonth(&st, -delta);
1813   }
1814   else
1815   {
1816     st = infoPtr->calendars[infoPtr->cal_num-1].month;
1817     MONTHCAL_GetMonth(&st, delta);
1818   }
1819
1820   if(!MONTHCAL_IsDateInValidRange(infoPtr, &st, FALSE)) return;
1821
1822   MONTHCAL_Scroll(infoPtr, direction == DIRECTION_BACKWARD ? -delta : delta);
1823   MONTHCAL_NotifyDayState(infoPtr);
1824   MONTHCAL_NotifySelectionChange(infoPtr);
1825 }
1826
1827 static LRESULT
1828 MONTHCAL_RButtonUp(MONTHCAL_INFO *infoPtr, LPARAM lParam)
1829 {
1830   static const WCHAR todayW[] = { 'G','o',' ','t','o',' ','T','o','d','a','y',':',0 };
1831   HMENU hMenu;
1832   POINT menupoint;
1833   WCHAR buf[32];
1834
1835   hMenu = CreatePopupMenu();
1836   if (!LoadStringW(COMCTL32_hModule, IDM_GOTODAY, buf, countof(buf)))
1837   {
1838       WARN("Can't load resource\n");
1839       strcpyW(buf, todayW);
1840   }
1841   AppendMenuW(hMenu, MF_STRING|MF_ENABLED, 1, buf);
1842   menupoint.x = (short)LOWORD(lParam);
1843   menupoint.y = (short)HIWORD(lParam);
1844   ClientToScreen(infoPtr->hwndSelf, &menupoint);
1845   if( TrackPopupMenu(hMenu, TPM_RIGHTBUTTON | TPM_NONOTIFY | TPM_RETURNCMD,
1846                      menupoint.x, menupoint.y, 0, infoPtr->hwndSelf, NULL))
1847   {
1848       infoPtr->calendars[0].month = infoPtr->todaysDate;
1849       infoPtr->minSel = infoPtr->todaysDate;
1850       infoPtr->maxSel = infoPtr->todaysDate;
1851       InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1852   }
1853
1854   return 0;
1855 }
1856
1857 /***
1858  * DESCRIPTION:
1859  * Subclassed edit control windproc function
1860  *
1861  * PARAMETER(S):
1862  * [I] hwnd : the edit window handle
1863  * [I] uMsg : the message that is to be processed
1864  * [I] wParam : first message parameter
1865  * [I] lParam : second message parameter
1866  *
1867  */
1868 static LRESULT CALLBACK EditWndProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
1869 {
1870     MONTHCAL_INFO *infoPtr = (MONTHCAL_INFO *)GetWindowLongPtrW(GetParent(hwnd), 0);
1871
1872     TRACE("(hwnd=%p, uMsg=%x, wParam=%lx, lParam=%lx)\n",
1873           hwnd, uMsg, wParam, lParam);
1874
1875     switch (uMsg)
1876     {
1877         case WM_GETDLGCODE:
1878           return DLGC_WANTARROWS | DLGC_WANTALLKEYS;
1879
1880         case WM_DESTROY:
1881         {
1882             WNDPROC editProc = infoPtr->EditWndProc;
1883             infoPtr->EditWndProc = NULL;
1884             SetWindowLongPtrW(hwnd, GWLP_WNDPROC, (DWORD_PTR)editProc);
1885             return CallWindowProcW(editProc, hwnd, uMsg, wParam, lParam);
1886         }
1887
1888         case WM_KILLFOCUS:
1889             break;
1890
1891         case WM_KEYDOWN:
1892             if ((VK_ESCAPE == (INT)wParam) || (VK_RETURN == (INT)wParam))
1893                 break;
1894
1895         default:
1896             return CallWindowProcW(infoPtr->EditWndProc, hwnd, uMsg, wParam, lParam);
1897     }
1898
1899     SendMessageW(infoPtr->hWndYearUpDown, WM_CLOSE, 0, 0);
1900     SendMessageW(hwnd, WM_CLOSE, 0, 0);
1901     return 0;
1902 }
1903
1904 /* creates updown control and edit box */
1905 static void MONTHCAL_EditYear(MONTHCAL_INFO *infoPtr, INT calIdx)
1906 {
1907     RECT *rc = &infoPtr->calendars[calIdx].titleyear;
1908     RECT *title = &infoPtr->calendars[calIdx].title;
1909
1910     infoPtr->hWndYearEdit =
1911         CreateWindowExW(0, WC_EDITW, 0, WS_VISIBLE | WS_CHILD | ES_READONLY,
1912                         rc->left + 3, (title->bottom + title->top - infoPtr->textHeight) / 2,
1913                         rc->right - rc->left + 4,
1914                         infoPtr->textHeight, infoPtr->hwndSelf,
1915                         NULL, NULL, NULL);
1916
1917     SendMessageW(infoPtr->hWndYearEdit, WM_SETFONT, (WPARAM)infoPtr->hBoldFont, TRUE);
1918
1919     infoPtr->hWndYearUpDown =
1920         CreateWindowExW(0, UPDOWN_CLASSW, 0,
1921                         WS_VISIBLE | WS_CHILD | UDS_SETBUDDYINT | UDS_NOTHOUSANDS | UDS_ARROWKEYS,
1922                         rc->right + 7, (title->bottom + title->top - infoPtr->textHeight) / 2,
1923                         18, infoPtr->textHeight, infoPtr->hwndSelf,
1924                         NULL, NULL, NULL);
1925
1926     /* attach edit box */
1927     SendMessageW(infoPtr->hWndYearUpDown, UDM_SETRANGE, 0,
1928                  MAKELONG(max_allowed_date.wYear, min_allowed_date.wYear));
1929     SendMessageW(infoPtr->hWndYearUpDown, UDM_SETBUDDY, (WPARAM)infoPtr->hWndYearEdit, 0);
1930     SendMessageW(infoPtr->hWndYearUpDown, UDM_SETPOS, 0, infoPtr->calendars[calIdx].month.wYear);
1931
1932     /* subclass edit box */
1933     infoPtr->EditWndProc = (WNDPROC)SetWindowLongPtrW(infoPtr->hWndYearEdit,
1934                                   GWLP_WNDPROC, (DWORD_PTR)EditWndProc);
1935
1936     SetFocus(infoPtr->hWndYearEdit);
1937 }
1938
1939 static LRESULT
1940 MONTHCAL_LButtonDown(MONTHCAL_INFO *infoPtr, LPARAM lParam)
1941 {
1942   MCHITTESTINFO ht;
1943   DWORD hit;
1944
1945   /* Actually we don't need input focus for calendar, this is used to kill
1946      year updown and its buddy edit box */
1947   if (IsWindow(infoPtr->hWndYearUpDown))
1948   {
1949       SetFocus(infoPtr->hwndSelf);
1950       return 0;
1951   }
1952
1953   SetCapture(infoPtr->hwndSelf);
1954
1955   ht.cbSize = sizeof(MCHITTESTINFO);
1956   ht.pt.x = (short)LOWORD(lParam);
1957   ht.pt.y = (short)HIWORD(lParam);
1958
1959   hit = MONTHCAL_HitTest(infoPtr, &ht);
1960
1961   TRACE("%x at (%d, %d)\n", hit, ht.pt.x, ht.pt.y);
1962
1963   switch(hit)
1964   {
1965   case MCHT_TITLEBTNNEXT:
1966     MONTHCAL_GoToMonth(infoPtr, DIRECTION_FORWARD);
1967     infoPtr->status = MC_NEXTPRESSED;
1968     SetTimer(infoPtr->hwndSelf, MC_PREVNEXTMONTHTIMER, MC_PREVNEXTMONTHDELAY, 0);
1969     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1970     return 0;
1971
1972   case MCHT_TITLEBTNPREV:
1973     MONTHCAL_GoToMonth(infoPtr, DIRECTION_BACKWARD);
1974     infoPtr->status = MC_PREVPRESSED;
1975     SetTimer(infoPtr->hwndSelf, MC_PREVNEXTMONTHTIMER, MC_PREVNEXTMONTHDELAY, 0);
1976     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
1977     return 0;
1978
1979   case MCHT_TITLEMONTH:
1980   {
1981     HMENU hMenu = CreatePopupMenu();
1982     WCHAR buf[32];
1983     POINT menupoint;
1984     INT i;
1985
1986     for (i = 0; i < 12; i++)
1987     {
1988         GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SMONTHNAME1+i, buf, countof(buf));
1989         AppendMenuW(hMenu, MF_STRING|MF_ENABLED, i + 1, buf);
1990     }
1991     menupoint.x = ht.pt.x;
1992     menupoint.y = ht.pt.y;
1993     ClientToScreen(infoPtr->hwndSelf, &menupoint);
1994     i = TrackPopupMenu(hMenu,TPM_LEFTALIGN | TPM_NONOTIFY | TPM_RIGHTBUTTON | TPM_RETURNCMD,
1995                        menupoint.x, menupoint.y, 0, infoPtr->hwndSelf, NULL);
1996
1997     if ((i > 0) && (i < 13) && infoPtr->calendars[ht.iOffset].month.wMonth != i)
1998     {
1999         INT delta = i - infoPtr->calendars[ht.iOffset].month.wMonth;
2000         SYSTEMTIME st;
2001
2002         /* check if change allowed by range set */
2003         st = delta < 0 ? infoPtr->calendars[0].month :
2004                          infoPtr->calendars[infoPtr->cal_num-1].month;
2005         MONTHCAL_GetMonth(&st, delta);
2006
2007         if (MONTHCAL_IsDateInValidRange(infoPtr, &st, FALSE))
2008         {
2009             MONTHCAL_Scroll(infoPtr, delta);
2010             MONTHCAL_NotifyDayState(infoPtr);
2011             MONTHCAL_NotifySelectionChange(infoPtr);
2012             InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
2013         }
2014     }
2015     return 0;
2016   }
2017   case MCHT_TITLEYEAR:
2018   {
2019     MONTHCAL_EditYear(infoPtr, ht.iOffset);
2020     return 0;
2021   }
2022   case MCHT_TODAYLINK:
2023   {
2024     infoPtr->calendars[0].month = infoPtr->todaysDate;
2025     infoPtr->minSel = infoPtr->todaysDate;
2026     infoPtr->maxSel = infoPtr->todaysDate;
2027     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
2028
2029     MONTHCAL_NotifySelectionChange(infoPtr);
2030     MONTHCAL_NotifySelect(infoPtr);
2031     return 0;
2032   }
2033   case MCHT_CALENDARDATENEXT:
2034   case MCHT_CALENDARDATEPREV:
2035   case MCHT_CALENDARDATE:
2036   {
2037     SYSTEMTIME st[2];
2038
2039     MONTHCAL_CopyDate(&ht.st, &infoPtr->firstSel);
2040
2041     st[0] = st[1] = ht.st;
2042     /* clear selection range */
2043     MONTHCAL_SetSelRange(infoPtr, st);
2044
2045     infoPtr->status = MC_SEL_LBUTDOWN;
2046     MONTHCAL_SetDayFocus(infoPtr, &ht.st);
2047     return 0;
2048   }
2049   }
2050
2051   return 1;
2052 }
2053
2054
2055 static LRESULT
2056 MONTHCAL_LButtonUp(MONTHCAL_INFO *infoPtr, LPARAM lParam)
2057 {
2058   NMHDR nmhdr;
2059   MCHITTESTINFO ht;
2060   DWORD hit;
2061
2062   TRACE("\n");
2063
2064   if(infoPtr->status & (MC_PREVPRESSED | MC_NEXTPRESSED)) {
2065     RECT *r;
2066
2067     KillTimer(infoPtr->hwndSelf, MC_PREVNEXTMONTHTIMER);
2068     r = infoPtr->status & MC_PREVPRESSED ? &infoPtr->titlebtnprev : &infoPtr->titlebtnnext;
2069     infoPtr->status &= ~(MC_PREVPRESSED | MC_NEXTPRESSED);
2070
2071     InvalidateRect(infoPtr->hwndSelf, r, FALSE);
2072   }
2073
2074   ReleaseCapture();
2075
2076   /* always send NM_RELEASEDCAPTURE notification */
2077   nmhdr.hwndFrom = infoPtr->hwndSelf;
2078   nmhdr.idFrom   = GetWindowLongPtrW(infoPtr->hwndSelf, GWLP_ID);
2079   nmhdr.code     = NM_RELEASEDCAPTURE;
2080   TRACE("Sent notification from %p to %p\n", infoPtr->hwndSelf, infoPtr->hwndNotify);
2081
2082   SendMessageW(infoPtr->hwndNotify, WM_NOTIFY, nmhdr.idFrom, (LPARAM)&nmhdr);
2083
2084   if(!(infoPtr->status & MC_SEL_LBUTDOWN)) return 0;
2085
2086   ht.cbSize = sizeof(MCHITTESTINFO);
2087   ht.pt.x = (short)LOWORD(lParam);
2088   ht.pt.y = (short)HIWORD(lParam);
2089   hit = MONTHCAL_HitTest(infoPtr, &ht);
2090
2091   infoPtr->status = MC_SEL_LBUTUP;
2092   MONTHCAL_SetDayFocus(infoPtr, NULL);
2093
2094   if((hit & MCHT_CALENDARDATE) == MCHT_CALENDARDATE)
2095   {
2096     SYSTEMTIME sel = infoPtr->minSel;
2097
2098     /* will be invalidated here */
2099     MONTHCAL_SetCurSel(infoPtr, &ht.st);
2100
2101     /* send MCN_SELCHANGE only if new date selected */
2102     if (!MONTHCAL_IsDateEqual(&sel, &ht.st))
2103         MONTHCAL_NotifySelectionChange(infoPtr);
2104
2105     MONTHCAL_NotifySelect(infoPtr);
2106   }
2107
2108   return 0;
2109 }
2110
2111
2112 static LRESULT
2113 MONTHCAL_Timer(MONTHCAL_INFO *infoPtr, WPARAM id)
2114 {
2115   TRACE("%ld\n", id);
2116
2117   switch(id) {
2118   case MC_PREVNEXTMONTHTIMER:
2119     if(infoPtr->status & MC_NEXTPRESSED) MONTHCAL_GoToMonth(infoPtr, DIRECTION_FORWARD);
2120     if(infoPtr->status & MC_PREVPRESSED) MONTHCAL_GoToMonth(infoPtr, DIRECTION_BACKWARD);
2121     InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
2122     break;
2123   case MC_TODAYUPDATETIMER:
2124   {
2125     SYSTEMTIME st;
2126
2127     if(infoPtr->todaySet) return 0;
2128
2129     GetLocalTime(&st);
2130     MONTHCAL_UpdateToday(infoPtr, &st);
2131
2132     /* notification sent anyway */
2133     MONTHCAL_NotifySelectionChange(infoPtr);
2134
2135     return 0;
2136   }
2137   default:
2138     ERR("got unknown timer %ld\n", id);
2139     break;
2140   }
2141
2142   return 0;
2143 }
2144
2145
2146 static LRESULT
2147 MONTHCAL_MouseMove(MONTHCAL_INFO *infoPtr, LPARAM lParam)
2148 {
2149   MCHITTESTINFO ht;
2150   SYSTEMTIME st_ht;
2151   INT hit;
2152   RECT r;
2153
2154   if(!(infoPtr->status & MC_SEL_LBUTDOWN)) return 0;
2155
2156   ht.cbSize = sizeof(MCHITTESTINFO);
2157   ht.pt.x = (short)LOWORD(lParam);
2158   ht.pt.y = (short)HIWORD(lParam);
2159
2160   hit = MONTHCAL_HitTest(infoPtr, &ht);
2161
2162   /* not on the calendar date numbers? bail out */
2163   TRACE("hit:%x\n",hit);
2164   if((hit & MCHT_CALENDARDATE) != MCHT_CALENDARDATE)
2165   {
2166     MONTHCAL_SetDayFocus(infoPtr, NULL);
2167     return 0;
2168   }
2169
2170   st_ht = ht.st;
2171
2172   /* if pointer is over focused day still there's nothing to do */
2173   if(!MONTHCAL_SetDayFocus(infoPtr, &ht.st)) return 0;
2174
2175   MONTHCAL_CalcPosFromDay(infoPtr, &ht.st, &r);
2176
2177   if(infoPtr->dwStyle & MCS_MULTISELECT) {
2178     SYSTEMTIME st[2];
2179
2180     MONTHCAL_GetSelRange(infoPtr, st);
2181
2182     /* If we're still at the first selected date and range is empty, return.
2183        If range isn't empty we should change range to a single firstSel */
2184     if(MONTHCAL_IsDateEqual(&infoPtr->firstSel, &st_ht) &&
2185        MONTHCAL_IsDateEqual(&st[0], &st[1])) goto done;
2186
2187     MONTHCAL_IsSelRangeValid(infoPtr, &st_ht, &infoPtr->firstSel, &st_ht);
2188
2189     st[0] = infoPtr->firstSel;
2190     /* we should overwrite timestamp here */
2191     MONTHCAL_CopyDate(&st_ht, &st[1]);
2192
2193     /* bounds will be swapped here if needed */
2194     MONTHCAL_SetSelRange(infoPtr, st);
2195
2196     return 0;
2197   }
2198
2199 done:
2200
2201   /* FIXME: this should specify a rectangle containing only the days that changed
2202      using InvalidateRect */
2203   InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
2204
2205   return 0;
2206 }
2207
2208
2209 static LRESULT
2210 MONTHCAL_Paint(MONTHCAL_INFO *infoPtr, HDC hdc_paint)
2211 {
2212   HDC hdc;
2213   PAINTSTRUCT ps;
2214
2215   if (hdc_paint)
2216   {
2217     GetClientRect(infoPtr->hwndSelf, &ps.rcPaint);
2218     hdc = hdc_paint;
2219   }
2220   else
2221     hdc = BeginPaint(infoPtr->hwndSelf, &ps);
2222
2223   MONTHCAL_Refresh(infoPtr, hdc, &ps);
2224   if (!hdc_paint) EndPaint(infoPtr->hwndSelf, &ps);
2225   return 0;
2226 }
2227
2228 static LRESULT
2229 MONTHCAL_EraseBkgnd(const MONTHCAL_INFO *infoPtr, HDC hdc)
2230 {
2231   RECT rc;
2232
2233   if (!GetClipBox(hdc, &rc)) return FALSE;
2234
2235   /* fill background */
2236   FillRect(hdc, &rc, infoPtr->brushes[MCSC_BACKGROUND]);
2237
2238   return TRUE;
2239 }
2240
2241 static LRESULT
2242 MONTHCAL_PrintClient(MONTHCAL_INFO *infoPtr, HDC hdc, DWORD options)
2243 {
2244   FIXME("Partial Stub: (hdc=%p options=0x%08x)\n", hdc, options);
2245
2246   if ((options & PRF_CHECKVISIBLE) && !IsWindowVisible(infoPtr->hwndSelf))
2247       return 0;
2248
2249   if (options & PRF_ERASEBKGND)
2250       MONTHCAL_EraseBkgnd(infoPtr, hdc);
2251
2252   if (options & PRF_CLIENT)
2253       MONTHCAL_Paint(infoPtr, hdc);
2254
2255   return 0;
2256 }
2257
2258 static LRESULT
2259 MONTHCAL_SetFocus(const MONTHCAL_INFO *infoPtr)
2260 {
2261   TRACE("\n");
2262
2263   InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
2264
2265   return 0;
2266 }
2267
2268 /* sets the size information */
2269 static void MONTHCAL_UpdateSize(MONTHCAL_INFO *infoPtr)
2270 {
2271   static const WCHAR O0W[] = { '0','0',0 };
2272   HDC hdc = GetDC(infoPtr->hwndSelf);
2273   RECT *title=&infoPtr->calendars[0].title;
2274   RECT *prev=&infoPtr->titlebtnprev;
2275   RECT *next=&infoPtr->titlebtnnext;
2276   RECT *titlemonth=&infoPtr->calendars[0].titlemonth;
2277   RECT *titleyear=&infoPtr->calendars[0].titleyear;
2278   RECT *wdays=&infoPtr->calendars[0].wdays;
2279   RECT *weeknumrect=&infoPtr->calendars[0].weeknums;
2280   RECT *days=&infoPtr->calendars[0].days;
2281   RECT *todayrect=&infoPtr->todayrect;
2282   SIZE size, sz;
2283   TEXTMETRICW tm;
2284   HFONT currentFont;
2285   INT xdiv, dx, dy, i;
2286   RECT rcClient;
2287   WCHAR buff[80];
2288
2289   GetClientRect(infoPtr->hwndSelf, &rcClient);
2290
2291   currentFont = SelectObject(hdc, infoPtr->hFont);
2292
2293   /* get the height and width of each day's text */
2294   GetTextMetricsW(hdc, &tm);
2295   infoPtr->textHeight = tm.tmHeight + tm.tmExternalLeading + tm.tmInternalLeading;
2296
2297   /* find largest abbreviated day name for current locale */
2298   size.cx = sz.cx = 0;
2299   for (i = 0; i < 7; i++)
2300   {
2301       if(GetLocaleInfoW(LOCALE_USER_DEFAULT, LOCALE_SABBREVDAYNAME1 + i,
2302                         buff, countof(buff)))
2303       {
2304           GetTextExtentPoint32W(hdc, buff, lstrlenW(buff), &sz);
2305           if (sz.cx > size.cx) size.cx = sz.cx;
2306       }
2307       else /* locale independent fallback on failure */
2308       {
2309           static const WCHAR SunW[] = { 'S','u','n',0 };
2310
2311           GetTextExtentPoint32W(hdc, SunW, lstrlenW(SunW), &size);
2312           break;
2313       }
2314   }
2315
2316   infoPtr->textWidth = size.cx + 2;
2317
2318   /* recalculate the height and width increments and offsets */
2319   GetTextExtentPoint32W(hdc, O0W, 2, &size);
2320
2321   xdiv = (infoPtr->dwStyle & MCS_WEEKNUMBERS) ? 8 : 7;
2322
2323   infoPtr->width_increment  = size.cx * 2 + 4;
2324   infoPtr->height_increment = infoPtr->textHeight;
2325
2326   /* calculate title area */
2327   title->top    = 0;
2328   title->bottom = 3 * infoPtr->height_increment / 2;
2329   title->left   = 0;
2330   title->right  = infoPtr->width_increment * xdiv;
2331
2332   /* set the dimensions of the next and previous buttons and center */
2333   /* the month text vertically */
2334   prev->top    = next->top    = title->top + 4;
2335   prev->bottom = next->bottom = title->bottom - 4;
2336   prev->left   = title->left + 4;
2337   prev->right  = prev->left + (title->bottom - title->top);
2338   next->right  = title->right - 4;
2339   next->left   = next->right - (title->bottom - title->top);
2340
2341   /* titlemonth->left and right change based upon the current month */
2342   /* and are recalculated in refresh as the current month may change */
2343   /* without the control being resized */
2344   titlemonth->top    = titleyear->top    = title->top    + (infoPtr->height_increment)/2;
2345   titlemonth->bottom = titleyear->bottom = title->bottom - (infoPtr->height_increment)/2;
2346
2347   /* setup the dimensions of the rectangle we draw the names of the */
2348   /* days of the week in */
2349   weeknumrect->left = 0;
2350
2351   if(infoPtr->dwStyle & MCS_WEEKNUMBERS)
2352     weeknumrect->right = prev->right;
2353   else
2354     weeknumrect->right = weeknumrect->left;
2355
2356   wdays->left   = days->left   = weeknumrect->right;
2357   wdays->right  = days->right  = wdays->left + 7 * infoPtr->width_increment;
2358   wdays->top    = title->bottom;
2359   wdays->bottom = wdays->top + infoPtr->height_increment;
2360
2361   days->top    = weeknumrect->top = wdays->bottom;
2362   days->bottom = weeknumrect->bottom = days->top + 6 * infoPtr->height_increment;
2363
2364   todayrect->left   = 0;
2365   todayrect->right  = title->right;
2366   todayrect->top    = days->bottom;
2367   todayrect->bottom = days->bottom + infoPtr->height_increment;
2368
2369   /* offset all rectangles to center in client area */
2370   dx = (rcClient.right  - title->right) / 2;
2371   dy = (rcClient.bottom - todayrect->bottom) / 2;
2372
2373   /* if calendar doesn't fit client area show it at left/top bounds */
2374   if (title->left + dx < 0) dx = 0;
2375   if (title->top  + dy < 0) dy = 0;
2376
2377   if (dx != 0 || dy != 0)
2378   {
2379     OffsetRect(title, dx, dy);
2380     OffsetRect(prev,  dx, dy);
2381     OffsetRect(next,  dx, dy);
2382     OffsetRect(titlemonth, dx, dy);
2383     OffsetRect(titleyear, dx, dy);
2384     OffsetRect(wdays, dx, dy);
2385     OffsetRect(weeknumrect, dx, dy);
2386     OffsetRect(days, dx, dy);
2387     OffsetRect(todayrect, dx, dy);
2388   }
2389
2390   TRACE("dx=%d dy=%d client[%s] title[%s] wdays[%s] days[%s] today[%s]\n",
2391         infoPtr->width_increment,infoPtr->height_increment,
2392         wine_dbgstr_rect(&rcClient),
2393         wine_dbgstr_rect(title),
2394         wine_dbgstr_rect(wdays),
2395         wine_dbgstr_rect(days),
2396         wine_dbgstr_rect(todayrect));
2397
2398   /* restore the originally selected font */
2399   SelectObject(hdc, currentFont);
2400
2401   ReleaseDC(infoPtr->hwndSelf, hdc);
2402 }
2403
2404 static LRESULT MONTHCAL_Size(MONTHCAL_INFO *infoPtr, int Width, int Height)
2405 {
2406   TRACE("(width=%d, height=%d)\n", Width, Height);
2407
2408   MONTHCAL_UpdateSize(infoPtr);
2409   InvalidateRect(infoPtr->hwndSelf, NULL, TRUE);
2410
2411   return 0;
2412 }
2413
2414 static LRESULT MONTHCAL_GetFont(const MONTHCAL_INFO *infoPtr)
2415 {
2416     return (LRESULT)infoPtr->hFont;
2417 }
2418
2419 static LRESULT MONTHCAL_SetFont(MONTHCAL_INFO *infoPtr, HFONT hFont, BOOL redraw)
2420 {
2421     HFONT hOldFont;
2422     LOGFONTW lf;
2423
2424     if (!hFont) return 0;
2425
2426     hOldFont = infoPtr->hFont;
2427     infoPtr->hFont = hFont;
2428
2429     GetObjectW(infoPtr->hFont, sizeof(lf), &lf);
2430     lf.lfWeight = FW_BOLD;
2431     infoPtr->hBoldFont = CreateFontIndirectW(&lf);
2432
2433     MONTHCAL_UpdateSize(infoPtr);
2434
2435     if (redraw)
2436         InvalidateRect(infoPtr->hwndSelf, NULL, FALSE);
2437
2438     return (LRESULT)hOldFont;
2439 }
2440
2441 /* update theme after a WM_THEMECHANGED message */
2442 static LRESULT theme_changed (const MONTHCAL_INFO* infoPtr)
2443 {
2444     HTHEME theme = GetWindowTheme (infoPtr->hwndSelf);
2445     CloseThemeData (theme);
2446     OpenThemeData (infoPtr->hwndSelf, themeClass);
2447     return 0;
2448 }
2449
2450 static INT MONTHCAL_StyleChanged(MONTHCAL_INFO *infoPtr, WPARAM wStyleType,
2451                                  const STYLESTRUCT *lpss)
2452 {
2453     TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
2454           wStyleType, lpss->styleOld, lpss->styleNew);
2455
2456     if (wStyleType != GWL_STYLE) return 0;
2457
2458     infoPtr->dwStyle = lpss->styleNew;
2459
2460     /* make room for week numbers */
2461     if ((lpss->styleNew ^ lpss->styleOld) & MCS_WEEKNUMBERS)
2462         MONTHCAL_UpdateSize(infoPtr);
2463
2464     return 0;
2465 }
2466
2467 static INT MONTHCAL_StyleChanging(MONTHCAL_INFO *infoPtr, WPARAM wStyleType,
2468                                   STYLESTRUCT *lpss)
2469 {
2470     TRACE("(styletype=%lx, styleOld=0x%08x, styleNew=0x%08x)\n",
2471           wStyleType, lpss->styleOld, lpss->styleNew);
2472
2473     /* block MCS_MULTISELECT change */
2474     if ((lpss->styleNew ^ lpss->styleOld) & MCS_MULTISELECT)
2475     {
2476         if (lpss->styleOld & MCS_MULTISELECT)
2477             lpss->styleNew |= MCS_MULTISELECT;
2478         else
2479             lpss->styleNew &= ~MCS_MULTISELECT;
2480     }
2481
2482     return 0;
2483 }
2484
2485 /* FIXME: check whether dateMin/dateMax need to be adjusted. */
2486 static LRESULT
2487 MONTHCAL_Create(HWND hwnd, LPCREATESTRUCTW lpcs)
2488 {
2489   MONTHCAL_INFO *infoPtr;
2490
2491   /* allocate memory for info structure */
2492   infoPtr = Alloc(sizeof(MONTHCAL_INFO));
2493   SetWindowLongPtrW(hwnd, 0, (DWORD_PTR)infoPtr);
2494
2495   if (infoPtr == NULL) {
2496     ERR("could not allocate info memory!\n");
2497     return 0;
2498   }
2499
2500   infoPtr->hwndSelf = hwnd;
2501   infoPtr->hwndNotify = lpcs->hwndParent;
2502   infoPtr->dwStyle  = GetWindowLongW(hwnd, GWL_STYLE);
2503   infoPtr->calendars = Alloc(sizeof(CALENDAR_INFO));
2504   if (!infoPtr->calendars) goto fail;
2505
2506   infoPtr->cal_num = 1;
2507
2508   MONTHCAL_SetFont(infoPtr, GetStockObject(DEFAULT_GUI_FONT), FALSE);
2509
2510   /* initialize info structure */
2511   /* FIXME: calculate systemtime ->> localtime(substract timezoneinfo) */
2512
2513   GetLocalTime(&infoPtr->todaysDate);
2514   MONTHCAL_SetFirstDayOfWeek(infoPtr, -1);
2515
2516   infoPtr->maxSelCount   = (infoPtr->dwStyle & MCS_MULTISELECT) ? 7 : 1;
2517   infoPtr->monthRange    = 3;
2518
2519   infoPtr->monthdayState = Alloc(infoPtr->monthRange * sizeof(MONTHDAYSTATE));
2520   if (!infoPtr->monthdayState) goto fail;
2521
2522   infoPtr->colors[MCSC_BACKGROUND]   = comctl32_color.clrWindow;
2523   infoPtr->colors[MCSC_TEXT]         = comctl32_color.clrWindowText;
2524   infoPtr->colors[MCSC_TITLEBK]      = comctl32_color.clrActiveCaption;
2525   infoPtr->colors[MCSC_TITLETEXT]    = comctl32_color.clrWindow;
2526   infoPtr->colors[MCSC_MONTHBK]      = comctl32_color.clrWindow;
2527   infoPtr->colors[MCSC_TRAILINGTEXT] = comctl32_color.clrGrayText;
2528
2529   infoPtr->brushes[MCSC_BACKGROUND]  = CreateSolidBrush(infoPtr->colors[MCSC_BACKGROUND]);
2530   infoPtr->brushes[MCSC_TITLEBK]     = CreateSolidBrush(infoPtr->colors[MCSC_TITLEBK]);
2531   infoPtr->brushes[MCSC_MONTHBK]     = CreateSolidBrush(infoPtr->colors[MCSC_MONTHBK]);
2532
2533   infoPtr->minSel = infoPtr->todaysDate;
2534   infoPtr->maxSel = infoPtr->todaysDate;
2535   infoPtr->calendars[0].month = infoPtr->todaysDate;
2536   infoPtr->isUnicode = TRUE;
2537
2538   /* call MONTHCAL_UpdateSize to set all of the dimensions */
2539   /* of the control */
2540   MONTHCAL_UpdateSize(infoPtr);
2541
2542   /* today auto update timer, to be freed only on control destruction */
2543   SetTimer(infoPtr->hwndSelf, MC_TODAYUPDATETIMER, MC_TODAYUPDATEDELAY, 0);
2544
2545   OpenThemeData (infoPtr->hwndSelf, themeClass);
2546
2547   return 0;
2548
2549 fail:
2550   Free(infoPtr->monthdayState);
2551   Free(infoPtr->calendars);
2552   Free(infoPtr);
2553   return 0;
2554 }
2555
2556 static LRESULT
2557 MONTHCAL_Destroy(MONTHCAL_INFO *infoPtr)
2558 {
2559   /* free month calendar info data */
2560   Free(infoPtr->monthdayState);
2561   Free(infoPtr->calendars);
2562   SetWindowLongPtrW(infoPtr->hwndSelf, 0, 0);
2563
2564   CloseThemeData (GetWindowTheme (infoPtr->hwndSelf));
2565
2566   DeleteObject(infoPtr->brushes[MCSC_BACKGROUND]);
2567   DeleteObject(infoPtr->brushes[MCSC_TITLEBK]);
2568   DeleteObject(infoPtr->brushes[MCSC_MONTHBK]);
2569
2570   Free(infoPtr);
2571   return 0;
2572 }
2573
2574 /*
2575  * Handler for WM_NOTIFY messages
2576  */
2577 static LRESULT
2578 MONTHCAL_Notify(MONTHCAL_INFO *infoPtr, NMHDR *hdr)
2579 {
2580   /* notification from year edit updown */
2581   if (hdr->code == UDN_DELTAPOS)
2582   {
2583     NMUPDOWN *nmud = (NMUPDOWN*)hdr;
2584
2585     if (hdr->hwndFrom == infoPtr->hWndYearUpDown && nmud->iDelta)
2586     {
2587       /* year value limits are set up explicitly after updown creation */
2588       MONTHCAL_Scroll(infoPtr, 12 * nmud->iDelta);
2589       MONTHCAL_NotifyDayState(infoPtr);
2590       MONTHCAL_NotifySelectionChange(infoPtr);
2591     }
2592   }
2593   return 0;
2594 }
2595
2596 static inline BOOL
2597 MONTHCAL_SetUnicodeFormat(MONTHCAL_INFO *infoPtr, BOOL isUnicode)
2598 {
2599   BOOL prev = infoPtr->isUnicode;
2600   infoPtr->isUnicode = isUnicode;
2601   return prev;
2602 }
2603
2604 static inline BOOL
2605 MONTHCAL_GetUnicodeFormat(const MONTHCAL_INFO *infoPtr)
2606 {
2607   return infoPtr->isUnicode;
2608 }
2609
2610 static LRESULT WINAPI
2611 MONTHCAL_WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
2612 {
2613   MONTHCAL_INFO *infoPtr = (MONTHCAL_INFO *)GetWindowLongPtrW(hwnd, 0);
2614
2615   TRACE("hwnd=%p msg=%x wparam=%lx lparam=%lx\n", hwnd, uMsg, wParam, lParam);
2616
2617   if (!infoPtr && (uMsg != WM_CREATE))
2618     return DefWindowProcW(hwnd, uMsg, wParam, lParam);
2619   switch(uMsg)
2620   {
2621   case MCM_GETCURSEL:
2622     return MONTHCAL_GetCurSel(infoPtr, (LPSYSTEMTIME)lParam);
2623
2624   case MCM_SETCURSEL:
2625     return MONTHCAL_SetCurSel(infoPtr, (LPSYSTEMTIME)lParam);
2626
2627   case MCM_GETMAXSELCOUNT:
2628     return MONTHCAL_GetMaxSelCount(infoPtr);
2629
2630   case MCM_SETMAXSELCOUNT:
2631     return MONTHCAL_SetMaxSelCount(infoPtr, wParam);
2632
2633   case MCM_GETSELRANGE:
2634     return MONTHCAL_GetSelRange(infoPtr, (LPSYSTEMTIME)lParam);
2635
2636   case MCM_SETSELRANGE:
2637     return MONTHCAL_SetSelRange(infoPtr, (LPSYSTEMTIME)lParam);
2638
2639   case MCM_GETMONTHRANGE:
2640     return MONTHCAL_GetMonthRange(infoPtr, wParam, (SYSTEMTIME*)lParam);
2641
2642   case MCM_SETDAYSTATE:
2643     return MONTHCAL_SetDayState(infoPtr, (INT)wParam, (LPMONTHDAYSTATE)lParam);
2644
2645   case MCM_GETMINREQRECT:
2646     return MONTHCAL_GetMinReqRect(infoPtr, (LPRECT)lParam);
2647
2648   case MCM_GETCOLOR:
2649     return MONTHCAL_GetColor(infoPtr, wParam);
2650
2651   case MCM_SETCOLOR:
2652     return MONTHCAL_SetColor(infoPtr, wParam, (COLORREF)lParam);
2653
2654   case MCM_GETTODAY:
2655     return MONTHCAL_GetToday(infoPtr, (LPSYSTEMTIME)lParam);
2656
2657   case MCM_SETTODAY:
2658     return MONTHCAL_SetToday(infoPtr, (LPSYSTEMTIME)lParam);
2659
2660   case MCM_HITTEST:
2661     return MONTHCAL_HitTest(infoPtr, (PMCHITTESTINFO)lParam);
2662
2663   case MCM_GETFIRSTDAYOFWEEK:
2664     return MONTHCAL_GetFirstDayOfWeek(infoPtr);
2665
2666   case MCM_SETFIRSTDAYOFWEEK:
2667     return MONTHCAL_SetFirstDayOfWeek(infoPtr, (INT)lParam);
2668
2669   case MCM_GETRANGE:
2670     return MONTHCAL_GetRange(infoPtr, (LPSYSTEMTIME)lParam);
2671
2672   case MCM_SETRANGE:
2673     return MONTHCAL_SetRange(infoPtr, (SHORT)wParam, (LPSYSTEMTIME)lParam);
2674
2675   case MCM_GETMONTHDELTA:
2676     return MONTHCAL_GetMonthDelta(infoPtr);
2677
2678   case MCM_SETMONTHDELTA:
2679     return MONTHCAL_SetMonthDelta(infoPtr, wParam);
2680
2681   case MCM_GETMAXTODAYWIDTH:
2682     return MONTHCAL_GetMaxTodayWidth(infoPtr);
2683
2684   case MCM_SETUNICODEFORMAT:
2685     return MONTHCAL_SetUnicodeFormat(infoPtr, (BOOL)wParam);
2686
2687   case MCM_GETUNICODEFORMAT:
2688     return MONTHCAL_GetUnicodeFormat(infoPtr);
2689
2690   case WM_GETDLGCODE:
2691     return DLGC_WANTARROWS | DLGC_WANTCHARS;
2692
2693   case WM_RBUTTONUP:
2694     return MONTHCAL_RButtonUp(infoPtr, lParam);
2695
2696   case WM_LBUTTONDOWN:
2697     return MONTHCAL_LButtonDown(infoPtr, lParam);
2698
2699   case WM_MOUSEMOVE:
2700     return MONTHCAL_MouseMove(infoPtr, lParam);
2701
2702   case WM_LBUTTONUP:
2703     return MONTHCAL_LButtonUp(infoPtr, lParam);
2704
2705   case WM_PAINT:
2706     return MONTHCAL_Paint(infoPtr, (HDC)wParam);
2707
2708   case WM_PRINTCLIENT:
2709     return MONTHCAL_PrintClient(infoPtr, (HDC)wParam, (DWORD)lParam);
2710
2711   case WM_ERASEBKGND:
2712     return MONTHCAL_EraseBkgnd(infoPtr, (HDC)wParam);
2713
2714   case WM_SETFOCUS:
2715     return MONTHCAL_SetFocus(infoPtr);
2716
2717   case WM_SIZE:
2718     return MONTHCAL_Size(infoPtr, (SHORT)LOWORD(lParam), (SHORT)HIWORD(lParam));
2719
2720   case WM_NOTIFY:
2721     return MONTHCAL_Notify(infoPtr, (NMHDR*)lParam);
2722
2723   case WM_CREATE:
2724     return MONTHCAL_Create(hwnd, (LPCREATESTRUCTW)lParam);
2725
2726   case WM_SETFONT:
2727     return MONTHCAL_SetFont(infoPtr, (HFONT)wParam, (BOOL)lParam);
2728
2729   case WM_GETFONT:
2730     return MONTHCAL_GetFont(infoPtr);
2731
2732   case WM_TIMER:
2733     return MONTHCAL_Timer(infoPtr, wParam);
2734
2735   case WM_THEMECHANGED:
2736     return theme_changed (infoPtr);
2737
2738   case WM_DESTROY:
2739     return MONTHCAL_Destroy(infoPtr);
2740
2741   case WM_SYSCOLORCHANGE:
2742     COMCTL32_RefreshSysColors();
2743     return 0;
2744
2745   case WM_STYLECHANGED:
2746     return MONTHCAL_StyleChanged(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
2747
2748   case WM_STYLECHANGING:
2749     return MONTHCAL_StyleChanging(infoPtr, wParam, (LPSTYLESTRUCT)lParam);
2750
2751   default:
2752     if ((uMsg >= WM_USER) && (uMsg < WM_APP) && !COMCTL32_IsReflectedMessage(uMsg))
2753       ERR( "unknown msg %04x wp=%08lx lp=%08lx\n", uMsg, wParam, lParam);
2754     return DefWindowProcW(hwnd, uMsg, wParam, lParam);
2755   }
2756 }
2757
2758
2759 void
2760 MONTHCAL_Register(void)
2761 {
2762   WNDCLASSW wndClass;
2763
2764   ZeroMemory(&wndClass, sizeof(WNDCLASSW));
2765   wndClass.style         = CS_GLOBALCLASS;
2766   wndClass.lpfnWndProc   = MONTHCAL_WindowProc;
2767   wndClass.cbClsExtra    = 0;
2768   wndClass.cbWndExtra    = sizeof(MONTHCAL_INFO *);
2769   wndClass.hCursor       = LoadCursorW(0, (LPWSTR)IDC_ARROW);
2770   wndClass.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
2771   wndClass.lpszClassName = MONTHCAL_CLASSW;
2772
2773   RegisterClassW(&wndClass);
2774 }
2775
2776
2777 void
2778 MONTHCAL_Unregister(void)
2779 {
2780     UnregisterClassW(MONTHCAL_CLASSW, NULL);
2781 }