monthcal.c File Reference

#include "timedate.h"
#include <windowsx.h>

Include dependency graph for monthcal.c:

Go to the source code of this file.

Classes
struct	_MONTHCALWND

Macros
#define	MONTHCAL_HEADERBG   COLOR_INACTIVECAPTION
#define	MONTHCAL_HEADERFG   COLOR_INACTIVECAPTIONTEXT
#define	MONTHCAL_CTRLBG   COLOR_WINDOW
#define	MONTHCAL_CTRLFG   COLOR_WINDOWTEXT
#define	MONTHCAL_SELBG   COLOR_ACTIVECAPTION
#define	MONTHCAL_SELFG   COLOR_CAPTIONTEXT
#define	MONTHCAL_DISABLED_HEADERBG   COLOR_INACTIVECAPTION
#define	MONTHCAL_DISABLED_HEADERFG   COLOR_INACTIVECAPTIONTEXT
#define	MONTHCAL_DISABLED_CTRLBG   COLOR_WINDOW
#define	MONTHCAL_DISABLED_CTRLFG   COLOR_WINDOWTEXT
#define	MONTHCAL_DISABLED_SELBG   COLOR_INACTIVECAPTION
#define	MONTHCAL_DISABLED_SELFG   COLOR_INACTIVECAPTIONTEXT
#define	ID_DAYTIMER   1

Typedefs
typedef struct _MONTHCALWND	MONTHCALWND
typedef struct _MONTHCALWND *	PMONTHCALWND

Functions
static LRESULT	MonthCalNotifyControlParent (IN PMONTHCALWND infoPtr, IN UINT code, IN OUT PVOID data)
static WORD	LeapYear (IN WORD Year)
static WORD	MonthCalMonthLength (IN WORD Month, IN WORD Year)
static WORD	MonthCalWeekInMonth (IN WORD Day, IN WORD DayOfWeek)
static WORD	MonthCalDayOfWeek (IN PMONTHCALWND infoPtr, IN WORD Day, IN WORD Month, IN WORD Year)
static WORD	MonthCalFirstDayOfWeek (VOID)
static BOOL	MonthCalValidDate (IN WORD Day, IN WORD Month, IN WORD Year)
static VOID	MonthCalUpdate (IN PMONTHCALWND infoPtr)
static VOID	MonthCalSetupDayTimer (IN PMONTHCALWND infoPtr)
static VOID	MonthCalReload (IN PMONTHCALWND infoPtr)
static BOOL	MonthCalGetDayRect (IN PMONTHCALWND infoPtr, IN WORD Day, OUT RECT *rcCell)
static VOID	MonthCalChange (IN PMONTHCALWND infoPtr)
static BOOL	MonthCalSetDate (IN PMONTHCALWND infoPtr, IN WORD Day, IN WORD Month, IN WORD Year)
static VOID	MonthCalSetLocalTime (IN PMONTHCALWND infoPtr, OUT SYSTEMTIME *Time)
static VOID	MonthCalRepaintDay (IN PMONTHCALWND infoPtr, IN WORD Day)
static VOID	MonthCalPaint (IN PMONTHCALWND infoPtr, IN HDC hDC, IN LPRECT prcUpdate)
static HFONT	MonthCalChangeFont (IN PMONTHCALWND infoPtr, IN HFONT hFont, IN BOOL Redraw)
static WORD	MonthCalPtToDay (IN PMONTHCALWND infoPtr, IN INT x, IN INT y)
static LRESULT CALLBACK	MonthCalWndProc (IN HWND hwnd, IN UINT uMsg, IN WPARAM wParam, IN LPARAM lParam)
BOOL	RegisterMonthCalControl (IN HINSTANCE hInstance)
VOID	UnregisterMonthCalControl (IN HINSTANCE hInstance)

Variables
static const WCHAR	szMonthCalWndClass [] = L"MonthCalWnd"

Macro Definition Documentation

ID_DAYTIMER

#define ID_DAYTIMER   1

Definition at line 29 of file monthcal.c.

MONTHCAL_CTRLBG

#define MONTHCAL_CTRLBG   COLOR_WINDOW

Definition at line 18 of file monthcal.c.

MONTHCAL_CTRLFG

#define MONTHCAL_CTRLFG   COLOR_WINDOWTEXT

Definition at line 19 of file monthcal.c.

MONTHCAL_DISABLED_CTRLBG

#define MONTHCAL_DISABLED_CTRLBG   COLOR_WINDOW

Definition at line 24 of file monthcal.c.

MONTHCAL_DISABLED_CTRLFG

#define MONTHCAL_DISABLED_CTRLFG   COLOR_WINDOWTEXT

Definition at line 25 of file monthcal.c.

MONTHCAL_DISABLED_HEADERBG

#define MONTHCAL_DISABLED_HEADERBG   COLOR_INACTIVECAPTION

Definition at line 22 of file monthcal.c.

MONTHCAL_DISABLED_HEADERFG

#define MONTHCAL_DISABLED_HEADERFG   COLOR_INACTIVECAPTIONTEXT

Definition at line 23 of file monthcal.c.

MONTHCAL_DISABLED_SELBG

#define MONTHCAL_DISABLED_SELBG   COLOR_INACTIVECAPTION

Definition at line 26 of file monthcal.c.

MONTHCAL_DISABLED_SELFG

#define MONTHCAL_DISABLED_SELFG   COLOR_INACTIVECAPTIONTEXT

Definition at line 27 of file monthcal.c.

MONTHCAL_HEADERBG

#define MONTHCAL_HEADERBG   COLOR_INACTIVECAPTION

Definition at line 16 of file monthcal.c.

MONTHCAL_HEADERFG

#define MONTHCAL_HEADERFG   COLOR_INACTIVECAPTIONTEXT

Definition at line 17 of file monthcal.c.

MONTHCAL_SELBG

#define MONTHCAL_SELBG   COLOR_ACTIVECAPTION

Definition at line 20 of file monthcal.c.

MONTHCAL_SELFG

#define MONTHCAL_SELFG   COLOR_CAPTIONTEXT

Definition at line 21 of file monthcal.c.

Typedef Documentation

MONTHCALWND

typedef struct _MONTHCALWND MONTHCALWND

PMONTHCALWND

typedef struct _MONTHCALWND * PMONTHCALWND

Function Documentation

LeapYear()

static WORD LeapYear ( IN WORD  Year )

static

Definition at line 84 of file monthcal.c.

{
    return
#ifdef WITH_1752
        (Year <= 1752) ? !(Year % 4) :
#endif
        !(Year % 4) && ((Year % 100) || !(Year % 400));
}

Referenced by MonthCalMonthLength(), and RtlTimeToTimeFields().

MonthCalChange()

static VOID MonthCalChange ( IN PMONTHCALWND  infoPtr )

static

Definition at line 313 of file monthcal.c.

{
    infoPtr->Changed = TRUE;
 
    /* Kill the day timer */
    if (infoPtr->DayTimerSet)
    {
        KillTimer(infoPtr->hSelf,
                  ID_DAYTIMER);
        infoPtr->DayTimerSet = FALSE;
    }
}

Referenced by MonthCalSetDate().

MonthCalChangeFont()

static HFONT MonthCalChangeFont ( IN PMONTHCALWND  infoPtr, IN HFONT  hFont, IN BOOL  Redraw  )

static

Definition at line 641 of file monthcal.c.

{
    HFONT hOldFont = infoPtr->hFont;
    infoPtr->hFont = hFont;
 
    if (Redraw)
    {
        InvalidateRect(infoPtr->hSelf,
                       NULL,
                       TRUE);
    }
 
    return hOldFont;
}

Referenced by MonthCalWndProc().

MonthCalDayOfWeek()

static WORD MonthCalDayOfWeek ( IN PMONTHCALWND  infoPtr, IN WORD  Day, IN WORD  Month, IN WORD  Year  )

static

Definition at line 120 of file monthcal.c.

{
    const BYTE DayOfWeek[] = {0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4};
    WORD Ret;
 
    Year -= (Month < 3);
    Ret = (Year + (Year / 4) - (Year / 100) + (Year / 400) + DayOfWeek[Month - 1] + Day + 6) % 7;
 
    return (7 + Ret - infoPtr->FirstDayOfWeek) % 7;
}

Referenced by MonthCalGetDayRect(), and MonthCalUpdate().

MonthCalFirstDayOfWeek()

static WORD MonthCalFirstDayOfWeek ( VOID  )

static

Definition at line 135 of file monthcal.c.

{
    WCHAR szBuf[2] = {0};
    WORD Ret = 0;
 
    if (GetLocaleInfoW(LOCALE_USER_DEFAULT,
                       LOCALE_IFIRSTDAYOFWEEK,
                       szBuf,
                       sizeof(szBuf) / sizeof(szBuf[0])) != 0)
    {
        Ret = (WORD)(szBuf[0] - TEXT('0'));
    }
 
    return Ret;
}

Referenced by MonthCalReload().

MonthCalGetDayRect()

static BOOL MonthCalGetDayRect ( IN PMONTHCALWND  infoPtr, IN WORD  Day, OUT RECT *  rcCell  )

static

Definition at line 286 of file monthcal.c.

{
    if (Day >= 1 && Day <= MonthCalMonthLength(infoPtr->Month,
                                               infoPtr->Year))
    {
        WORD DayOfWeek;
 
        DayOfWeek = MonthCalDayOfWeek(infoPtr,
                                      Day,
                                      infoPtr->Month,
                                      infoPtr->Year);
 
        rcCell->left = DayOfWeek * infoPtr->CellSize.cx;
        rcCell->top = (MonthCalWeekInMonth(Day,
                                           DayOfWeek) + 1) * infoPtr->CellSize.cy;
        rcCell->right = rcCell->left + infoPtr->CellSize.cx;
        rcCell->bottom = rcCell->top + infoPtr->CellSize.cy;
 
        return TRUE;
    }
 
    return FALSE;
}

Referenced by MonthCalRepaintDay(), and MonthCalSetDate().

MonthCalMonthLength()

static WORD MonthCalMonthLength ( IN WORD  Month, IN WORD  Year  )

static

Definition at line 94 of file monthcal.c.

{
    const BYTE MonthDays[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 0};
 
    if(Month == 2)
        return MonthDays[Month - 1] + LeapYear(Year);
    else
    {
#ifdef WITH_1752
        if ((Year == 1752) && (Month == 9))
       return 19; // Special case: September 1752 has no 3rd-13th
    else
#endif
           return MonthDays[Month - 1];
    }
}

Referenced by MonthCalGetDayRect(), MonthCalUpdate(), MonthCalValidDate(), and MonthCalWndProc().

MonthCalNotifyControlParent()

static LRESULT MonthCalNotifyControlParent ( IN PMONTHCALWND  infoPtr, IN UINT  code, IN OUT PVOID  data  )

static

Definition at line 56 of file monthcal.c.

{
    LRESULT Ret = 0;
 
    if (infoPtr->hNotify != NULL)
    {
        LPNMHDR pnmh = (LPNMHDR)data;
 
        pnmh->hwndFrom = infoPtr->hSelf;
        pnmh->idFrom = GetWindowLongPtrW(infoPtr->hSelf,
                                         GWLP_ID);
        pnmh->code = code;
 
        Ret = SendMessageW(infoPtr->hNotify,
                           WM_NOTIFY,
                           (WPARAM)pnmh->idFrom,
                           (LPARAM)pnmh);
    }
 
    return Ret;
}

Referenced by MonthCalSetDate(), and MonthCalSetLocalTime().

MonthCalPaint()

static VOID MonthCalPaint ( IN PMONTHCALWND  infoPtr, IN HDC  hDC, IN LPRECT  prcUpdate  )

static

Definition at line 453 of file monthcal.c.

{
    LONG x, y;
    RECT rcCell;
    COLORREF crOldText, crOldCtrlText = CLR_INVALID;
    HFONT hOldFont;
    INT iOldBkMode;
 
#if MONTHCAL_CTRLBG != MONTHCAL_DISABLED_CTRLBG
    if (!infoPtr->Enabled)
    {
        FillRect(hDC,
                 prcUpdate,
                 GetSysColorBrush(MONTHCAL_DISABLED_CTRLBG));
    }
#endif
 
    iOldBkMode = SetBkMode(hDC,
                           TRANSPARENT);
    hOldFont = (HFONT)SelectObject(hDC,
                                   infoPtr->hFont);
 
    for (y = prcUpdate->top / infoPtr->CellSize.cy;
         y <= prcUpdate->bottom / infoPtr->CellSize.cy && y < 7;
         y++)
    {
        rcCell.top = y * infoPtr->CellSize.cy;
        rcCell.bottom = rcCell.top + infoPtr->CellSize.cy;
 
        if (y == 0)
        {
            RECT rcHeader;
 
            /* Paint the header */
            rcHeader.left = prcUpdate->left;
            rcHeader.top = rcCell.top;
            rcHeader.right = prcUpdate->right;
            rcHeader.bottom = rcCell.bottom;
 
            FillRect(hDC,
                     &rcHeader,
                     infoPtr->hbHeader);
 
            crOldText = SetTextColor(hDC,
                                     GetSysColor(infoPtr->Enabled ? MONTHCAL_HEADERFG : MONTHCAL_DISABLED_HEADERFG));
 
            for (x = prcUpdate->left / infoPtr->CellSize.cx;
                 x <= prcUpdate->right / infoPtr->CellSize.cx && x < 7;
                 x++)
            {
                rcCell.left = x * infoPtr->CellSize.cx;
                rcCell.right = rcCell.left + infoPtr->CellSize.cx;
 
                /* Write the first letter of each weekday */
                DrawTextW(hDC,
                          &infoPtr->Week[x],
                          1,
                          &rcCell,
                          DT_SINGLELINE | DT_NOPREFIX | DT_CENTER | DT_VCENTER);
            }
 
            SetTextColor(hDC,
                         crOldText);
        }
        else
        {
            if (crOldCtrlText == CLR_INVALID)
            {
                crOldCtrlText = SetTextColor(hDC,
                                             GetSysColor(infoPtr->Enabled ? MONTHCAL_CTRLFG : MONTHCAL_DISABLED_CTRLFG));
            }
 
            for (x = prcUpdate->left / infoPtr->CellSize.cx;
                 x <= prcUpdate->right / infoPtr->CellSize.cx && x < 7;
                 x++)
            {
                UINT Day = infoPtr->Days[y - 1][x];
 
                rcCell.left = x * infoPtr->CellSize.cx;
                rcCell.right = rcCell.left + infoPtr->CellSize.cx;
 
                /* Write the day number */
                if (Day != 0 && Day < 100)
                {
                    WCHAR szDay[3];
                    INT szDayLen;
                    RECT rcText;
                    SIZE TextSize;
 
                    szDayLen = _swprintf(szDay, L"%lu", Day);
 
                    if (GetTextExtentPoint32W(hDC,
                                              szDay,
                                              szDayLen,
                                              &TextSize))
                    {
                        RECT rcHighlight = { 0, 0, 0, 0 };
 
                        rcText.left = rcCell.left + (infoPtr->CellSize.cx / 2) - (TextSize.cx / 2);
                        rcText.top = rcCell.top + (infoPtr->CellSize.cy / 2) - (TextSize.cy / 2);
                        rcText.right = rcText.left + TextSize.cx;
                        rcText.bottom = rcText.top + TextSize.cy;
 
                        if (Day == infoPtr->Day)
                        {
                            SIZE TextSel;
 
                            TextSel.cx = (infoPtr->CellSize.cx * 2) / 3;
                            TextSel.cy = (infoPtr->CellSize.cy * 3) / 4;
 
                            if (TextSel.cx < rcText.right - rcText.left)
                                TextSel.cx = rcText.right - rcText.left;
                            if (TextSel.cy < rcText.bottom - rcText.top)
                                TextSel.cy = rcText.bottom - rcText.top;
 
                            rcHighlight.left = rcCell.left + (infoPtr->CellSize.cx / 2) - (TextSel.cx / 2);
                            rcHighlight.right = rcHighlight.left + TextSel.cx;
                            rcHighlight.top = rcCell.top + (infoPtr->CellSize.cy / 2) - (TextSel.cy / 2);
                            rcHighlight.bottom = rcHighlight.top + TextSel.cy;
 
                            InflateRect(&rcHighlight,
                                        GetSystemMetrics(SM_CXFOCUSBORDER),
                                        GetSystemMetrics(SM_CYFOCUSBORDER));
 
                            if (!FillRect(hDC,
                                          &rcHighlight,
                                          infoPtr->hbSelection))
                            {
                                goto FailNoHighlight;
                            }
 
                            /* Highlight the selected day */
                            crOldText = SetTextColor(hDC,
                                                     GetSysColor(infoPtr->Enabled ? MONTHCAL_SELFG : MONTHCAL_DISABLED_SELFG));
                        }
                        else
                        {
FailNoHighlight:
                            /* Don't change the text color, we're not highlighting it... */
                            crOldText = CLR_INVALID;
                        }
 
                        TextOutW(hDC,
                                 rcText.left,
                                 rcText.top,
                                 szDay,
                                 szDayLen);
 
                        if (Day == infoPtr->Day && crOldText != CLR_INVALID)
                        {
                            if (infoPtr->HasFocus && infoPtr->Enabled && !(infoPtr->UIState & UISF_HIDEFOCUS))
                            {
                                COLORREF crOldBk;
 
                                crOldBk = SetBkColor(hDC,
                                                     GetSysColor(infoPtr->Enabled ? MONTHCAL_SELBG : MONTHCAL_DISABLED_SELBG));
 
                                DrawFocusRect(hDC,
                                              &rcHighlight);
 
                                SetBkColor(hDC,
                                           crOldBk);
                            }
 
                            SetTextColor(hDC,
                                         crOldText);
                        }
                    }
                }
            }
        }
    }
 
    if (crOldCtrlText != CLR_INVALID)
    {
        SetTextColor(hDC,
                     crOldCtrlText);
    }
 
    SetBkMode(hDC,
              iOldBkMode);
    SelectObject(hDC,
                 (HGDIOBJ)hOldFont);
}

Referenced by MonthCalWndProc().

MonthCalPtToDay()

static WORD MonthCalPtToDay ( IN PMONTHCALWND  infoPtr, IN INT  x, IN INT  y  )

static

Definition at line 659 of file monthcal.c.

{
    WORD Ret = 0;
 
    if (infoPtr->CellSize.cx != 0 && infoPtr->CellSize.cy != 0 &&
        x >= 0 && y >= 0)
    {
        x /= infoPtr->CellSize.cx;
        y /= infoPtr->CellSize.cy;
 
        if (x < 7 && y != 0 && y < 7)
        {
            Ret = (WORD)infoPtr->Days[y - 1][x];
        }
    }
 
    return Ret;
}

Referenced by MonthCalWndProc().

MonthCalReload()

static VOID MonthCalReload ( IN PMONTHCALWND  infoPtr )

static

Definition at line 252 of file monthcal.c.

{
    WCHAR szBuf[64];
    UINT i;
 
    infoPtr->UIState = (DWORD)SendMessageW(GetAncestor(infoPtr->hSelf,
                                                       GA_PARENT),
                                            WM_QUERYUISTATE,
                                            0,
                                            0);
 
    /* Cache the configuration */
    infoPtr->FirstDayOfWeek = MonthCalFirstDayOfWeek();
 
    infoPtr->hbHeader = GetSysColorBrush(infoPtr->Enabled ? MONTHCAL_HEADERBG : MONTHCAL_DISABLED_HEADERBG);
    infoPtr->hbSelection = GetSysColorBrush(infoPtr->Enabled ? MONTHCAL_SELBG : MONTHCAL_DISABLED_SELBG);
 
    for (i = 0; i < 7; i++)
    {
        if (GetLocaleInfoW(LOCALE_USER_DEFAULT,
                           LOCALE_SABBREVDAYNAME1 +
                               ((i + infoPtr->FirstDayOfWeek) % 7),
                           szBuf,
                           sizeof(szBuf) / sizeof(szBuf[0])) != 0)
        {
            infoPtr->Week[i] = szBuf[0];
        }
    }
 
    /* Update the control */
    MonthCalUpdate(infoPtr);
}

Referenced by MonthCalWndProc().

MonthCalRepaintDay()

static VOID MonthCalRepaintDay ( IN PMONTHCALWND  infoPtr, IN WORD  Day  )

static

Definition at line 437 of file monthcal.c.

{
    RECT rcCell;
 
    if (MonthCalGetDayRect(infoPtr,
                           Day,
                           &rcCell))
    {
        InvalidateRect(infoPtr->hSelf,
                       &rcCell,
                       TRUE);
    }
}

Referenced by MonthCalWndProc().

MonthCalSetDate()

static BOOL MonthCalSetDate ( IN PMONTHCALWND  infoPtr, IN WORD  Day, IN WORD  Month, IN WORD  Year  )

static

Definition at line 328 of file monthcal.c.

{
    NMMCCSELCHANGE sc;
    BOOL Ret = FALSE;
 
    sc.OldDay = infoPtr->Day;
    sc.OldMonth = infoPtr->Month;
    sc.OldYear = infoPtr->Year;
    sc.NewDay = Day;
    sc.NewMonth = Month;
    sc.NewYear = Year;
 
    /* Notify the parent */
    if (!MonthCalNotifyControlParent(infoPtr,
                                     MCCN_SELCHANGE,
                                     &sc))
    {
        /* Check if we actually need to update */
        if (infoPtr->Month != sc.NewMonth ||
            infoPtr->Year != sc.NewYear)
        {
            infoPtr->Day = sc.NewDay;
            infoPtr->Month = sc.NewMonth;
            infoPtr->Year = sc.NewYear;
 
            MonthCalChange(infoPtr);
 
            /* Repaint the entire control */
            MonthCalUpdate(infoPtr);
 
            Ret = TRUE;
        }
        else if (infoPtr->Day != sc.NewDay)
        {
            RECT rcUpdate;
 
            infoPtr->Day = sc.NewDay;
 
            MonthCalChange(infoPtr);
 
            if (MonthCalGetDayRect(infoPtr,
                                   sc.OldDay,
                                   &rcUpdate))
            {
                /* Repaint the day cells that need to be updated */
                InvalidateRect(infoPtr->hSelf,
                               &rcUpdate,
                               TRUE);
                if (MonthCalGetDayRect(infoPtr,
                                       sc.NewDay,
                                       &rcUpdate))
                {
                    InvalidateRect(infoPtr->hSelf,
                                   &rcUpdate,
                                   TRUE);
                }
            }
 
            Ret = TRUE;
        }
    }
 
    return Ret;
}

Referenced by MonthCalSetLocalTime(), and MonthCalWndProc().

MonthCalSetLocalTime()

static VOID MonthCalSetLocalTime ( IN PMONTHCALWND  infoPtr, OUT SYSTEMTIME *  Time  )

static

Definition at line 397 of file monthcal.c.

{
    NMMCCAUTOUPDATE au;
    SYSTEMTIME LocalTime = {0};
 
    GetLocalTime(&LocalTime);
 
    au.SystemTime = LocalTime;
    if (!MonthCalNotifyControlParent(infoPtr,
                                     MCCN_AUTOUPDATE,
                                     &au))
    {
        if (MonthCalSetDate(infoPtr,
                            LocalTime.wDay,
                            LocalTime.wMonth,
                            LocalTime.wYear))
        {
            infoPtr->Changed = FALSE;
        }
    }
 
    /* Kill the day timer */
    if (infoPtr->DayTimerSet)
    {
        KillTimer(infoPtr->hSelf,
                  ID_DAYTIMER);
        infoPtr->DayTimerSet = FALSE;
    }
 
    /* Setup the new day timer */
    MonthCalSetupDayTimer(infoPtr);
 
    if (Time != NULL)
    {
        *Time = LocalTime;
    }
}

Referenced by MonthCalWndProc().

MonthCalSetupDayTimer()

static VOID MonthCalSetupDayTimer ( IN PMONTHCALWND  infoPtr )

static

Definition at line 227 of file monthcal.c.

{
    SYSTEMTIME LocalTime = {0};
    UINT uElapse;
 
    /* Update the current date */
    GetLocalTime(&LocalTime);
 
    /* Calculate the number of remaining milliseconds until midnight */
    uElapse = 1000 - (UINT)LocalTime.wMilliseconds;
    uElapse += (59 - (UINT)LocalTime.wSecond) * 1000;
    uElapse += (59 - (UINT)LocalTime.wMinute) * 60 * 1000;
    uElapse += (23 - (UINT)LocalTime.wHour) * 60 * 60 * 1000;
 
    /* Setup the new timer */
    if (SetTimer(infoPtr->hSelf,
                 ID_DAYTIMER,
                 uElapse,
                 NULL) != 0)
    {
        infoPtr->DayTimerSet = TRUE;
    }
}

Referenced by MonthCalSetLocalTime().

MonthCalUpdate()

static VOID MonthCalUpdate ( IN PMONTHCALWND  infoPtr )

static

Definition at line 168 of file monthcal.c.

{
    PBYTE pDay, pDayEnd;
    WORD DayOfWeek, MonthLength, d = 0;
    SIZE NewCellSize;
    BOOL RepaintHeader = FALSE;
 
    NewCellSize.cx = infoPtr->ClientSize.cx / 7;
    NewCellSize.cy = infoPtr->ClientSize.cy / 7;
 
    if (infoPtr->CellSize.cx != NewCellSize.cx ||
        infoPtr->CellSize.cy != NewCellSize.cy)
    {
        infoPtr->CellSize = NewCellSize;
        RepaintHeader = TRUE;
    }
 
    /* Update the days layout of the current month */
    ZeroMemory(infoPtr->Days,
               sizeof(infoPtr->Days));
 
    DayOfWeek = MonthCalDayOfWeek(infoPtr,
                                  1,
                                  infoPtr->Month,
                                  infoPtr->Year);
 
    MonthLength = MonthCalMonthLength(infoPtr->Month,
                                      infoPtr->Year);
 
    pDay = &infoPtr->Days[0][DayOfWeek];
    pDayEnd = pDay + MonthLength;
    while (pDay != pDayEnd)
    {
        *(pDay++) = (BYTE)++d;
    }
 
    /* Repaint the control */
    if (RepaintHeader)
    {
        InvalidateRect(infoPtr->hSelf,
                       NULL,
                       TRUE);
    }
    else
    {
        RECT rcClient;
 
        rcClient.left = 0;
        rcClient.top = infoPtr->CellSize.cy;
        rcClient.right = infoPtr->ClientSize.cx;
        rcClient.bottom = infoPtr->ClientSize.cy;
 
        InvalidateRect(infoPtr->hSelf,
                       &rcClient,
                       TRUE);
    }
}

Referenced by MonthCalReload(), MonthCalSetDate(), and MonthCalWndProc().

MonthCalValidDate()

static BOOL MonthCalValidDate ( IN WORD  Day, IN WORD  Month, IN WORD  Year  )

static

Definition at line 152 of file monthcal.c.

{
    if (Month < 1 || Month > 12 ||
        Day == 0 || Day > MonthCalMonthLength(Month,
                                              Year) ||
        Year < 1899 || Year > 9999)
    {
        return FALSE;
    }
 
    return TRUE;
}

Referenced by MonthCalWndProc().

MonthCalWeekInMonth()

static WORD MonthCalWeekInMonth ( IN WORD  Day, IN WORD  DayOfWeek  )

static

Definition at line 113 of file monthcal.c.

{
    return (Day - DayOfWeek + 5) / 7;
}

Referenced by MonthCalGetDayRect().

MonthCalWndProc()

static LRESULT CALLBACK MonthCalWndProc ( IN HWND  hwnd, IN UINT  uMsg, IN WPARAM  wParam, IN LPARAM  lParam  )

static

Definition at line 681 of file monthcal.c.

{
    PMONTHCALWND infoPtr;
    LRESULT Ret = 0;
 
    infoPtr = (PMONTHCALWND)GetWindowLongPtrW(hwnd,
                                              0);
 
    if (infoPtr == NULL && uMsg != WM_CREATE)
    {
        goto HandleDefaultMessage;
    }
 
    switch (uMsg)
    {
#if MONTHCAL_CTRLBG != MONTHCAL_DISABLED_CTRLBG
        case WM_ERASEBKGND:
            Ret = !infoPtr->Enabled;
            break;
#endif
 
        case WM_PAINT:
        case WM_PRINTCLIENT:
        {
            if (infoPtr->CellSize.cx != 0 && infoPtr->CellSize.cy != 0)
            {
                PAINTSTRUCT ps;
                HDC hDC;
 
                if (wParam != 0)
                {
                    if (!GetUpdateRect(hwnd,
                                       &ps.rcPaint,
                                       TRUE))
                    {
                        break;
                    }
                    hDC = (HDC)wParam;
                }
                else
                {
                    hDC = BeginPaint(hwnd,
                                     &ps);
                    if (hDC == NULL)
                    {
                        break;
                    }
                }
 
                MonthCalPaint(infoPtr,
                              hDC,
                              &ps.rcPaint);
 
                if (wParam == 0)
                {
                    EndPaint(hwnd,
                             &ps);
                }
            }
            break;
        }
 
        case WM_LBUTTONDBLCLK:
        case WM_LBUTTONDOWN:
        {
            WORD SelDay;
 
            SelDay = MonthCalPtToDay(infoPtr,
                                     GET_X_LPARAM(lParam),
                                     GET_Y_LPARAM(lParam));
            if (SelDay != 0 && SelDay != infoPtr->Day)
            {
                MonthCalSetDate(infoPtr,
                                SelDay,
                                infoPtr->Month,
                                infoPtr->Year);
            }
 
            /* Fall through */
        }
 
        case WM_MBUTTONDOWN:
        case WM_RBUTTONDOWN:
        {
            if (!infoPtr->HasFocus)
            {
                SetFocus(hwnd);
            }
            break;
        }
 
        case WM_KEYDOWN:
        {
            WORD NewDay = 0;
 
            switch (wParam)
            {
                case VK_UP:
                {
                    if (infoPtr->Day > 7)
                    {
                        NewDay = infoPtr->Day - 7;
                    }
                    break;
                }
 
                case VK_DOWN:
                {
                    if (infoPtr->Day + 7 <= MonthCalMonthLength(infoPtr->Month,
                                                                infoPtr->Year))
                    {
                        NewDay = infoPtr->Day + 7;
                    }
                    break;
                }
 
                case VK_LEFT:
                {
                    if (infoPtr->Day > 1)
                    {
                        NewDay = infoPtr->Day - 1;
                    }
                    break;
                }
 
                case VK_RIGHT:
                {
                    if (infoPtr->Day < MonthCalMonthLength(infoPtr->Month,
                                                           infoPtr->Year))
                    {
                        NewDay = infoPtr->Day + 1;
                    }
                    break;
                }
            }
 
            /* Update the selection */
            if (NewDay != 0)
            {
                MonthCalSetDate(infoPtr,
                                NewDay,
                                infoPtr->Month,
                                infoPtr->Year);
            }
 
            goto HandleDefaultMessage;
        }
 
        case WM_GETDLGCODE:
        {
            INT virtKey;
 
            virtKey = (lParam != 0 ? (INT)((LPMSG)lParam)->wParam : 0);
            switch (virtKey)
            {
                case VK_TAB:
                {
                    /* Change the UI status */
                    SendMessageW(GetAncestor(hwnd,
                                             GA_PARENT),
                                 WM_CHANGEUISTATE,
                                 MAKEWPARAM(UIS_INITIALIZE,
                                            0),
                                 0);
                    break;
                }
            }
 
            Ret |= DLGC_WANTARROWS;
            break;
        }
 
        case WM_SETFOCUS:
        {
            infoPtr->HasFocus = TRUE;
            MonthCalRepaintDay(infoPtr,
                               infoPtr->Day);
            break;
        }
 
        case WM_KILLFOCUS:
        {
            infoPtr->HasFocus = FALSE;
            MonthCalRepaintDay(infoPtr,
                               infoPtr->Day);
            break;
        }
 
        case WM_UPDATEUISTATE:
        {
            DWORD OldUIState;
 
            Ret = DefWindowProcW(hwnd,
                                 uMsg,
                                 wParam,
                                 lParam);
 
            OldUIState = infoPtr->UIState;
            switch (LOWORD(wParam))
            {
                case UIS_SET:
                    infoPtr->UIState |= HIWORD(wParam);
                    break;
 
                case UIS_CLEAR:
                    infoPtr->UIState &= ~HIWORD(wParam);
                    break;
            }
 
            if (infoPtr->UIState != OldUIState)
            {
                MonthCalRepaintDay(infoPtr,
                                   infoPtr->Day);
            }
            break;
        }
 
        case MCCM_SETDATE:
        {
            WORD Day, Month, Year, DaysCount;
 
            Day = LOWORD(wParam);
            Month = HIWORD(wParam);
            Year = LOWORD(lParam);
 
            if (Day == (WORD)-1)
                Day = infoPtr->Day;
            if (Month == (WORD)-1)
                Month = infoPtr->Month;
            if (Year == (WORD)-1)
                Year = infoPtr->Year;
 
            DaysCount = MonthCalMonthLength(Month,
                                            Year);
            if (Day > DaysCount)
                Day = DaysCount;
 
            if (MonthCalValidDate(Day,
                                  Month,
                                  Year))
            {
                if (Day != infoPtr->Day ||
                    Month != infoPtr->Month ||
                    Year != infoPtr->Year)
                {
                    Ret = MonthCalSetDate(infoPtr,
                                          Day,
                                          Month,
                                          Year);
                }
            }
            break;
        }
 
        case MCCM_GETDATE:
        {
            LPSYSTEMTIME lpSystemTime = (LPSYSTEMTIME)wParam;
 
            lpSystemTime->wYear = infoPtr->Year;
            lpSystemTime->wMonth = infoPtr->Month;
            lpSystemTime->wDay = infoPtr->Day;
 
            Ret = TRUE;
            break;
        }
 
        case MCCM_RESET:
        {
            MonthCalSetLocalTime(infoPtr,
                                 NULL);
            Ret = TRUE;
            break;
        }
 
        case MCCM_CHANGED:
        {
            Ret = infoPtr->Changed;
            break;
        }
 
        case WM_TIMER:
        {
            switch (wParam)
            {
                case ID_DAYTIMER:
                {
                    /* Kill the timer */
                    KillTimer(hwnd,
                              ID_DAYTIMER);
                    infoPtr->DayTimerSet = FALSE;
 
                    if (!infoPtr->Changed)
                    {
                        /* Update the system time and setup the new day timer */
                        MonthCalSetLocalTime(infoPtr,
                                             NULL);
 
                        /* Update the control */
                        MonthCalUpdate(infoPtr);
                    }
                    break;
                }
            }
            break;
        }
 
        case WM_SETFONT:
        {
            Ret = (LRESULT)MonthCalChangeFont(infoPtr,
                                              (HFONT)wParam,
                                              (BOOL)LOWORD(lParam));
            break;
        }
 
        case WM_SIZE:
        {
            infoPtr->ClientSize.cx = LOWORD(lParam);
            infoPtr->ClientSize.cy = HIWORD(lParam);
            infoPtr->CellSize.cx = infoPtr->ClientSize.cx / 7;
            infoPtr->CellSize.cy = infoPtr->ClientSize.cy / 7;
 
            /* Repaint the control */
            InvalidateRect(hwnd,
                           NULL,
                           TRUE);
            break;
        }
 
        case WM_GETFONT:
        {
            Ret = (LRESULT)infoPtr->hFont;
            break;
        }
 
        case WM_ENABLE:
        {
            infoPtr->Enabled = ((BOOL)wParam != FALSE);
            MonthCalReload(infoPtr);
            break;
        }
 
        case WM_STYLECHANGED:
        {
            if (wParam == GWL_STYLE)
            {
                unsigned int OldEnabled = infoPtr->Enabled;
                infoPtr->Enabled = !(((LPSTYLESTRUCT)lParam)->styleNew & WS_DISABLED);
 
                if (OldEnabled != infoPtr->Enabled)
                {
                    MonthCalReload(infoPtr);
                }
            }
            break;
        }
 
        case WM_CREATE:
        {
            infoPtr = (MONTHCALWND*) HeapAlloc(GetProcessHeap(),
                                0,
                                sizeof(MONTHCALWND));
            if (infoPtr == NULL)
            {
                Ret = (LRESULT)-1;
                break;
            }
 
            SetWindowLongPtrW(hwnd,
                              0,
                              (LONG_PTR)infoPtr);
 
            ZeroMemory(infoPtr,
                       sizeof(MONTHCALWND));
 
            infoPtr->hSelf = hwnd;
            infoPtr->hNotify = ((LPCREATESTRUCTW)lParam)->hwndParent;
            infoPtr->Enabled = !(((LPCREATESTRUCTW)lParam)->style & WS_DISABLED);
 
            MonthCalSetLocalTime(infoPtr,
                                 NULL);
 
            MonthCalReload(infoPtr);
            break;
        }
 
        case WM_DESTROY:
        {
            HeapFree(GetProcessHeap(),
                     0,
                     infoPtr);
            SetWindowLongPtrW(hwnd,
                              0,
                              (DWORD_PTR)NULL);
            break;
        }
 
        default:
        {
HandleDefaultMessage:
            Ret = DefWindowProcW(hwnd,
                                 uMsg,
                                 wParam,
                                 lParam);
            break;
        }
    }
 
    return Ret;
}

Referenced by RegisterMonthCalControl().

RegisterMonthCalControl()

BOOL RegisterMonthCalControl

(

IN HINSTANCE

hInstance

)

Definition at line 1095 of file monthcal.c.

{
    WNDCLASSW wc = {0};
 
    wc.style = CS_DBLCLKS;
    wc.lpfnWndProc = MonthCalWndProc;
    wc.cbWndExtra = sizeof(PMONTHCALWND);
    wc.hInstance = hInstance;
    wc.hCursor = LoadCursorW(NULL,
                             (LPWSTR)IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(MONTHCAL_CTRLBG + 1);
    wc.lpszClassName = szMonthCalWndClass;
 
    return RegisterClassW(&wc) != 0;
}

Referenced by Applet().

UnregisterMonthCalControl()

VOID UnregisterMonthCalControl

(

IN HINSTANCE

hInstance

)

Definition at line 1112 of file monthcal.c.

{
    UnregisterClassW(szMonthCalWndClass,
                     hInstance);
}

Referenced by Applet().

Variable Documentation

szMonthCalWndClass

const WCHAR szMonthCalWndClass[] = L"MonthCalWnd"

static

Definition at line 14 of file monthcal.c.

Referenced by RegisterMonthCalControl(), and UnregisterMonthCalControl().