#include <windows.h>
#include <list>

const WCHAR g_testString[] = L"THIS IS AN ALL CAPS TEST STRING";

std::list<HFONT> g_fonts;
bool g_checkerboard = false;

static void RenderFont (HDC hDC, HFONT font, int& y)
{
    size_t testStringLen = sizeof (g_testString) / sizeof (WCHAR) - 1;

    HGDIOBJ prevObj = SelectObject (hDC, font);
    TextOutW (hDC, 16, y, g_testString, testStringLen);

    SIZE sz;
    if (g_checkerboard)
    {
        int lastX = 0;
        bool flip = true;
        for (int i = 1; i <= testStringLen; i++)
        {
            GetTextExtentPoint32W (hDC, g_testString, i, &sz);
            if (flip)
                BitBlt (hDC, 16 + lastX, y, sz.cx - lastX, sz.cy, NULL, 0, 0, DSTINVERT);
            
            flip = !flip;
            lastX = sz.cx;
        }
    }
    else
    {
        GetTextExtentPoint32W (hDC, g_testString, testStringLen, &sz);
        BitBlt (hDC, 16 + sz.cx, y, 1, sz.cy, NULL, 0, 0, DSTINVERT);
    }

    SelectObject (hDC, prevObj);

    y += 16 + sz.cy;
}

static void Render (HDC hDC)
{
    BitBlt (hDC, 0, 0, 1024, 1024, NULL, 0, 0, WHITENESS);

    int y = 16;
    for (HFONT font : g_fonts)
        RenderFont (hDC, font, y);
}

static LONG WndProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
    switch (uMsg)
    {
    case WM_PAINT:
        if (GetUpdateRect (hWnd, NULL, false))
        {
            PAINTSTRUCT    paint;
            HDC hDC = BeginPaint (hWnd, &paint);
            Render (hDC);
            EndPaint (hWnd, &paint);
        }
        break;

    case WM_CHAR:
        if (wParam == ' ')
            g_checkerboard = !g_checkerboard;

        InvalidateRect (hWnd, NULL, false);
        break;

    case WM_CLOSE:
        PostQuitMessage (0);
        break;

    default:
        return DefWindowProc (hWnd, uMsg, wParam, lParam);
    }

    return 1;
}

int main ()
{
    WNDCLASSEX    wndClass = {0};

    wndClass.cbSize            = sizeof (wndClass);
    wndClass.style            = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    wndClass.lpfnWndProc    = (WNDPROC)WndProc;
    wndClass.hInstance        = NULL;
    wndClass.lpszClassName    = L"TestFonts";

    if (!RegisterClassExW (&wndClass))
        return false;

    for (int height = 10; height < 20; height++)
    {
        g_fonts.push_back (CreateFontW (height, 0, 0, 0, FW_NORMAL,    0, 0, 0, 0, 0, 0, NONANTIALIASED_QUALITY, DEFAULT_PITCH, L"Arial"));
        g_fonts.push_back (CreateFontW (height, 0, 0, 0, FW_NORMAL,    0, 0, 0, 0, 0, 0, ANTIALIASED_QUALITY, DEFAULT_PITCH, L"Arial"));
    }

    HWND hWnd = CreateWindowExW (0, wndClass.lpszClassName, wndClass.lpszClassName, WS_TILEDWINDOW, 0, 0, 800, 1024, NULL, NULL, NULL, NULL);
    ShowWindow (hWnd, SW_SHOWDEFAULT);

    MSG msg;
    while (GetMessage (&msg, NULL, 0, 0))
    {
        TranslateMessage (&msg);
        DispatchMessage (&msg);
    }

    CloseWindow (hWnd);
}

// SerialPort.h
#pragma once

struct SerialPort {
    static SerialPort *create(const char* name,const char* prm=0);
    virtual void close()=0;
    virtual int invalid()=0;
    virtual int setup(const char* config)=0;
    virtual int set_dtr(bool dtr)=0;
    virtual int set_rts(bool dtr)=0;
    virtual int get_rxqueue()=0;
    virtual int read(void* data,int size)=0;
    virtual int write(void* data,int size)=0;
    virtual ~SerialPort() {}
};

// SerialPort.cpp
#include "SerailPort.h"
#include <windows.h>

struct WinSerialPort : SerialPort {
    HANDLE handle;
    int open(const char* name,const char* prm) {
        close();
        handle=CreateFileA(name,GENERIC_READ|GENERIC_WRITE,0,0,OPEN_EXISTING,0,0);
        return handle==INVALID_HANDLE_VALUE ? 1 : 0 ;
    }
    void close() {
        if (invalid()) return;
        CloseHandle(handle); handle=INVALID_HANDLE_VALUE;
    }
    int invalid() { return handle==INVALID_HANDLE_VALUE; }
    int setup(const char* config) {
        if (invalid()) return 1;
        DCB dcb[1]; ZeroMemory(dcb,sizeof(*dcb));
        dcb->DCBlength=sizeof(*dcb);
        // COMx[:][baud=b][parity=p][data=d][stop=s][to={on|off}][xon={on|off}][odsr={on|off}][octs={on|off}][dtr={on|off|hs}][rts={on|off|hs|tg}][idsr={on|off}]
        BOOL rv=BuildCommDCBA(config,dcb); if (!rv) return 2;
        rv=SetCommState(handle,dcb); if (!rv) return 3;
        #if 0
            COMMTIMEOUTS timeouts[1]; ZeroMemory(timeouts,sizeof(*timeouts));
            timeouts->ReadIntervalTimeout=100;        /* Maximum time between read chars. */
            timeouts->ReadTotalTimeoutMultiplier=10;  /* Multiplier of characters.        */
            timeouts->ReadTotalTimeoutConstant=100;   /* Constant in milliseconds.        */
            timeouts->WriteTotalTimeoutMultiplier=10; /* Multiplier of characters.        */
            timeouts->WriteTotalTimeoutConstant=100;  /* Constant in milliseconds.        */
            rv=SetCommTimeouts(handle,timeouts); if (!rc) return 4;
        #endif
        return 0;
    }
    int set_dtr(bool value) {
        if (invalid()) return 1;
        BOOL rv=EscapeCommFunction(handle, value ? SETDTR : CLRDTR);
        return rv ? 0 : 2;
    }
    int set_rts(bool value) {
        if (invalid()) return 1;
        BOOL rv=EscapeCommFunction(handle, value ? SETRTS : CLRRTS);
        return rv ? 0 : 2;
    }
    int get_rxqueue() {
        if (invalid()) return 0;
        DWORD Errors=0; COMSTAT stat[1];
        BOOL rv=ClearCommError(handle,&Errors,stat);
        return rv ? stat->cbInQue : 0;
    }
    int read(void* data,int size) {
        if (invalid()) return 0;
        DWORD rd=0;
        BOOL rv=ReadFile(handle,data,size,&rd,0);
        return rd;
    }
    int write(void* data,int size) {
        if (invalid()) return 0;
        DWORD wr=0;
        BOOL rv=WriteFile(handle,data,size,&wr,0);
        return wr;
    }
    WinSerialPort() {
        handle=INVALID_HANDLE_VALUE;
    }
    ~WinSerialPort() {
        close();
    }
};

SerialPort* SerialPort::create(const char* name,const char* prm) {
    WinSerialPort *port=new WinSerialPort();
    int res=port->open(name,prm);
    if (prm) port->setup(prm);
    return port;
}

Canvas->Pixels[x][y] = clRed;