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