making a clock in win32

okay... clock without multi-threading... here we go:

First -- Get accurate(enough) time.
If you're using C, include <time.h>
else if you're using C++, include <ctime>

time_t value = NULL; // use time_t type and initilize to 0
time(&value); // Get current time
tm actualTime = {0}; // use tm struct type and initilize struct to 0
localtime_s(&actualTime, value); // convert to an actual clock time

That gets the time... (tm structure has a tm_sec, tm_min, and tm_hour members to show the time)

Next you need to route an event so you can update the time

UINT_PTR SetTimer(
HWND hWnd,
UINT_PTR nIDEvent,
UINT uElapse,
TIMERPROC lpTimerFunc
);

the above function does that... an example:

#define IDT_MAIN 1001

// Routes a event to WM_TIMER every 700 miliseconds, or 7/10 a second.
// It is better to update more than once a second due to windows
// timer inaccurices.

SetTimer(windowHandle, IDT_MAIN, 700, NULL);

// Just remember to call this before WinMain returns
KillTimer(windowHandle, IDT_MAIN);

// For the window message.. here
switch (message)
{
case WM_TIMER:
{
if (wParam == IDT_MAIN)
{
// Get time and display it somewhere
}
} break;
}

There we go. I think I got everything... need any more help feel free to ask. ;)

Just to add. You don't post WM_PAINT messages ever. The way to trigger a paint is to InvalidateRect and then UpdateWindow

finished the clock

//analogue alarm clock
//started 11 august 2007
//version 0.5
//coded by g3RC4n

//******************************************************************************
//notes:
// clock is always square
// diameter is 3/4 os the shortest axis
//******************************************************************************

#include <windows.h>
#include <ctime>
#include <math.h>

#define IDT_MAIN 1001

char szClassName[ ] = "WindowsApp";

const int x_boarder = 8;
const int y_boarder = 34;
const int client_area = 200;
const int dls = 1;

POINT circle[60];

struct curTime
{
int sec;
int min;
int hour;
};

LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);
void DrawCircle(HWND hwnd);
curTime CurrentTime();

int WINAPI WinMain (HINSTANCE hThisInstance,
HINSTANCE hPrevInstance,
LPSTR lpszArgument,
int nFunsterStil)

{
HWND hwnd;
MSG messages;
WNDCLASSEX wincl;

wincl.hInstance = hThisInstance;
wincl.lpszClassName = szClassName;
wincl.lpfnWndProc = WindowProcedure;
wincl.style = CS_DBLCLKS;
wincl.cbSize = sizeof (WNDCLASSEX);
wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
wincl.lpszMenuName = NULL;
wincl.cbClsExtra = 0;
wincl.cbWndExtra = 0;
wincl.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);

if (!RegisterClassEx (&wincl))
return 0;

hwnd = CreateWindowEx (
0,
szClassName,
"g3 analogue clock v0.5",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT,
CW_USEDEFAULT,
client_area + x_boarder,
client_area + y_boarder,
HWND_DESKTOP,
NULL,
hThisInstance,
NULL
);

ShowWindow (hwnd, nFunsterStil);

while (GetMessage (&messages, NULL, 0, 0))
{
TranslateMessage(&messages);
DispatchMessage(&messages);
}
KillTimer(hwnd, IDT_MAIN);

return messages.wParam;
}

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_CREATE:
SetTimer(hwnd, IDT_MAIN, 700, NULL);
return 0;

case WM_TIMER:
if (wParam == IDT_MAIN)
{
DrawCircle(hwnd);
SetTimer(hwnd, IDT_MAIN, 700, NULL);
}
return 0;

case WM_SIZE:
DrawCircle(hwnd);
return 0;

case WM_PAINT:
DrawCircle(hwnd);
return 0;

case WM_DESTROY:
PostQuitMessage (0);
return 0;

default:
return DefWindowProc (hwnd, message, wParam, lParam);
}

return 0;
}

void DrawCircle(HWND hwnd)
{
HDC hdc;
PAINTSTRUCT ps;
curTime time;
RECT rect;
int shrtax;
int buffer;

GetClientRect(hwnd, &rect);
if(rect.right < rect.bottom)
{
shrtax = rect.right;
}
else
{
shrtax = rect.bottom;
}

double pi = 3.142;
int x;
int y;
double a = pi/2;
int r = shrtax;
int i = 0;
int i2 = 59;

while(i < 60)
{
x = cos(a) * r;
y = sin(a) * r;
a+= pi/30;
circle[i2].x = x;
circle[i2].y = y;
i2--;
i++;
}

InvalidateRect(hwnd, &rect, true);



hdc = BeginPaint(hwnd, &ps);
//set mapping mode 0,0 at the origin
// |+
// |
//-____|_____+
// |
// |
// |-
//*****************************
SetMapMode(hdc, MM_ISOTROPIC);
SetWindowExtEx(hdc, 1000, 1000, NULL);
SetViewportExtEx(hdc, shrtax/2 , -shrtax/2, NULL);
SetViewportOrgEx(hdc, shrtax/2, shrtax/2, NULL);
//*****************************

SetPixel(hdc, 0,0,RGB(0,0,0));

i = 0;
while(i < 10000)
{
x = cos(a) * r;
y = sin(a) * r;
a+= pi/30;
SetPixel(hdc, x,y,RGB(0,0,0));
i++;
}
time = CurrentTime();

HPEN hpen;
//hour hand
//thickest pen

hpen = CreatePen(PS_SOLID, 8, RGB(0,0,0));
SelectObject(hdc, hpen);
buffer = time.hour * 5;

MoveToEx(hdc, 0, 0, NULL);
LineTo(hdc, circle[buffer].x, circle[buffer].y);

//minuet hand
//midum pen
hpen = CreatePen(PS_SOLID, 4, RGB(0,0,0));
SelectObject(hdc, hpen);
MoveToEx(hdc, 0, 0, NULL);
LineTo(hdc, circle[time.min].x, circle[time.min].y);

//second hand
hpen = CreatePen(PS_SOLID, 1, RGB(0,0,0));
SelectObject(hdc, hpen);
MoveToEx(hdc, 0, 0, NULL);
LineTo(hdc, circle[time.sec].x, circle[time.sec].y);


EndPaint(hwnd, &ps);
DeleteDC(hdc);
DeleteObject(hpen);
return;
}

curTime CurrentTime()
{
curTime cur = {0,0,0};

time_t value = 0;
time(&value);

value = value % 43200;
cur.hour = (value / 3600) + dls;
value %= 3600;
cur.min = value / 60;
value %= 60;
cur.sec = value;
return cur;
}

compiles in dev c++

the clocks fugly but it's more about the concept, it's alos a tad messy but anyway

the clock isn't smooth lol

Okay, I am sorry I did not make this clear: SetTimer must only be called once; else that is a (albiet small) memory loss.Could you please explain what memoy will be lost if SetTimer() is called multiple times?

This is a VERY strange idea! Why would you do that?
It will NOT improve the accuracy of Window's timer, but it wil make your clock "jerky": one digit will stay up .7 seconds, another - 1.4 seconds.
BTW, it's very popular to blame Windows' timer (and other things), but I want to assure you that it's perfectly fine for this task - to count seconds.

Just to visualize what he said:

Time line: .......|.......|.......|.......|.......|.......|.......|...-> t
57 58 59 00 01 02 03
Samples Line: .....|.....|.....|.....|.....|.....|.....|.....|.....|.....|...-> t
Result: 56 57 58 58 59 00 00 01 02 03

* Every '.' is 100ms...

Because 1 second (1000ms) doesnt devide without reminder with 700ms
then some seconds seconds will be sampled ones, and some once,
meaning those that will be sampled once, will show up only 700ms,
and those who sampled twice will show up 1400ms!

I would recommend using 100ms, 200ms. (5 or 10 times a second).

Yea I know you already said that he was correct, I just wanted to
"visualize" as I said...

Anyway, he isnt creating a new timer every 0.7sec hes just unecessary updating it every 0.7sec since he is using the same ID over and over again, and if you use a already used ID than it just updates and resets the timer.