clock.c File Reference

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

Include dependency graph for clock.c:

Go to the source code of this file.

Classes
struct	_CLOCKDATA

Macros
#define	TWOPI   (2 * 3.14159)

Typedefs
typedef struct _CLOCKDATA	CLOCKDATA
typedef struct _CLOCKDATA *	PCLOCKDATA

Functions
static VOID	RotatePoint (POINT pt[], INT iNum, INT iAngle)
static INT	DrawClock (HDC hdc, PCLOCKDATA pClockData)
static VOID	DrawHands (HDC hdc, SYSTEMTIME *pst, BOOL fChange, INT Radius)
static LRESULT CALLBACK	ClockWndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
BOOL	RegisterClockControl (VOID)
VOID	UnregisterClockControl (VOID)

Variables
static const WCHAR	szClockWndClass [] = L"ClockWndClass"

Macro Definition Documentation

TWOPI

#define TWOPI   (2 * 3.14159)

Definition at line 28 of file clock.c.

Typedef Documentation

CLOCKDATA

typedef struct _CLOCKDATA CLOCKDATA

PCLOCKDATA

typedef struct _CLOCKDATA * PCLOCKDATA

Function Documentation

ClockWndProc()

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

static

Definition at line 135 of file clock.c.

{
    PCLOCKDATA pClockData;
    HDC hdc, hdcMem;
    PAINTSTRUCT ps;
 
    pClockData = (PCLOCKDATA)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
 
    switch (uMsg)
    {
        case WM_CREATE:
            pClockData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLOCKDATA));
            SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)pClockData);
 
            pClockData->hGreyPen = CreatePen(PS_SOLID, 1, RGB(128, 128, 128));
            pClockData->hGreyBrush = CreateSolidBrush(RGB(128, 128, 128));
 
            GetLocalTime(&pClockData->stCurrent);
            pClockData->stPrevious = pClockData->stCurrent;
 
            pClockData->bTimer = (SetTimer(hwnd, ID_TIMER, 1000 - pClockData->stCurrent.wMilliseconds, NULL) != 0);
            break;
 
        case WM_SIZE:
            pClockData->cxClient = LOWORD(lParam);
            pClockData->cyClient = HIWORD(lParam);
            break;
 
        case WM_TIMECHANGE:
        case WM_TIMER:
            GetLocalTime(&pClockData->stCurrent);
            InvalidateRect(hwnd, NULL, FALSE);
            pClockData->stPrevious = pClockData->stCurrent;
 
            // Reset timeout.
            if (pClockData->bTimer)
            {
                SetTimer(hwnd, ID_TIMER, 1000 - pClockData->stCurrent.wMilliseconds, NULL);
            }
            break;
 
        case WM_PAINT:
            hdc = BeginPaint(hwnd, &ps);
 
            hdcMem = CreateCompatibleDC(hdc);
            if (hdcMem)
            {
                HBITMAP hBmp, hBmpOld;
 
                hBmp = CreateCompatibleBitmap(hdc,
                                              pClockData->cxClient,
                                              pClockData->cyClient);
                if (hBmp)
                {
                    RECT rcParent;
                    HWND hParentWnd = GetParent(hwnd);
                    INT oldMap, Radius;
                    POINT oldOrg;
 
                    hBmpOld = SelectObject(hdcMem, hBmp);
 
                    SetRect(&rcParent, 0, 0, pClockData->cxClient, pClockData->cyClient);
                    MapWindowPoints(hwnd, hParentWnd, (POINT*)&rcParent, 2);
                    OffsetViewportOrgEx(hdcMem, -rcParent.left, -rcParent.top, &oldOrg);
                    SendMessage(hParentWnd, WM_PRINT, (WPARAM)hdcMem, PRF_ERASEBKGND | PRF_CLIENT);
                    SetViewportOrgEx(hdcMem, oldOrg.x, oldOrg.y, NULL);
 
                    oldMap = SetMapMode(hdcMem, MM_ISOTROPIC);
                    SetWindowExtEx(hdcMem, 3600, 2700, NULL);
                    SetViewportExtEx(hdcMem, 800, -600, NULL);
                    SetViewportOrgEx(hdcMem,
                                     pClockData->cxClient / 2,
                                     pClockData->cyClient / 2,
                                     &oldOrg);
 
                    Radius = DrawClock(hdcMem, pClockData);
                    DrawHands(hdcMem, &pClockData->stPrevious, TRUE, Radius);
 
                    SetMapMode(hdcMem, oldMap);
                    SetViewportOrgEx(hdcMem, oldOrg.x, oldOrg.y, NULL);
 
                    BitBlt(hdc,
                           0,
                           0,
                           pClockData->cxClient,
                           pClockData->cyClient,
                           hdcMem,
                           0,
                           0,
                           SRCCOPY);
 
                    SelectObject(hdcMem, hBmpOld);
                    DeleteObject(hBmp);
                }
 
                DeleteDC(hdcMem);
            }
 
            EndPaint(hwnd, &ps);
            break;
 
        /* No need to erase background, handled during paint */
        case WM_ERASEBKGND:
            return 1;
 
        case WM_DESTROY:
            DeleteObject(pClockData->hGreyPen);
            DeleteObject(pClockData->hGreyBrush);
 
            if (pClockData->bTimer)
                KillTimer(hwnd, ID_TIMER);
 
            HeapFree(GetProcessHeap(), 0, pClockData);
            break;
 
        case CLM_STOPCLOCK:
            if (pClockData->bTimer)
            {
                KillTimer(hwnd, ID_TIMER);
                pClockData->bTimer = FALSE;
            }
            break;
 
        case CLM_STARTCLOCK:
            if (!pClockData->bTimer)
            {
                SYSTEMTIME LocalTime;
 
                GetLocalTime(&LocalTime);
                pClockData->bTimer = (SetTimer(hwnd, ID_TIMER, 1000 - LocalTime.wMilliseconds, NULL) != 0);
            }
            break;
 
        default:
            DefWindowProcW(hwnd,
                           uMsg,
                           wParam,
                           lParam);
    }
 
    return TRUE;
}

Referenced by RegisterClockControl().

DrawClock()

static INT DrawClock ( HDC  hdc, PCLOCKDATA  pClockData  )

static

Definition at line 52 of file clock.c.

{
     INT iAngle,Radius;
     POINT pt[3];
     HBRUSH hBrushOld;
     HPEN hPenOld = NULL;
 
     /* Grey brush to fill the dots */
     hBrushOld = SelectObject(hdc, pClockData->hGreyBrush);
 
     hPenOld = GetCurrentObject(hdc, OBJ_PEN);
 
     // TODO: Check if this conversion is correct resp. usable
     Radius = min(pClockData->cxClient,pClockData->cyClient) * 2;
 
     for (iAngle = 0; iAngle < 360; iAngle += 6)
     {
          /* Starting coords */
          pt[0].x = 0;
          pt[0].y = Radius;
 
          /* Rotate start coords */
          RotatePoint(pt, 1, iAngle);
 
          /* Determine whether it's a big dot or a little dot
           * i.e. 1-4 or 5, 6-9 or 10, 11-14 or 15 */
          if (iAngle % 5)
          {
                pt[2].x = pt[2].y = 7;
                SelectObject(hdc, pClockData->hGreyPen);
          }
          else
          {
              pt[2].x = pt[2].y = 16;
              SelectObject(hdc, GetStockObject(BLACK_PEN));
          }
 
          pt[0].x -= pt[2].x / 2;
          pt[0].y -= pt[2].y / 2;
 
          pt[1].x  = pt[0].x + pt[2].x;
          pt[1].y  = pt[0].y + pt[2].y;
 
          Ellipse(hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
     }
 
     SelectObject(hdc, hBrushOld);
     SelectObject(hdc, hPenOld);
     return Radius;
}

Referenced by ClockWndProc().

DrawHands()

static VOID DrawHands ( HDC  hdc, SYSTEMTIME *  pst, BOOL  fChange, INT  Radius  )

static

Definition at line 105 of file clock.c.

{
     POINT pt[3][5] = { {{0, (INT)-Radius/6}, {(INT)Radius/9, 0},
         {0, (INT)Radius/1.8}, {(INT)-Radius/9, 0}, {0, (INT)-Radius/6}},
     {{0, (INT)-Radius/4.5}, {(INT)Radius/18, 0}, {0, (INT) Radius*0.89},
         {(INT)-Radius/18, 0}, {0, (INT)-Radius/4.5}},
     {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, (INT) Radius*0.89}} };
     INT i, iAngle[3];
     POINT ptTemp[3][5];
 
     /* Black pen for outline, white brush for fill */
     SelectObject(hdc, GetStockObject(BLACK_PEN));
     SelectObject(hdc, GetStockObject(WHITE_BRUSH));
 
     iAngle[0] = (pst->wHour * 30) % 360 + pst->wMinute / 2;
     iAngle[1] = pst->wMinute * 6;
     iAngle[2] = pst->wSecond * 6;
 
     CopyMemory(ptTemp, pt, sizeof(pt));
 
     for (i = fChange ? 0 : 2; i < 3; i++)
     {
          RotatePoint(ptTemp[i], 5, iAngle[i]);
 
          Polygon(hdc, ptTemp[i], 5);
     }
}

Referenced by ClockWndProc().

RegisterClockControl()

BOOL RegisterClockControl

(

VOID

)

Definition at line 283 of file clock.c.

{
    WNDCLASSEXW wc = {0};
 
    wc.cbSize = sizeof(WNDCLASSEXW);
    wc.lpfnWndProc = ClockWndProc;
    wc.hInstance = hApplet;
    wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
    wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
    wc.lpszClassName = szClockWndClass;
 
    return RegisterClassExW(&wc) != (ATOM)0;
}

Referenced by Applet().

RotatePoint()

static VOID RotatePoint ( POINT  pt[], INT  iNum, INT  iAngle  )

static

Definition at line 33 of file clock.c.

{
     INT i;
     POINT ptTemp;
 
     for (i = 0 ; i < iNum ; i++)
     {
          ptTemp.x = (INT) (pt[i].x * cos (TWOPI * iAngle / 360) +
               pt[i].y * sin (TWOPI * iAngle / 360));
 
          ptTemp.y = (INT) (pt[i].y * cos (TWOPI * iAngle / 360) -
               pt[i].x * sin (TWOPI * iAngle / 360));
 
          pt[i] = ptTemp;
     }
}

Referenced by DrawClock(), and DrawHands().

UnregisterClockControl()

VOID UnregisterClockControl

(

VOID

)

Definition at line 299 of file clock.c.

{
    UnregisterClassW(szClockWndClass,
                     hApplet);
}

Referenced by Applet().

Variable Documentation

szClockWndClass

const WCHAR szClockWndClass[] = L"ClockWndClass"

static

Definition at line 30 of file clock.c.

Referenced by RegisterClockControl(), and UnregisterClockControl().