dll/cpl/timedate/clock.c

   1 /*
   2  * PROJECT:     ReactOS Timedate Control Panel
   3  * LICENSE:     GPL - See COPYING in the top level directory
   4  * FILE:        dll/cpl/timedate/clock.c
   5  * PURPOSE:     Draws the analog clock
   6  * COPYRIGHT:   Copyright 2006 Ged Murphy <gedmurphy@gmail.com>
   7  *              Copyright 2007 Eric Kohl
   8  */
   9
  10 /* Code based on clock.c from Programming Windows, Charles Petzold */
  11
  12 #include "timedate.h"
  13
  14 #include <math.h>
  15
  16 typedef struct _CLOCKDATA
  17 {
  18     HBRUSH hGreyBrush;
  19     HPEN hGreyPen;
  20     INT cxClient;
  21     INT cyClient;
  22     SYSTEMTIME stCurrent;
  23     SYSTEMTIME stPrevious;
  24     BOOL bTimer;
  25 } CLOCKDATA, *PCLOCKDATA;
  26
  27
  28 #define TWOPI (2 * 3.14159)
  29
  30 static const WCHAR szClockWndClass[] = L"ClockWndClass";
  31
  32 static VOID
  33 RotatePoint(POINT pt[], INT iNum, INT iAngle)
  34 {
  35      INT i;
  36      POINT ptTemp;
  37
  38      for (i = 0 ; i < iNum ; i++)
  39      {
  40           ptTemp.x = (INT) (pt[i].x * cos (TWOPI * iAngle / 360) +
  41                pt[i].y * sin (TWOPI * iAngle / 360));
  42
  43           ptTemp.y = (INT) (pt[i].y * cos (TWOPI * iAngle / 360) -
  44                pt[i].x * sin (TWOPI * iAngle / 360));
  45
  46           pt[i] = ptTemp;
  47      }
  48 }
  49
  50
  51 static INT
  52 DrawClock(HDC hdc, PCLOCKDATA pClockData)
  53 {
  54      INT iAngle,Radius;
  55      POINT pt[3];
  56      HBRUSH hBrushOld;
  57      HPEN hPenOld = NULL;
  58
  59      /* Grey brush to fill the dots */
  60      hBrushOld = SelectObject(hdc, pClockData->hGreyBrush);
  61
  62      hPenOld = GetCurrentObject(hdc, OBJ_PEN);
  63
  64      // TODO: Check if this conversion is correct resp. usable
  65      Radius = min(pClockData->cxClient,pClockData->cyClient) * 2;
  66
  67      for (iAngle = 0; iAngle < 360; iAngle += 6)
  68      {
  69           /* Starting coords */
  70           pt[0].x = 0;
  71           pt[0].y = Radius;
  72
  73           /* Rotate start coords */
  74           RotatePoint(pt, 1, iAngle);
  75
  76           /* Determine whether it's a big dot or a little dot
  77            * i.e. 1-4 or 5, 6-9 or 10, 11-14 or 15 */
  78           if (iAngle % 5)
  79           {
  80                 pt[2].x = pt[2].y = 7;
  81                 SelectObject(hdc, pClockData->hGreyPen);
  82           }
  83           else
  84           {
  85               pt[2].x = pt[2].y = 16;
  86               SelectObject(hdc, GetStockObject(BLACK_PEN));
  87           }
  88
  89           pt[0].x -= pt[2].x / 2;
  90           pt[0].y -= pt[2].y / 2;
  91
  92           pt[1].x  = pt[0].x + pt[2].x;
  93           pt[1].y  = pt[0].y + pt[2].y;
  94
  95           Ellipse(hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
  96      }
  97
  98      SelectObject(hdc, hBrushOld);
  99      SelectObject(hdc, hPenOld);
 100      return Radius;
 101 }
 102
 103
 104 static VOID
 105 DrawHands(HDC hdc, SYSTEMTIME * pst, BOOL fChange, INT Radius)
 106 {
 107      POINT pt[3][5] = { {{0, (INT)-Radius/6}, {(INT)Radius/9, 0},
 108              {0, (INT)Radius/1.8}, {(INT)-Radius/9, 0}, {0, (INT)-Radius/6}},
 109      {{0, (INT)-Radius/4.5}, {(INT)Radius/18, 0}, {0, (INT) Radius*0.89},
 110              {(INT)-Radius/18, 0}, {0, (INT)-Radius/4.5}},
 111      {{0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, (INT) Radius*0.89}} };
 112      INT i, iAngle[3];
 113      POINT ptTemp[3][5];
 114
 115      /* Black pen for outline, white brush for fill */
 116      SelectObject(hdc, GetStockObject(BLACK_PEN));
 117      SelectObject(hdc, GetStockObject(WHITE_BRUSH));
 118
 119      iAngle[0] = (pst->wHour * 30) % 360 + pst->wMinute / 2;
 120      iAngle[1] = pst->wMinute * 6;
 121      iAngle[2] = pst->wSecond * 6;
 122
 123      CopyMemory(ptTemp, pt, sizeof(pt));
 124
 125      for (i = fChange ? 0 : 2; i < 3; i++)
 126      {
 127           RotatePoint(ptTemp[i], 5, iAngle[i]);
 128
 129           Polygon(hdc, ptTemp[i], 5);
 130      }
 131 }
 132
 133
 134 static LRESULT CALLBACK
 135 ClockWndProc(HWND hwnd,
 136              UINT uMsg,
 137              WPARAM wParam,
 138              LPARAM lParam)
 139 {
 140     PCLOCKDATA pClockData;
 141     HDC hdc, hdcMem;
 142     PAINTSTRUCT ps;
 143
 144     pClockData = (PCLOCKDATA)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
 145
 146     switch (uMsg)
 147     {
 148         case WM_CREATE:
 149             pClockData = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLOCKDATA));
 150             SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)pClockData);
 151
 152             pClockData->hGreyPen = CreatePen(PS_SOLID, 1, RGB(128, 128, 128));
 153             pClockData->hGreyBrush = CreateSolidBrush(RGB(128, 128, 128));
 154
 155             SetTimer(hwnd, ID_TIMER, 1000, NULL);
 156             pClockData->bTimer = TRUE;
 157             GetLocalTime(&pClockData->stCurrent);
 158             pClockData->stPrevious = pClockData->stCurrent;
 159             break;
 160
 161         case WM_SIZE:
 162             pClockData->cxClient = LOWORD(lParam);
 163             pClockData->cyClient = HIWORD(lParam);
 164             break;
 165
 166         case WM_TIMER:
 167             GetLocalTime(&pClockData->stCurrent);
 168             InvalidateRect(hwnd, NULL, FALSE);
 169             pClockData->stPrevious = pClockData->stCurrent;
 170             break;
 171
 172         case WM_PAINT:
 173             hdc = BeginPaint(hwnd, &ps);
 174
 175             hdcMem = CreateCompatibleDC(hdc);
 176             if (hdcMem)
 177             {
 178                 HBITMAP hBmp, hBmpOld;
 179
 180                 hBmp = CreateCompatibleBitmap(hdc,
 181                                               pClockData->cxClient,
 182                                               pClockData->cyClient);
 183                 if (hBmp)
 184                 {
 185                     RECT rcParent;
 186                     HWND hParentWnd = GetParent(hwnd);
 187                     INT oldMap, Radius;
 188                     POINT oldOrg;
 189
 190                     hBmpOld = SelectObject(hdcMem, hBmp);
 191
 192                     SetRect(&rcParent, 0, 0, pClockData->cxClient, pClockData->cyClient);
 193                     MapWindowPoints(hwnd, hParentWnd, (POINT*)&rcParent, 2);
 194                     OffsetViewportOrgEx(hdcMem, -rcParent.left, -rcParent.top, &oldOrg);
 195                     SendMessage(hParentWnd, WM_PRINT, (WPARAM)hdcMem, PRF_ERASEBKGND | PRF_CLIENT);
 196                     SetViewportOrgEx(hdcMem, oldOrg.x, oldOrg.y, NULL);
 197
 198                     oldMap = SetMapMode(hdcMem, MM_ISOTROPIC);
 199                     SetWindowExtEx(hdcMem, 3600, 2700, NULL);
 200                     SetViewportExtEx(hdcMem, 800, -600, NULL);
 201                     SetViewportOrgEx(hdcMem,
 202                                      pClockData->cxClient / 2,
 203                                      pClockData->cyClient / 2,
 204                                      &oldOrg);
 205
 206                     Radius = DrawClock(hdcMem, pClockData);
 207                     DrawHands(hdcMem, &pClockData->stPrevious, TRUE, Radius);
 208
 209                     SetMapMode(hdcMem, oldMap);
 210                     SetViewportOrgEx(hdcMem, oldOrg.x, oldOrg.y, NULL);
 211
 212                     BitBlt(hdc,
 213                            0,
 214                            0,
 215                            pClockData->cxClient,
 216                            pClockData->cyClient,
 217                            hdcMem,
 218                            0,
 219                            0,
 220                            SRCCOPY);
 221
 222                     SelectObject(hdcMem, hBmpOld);
 223                     DeleteObject(hBmp);
 224                 }
 225
 226                 DeleteDC(hdcMem);
 227             }
 228
 229             EndPaint(hwnd, &ps);
 230             break;
 231
 232         /* No need to erase background, handled during paint */
 233         case WM_ERASEBKGND:
 234             return 1;
 235
 236         case WM_DESTROY:
 237             DeleteObject(pClockData->hGreyPen);
 238             DeleteObject(pClockData->hGreyBrush);
 239
 240             if (pClockData->bTimer)
 241                 KillTimer(hwnd, ID_TIMER);
 242
 243             HeapFree(GetProcessHeap(), 0, pClockData);
 244             break;
 245
 246         case CLM_STOPCLOCK:
 247             if (pClockData->bTimer)
 248             {
 249                 KillTimer(hwnd, ID_TIMER);
 250                 pClockData->bTimer = FALSE;
 251             }
 252             break;
 253
 254         case CLM_STARTCLOCK:
 255             if (!pClockData->bTimer)
 256             {
 257                 SetTimer(hwnd, ID_TIMER, 1000, NULL);
 258                 pClockData->bTimer = TRUE;
 259             }
 260             break;
 261
 262         default:
 263             DefWindowProcW(hwnd,
 264                            uMsg,
 265                            wParam,
 266                            lParam);
 267     }
 268
 269     return TRUE;
 270 }
 271
 272
 273 BOOL
 274 RegisterClockControl(VOID)
 275 {
 276     WNDCLASSEXW wc = {0};
 277
 278     wc.cbSize = sizeof(WNDCLASSEXW);
 279     wc.lpfnWndProc = ClockWndProc;
 280     wc.hInstance = hApplet;
 281     wc.hCursor = LoadCursorW(NULL, IDC_ARROW);
 282     wc.hbrBackground = (HBRUSH)(COLOR_BTNFACE + 1);
 283     wc.lpszClassName = szClockWndClass;
 284
 285     return RegisterClassExW(&wc) != (ATOM)0;
 286 }
 287
 288
 289 VOID
 290 UnregisterClockControl(VOID)
 291 {
 292     UnregisterClassW(szClockWndClass,
 293                      hApplet);
 294 }