Nuklear/demo/win32.c

464 lines
12 KiB
C
Raw Normal View History

2015-04-29 16:56:46 +03:00
/*
Copyright (c) 2015
vurtun <polygone@gmx.net>
MIT licence
*/
2015-04-28 16:32:44 +03:00
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <windows.h>
#include <windowsx.h>
#include <assert.h>
#include <string.h>
2015-04-28 16:32:44 +03:00
/* macros */
2015-06-03 01:58:57 +03:00
#define DTIME 16
2015-04-28 16:32:44 +03:00
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#define MAX(a,b) ((a) < (b) ? (b) : (a))
#define CLAMP(i,v,x) (MAX(MIN(v,x), i))
#define LEN(a) (sizeof(a)/sizeof(a)[0])
#define UNUSED(a) ((void)(a))
2015-06-03 01:58:57 +03:00
#define GUI_IMPLEMENTATION
#include "../tiny_gui.h"
#include "demo.c"
2015-04-28 16:32:44 +03:00
/* Types */
typedef struct XFont {
HFONT handle;
int height;
2015-04-29 16:56:46 +03:00
int ascent;
int descent;
2015-04-28 16:32:44 +03:00
} XFont;
typedef struct XSurface {
int save;
HDC hdc;
HBITMAP bitmap;
HRGN region;
unsigned int width;
unsigned int height;
} XSurface;
typedef struct XWindow {
HINSTANCE hInstance;
WNDCLASS wc;
HWND hWnd;
HDC hdc;
RECT rect;
XSurface *backbuffer;
XFont *font;
2015-04-29 16:56:46 +03:00
unsigned int width;
unsigned int height;
2015-04-28 16:32:44 +03:00
} XWindow;
static int running = 1;
2015-04-29 16:56:46 +03:00
static int quit = 0;
static XWindow xw;
2015-04-28 16:32:44 +03:00
static void
die(const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
fputs("\n", stderr);
2015-04-28 16:32:44 +03:00
exit(EXIT_FAILURE);
}
static long long
timestamp(LARGE_INTEGER freq)
{
LARGE_INTEGER now;
QueryPerformanceCounter(&now);
return (1000LL * now.QuadPart) / freq.QuadPart;
}
static XFont*
2015-04-29 16:56:46 +03:00
font_new(HDC hdc, const char *name, int height)
2015-04-28 16:32:44 +03:00
{
2015-04-29 16:56:46 +03:00
HFONT old;
TEXTMETRIC metrics;
2015-04-28 16:32:44 +03:00
XFont *font = malloc(sizeof(XFont));
if (!font) return NULL;
2015-04-28 16:32:44 +03:00
font->height = height;
font->handle = CreateFont(height, 0, 0, 0, 0, FALSE, FALSE, FALSE,
2015-05-02 16:41:11 +03:00
ANSI_CHARSET, OUT_CHARACTER_PRECIS, CLIP_CHARACTER_PRECIS,
ANTIALIASED_QUALITY, DEFAULT_PITCH, name);
2015-04-29 16:56:46 +03:00
old = SelectObject(hdc, font->handle);
GetTextMetrics(hdc, &metrics);
font->ascent = metrics.tmAscent;
font->descent = metrics.tmDescent;
SelectObject(hdc, old);
2015-04-28 16:32:44 +03:00
return font;
}
gui_size
2015-05-31 15:46:02 +03:00
font_get_text_width(gui_handle handle, const gui_char *text, gui_size len)
2015-04-28 16:32:44 +03:00
{
SIZE size;
HFONT old;
2015-05-31 15:46:02 +03:00
XWindow *win = handle.ptr;
2015-04-28 16:32:44 +03:00
XFont *font = win->font;
XSurface *surf = win->backbuffer;
if (!font ||!text || !len) return 0;
old = SelectObject(surf->hdc, font->handle);
GetTextExtentPoint32(surf->hdc, (LPCTSTR)text, len, &size);
SelectObject(surf->hdc, old);
return size.cx;
}
static void
font_del(XFont *font)
{
if (font->handle)
DeleteObject(font->handle);
2015-04-28 16:32:44 +03:00
free(font);
}
static XSurface*
surface_new(HDC hdc, unsigned int width, unsigned int height)
{
XSurface *surf = malloc(sizeof(XSurface));
if (!surf) return NULL;
2015-04-28 16:32:44 +03:00
surf->hdc = CreateCompatibleDC(hdc);
surf->bitmap = CreateCompatibleBitmap(hdc, width, height);
surf->width = width;
surf->height = height;
surf->region = NULL;
return surf;
}
static void
surface_resize(XSurface *surf, HDC hdc, unsigned int width, unsigned int height)
{
DeleteObject(surf->bitmap);
surf->bitmap = CreateCompatibleBitmap(hdc, width, height);
surf->width = width;
surf->height = height;
}
static void
surface_del(XSurface *surf)
{
if (surf->region) DeleteObject(surf->region);
DeleteDC(surf->hdc);
DeleteObject(surf->bitmap);
free(surf);
}
static void
surface_scissor(XSurface *surf, short x, short y, unsigned short w, unsigned short h)
{
if (surf->region) DeleteObject(surf->region);
surf->region = CreateRectRgn(x, y, x + w, y + h);
SelectClipRgn(surf->hdc, surf->region);
}
static void
surface_draw_line(XSurface *surf, short x0, short y0, short x1, short y1,
unsigned char r, unsigned char g, unsigned char b)
{
HPEN hPen;
HPEN old;
hPen = CreatePen(PS_SOLID, 1, RGB(r,g,b));
old = SelectObject(surf->hdc, hPen);
MoveToEx(surf->hdc, x0, y0, NULL);
LineTo(surf->hdc, x1, y1);
SelectObject(surf->hdc, old);
DeleteObject(hPen);
}
static void
surface_draw_rect(XSurface *surf, short x, short y, unsigned short w, unsigned short h,
unsigned char r, unsigned char g, unsigned char b)
{
HBRUSH hBrush;
HBRUSH old;
RECT rect;
rect.left = (LONG)x;
rect.top = (LONG)y;
rect.right = (LONG)(x + w);
rect.bottom = (LONG)(y + h);
hBrush = CreateSolidBrush(RGB(r,g,b));
old = SelectObject(surf->hdc, hBrush);
FillRect(surf->hdc, &rect, hBrush);
SelectObject(surf->hdc, old);
DeleteObject(hBrush);
}
static void
surface_draw_circle(XSurface *surf, short x, short y, unsigned short w, unsigned short h,
unsigned char r, unsigned char g, unsigned char b)
{
HBRUSH hBrush;
HBRUSH old;
hBrush = CreateSolidBrush(RGB(r,g,b));
old = SelectObject(surf->hdc, hBrush);
Ellipse(surf->hdc, x, y, (x + w), (y + h));
SelectObject(surf->hdc, old);
DeleteObject(hBrush);
}
static void
surface_draw_triangle(XSurface *surf, short x0, short y0, short x1, short y1,
short x2, short y2, unsigned char r, unsigned char g, unsigned char b)
{
HBRUSH old;
HBRUSH hBrush;
POINT pnt[3];
pnt[0].x = (LONG)x0;
pnt[0].y = (LONG)y0;
pnt[1].x = (LONG)x1;
pnt[1].y = (LONG)y1;
pnt[2].x = (LONG)x2;
pnt[2].y = (LONG)y2;
hBrush = CreateSolidBrush(RGB(r,g,b));
old = SelectObject(surf->hdc, hBrush);
Polygon(surf->hdc, pnt, 3);
SelectObject(surf->hdc, old);
DeleteObject(hBrush);
}
static void
surface_draw_text(XSurface *surf, XFont *font, short x, short y, unsigned short w, unsigned short h,
const char *text, unsigned int len,
unsigned char bg_r, unsigned char bg_g, unsigned char bg_b,
unsigned char fg_r, unsigned char fg_g, unsigned char fg_b)
{
RECT format;
UINT bg = RGB(bg_r, bg_g, bg_b);
UINT fg = RGB(fg_r, fg_g, fg_b);
HFONT old = SelectObject(surf->hdc, font->handle);
2015-04-29 16:56:46 +03:00
2015-04-28 16:32:44 +03:00
format.left = x;
format.top = y;
format.right = x + w;
format.bottom = y + h;
SetBkColor(surf->hdc, bg);
SetTextColor(surf->hdc, fg);
SetBkMode(surf->hdc, OPAQUE);
DrawText(surf->hdc, text, len, &format, DT_LEFT|DT_SINGLELINE|DT_VCENTER);
2015-04-28 16:32:44 +03:00
SelectObject(surf->hdc, old);
}
static void
surface_clear(XSurface *surf, unsigned char r, unsigned char g, unsigned char b)
{surface_draw_rect(surf, 0, 0, (unsigned short)surf->width, (unsigned short)surf->height, r, g, b);}
static void
surface_begin(XSurface *surf)
{
surf->save = SaveDC(surf->hdc);
SelectObject(surf->hdc, surf->bitmap);
}
static void
surface_end(XSurface *surf, HDC hdc)
{
BitBlt(hdc, 0, 0, surf->width, surf->height, surf->hdc, 0, 0, SRCCOPY);
RestoreDC(hdc, surf->save);
}
static void
2015-05-29 16:28:08 +03:00
execute(XSurface *surf, gui_command_buffer *buffer)
2015-04-28 16:32:44 +03:00
{
2015-05-04 12:03:15 +03:00
const struct gui_command *cmd;
2015-05-29 16:28:08 +03:00
gui_foreach_command(cmd, buffer) {
2015-04-28 16:32:44 +03:00
switch (cmd->type) {
case GUI_COMMAND_NOP: break;
case GUI_COMMAND_SCISSOR: {
2015-05-29 16:28:08 +03:00
const struct gui_command_scissor *s = gui_command(scissor, cmd);
2015-04-28 16:32:44 +03:00
surface_scissor(surf, s->x, s->y, s->w, s->h);
} break;
case GUI_COMMAND_LINE: {
2015-05-29 16:28:08 +03:00
const struct gui_command_line *l = gui_command(line, cmd);
2015-04-28 16:32:44 +03:00
surface_draw_line(surf, l->begin[0], l->begin[1], l->end[0],
l->end[1], l->color.r, l->color.g, l->color.b);
} break;
case GUI_COMMAND_RECT: {
2015-05-29 16:28:08 +03:00
const struct gui_command_rect *r = gui_command(rect, cmd);
2015-04-28 16:32:44 +03:00
surface_draw_rect(surf, r->x, r->y, r->w, r->h,
2015-05-02 16:41:11 +03:00
r->color.r, r->color.g, r->color.b);
2015-04-28 16:32:44 +03:00
} break;
case GUI_COMMAND_CIRCLE: {
2015-05-29 16:28:08 +03:00
const struct gui_command_circle *c = gui_command(circle, cmd);
2015-04-28 16:32:44 +03:00
surface_draw_circle(surf, c->x, c->y, c->w, c->h,
2015-05-02 16:41:11 +03:00
c->color.r, c->color.g, c->color.b);
2015-04-28 16:32:44 +03:00
} break;
case GUI_COMMAND_TRIANGLE: {
2015-05-29 16:28:08 +03:00
const struct gui_command_triangle *t = gui_command(triangle, cmd);
2015-04-28 16:32:44 +03:00
surface_draw_triangle(surf, t->a[0], t->a[1], t->b[0], t->b[1],
t->c[0], t->c[1], t->color.r, t->color.g, t->color.b);
} break;
case GUI_COMMAND_TEXT: {
2015-05-29 16:28:08 +03:00
const struct gui_command_text *t = gui_command(text, cmd);
2015-06-02 14:59:04 +03:00
XWindow *win = t->font.ptr;
surface_draw_text(surf, win->font, t->x, t->y, t->w, t->h, (const char*)t->string,
2015-04-28 16:32:44 +03:00
t->length, t->bg.r, t->bg.g, t->bg.b, t->fg.r, t->fg.g, t->fg.b);
} break;
2015-05-21 23:10:07 +03:00
case GUI_COMMAND_IMAGE:
2015-04-28 16:32:44 +03:00
default: break;
}
}
}
static void
2015-05-29 16:28:08 +03:00
draw(XSurface *surf, struct gui_stack *stack)
2015-04-28 16:32:44 +03:00
{
2015-05-29 16:28:08 +03:00
struct gui_panel *iter;
gui_foreach_panel(iter, stack)
execute(surf, iter->buffer);
2015-04-28 16:32:44 +03:00
}
static void
key(struct gui_input *in, MSG *msg, gui_bool down)
{
if (msg->lParam == VK_CONTROL)
gui_input_key(in, GUI_KEY_CTRL, down);
else if (msg->lParam == VK_SHIFT)
gui_input_key(in, GUI_KEY_SHIFT, down);
else if (msg->lParam == VK_DELETE)
gui_input_key(in, GUI_KEY_DEL, down);
else if (msg->lParam == VK_RETURN)
gui_input_key(in, GUI_KEY_ENTER, down);
else if (msg->lParam == VK_SPACE)
gui_input_key(in, GUI_KEY_SPACE, down);
else if (msg->lParam == VK_BACK)
gui_input_key(in, GUI_KEY_BACKSPACE, down);
}
static void
text(struct gui_input *in, MSG *msg)
{
gui_glyph glyph;
if (msg->wParam < 32 && msg->wParam >= 128) return;
glyph[0] = (gui_char)msg->wParam;
gui_input_char(in, glyph);
}
static void
motion(struct gui_input *in, MSG *msg)
{
const gui_int x = GET_X_LPARAM(msg->lParam);
const gui_int y = GET_Y_LPARAM(msg->lParam);
gui_input_motion(in, x, y);
}
static void
btn(struct gui_input *in, MSG *msg, gui_bool down)
{
const gui_int x = GET_X_LPARAM(msg->lParam);
const gui_int y = GET_Y_LPARAM(msg->lParam);
gui_input_button(in, x, y, down);
}
LRESULT CALLBACK
wnd_proc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg) {
2015-05-02 16:41:11 +03:00
case WM_DESTROY:
PostQuitMessage(WM_QUIT);
running = 0;
quit = 1;
break;
case WM_SIZE:
if (xw.backbuffer) {
xw.width = LOWORD(lParam);
xw.height = HIWORD(lParam);
surface_resize(xw.backbuffer, xw.hdc, xw.width, xw.height);
} break;
default:
return DefWindowProc(hWnd, msg, wParam, lParam);
2015-04-28 16:32:44 +03:00
}
return 0;
}
INT WINAPI
WinMain(HINSTANCE hInstance, HINSTANCE prev, LPSTR lpCmdLine, int shown)
2015-04-28 16:32:44 +03:00
{
LARGE_INTEGER freq;
long long start;
long long dt;
/* GUI */
struct gui_input in;
struct gui_font font;
2015-05-13 15:47:11 +03:00
struct demo_gui gui;
2015-04-28 16:32:44 +03:00
/* Window */
2015-04-29 16:56:46 +03:00
QueryPerformanceFrequency(&freq);
2015-04-28 16:32:44 +03:00
xw.wc.style = CS_HREDRAW|CS_VREDRAW;
xw.wc.lpfnWndProc = wnd_proc;
xw.wc.hInstance = hInstance;
xw.wc.lpszClassName = "GUI";
RegisterClass(&xw.wc);
xw.hWnd = CreateWindowEx(
2015-05-02 16:41:11 +03:00
0, xw.wc.lpszClassName, "Demo",
WS_OVERLAPPED|WS_CAPTION|WS_SYSMENU|WS_MINIMIZEBOX|WS_MAXIMIZEBOX|WS_VISIBLE,
2015-05-02 16:41:11 +03:00
CW_USEDEFAULT, CW_USEDEFAULT,
WINDOW_WIDTH, WINDOW_HEIGHT,
2015-05-02 16:41:11 +03:00
0, 0, hInstance, 0);
2015-04-28 16:32:44 +03:00
xw.hdc = GetDC(xw.hWnd);
GetClientRect(xw.hWnd, &xw.rect);
xw.backbuffer = surface_new(xw.hdc, xw.rect.right, xw.rect.bottom);
2015-04-29 16:56:46 +03:00
xw.font = font_new(xw.hdc, "Times New Roman", 14);
xw.width = xw.rect.right;
xw.height = xw.rect.bottom;
2015-04-28 16:32:44 +03:00
/* GUI */
memset(&in, 0, sizeof in);
2015-05-13 15:47:11 +03:00
memset(&gui, 0, sizeof gui);
2015-05-31 15:46:02 +03:00
font.userdata.ptr = &xw;
2015-04-28 16:32:44 +03:00
font.height = (gui_float)xw.font->height;
font.width = font_get_text_width;
gui.running = gui_true;
2015-05-29 16:28:08 +03:00
gui.memory = malloc(MAX_MEMORY);
2015-05-13 15:47:11 +03:00
init_demo(&gui, &font);
2015-04-28 16:32:44 +03:00
while (gui.running && !quit) {
2015-04-28 16:32:44 +03:00
/* Input */
2015-05-02 16:41:11 +03:00
MSG msg;
start = timestamp(freq);
2015-04-28 16:32:44 +03:00
gui_input_begin(&in);
2015-05-02 16:41:11 +03:00
while (PeekMessage(&msg, xw.hWnd, 0, 0, PM_REMOVE)) {
if (msg.message == WM_KEYDOWN) key(&in, &msg, gui_true);
else if (msg.message == WM_KEYUP) key(&in, &msg, gui_false);
else if (msg.message == WM_LBUTTONDOWN) btn(&in, &msg, gui_true);
else if (msg.message == WM_LBUTTONUP) btn(&in, &msg, gui_false);
else if (msg.message == WM_MOUSEMOVE) motion(&in, &msg);
else if (msg.message == WM_CHAR) text(&in, &msg);
2015-04-28 16:32:44 +03:00
TranslateMessage(&msg);
2015-05-02 16:41:11 +03:00
DispatchMessage(&msg);
}
2015-04-28 16:32:44 +03:00
gui_input_end(&in);
2015-05-02 16:41:11 +03:00
/* GUI */
run_demo(&gui, &in);
2015-04-28 16:32:44 +03:00
2015-05-02 16:41:11 +03:00
/* Draw */
surface_begin(xw.backbuffer);
surface_clear(xw.backbuffer, 100, 100, 100);
2015-05-21 23:10:07 +03:00
draw(xw.backbuffer, &gui.stack);
2015-05-02 16:41:11 +03:00
surface_end(xw.backbuffer, xw.hdc);
2015-04-28 16:32:44 +03:00
/* Timing */
2015-05-02 16:41:11 +03:00
dt = timestamp(freq) - start;
if (dt < DTIME) Sleep(DTIME - dt);
2015-04-28 16:32:44 +03:00
}
2015-05-29 16:28:08 +03:00
free(gui.memory);
2015-04-28 16:32:44 +03:00
font_del(xw.font);
surface_del(xw.backbuffer);
ReleaseDC(xw.hWnd, xw.hdc);
return 0;
}
2015-06-03 01:58:57 +03:00