wex.h

#pragma once
#define _USE_MATH_DEFINES
#include <cmath>
#include <iostream>
#include <thread>
#include <vector>
#include <map>
#include <functional>
#include <algorithm>
#include <windows.h>
#include <CommCtrl.h>
#include <Shellapi.h>
#include "cxy.h"
 
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
 
namespace wex
{
 
    class gui;
 
    typedef std::map<HWND, gui *> mgui_t;
    typedef std::vector<gui *> children_t;
 
    struct sMouse
    {
        int x;
        int y;
        bool left;
        bool right;
        bool shift;
    };
 
    enum eventMsgID
    {
        asyncReadComplete = WM_APP + 1,
        tcpServerAccept,
        tcpServerReadComplete,
    };
 
    class modalMgr
    {
    public:
        static modalMgr &get()
        {
            static modalMgr theModalMgr;
            return theModalMgr;
        }
 
        bool set(int id, HWND h)
        {
            if (!id)
            {
                myModalID = 0;
                return true;
            }
            if (myModalID)
            {
                std::cout << "App tried to show two modal windows\n";
                SetFocus(myModalHandle);
                return false;
            }
 
            myModalID = id;
            myModalHandle = h;
            return true;
        }
 
        bool canClose(int id)
        {
            if (!myModalID)
                return true; // no modal window is running
 
            if (myModalID == id)
            {
                // the modal window is being closed
                myModalID = 0;
                return true;
            }
 
            // attempt to close other window while modal window is running
            // give the modal window focus
            SetFocus(myModalHandle);
            return false;
        }
 
    private:
        int myModalID;
        HWND myModalHandle;
 
        modalMgr()
            : myModalID(0)
        {
        }
    };
 
    class eventhandler
    {
    public:
        eventhandler()
            : myfClickPropogate(false), myfMouseTracking(false)
        {
            // initialize functions with no-ops
            click([] {});
            clickDouble([] {});
            clickWex([] {});
            clickRight([] {});
            draw([](PAINTSTRUCT &ps) {});
            resize([](int w, int h) {});
            scrollH([](int c) {});
            scrollV([](int c) {});
            keydown([](int c) {});
            mouseEnter([] {});
            mouseLeave([] {});
            mouseMove([](sMouse &m) {});
            mouseWheel([](int dist) {});
            mouseUp([] {});
            timer([](int id) {});
            slid([](int pos) {});
            dropStart([](HDROP hDrop) {});
            drop([](const std::vector<std::string> &files) {});
            asyncReadComplete([](int id) {});
            tcpServerAccept([] {});
            tcpRead([] {});
            quitApp([]
                    { return true; });
            datePick([](int id, LPNMDATETIMECHANGE date) {});
        }
        bool onLeftdown()
        {
            myClickFunWex();
            myClickFunctionApp();
            return !myfClickPropogate;
        }
        void onRightDown()
        {
            myClickRightFunction();
        }
        void onMouseUp()
        {
            myMouseUpFunction();
        }
        void onDoubleClick()
        {
            myClickDoubleFunction();
        }
        void onDraw(PAINTSTRUCT &ps)
        {
            myDrawFunction(ps);
        }
        void onResize(int w, int h)
        {
            myResizeFunction(w, h);
        }
        void onScrollH(int code)
        {
            myScrollHFunction(code);
        }
        void onScrollV(int code)
        {
            myScrollVFunction(code);
        }
        void onMenuCommand(int id)
        {
            if (0 > id || id >= (int)myVectorMenuFunction.size())
                return;
            myVectorMenuFunction[id](myVectorMenuTitle[id]);
        }
        void onKeydown(int keycode)
        {
            myKeydownFunction(keycode);
        }
        void onMouseMove(WPARAM wParam, LPARAM lParam)
        {
            sMouse m;
            m.x = LOWORD(lParam);
            m.y = HIWORD(lParam);
 
            // left button or shift key ( never both )
            m.left = (wParam == MK_LBUTTON);
            m.shift = (wParam == MK_SHIFT);
 
            myMouseMoveFunction(m);
        }
        void onMouseEnter()
        {
            myMouseEnterFunction();
        }
        void onMouseWheel(int dist)
        {
            myMouseWheelFunction(dist);
        }
        void onMouseLeave()
        {
            myMouseLeaveFunction();
        }
        void onTimer(int id)
        {
            myTimerFunction(id);
        }
        bool onSelect(
            unsigned short id)
        {
            auto it = mapControlFunction().find(std::make_pair(id, CBN_SELCHANGE));
            if (it == mapControlFunction().end())
                return true;
            it->second();
            return true;
        }
        bool onChange(
            unsigned short id)
        {
            auto it = mapControlFunction().find(std::make_pair(id, EN_CHANGE));
            if (it == mapControlFunction().end())
                return true;
            it->second();
            return true;
        }
        void onSlid(unsigned short id)
        {
            mySlidFunction((int)id);
        }
        void onDropStart(HDROP hDrop)
        {
            myDropStartFunction(hDrop);
        }
        void onDrop(const std::vector<std::string> &files)
        {
            myDropFunction(files);
        }
        void onAsyncReadComplete(int id)
        {
            myAsyncReadCompleteFunction(id);
        }
        void onTcpServerAccept()
        {
            myTcpServerAcceptFunction();
        }
        void onTcpServerReadComplete()
        {
            myTcpServerReadCompleteFunction();
        }
        bool onQuitApp()
        {
            return myQuitAppFunction();
        }
        void onDatePicked(
            int idFrom,
            LPNMDATETIMECHANGE date)
        {
            myDatePickFunction(idFrom, date);
        }
 
        void click(
            std::function<void(void)> f,
            bool propogate = false)
        {
            myClickFunctionApp = f;
            myfClickPropogate = propogate;
        }
        void clickWex(std::function<void(void)> f)
        {
            myClickFunWex = f;
        }
        void clickPropogate(bool f = true)
        {
            myfClickPropogate = f;
        }
 
        void clickRight(std::function<void(void)> f)
        {
            myClickRightFunction = f;
        }
 
        void clickDouble(std::function<void(void)> f)
        {
            myClickDoubleFunction = f;
        }
 
        void draw(std::function<void(PAINTSTRUCT &ps)> f)
        {
            myDrawFunction = f;
        }
        void resize(std::function<void(int w, int h)> f)
        {
            myResizeFunction = f;
        }
        void scrollH(std::function<void(int code)> f)
        {
            myScrollHFunction = f;
        }
        void scrollV(std::function<void(int code)> f)
        {
            myScrollVFunction = f;
        }
        int menuCommand(
            std::function<void(const std::string &title)> f,
            const std::string &title)
        {
            int id = (int)myVectorMenuFunction.size();
            myVectorMenuFunction.push_back(f);
            myVectorMenuTitle.push_back(title);
            return id;
        }
        void select(
            int id,
            std::function<void(void)> f)
        {
            mapControlFunction().insert(
                std::make_pair(std::make_pair(id, CBN_SELCHANGE), f));
        }
        void change(
            int id,
            std::function<void(void)> f)
        {
            mapControlFunction().insert(
                std::make_pair(std::make_pair(id, EN_CHANGE), f));
        }
        void keydown(std::function<void(int keydown)> f)
        {
            myKeydownFunction = f;
        }
        void mouseEnter(std::function<void(void)> f)
        {
            myMouseEnterFunction = f;
        }
        void mouseMove(std::function<void(sMouse &m)> f)
        {
            myMouseMoveFunction = f;
        }
        void mouseWheel(std::function<void(int dist)> f)
        {
            myMouseWheelFunction = f;
        }
        void mouseUp(std::function<void(void)> f)
        {
            myMouseUpFunction = f;
        }
        void mouseLeave(std::function<void(void)> f)
        {
            myMouseLeaveFunction = f;
        }
        void timer(std::function<void(int id)> f)
        {
            myTimerFunction = f;
        }
        void slid(std::function<void(int pos)> f)
        {
            mySlidFunction = f;
        }
        void dropStart(std::function<void(HDROP hDrop)> f)
        {
            myDropStartFunction = f;
        }
        void drop(std::function<void(const std::vector<std::string> &files)> f)
        {
            myDropFunction = f;
        }
        void asyncReadComplete(std::function<void(int id)> f)
        {
            myAsyncReadCompleteFunction = f;
        }
        void tcpServerAccept(std::function<void(void)> f)
        {
            myTcpServerAcceptFunction = f;
        }
        void tcpRead(std::function<void(void)> f)
        {
            myTcpServerReadCompleteFunction = f;
        }
        void quitApp(std::function<bool(void)> f)
        {
            myQuitAppFunction = f;
        }
        void datePick(std::function<void(int, LPNMDATETIMECHANGE)> f)
        {
            myDatePickFunction = f;
        }
 
    private:
        bool myfClickPropogate;
        bool myfMouseTracking;
 
        // event handlers registered by application code
        std::function<void(void)> myClickFunctionApp;
        std::function<void(void)> myClickRightFunction;
        std::function<void(void)> myClickDoubleFunction;
        std::function<void(PAINTSTRUCT &ps)> myDrawFunction;
        std::function<void(int w, int h)> myResizeFunction;
        std::function<void(int code)> myScrollHFunction;
        std::function<void(int code)> myScrollVFunction;
        std::vector<std::function<void(const std::string &title)>> myVectorMenuFunction;
        std::vector<std::string> myVectorMenuTitle;
        std::function<void(int keycode)> myKeydownFunction;
        std::function<void(sMouse &m)> myMouseMoveFunction;
        std::function<void(void)> myMouseEnterFunction;
        std::function<void(int dist)> myMouseWheelFunction;
        std::function<void(int id)> myTimerFunction;
        std::function<void(void)> myMouseUpFunction;
        std::function<void(void)> myMouseLeaveFunction;
        std::function<void(int pos)> mySlidFunction;
        std::function<void(HDROP hDrop)> myDropStartFunction;
        std::function<void(const std::vector<std::string> &files)> myDropFunction;
        std::function<void(int id)> myAsyncReadCompleteFunction;
        std::function<void(void)> myTcpServerAcceptFunction;
        std::function<void(void)> myTcpServerReadCompleteFunction;
        std::function<bool(void)> myQuitAppFunction;
        std::function<void(int, LPNMDATETIMECHANGE)> myDatePickFunction;
 
        // event handlers registered by windex class
        std::function<void(void)> myClickFunWex;
 
        std::map<std::pair<int, unsigned short>, std::function<void(void)>> &
        mapControlFunction()
        {
            static std::map<std::pair<int, unsigned short>, std::function<void(void)>>
                myMapControlFunction;
            return myMapControlFunction;
        }
    };
 
    class shapes
    {
    public:
        shapes(PAINTSTRUCT &ps)
            : myHDC(ps.hdc), myPenThick(1), myFill(false)
        {
            hPen = CreatePen(
                PS_SOLID,
                myPenThick,
                RGB(0, 0, 0));
            hPenOld = SelectObject(myHDC, hPen);
 
            myLogfont = {0};
            HANDLE hFont;
            ZeroMemory(&myLogfont, sizeof(LOGFONT));
            myLogfont.lfWeight = FW_NORMAL;
            strcpy(myLogfont.lfFaceName, "Tahoma");
            myLogfont.lfHeight = 20;
            hFont = CreateFontIndirect(&myLogfont);
            hFont = (HFONT)SelectObject(myHDC, hFont);
            DeleteObject(hFont);
        }
        ~shapes()
        {
            HGDIOBJ pen = SelectObject(myHDC, hPenOld);
            DeleteObject(pen);
        }
        void color(int r, int g, int b)
        {
            color(RGB(r, g, b));
        }
        void color(int c)
        {
            myColor = c;
            hPen = CreatePen(
                PS_SOLID,
                myPenThick,
                c);
            HGDIOBJ old = SelectObject(myHDC, hPen);
            DeleteObject(old);
            SetTextColor(myHDC, c);
            HBRUSH brush = CreateSolidBrush(c);
            old = SelectObject(myHDC, brush);
            DeleteObject(old);
        }
        void bgcolor(int c)
        {
            SetBkColor(
                myHDC,
                c);
        }
        void bgcolor(int r, int g, int b)
        {
            bgcolor(RGB(r, g, b));
        }
        void transparent(bool f = true)
        {
            SetBkMode(
                myHDC,
                TRANSPARENT);
        }
 
        void penThick(int t)
        {
            myPenThick = t;
            color(myColor);
        }
 
        void fill(bool f = true)
        {
            myFill = f;
        }
        void pixel(int x, int y)
        {
            SetPixel(myHDC, x, y, myColor);
        }
        void line(const std::vector<int> &v)
        {
            MoveToEx(
                myHDC,
                v[0],
                v[1],
                NULL);
            LineTo(
                myHDC,
                v[2],
                v[3]);
        }
 
        void polyLine(POINT *pp, int n)
        {
            Polyline(
                myHDC,
                pp,
                n);
        }
        void line(const cxy &p1, const cxy &p2)
        {
            line({(int)p1.x, (int)p1.y,
                  (int)p2.x, (int)p2.y});
        }
        void rectangle(const std::vector<int> &v)
        {
            if (!myFill)
            {
                MoveToEx(
                    myHDC,
                    v[0],
                    v[1],
                    NULL);
                LineTo(
                    myHDC,
                    v[0] + v[2],
                    v[1]);
                LineTo(
                    myHDC,
                    v[0] + v[2],
                    v[1] + v[3]);
                LineTo(
                    myHDC,
                    v[0],
                    v[1] + v[3]);
                LineTo(
                    myHDC,
                    v[0],
                    v[1]);
            }
            else
            {
                //            std::cout << "wex rectangle fill "  << v[0]<<" "<< v[1]<<" "<<  v[0]+v[2]<<" "<<  v[1]+v[3] << "\n";
                Rectangle(
                    myHDC,
                    v[0], v[1], v[0] + v[2], v[1] + v[3]);
            }
        }
 
        void polygon(const std::vector<int> &v)
        {
            //  'empty' polygons are filled with a null brush
            HGDIOBJ oldBrush;
            if (!myFill)
                oldBrush = SelectObject(myHDC, GetStockObject(NULL_BRUSH));
            Polygon(myHDC, (const POINT *)&(v[0]), v.size() / 2);
            if (!myFill)
                SelectObject(myHDC, oldBrush);
        }
        void polygon(const std::vector<cxy> v)
        {
            std::vector<int> vi;
            for (auto &xy : v)
            {
                vi.push_back((int)xy.x);
                vi.push_back((int)xy.y);
            }
 
            polygon(vi);
        }
 
        void arc(
            int x, int y, double r,
            double sa, double ea)
        {
            int xl = round(x - r);
            int yt = round(y - r);
            int xr = round(x + r);
            int yb = round(y + r);
            int xs = round(x + r * cos(sa * M_PI / 180));
            int ys = round(y - r * sin(sa * M_PI / 180));
            int xe = round(x + r * cos(ea * M_PI / 180));
            int ye = round(y - r * sin(ea * M_PI / 180));
            Arc(
                myHDC,
                xl, yt, xr, yb, xs, ys, xe, ye);
        }
        void circle(int x0, int y0, double r)
        {
            //  'empty' circles are filled with a black brush
            HGDIOBJ oldBrush;
            if (!myFill)
                oldBrush = SelectObject(myHDC, GetStockObject(NULL_BRUSH));
            int ir = r;
            Ellipse(
                myHDC,
                x0 - ir, y0 - ir,
                x0 + ir, y0 + ir);
            if (!myFill)
                SelectObject(myHDC, oldBrush);
        }
        void circle(const cxy &xy, double r)
        {
            circle(xy.x, xy.y, r);
        }
        void text(
            const std::string &t,
            const std::vector<int> &v)
        {
            if (myLogfont.lfEscapement)
            {
                // rotated text
                TextOut(
                    myHDC,
                    v[0],
                    v[1],
                    t.c_str(),
                    t.length());
                return;
            }
            RECT rect;
            switch ((int)v.size())
            {
            case 2:
                TextOut(
                    myHDC,
                    v[0],
                    v[1],
                    t.c_str(),
                    t.length());
                break;
            case 4:
                rect.left = v[0];
                rect.top = v[1];
                rect.right = v[0] + v[2];
                rect.bottom = v[1] + v[3];
                DrawText(
                    myHDC,
                    t.c_str(),
                    -1,
                    &rect,
                    DT_WORDBREAK);
                break;
            }
            return;
        }
 
        void textxy(
            const std::string &t,
            const cxy &xy)
        {
            text(
                t,
                {(int)xy.x, (int)xy.y});
        }
        void textxy(
            const std::string &t,
            const cxy &topleft,
            const cxy &widthHeight)
        {
            text(
                t,
                {(int)topleft.x, (int)topleft.y,
                 (int)widthHeight.x, (int)widthHeight.y});
        }
        void rectangle(
            const cxy &topleft,
            const cxy &widthHeight)
        {
            rectangle(
                {(int)topleft.x, (int)topleft.y,
                 (int)widthHeight.x, (int)widthHeight.y});
        }
 
        void textCenterHz(
            const std::string &t,
            const std::vector<int> &v)
        {
            int ws = textWidthPixels(t);
            int pad = (v[2] - ws) / 2;
            if (pad < 0)
                pad = 0;
            std::vector<int> vc = v;
            vc[0] += pad;
            text(t, vc);
        }
        void textVertical(bool f = true)
        {
            if (f)
                myLogfont.lfEscapement = 2700;
            else
                myLogfont.lfEscapement = 0;
            myLogfont.lfOrientation = myLogfont.lfEscapement;
            HANDLE hFont = CreateFontIndirect(&myLogfont);
            hFont = (HFONT)SelectObject(myHDC, hFont);
            DeleteObject(hFont);
        }
 
        void textHeight(int h)
        {
            myLogfont.lfHeight = h;
            HANDLE hFont = CreateFontIndirect(&myLogfont);
            hFont = (HFONT)SelectObject(myHDC, hFont);
            DeleteObject(hFont);
        }
        void textFontName(const std::string &fn)
        {
            strcpy(myLogfont.lfFaceName, fn.c_str());
            HANDLE hFont = CreateFontIndirect(&myLogfont);
            hFont = (HFONT)SelectObject(myHDC, hFont);
            DeleteObject(hFont);
        }
        int textWidthPixels(const std::string &t)
        {
            SIZE sz;
            GetTextExtentPoint32A(
                myHDC,
                t.c_str(),
                t.length(),
                &sz);
            return sz.cx;
        }
 
    private:
        HDC myHDC;
        int myPenThick;
        HGDIOBJ hPen;
        HGDIOBJ hPenOld;
        bool myFill;
        LOGFONT myLogfont;
        int myColor; // foreground color
    };
 
    class gui
    {
    public:
        gui()
            : myParent(NULL), myBGColor(0xC8C8C8), myBGBrush(CreateSolidBrush(myBGColor)), myTextColor(0),
              myDeleteList(0), myfModal(false), myfEnabled(true), myfnobgerase(false), myToolTip(NULL), myAsyncReadCompleteMsgID(0), myCursorID(0)
        {
            myID = NewID();
            Create(
                NULL,
                "windex",
                WS_OVERLAPPEDWINDOW, WS_EX_CONTROLPARENT,
                0);
 
            /*  default resize event handler
            simply forces a refresh so partially visible widgets are correctly drawn
            Application code, if it needs to move child windows around,
            should overwrite this event handler.  Remember to call update() at end of event handler.
        */
            events().resize([this](int w, int h)
                            { update(); });
 
            /*  Construct font, initialized with default GUI font
 
            Each top level window keeps a font and associated logfont
            so that the font can be changed and inherited by all child windows
            */
            myLogFont = {0};
            GetObject(
                GetStockObject(DEFAULT_GUI_FONT),
                sizeof(myLogFont), &myLogFont);
 
            // default font clips descenders ( p, q, y) so increase height
            myLogFont.lfHeight = 18;
 
            myFont = CreateFontIndirectA(&myLogFont);
        }
        gui(
            gui *parent,
            const char *window_class = "windex",
            unsigned long style = WS_CHILD,
            unsigned long exstyle = WS_EX_CONTROLPARENT) : myParent(parent),
                                                           myDeleteList(0),
                                                           myfEnabled(true),
                                                           myToolTip(NULL),
                                                           myCursorID(IDC_ARROW)
        {
            // get a new unique ID
            myID = NewID();
 
            // create the window as requested
            Create(parent->handle(), window_class, style, exstyle, myID);
 
            // tell the parent that it has a new child
            parent->child(this);
 
            // by default show text with ID ( helps debugging )
            text("???" + std::to_string(myID));
 
            // inherit background color from parent
            bgcolor(parent->bgcolor());
 
            // inherit font from parent
            parent->font(myLogFont, myFont);
            SendMessage(
                myHandle,
                WM_SETFONT,
                (WPARAM)myFont,
                0);
 
            myTextColor = 0;
        }
        virtual ~gui()
        {
            // std::cout << "deleting " << myText << "\n";
            DestroyWindow(myHandle);
            if (myDeleteList)
                myDeleteList->push_back(myHandle);
        }
 
        void child(gui *w)
        {
            myChild.push_back(w);
        }
 
        children_t &children()
        {
            return myChild;
        }
 
        gui *parent()
        {
            return myParent;
        }
 
        gui *find(int id)
        {
            for (auto w : myChild)
            {
                if (w->id() == id)
                    return (gui *)w;
            }
            return nullptr;
        }
 
        void focus()
        {
            SetFocus(myHandle);
        }
        void bgcolor(int color)
        {
            myBGColor = color;
            DeleteObject(myBGBrush);
            myBGBrush = CreateSolidBrush(color);
            for (auto w : myChild)
                w->bgcolor(color);
        }
 
        void nobgerase()
        {
            myfnobgerase = true;
        }
        void enable(bool f = true)
        {
            myfEnabled = f;
            EnableWindow(myHandle, myfEnabled);
            update();
        }
        bool isEnabled() const
        {
            return myfEnabled;
        }
 
        void fontHeight(int h)
        {
            myLogFont.lfHeight = h;
            createNewFont();
            setfont(myLogFont, myFont);
        }
        void fontName(const std::string &name)
        {
            strcpy(myLogFont.lfFaceName, name.c_str());
            createNewFont();
            setfont(myLogFont, myFont);
        }
 
        void icon(const std::string &iconfilename)
        {
            HICON hIcon = ExtractIconA(
                NULL,
                iconfilename.c_str(),
                0);
            SetClassLongPtr(
                myHandle,
                GCLP_HICON,
                (LONG_PTR)hIcon);
 
            SendMessage(myHandle, WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
            SendMessage(myHandle, WM_SETICON, ICON_BIG, (LPARAM)hIcon);
            SendMessage(GetWindow(myHandle, GW_OWNER), WM_SETICON, ICON_SMALL, (LPARAM)hIcon);
            SendMessage(GetWindow(myHandle, GW_OWNER), WM_SETICON, ICON_BIG, (LPARAM)hIcon);
        }
        void cursor(char *cursorID)
        {
            myCursorID = cursorID;
        }
        int id()
        {
            return myID;
        }
        int bgcolor() const
        {
            return myBGColor;
        }
        void textColor(int c)
        {
            myTextColor = c;
        }
        void text(const std::string &text)
        {
            myText = text;
            SetWindowText(myHandle, myText.c_str());
        }
 
        std::string text() const
        {
            return myText;
        }
        void scroll(bool fHoriz = true)
        {
            myfScrollHoriz = fHoriz;
 
            // Add scrollbars to window style
            LONG_PTR extra;
            if (fHoriz)
                extra = WS_HSCROLL | WS_VSCROLL;
            else
                extra = WS_VSCROLL;
            SetWindowLongPtr(
                myHandle,
                GWL_STYLE,
                GetWindowLongPtr(myHandle, GWL_STYLE) | extra);
 
            // Set the scrolling range and page size to defaaults
            scrollRange(100, 100);
 
            // horizontal scroll handler
            events().scrollH([this](int code)
                             {
                                 SCROLLINFO si;
                                 si.cbSize = sizeof(si);
                                 si.fMask = SIF_POS | SIF_TRACKPOS | SIF_PAGE;
                                 if (!GetScrollInfo(myHandle, SB_HORZ, &si))
                                     return;
 
                                 int oldPos = scrollMove(si, code);
 
                                 si.fMask = SIF_POS;
                                 SetScrollInfo(myHandle, SB_HORZ, &si, TRUE);
                                 GetScrollInfo(myHandle, SB_CTL, &si);
 
                                 RECT rect;
                                 GetClientRect(myHandle, &rect);
                                 int xs = oldPos - si.nPos;
                                 //std::cout << "scrollH " << xs <<" "<< oldPos <<" "<< si.nPos << "\n";
                                 ScrollWindow(
                                     myHandle,
                                     xs,
                                     0, NULL, NULL);
                                UpdateWindow( myHandle );
 
                                 for (auto &w : myChild)
                                     w->update(); });
 
            // vertical scroll handler
            events().scrollV([this](int code)
                             {
                                 SCROLLINFO si;
                                 si.cbSize = sizeof(si);
                                 si.fMask = SIF_POS | SIF_TRACKPOS | SIF_PAGE;
                                 if (!GetScrollInfo(myHandle, SB_VERT, &si))
                                     return;
 
                                 int oldPos = scrollMove(si, code);
 
                                 si.fMask = SIF_POS;
                                 SetScrollInfo(myHandle, SB_VERT, &si, TRUE);
                                 GetScrollInfo(myHandle, SB_VERT, &si);
                                 RECT rect;
                                 GetClientRect(myHandle, &rect);
                                 int ys = oldPos - si.nPos;
                                 ScrollWindow(
                                     myHandle,
                                     0,
                                     ys, // amount to scroll
                                     NULL, NULL);
 
                                 // update entire window and all children
                                 // this prevents visual artefacts on fast scrolling
                                 // but creates an unpleasant flicker
                                 // so it is commented out
                                 //update();
 
                                 // update any child windows
                                 // this has a fast and smooth appearance
                                 // but sometimes leaves fragments littering the window
                                 for (auto &w : myChild)
                                     w->update(); });
        }
        void scrollRange(int width, int height)
        {
 
            /* maximum scroll position
 
            We want the max scroll position
            which is the top of the visible portion
            to be placed where the bottom if the underlying window is just visible
            */
 
            RECT r;
            GetClientRect(myHandle, &r);
            int xmax = width - r.right;
            if (xmax < 0)
                xmax = 0;
            int ymax = height - (r.bottom - r.top) + 60;
            if (ymax < 0)
                ymax = 0;
            SCROLLINFO si;
            si.cbSize = sizeof(si);
            si.fMask = SIF_RANGE | SIF_PAGE;
            si.nMin = 0;
            si.nMax = ymax;
            si.nPage = ymax / 10;
            SetScrollInfo(myHandle, SB_VERT, &si, TRUE);
            if (myfScrollHoriz)
            {
                si.nMax = xmax;
                si.nPage = xmax / 10;
                SetScrollInfo(myHandle, SB_HORZ, &si, TRUE);
            }
        }
 
        sMouse getMouseStatus()
        {
            sMouse m;
            POINT p;
            GetCursorPos(&p);
            if (!ScreenToClient(myHandle, &p))
            {
                m.x = -1;
                m.y = -1;
            }
            m.x = p.x;
            m.y = p.y;
            m.left = (GetKeyState(VK_LBUTTON) < 0);
            m.right = (GetKeyState(VK_RBUTTON) < 0);
            m.shift = (GetKeyState(VK_SHIFT) < 0);
            return m;
        }
        void run()
        {
            MSG msg = {};
            while (GetMessage(&msg, NULL, 0, 0))
            {
                //            std::cout << "gui::run " << msg.message << "\n";
                //            if( msg.message == 256 )
                //            {
                //                std::cout << "widget text: " << myText << "\n";
                //                int dbg = 0;
                //                continue;
                //            }
                if (!IsDialogMessage(myHandle, &msg))
                {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                }
            }
        }
 
        void tooltip(const std::string &text, int width = 0)
        {
            TOOLINFO toolInfo = {0};
            toolInfo.cbSize = sizeof(toolInfo);
            toolInfo.hwnd = myHandle;
            toolInfo.uFlags = TTF_IDISHWND | TTF_SUBCLASS;
            toolInfo.uId = (UINT_PTR)myHandle;
            toolInfo.lpszText = (char *)text.c_str();
 
            // check for existing tooltip
            if (!myToolTip)
            {
                // Create the tooltip.
                myToolTip = CreateWindowEx(0, TOOLTIPS_CLASS, NULL,
                                           WS_POPUP | TTS_ALWAYSTIP | TTS_BALLOON,
                                           CW_USEDEFAULT, CW_USEDEFAULT,
                                           CW_USEDEFAULT, CW_USEDEFAULT,
                                           myHandle, NULL, NULL, NULL);
                SendMessage(myToolTip, TTM_ADDTOOL, 0, (LPARAM)&toolInfo);
            }
 
            else
 
                // change tooltip
                SendMessage(myToolTip, TTM_UPDATETIPTEXT, 0, (LPARAM)&toolInfo);
 
            // std::cout << "tooltip: " << width << "\n" << text << "\n";
 
            if (width > 0)
                SendMessage(myToolTip, TTM_SETMAXTIPWIDTH, 0, width);
        }
 
        bool isWindowMessageWaiting()
        {
            MSG msg;
            return PeekMessage(
                &msg,
                myHandle,
                0, 0,
                PM_NOREMOVE | PM_NOYIELD);
        }
 
        virtual LRESULT WindowMessageHandler(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
        {
            //        if( uMsg != 132  && uMsg != 275 )
            //            std::cout << " widget " << myText << " WindowMessageHandler " << uMsg << "\n";
            if (hwnd == myHandle)
            {
                switch (uMsg)
                {
                case WM_CLOSE:
 
                    // Premission to close window requested
 
                    if (!modalMgr::get().canClose(myID))
                    {
                        // Cannot close when modal window running
                        return true;
                    }
                    if (myID == 1)
                    {
                        // check with registered QuitApp function
                        if (!myEvents.onQuitApp())
                        {
                            return true;
                        }
                    }
                    // close permission granted
                    DestroyWindow(myHandle);
 
                    return true;
 
                case WM_DESTROY:
 
                    // if this is the appliction window
                    // then quit application when destroyed
                    if (myID == 1)
                    {
                        PostQuitMessage(0);
                    }
                    return true;
 
                case WM_NCDESTROY:
 
                    // all the children are gone
                    // so a modal display can close
                    myfModal = false;
                    return false;
 
                    //            case WM_SETFOCUS:
                    //                std::cout << myText << "  got focus\n";
                    //                return true;
 
                case WM_ERASEBKGND:
                {
                    if (myfnobgerase)
                        return true;
                    RECT rc;
                    GetWindowRect(hwnd, &rc);
                    FillRect((HDC)wParam, &rc, myBGBrush);
                    return true;
                }
 
                case WM_PAINT:
                {
                    PAINTSTRUCT ps;
                    BeginPaint(myHandle, &ps);
                    if (!myfnobgerase)
                        FillRect(ps.hdc, &ps.rcPaint, myBGBrush);
                    draw(ps);
 
                    EndPaint(myHandle, &ps);
                }
                    return true;
 
                case WM_CTLCOLORSTATIC:
                {
                    //                SetBkColor((HDC)wParam, myBGColor);
                    //                return (INT_PTR)myBGBrush;
                    RECT r;
                    GetBoundsRect(GetDC(myHandle), &r, 0);
                    FillRect(GetDC(myHandle), &r, myBGBrush);
                    SetBkMode((HDC)wParam, TRANSPARENT);
 
                    return (INT_PTR)GetStockObject(NULL_BRUSH);
                }
 
                case WM_NOTIFY:
                {
                    NMHDR *pnmhdr = reinterpret_cast<NMHDR *>(lParam);
                    if (pnmhdr->code == DTN_DATETIMECHANGE)
                    {
                        myEvents.onDatePicked(
                            pnmhdr->idFrom,
                            (LPNMDATETIMECHANGE)(lParam));
                    }
                }
                break;
 
                case WM_LBUTTONDOWN:
                    // std::cout << "click on " << myText << "\n";
                    if (!myfEnabled)
                        return true;
                    if (myEvents.onLeftdown())
                        return true;
                    // the event was not completely handled, maybe the parent can look after it
                    if (myParent)
                    {
                        if (myParent->WindowMessageHandler(
                                myParent->handle(),
                                uMsg, wParam, lParam))
                            return true;
                    }
                    break;
 
                case WM_RBUTTONDOWN:
                    myEvents.onRightDown();
                    break;
 
                case WM_LBUTTONUP:
                case WM_RBUTTONUP:
                    myEvents.onMouseUp();
                    return true;
 
                case WM_LBUTTONDBLCLK:
                    std::cout << "WM_LBUTTONDBLCLK\n";
                    myEvents.onDoubleClick();
                    return true;
 
                case WM_MOUSEMOVE:
                    myEvents.onMouseMove(wParam, lParam);
                    break;
 
                case WM_MOUSEWHEEL:
                {
                    int d = HIWORD(wParam);
                    if (d > 0xEFFF)
                        d = -120;
                    myEvents.onMouseWheel(d);
                }
                break;
 
                case WM_MOUSELEAVE:
                    myEvents.onMouseLeave();
                    break;
 
                case WM_SIZE:
                    myEvents.onResize(LOWORD(lParam), HIWORD(lParam));
                    return true;
 
                case WM_HSCROLL:
                    if (lParam)
                        trackbarMessageHandler((HWND)lParam);
                    else
                        myEvents.onScrollH(LOWORD(wParam));
                    return true;
 
                case WM_VSCROLL:
                    std::cout << "VSCROLL\n";
                    if (lParam)
                        trackbarMessageHandler((HWND)lParam);
                    else
                        myEvents.onScrollV(LOWORD(wParam));
                    return true;
 
                case WM_COMMAND:
                {
                    // https://docs.microsoft.com/en-us/windows/win32/menurc/wm-command
 
                    auto wp_hi = HIWORD(wParam);
                    if (!wp_hi)
                    {
                        events().onMenuCommand(wParam);
                        return true;
                    }
 
                    if (wp_hi == CBN_SELCHANGE || wp_hi == LBN_SELCHANGE)
                    {
                        return events().onSelect(LOWORD(wParam));
                    }
 
                    if (wp_hi == EN_CHANGE)
                    {
                        return events().onChange(LOWORD(wParam));
                    }
                    return true;
                }
 
                case WM_TIMER:
                    events().onTimer((int)wParam);
                    return true;
 
                case WM_DROPFILES:
                    events().onDropStart((HDROP)wParam);
                    return true;
 
                case WM_GETDLGCODE:
                    return DLGC_WANTARROWS;
 
                case WM_KEYDOWN:
                    events().onKeydown((int)wParam);
                    return true;
 
                case WM_SETCURSOR:
                    if (myCursorID)
                    {
                        SetCursor(LoadCursor(NULL, (LPCSTR)myCursorID));
                        return true;
                    }
                    return false;
 
                case eventMsgID::asyncReadComplete:
                    events().onAsyncReadComplete(wParam);
                    return true;
 
                case eventMsgID::tcpServerAccept:
                    events().onTcpServerAccept();
                    return true;
 
                case eventMsgID::tcpServerReadComplete:
                    events().onTcpServerReadComplete();
                    return true;
                }
            }
            else
            {
                for (auto w : myChild)
                {
                    if (w->WindowMessageHandler(hwnd, uMsg, wParam, lParam))
                        return true;
                }
            }
 
            return false;
        }
 
        virtual void show(bool f = true)
        {
            int cmd = SW_SHOWDEFAULT;
            if (!f)
                cmd = SW_HIDE;
            // std::cout << "show " << myText <<" "<< myHandle <<" "<< myChild.size() << "\n"; ;
            ShowWindow(myHandle, cmd);
            // display any children
            for (auto w : myChild)
                w->show(f);
        }
 
        void showModal(gui &appWindow)
        {
            myfModal = true;
            if (!modalMgr::get().set(myID, myHandle))
            {
                // problem, abandon
                myfModal = false;
                return;
            }
 
            appWindow.enable(false);
 
            show();
 
            // prevent other windows from interaction
            // by running our own message loop
            // std::cout << "-> modal msg loop\n";
            MSG msg = {};
            while (GetMessage(&msg, NULL, 0, 0))
            {
                if (!IsDialogMessage(myHandle, &msg))
                {
                    TranslateMessage(&msg);
                    DispatchMessage(&msg);
                }
                else
                {
                    switch (msg.message)
                    {
                    case WM_CLOSE:
                        std::cout << myText << " WM_CLOSE";
                        break;
 
                    case WM_DESTROY:
                        std::cout << myText << " WM_DESTROY";
                        myfModal = false;
                        break;
                    }
                }
                // window no longer modal
                // so break out of our own message loop
                if (!myfModal)
                    break;
            }
            // std::cout << "<- modal msg loop\n";
 
            // restore rest of application
            appWindow.enable(true);
            appWindow.focus();
            appWindow.update();
        }
        void endModal()
        {
            myfModal = false;
            modalMgr::get().set(0, 0);
            DestroyWindow(myHandle);
            if (myDeleteList)
                myDeleteList->push_back(myHandle);
        }
 
        void update()
        {
            InvalidateRect(myHandle, NULL, true);
            UpdateWindow(myHandle);
            for (auto g : myChild)
                g->update();
        }
 
        void move(const std::vector<int> &r)
        {
            if (r.size() != 4)
                return;
            MoveWindow(myHandle,
                       r[0], r[1], r[2], r[3], false);
        }
        void size(int w, int h)
        {
            RECT rect;
            GetWindowRect(myHandle, &rect);
            MoveWindow(myHandle,
                       rect.left, rect.top, w, h,
                       false);
        }
        void move(int x, int y)
        {
            RECT rect;
            GetClientRect(myHandle, &rect);
            MoveWindow(myHandle,
                       x, y, rect.right - rect.left, rect.bottom - rect.top,
                       false);
        }
        void move(int x, int y, int w, int h)
        {
            MoveWindow(myHandle,
                       x, y, w, h, false);
        }
        std::vector<int> size()
        {
            RECT r;
            GetClientRect(myHandle, &r);
            std::vector<int> ret{
                r.right - r.left, r.bottom - r.top};
            return ret;
        }
        std::vector<int> lefttop()
        {
            RECT rp;
            GetWindowRect(myParent->handle(), &rp);
            RECT r;
            GetWindowRect(myHandle, &r);
            //        std::cout << "parent " << rp.left <<" "<< rp.top
            //                  << " child " << r.left <<" "<< r.top << "\n";
            static std::vector<int> ret(2);
            ret[0] = r.left - rp.left;
            ret[1] = r.top - rp.top;
            return ret;
        }
 
        eventhandler &events()
        {
            return myEvents;
        }
 
        HWND handle()
        {
            return myHandle;
        }
 
        void delete_list(std::vector<HWND> *list)
        {
            myDeleteList = list;
        }
 
        void setfont(LOGFONT &logfont, HFONT &font)
        {
            myLogFont = logfont;
            myFont = font;
            SendMessage(
                myHandle,
                WM_SETFONT,
                (WPARAM)myFont,
                0);
            for (auto w : myChild)
                w->setfont(myLogFont, myFont);
        }
        void setAsyncReadCompleteMsgID(int id)
        {
            myAsyncReadCompleteMsgID = id;
        }
 
    protected:
        HWND myHandle;
        gui *myParent;
        eventhandler myEvents;
        int myBGColor;
        int myTextColor;
        HBRUSH myBGBrush;
        LOGFONT myLogFont;
        HFONT myFont;
        std::vector<HWND> *myDeleteList;
        std::string myText;
        int myID;
        std::vector<gui *> myChild; 
        bool myfModal;              
        bool myfEnabled;            
        bool myfnobgerase;
        HWND myToolTip; 
        unsigned int myAsyncReadCompleteMsgID;
        char *myCursorID;
        bool myfScrollHoriz;
 
        void Create(
            HWND parent,
            const char *window_class,
            DWORD style, DWORD exstyle = 0,
            int id = 0)
        {
            myHandle = CreateWindowEx(
                exstyle,      // Optional window styles.
                window_class, // Window class
                "widget",     // Window text
                style,        // Window style
 
                // Size and position
                CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
 
                parent,                      // Parent window
                reinterpret_cast<HMENU>(id), // Menu or control id
                NULL,                        // Instance handle
                NULL                         // Additional application data
            );
 
            if (!myHandle)
                throw std::runtime_error(
                    "Create Window failed");
        }
 
        void font(LOGFONT &logfont, HFONT &font)
        {
            logfont = myLogFont;
            font = myFont;
        }
 
        void createNewFont()
        {
            DeleteObject(myFont);
            myFont = CreateFontIndirectA(&myLogFont);
        }
 
        virtual void draw(PAINTSTRUCT &ps)
        {
            SetBkColor(
                ps.hdc,
                myBGColor);
            int color = 0x000000;
            if (!myfEnabled)
                color = 0xAAAAAA;
            SetTextColor(
                ps.hdc,
                myTextColor);
            if (myParent)
            {
                SelectObject(ps.hdc, myFont);
 
                RECT r(ps.rcPaint);
                auto hbrBkgnd = CreateSolidBrush(myBGColor);
                FillRect(
                    ps.hdc,
                    &r,
                    hbrBkgnd);
                DeleteObject(hbrBkgnd);
                r.left += 1;
                r.top += 1;
                DrawText(
                    ps.hdc,
                    myText.c_str(),
                    -1,
                    &r,
                    0);
            }
            myEvents.onDraw(ps);
        }
 
        int NewID()
        {
            static int lastID = 0;
            lastID++;
            return lastID;
        }
        int scrollMove(SCROLLINFO &si, int code)
        {
            int oldPos = si.nPos;
            switch (code)
            {
            // User clicked the left arrow.
            case SB_LINELEFT:
                si.nPos -= 1;
                break;
 
            // User clicked the right arrow.
            case SB_LINERIGHT:
                si.nPos += 1;
                break;
 
            // User clicked the scroll bar shaft left of the scroll box.
            case SB_PAGELEFT:
                si.nPos -= si.nPage;
                break;
 
            // User clicked the scroll bar shaft right of the scroll box.
            case SB_PAGERIGHT:
                si.nPos += si.nPage;
                break;
 
            // User dragged the scroll box.
            case SB_THUMBTRACK:
                si.nPos = si.nTrackPos;
                break;
            }
            return oldPos;
        }
 
    private:
        void trackbarMessageHandler(HWND hwnd)
        {
            std::cout << "trackbarMessageHandler\n";
            // trackbar notifications are sent to trackbar's parent window
            // find the child that generated this notification
            // get the tackbar position and call the slid event handler
            for (auto c : myChild)
            {
                if (c->handle() == hwnd)
                {
                    c->events().onSlid(
                        SendMessage(
                            hwnd,
                            TBM_GETPOS,
                            (WPARAM)0, (LPARAM)0));
                }
            }
        }
    };
 
    class panel : public gui
    {
    public:
        panel(gui *parent)
            : gui(parent)
        {
            text("");
        }
    };
    class drop : public gui
    {
    public:
        drop(gui *parent)
            : gui(parent)
        {
            text("");
 
            // register as drop recipient
            DragAcceptFiles(myHandle, true);
 
            // handle drop event
            myEvents.dropStart([this](HDROP hDrop)
                               {
                                   int count = DragQueryFileA(hDrop, 0xFFFFFFFF, NULL, 0);
                                   if (count)
                                   {
                                       // extract files from drop structure
                                       std::vector<std::string> files;
                                       char fname[MAX_PATH];
                                       for (int k = 0; k < count; k++)
                                       {
                                           DragQueryFileA(hDrop, k, fname, MAX_PATH);
                                           files.push_back(fname);
                                       }
                                       // call app code's event handler
                                       myEvents.onDrop(files);
                                   }
                                   DragFinish(hDrop); });
        }
    };
 
    class groupbox : public panel
    {
    public:
        groupbox(gui *parent)
            : panel(parent)
        {
        }
        void move(const std::vector<int> &r)
        {
            if (r.size() != 4)
                return;
 
            // store location and size of groupbox
            myRect.left = r[0];
            myRect.top = r[1];
            myRect.right = r[0] + r[2];
            myRect.bottom = r[1] + r[3];
 
            // set location and size of groupbox label
            MoveWindow(myHandle,
                       r[0] + 5, r[1] + 2, 60, 25, false);
        }
        virtual void draw(PAINTSTRUCT &ps)
        {
            // Draw group box on parent window
            HDC hdc = GetDC(myParent->handle());
            DrawEdge(
                hdc,
                &myRect,
                EDGE_BUMP,
                BF_RECT);
            ReleaseDC(myParent->handle(), hdc);
 
            // Draw label
            SetBkColor(
                ps.hdc,
                myBGColor);
            SelectObject(ps.hdc, myFont);
            DrawText(
                ps.hdc,
                myText.c_str(),
                myText.length(),
                &ps.rcPaint,
                0);
        }
 
    private:
        RECT myRect;
    };
 
    class layout : public panel
    {
    public:
        layout(gui *parent)
            : panel(parent), myColCount(2), myfWidthsSpecified(false), myfColFirst(false)
        {
        }
        void grid(int cols)
        {
            myColCount = cols;
        }
        void colWidths(const std::vector<int> &vw)
        {
            myWidths = vw;
            myfWidthsSpecified = true;
        }
        void colfirst(bool f = true)
        {
            myfColFirst = f;
        }
        void draw(PAINTSTRUCT &ps)
        {
            if (!myChild.size())
                return;
            RECT r;
            GetClientRect(myHandle, &r);
            if (!myfWidthsSpecified)
            {
                // col widths not specified, default to all the same width to fill panel
                int colwidth = (r.right - r.left) / myColCount;
                myWidths.clear();
                for (int k = 0; k < myColCount; k++)
                {
                    myWidths.push_back(colwidth);
                }
            }
            int rowheight;
            if (!myfColFirst)
            {
                // rowheight = (r.bottom - r.top) / ((myChild.size() + 1) / myColCount);
                int rowCount = (myChild.size() + 1) / myColCount;
                if (!rowCount)
                    rowCount = 1;
                rowheight = (r.bottom - r.top) / rowCount;
            }
            else
                rowheight = 50;
 
            // display the children laid out in a grid
            int colcount = 0;
            int rowcount = 0;
            int x = 0;
 
            if (!myfColFirst)
            {
                for (auto w : myChild)
                {
                    w->move(x, rowcount * rowheight);
                    w->update();
 
                    x += myWidths[colcount];
                    colcount++;
                    if (colcount >= myColCount)
                    {
                        colcount = 0;
                        x = 0;
                        rowcount++;
                    }
                }
            }
            else
            {
                for (auto w : myChild)
                {
                    w->move(x, rowcount * rowheight);
                    w->update();
                    rowcount++;
                    if (rowcount >= (int)myChild.size() / myColCount)
                    {
                        rowcount = 0;
                        x += myWidths[colcount];
                        colcount++;
                    }
                }
            }
        }
 
    private:
        int myColCount;
        std::vector<int> myWidths;
        bool myfWidthsSpecified; // true if app code specified column widths
        bool myfColFirst;        // true if columns should be filled first
    };
 
    class button : public gui
    {
    public:
        button(gui *parent)
            : gui(parent), myBitmap(NULL)
        {
            myBGColor = 0xC8C8C8;
        }
 
        void imageFile(const std::string &name)
        {
            myBitmap = (HBITMAP)LoadImage(
                NULL, name.c_str(), IMAGE_BITMAP,
                0, 0, LR_LOADFROMFILE);
        }
        int imageResource(const std::string &name)
        {
            int ret = 0;
            auto h = GetModuleHandleA(NULL);
            if (!h)
                ret = 1;
            myBitmap = LoadBitmap(
                h, name.c_str());
            if (!myBitmap)
                ret = 2;
            if (ret)
                text("");
            return ret;
        }
 
    protected:
        HBITMAP myBitmap;
 
        virtual void draw(PAINTSTRUCT &ps)
        {
            if (!myBitmap)
            {
                // button with text
 
                int color = 0x000000;
                if (!myfEnabled)
                    color = 0xAAAAAA;
                SetTextColor(
                    ps.hdc,
                    myTextColor);
                SetBkColor(
                    ps.hdc,
                    myBGColor);
 
                SelectObject(ps.hdc, myFont);
 
                RECT r(ps.rcPaint);
                auto hbrBkgnd = CreateSolidBrush(myBGColor);
                FillRect(
                    ps.hdc,
                    &r,
                    hbrBkgnd);
                DeleteObject(hbrBkgnd);
 
                r.left += 1;
                r.top += 1;
                DrawText(
                    ps.hdc,
                    myText.c_str(),
                    -1,
                    &r,
                    DT_SINGLELINE | DT_CENTER | DT_VCENTER);
 
                DrawEdge(
                    ps.hdc,
                    &ps.rcPaint,
                    EDGE_RAISED,
                    BF_RECT);
            }
            else
            {
                // button with bitmap
 
                HDC hLocalDC = CreateCompatibleDC(ps.hdc);
                BITMAP qBitmap;
                GetObject(reinterpret_cast<HGDIOBJ>(myBitmap), sizeof(BITMAP),
                          reinterpret_cast<LPVOID>(&qBitmap));
                HBITMAP hOldBmp = (HBITMAP)SelectObject(hLocalDC, myBitmap);
                BitBlt(
                    ps.hdc, 0, 0, qBitmap.bmWidth, qBitmap.bmHeight,
                    hLocalDC, 0, 0, SRCCOPY);
                SelectObject(hLocalDC, hOldBmp);
                DeleteDC(hLocalDC);
            }
        }
    };
    class radiobutton : public gui
    {
    public:
        radiobutton(gui *parent)
            : gui(parent), myValue(false)
        {
            // Add to current group
            group().back().push_back(this);
            myGroup = group().size() - 1;
 
            // set the boolean value when clicked
            events().clickWex([this]
                              {
                                  if (!myfEnabled)
                                      return;
                                  // set all buttons in group false
                                  for (auto b : group()[myGroup])
                                  {
                                      b->myValue = false;
                                      b->update();
                                  }
                                  // set this button true
                                  myValue = true;
                                  update(); });
        }
        void first()
        {
            // find button in its group
            auto this_it = std::find(
                group()[myGroup].begin(),
                group()[myGroup].end(),
                this);
 
            if (this_it == group()[myGroup].end())
                throw std::runtime_error("wex::radiobutton::first error in group");
 
            // if button is first in group, nothing is needed
            if (this_it == group()[myGroup].begin())
                return;
 
            // construct new group
            std::vector<radiobutton *> g;
            group().push_back(g);
 
            // copy button and following buttons in same group to new group
            for (
                auto it = this_it;
                it != group()[myGroup].end();
                it++)
            {
                group().back().push_back(*it);
            }
 
            // erase from old group
            group()[myGroup].erase(
                this_it,
                group()[myGroup].end());
 
            // tell buttons that were moved about their new group
            for (auto b : group().back())
                b->myGroup = group().size() - 1;
 
            //        std::cout << "< first\n";
            //        for( int kg=0; kg< group().size(); kg++ )
            //        {
            //            for( auto b : group()[kg] )
            //                std::cout << b->id() << " , " << b->text() << " ";
            //            std::cout << "\n";
            //        }
        }
 
        bool isChecked()
        {
            return myValue;
        }
 
        int checkedOffset()
        {
            int off = 0;
            for (auto b : group()[myGroup])
            {
                if (b->isChecked())
                    break;
                off++;
            }
            if (off < (int)group()[myGroup].size())
                return off;
            return -1;
        }
 
        void check(bool f = true)
        {
            if (f)
            {
                // set all buttons in group false
                for (auto b : group()[myGroup])
                {
                    b->myValue = false;
                    b->update();
                }
            }
            myValue = f;
            update();
        }
 
        virtual void draw(PAINTSTRUCT &ps)
        {
            SelectObject(ps.hdc, myFont);
            int color = 0x000000;
            if (!myfEnabled)
                color = 0xAAAAAA;
            SetTextColor(
                ps.hdc,
                myTextColor);
            SetBkColor(
                ps.hdc,
                myBGColor);
            RECT r(ps.rcPaint);
            r.left += 20;
            shapes S(ps);
 
            DrawText(
                ps.hdc,
                myText.c_str(),
                -1,
                &r,
                0);
            if (!myValue)
            {
                S.circle(10, 10, 5);
            }
            else
            {
                SelectObject(ps.hdc, GetStockObject(BLACK_BRUSH));
                Ellipse(ps.hdc, 5, 5, 15, 15);
            }
        }
 
    private:
        bool myValue;
        int myGroup; 
 
        std::vector<std::vector<radiobutton *>> &group()
        {
            static std::vector<std::vector<radiobutton *>> theGroups;
            static bool fGroupInit = false;
            if (!fGroupInit)
            {
                // create first group
                fGroupInit = true;
                std::vector<radiobutton *> g;
                theGroups.push_back(g);
            }
            return theGroups;
        }
    };
 
    class checkbox : public gui
    {
        enum class eType
        {
            check,
            plus
        } myType;
 
    public:
        checkbox(gui *parent)
            : gui(parent), myType(eType::check), myValue(false)
        {
            // toggle the boolean value when clicked
            events().clickWex([this]
                              {
                                  if (!myfEnabled)
                                      return;
                                  myValue = !myValue;
                                  update(); });
        }
        void plus(bool f = true)
        {
            if (f)
                myType = eType::plus;
            else
                myType = eType::check;
        }
        void check(bool f = true)
        {
            myValue = f;
        }
        bool isChecked()
        {
            return (myValue);
        }
        virtual void draw(PAINTSTRUCT &ps)
        {
            SetBkColor(
                ps.hdc,
                myBGColor);
            RECT r(ps.rcPaint);
            int cbg = r.bottom - r.top - 10;
            r.left += cbg + 5;
            r.top -= 2;
 
            shapes S(ps);
            S.textHeight(myLogFont.lfHeight);
            S.textFontName(myLogFont.lfFaceName);
            S.text(myText, {r.left, r.top, r.right, r.bottom});
            S.rectangle({0, 0, cbg, cbg});
            S.fill();
            S.penThick(2);
            S.color(0);
            switch (myType)
            {
            case eType::check:
                if (myValue)
                {
                    S.line({2, cbg / 2, cbg / 2 - 1, cbg - 2});
                    S.line({cbg / 2, cbg - 3, cbg - 4, 3});
                }
                break;
            case eType::plus:
                S.line({2, cbg / 2, cbg - 2, cbg / 2});
                if (myValue)
                    S.line({1 + cbg / 2, 2, 1 + cbg / 2, cbg - 2});
                break;
            }
            S.penThick(1);
        }
        void clickFunction(std::function<void(void)> f)
        {
            myClickFunction = f;
        }
 
    private:
        bool myValue;
        std::function<void(void)> myClickFunction;
    };
 
    class msgbox
    {
    public:
        msgbox(
            const std::string &msg)
        {
            myReturn = MessageBox(NULL,
                                  msg.c_str(),
                                  "Message",
                                  MB_OK);
        }
        msgbox(
            gui &parent,
            const std::string &msg,
            const std::string &title,
            unsigned int type)
        {
            myReturn = MessageBox(parent.handle(),
                                  msg.c_str(),
                                  title.c_str(),
                                  type);
        }
        int myReturn; 
    };
 
    class label : public gui
    {
    public:
        label(gui *parent)
            : gui(parent)
        {
        }
    };
    class editbox : public gui
    {
    public:
        editbox(gui *parent)
            : gui(parent, "Edit",
                  WS_CHILD | ES_LEFT | WS_BORDER | WS_VISIBLE,
                  WS_EX_CLIENTEDGE)
        {
        }
        void notification(WORD ntf)
        {
            std::cout << "editbox notification " << ntf << "\n";
            if (ntf == EN_KILLFOCUS)
            {
                std::cout << "done\n";
            }
        }
        void text(const std::string &t)
        {
            SetDlgItemText(
                myParent->handle(),
                myID,
                t.c_str());
        }
        std::string text()
        {
            char buf[1000];
            buf[0] = '\0';
            GetWindowText(
                handle(),
                buf,
                999);
            return std::string(buf);
        }
        void readonly(bool f = true)
        {
            SendMessage(
                handle(),
                EM_SETREADONLY,
                (WPARAM)f, (LPARAM)0);
        }
    };
 
    class multiline : public gui
    {
    public:
        multiline(gui *parent)
            : gui(parent, "Edit",
                  WS_CHILD | ES_LEFT | WS_BORDER | WS_VISIBLE | ES_MULTILINE | ES_WANTRETURN,
                  WS_EX_CLIENTEDGE)
        {
        }
        void text(const std::string &t)
        {
            SetDlgItemText(
                myParent->handle(),
                myID,
                t.c_str());
        }
        std::string text()
        {
            char buf[1000];
            buf[0] = '\0';
            GetWindowText(
                handle(),
                buf,
                999);
            return std::string(buf);
        }
    };
    class choice : public gui
    {
    public:
        choice(gui *parent)
            : gui(parent, "Combobox",
                  CBS_DROPDOWNLIST | CBS_HASSTRINGS | WS_CHILD | WS_OVERLAPPED | WS_VISIBLE)
        {
        }
        void move(int x, int y, int w, int h)
        {
            if (h < 200)
                h = 200;
            gui::move(x, y, w, h);
        }
        void itemHeight(int h)
        {
            SendMessage(
                handle(),
                CB_SETITEMHEIGHT,
                (WPARAM)0, (LPARAM)20);
 
            /* WPARAM = 1 is supposed to set the "selection box" height
        but it appears to do nothing */
            //        SendMessage(
            //            handle(),
            //            CB_SETITEMHEIGHT,
            //            (WPARAM)1, (LPARAM)40);
        }
 
        void add(const std::string &s)
        {
            SendMessageA(
                handle(),
                (UINT)CB_ADDSTRING,
                (WPARAM)0,
                (LPARAM)s.c_str());
        }
        void clear()
        {
            SendMessage(
                handle(),
                CB_RESETCONTENT,
                (WPARAM)0, (LPARAM)0);
        }
        void select(int i)
        {
            SendMessage(
                handle(),
                CB_SETCURSEL,
                (WPARAM)i, (LPARAM)0);
        }
        void select(const std::string &s)
        {
            SendMessage(
                handle(),
                CB_SELECTSTRING,
                (WPARAM)-1, (LPARAM)s.c_str());
        }
        int selectedIndex()
        {
            return SendMessage(
                handle(),
                (UINT)CB_GETCURSEL,
                (WPARAM)0, (LPARAM)0);
        }
        std::string selectedText()
        {
            int i = selectedIndex();
            if (i < 0)
                return std::string("");
            return text(i);
        }
        std::string text(int i)
        {
            char buf[256];
            SendMessage(
                handle(),
                (UINT)CB_GETLBTEXT,
                (WPARAM)i,
                (LPARAM)buf);
            return std::string(buf);
        }
        int count()
        {
            return SendMessage(
                handle(),
                (UINT)CB_GETCOUNT,
                (WPARAM)0, (LPARAM)0);
        }
    };
 
    class list : public gui
    {
    public:
        list(gui *parent)
            : gui(parent, "listbox",
                  LBS_NOTIFY | WS_VSCROLL | WS_BORDER |
                      WS_CHILD | WS_OVERLAPPED | WS_VISIBLE)
        {
        }
        void move(int x, int y, int w, int h)
        {
            gui::move(x, y, w, h);
            SendMessageA(
                handle(),
                (UINT)LB_SETCOLUMNWIDTH,
                (WPARAM)w,
                (LPARAM)0);
        }
        void add(const std::string &s)
        {
            SendMessageA(
                handle(),
                (UINT)LB_ADDSTRING,
                (WPARAM)0,
                (LPARAM)s.c_str());
        }
        void clear()
        {
            SendMessage(
                handle(),
                LB_RESETCONTENT,
                (WPARAM)0, (LPARAM)0);
        }
        void select(int i)
        {
            SendMessage(
                handle(),
                LB_SETCURSEL,
                (WPARAM)i, (LPARAM)0);
        }
        void deleteItem(int i)
        {
            SendMessage(
                handle(),
                LB_DELETESTRING,
                (WPARAM)i, (LPARAM)0);
        }
        void select(const std::string &s)
        {
            SendMessage(
                handle(),
                LB_SELECTSTRING,
                (WPARAM)-1, (LPARAM)s.c_str());
        }
        int selectedIndex()
        {
            return SendMessage(
                handle(),
                (UINT)LB_GETCURSEL,
                (WPARAM)0, (LPARAM)0);
        }
 
        std::string selectedText()
        {
            int i = selectedIndex();
            if (i < 0)
                return std::string("");
            char buf[256];
            SendMessage(
                handle(),
                (UINT)LB_GETTEXT,
                (WPARAM)i,
                (LPARAM)buf);
            return std::string(buf);
        }
        int count()
        {
            return SendMessage(
                handle(),
                (UINT)LB_GETCOUNT,
                (WPARAM)0, (LPARAM)0);
        }
    };
 
    class windex
    {
    public:
        static windex &get()
        {
            static windex theInstance;
            return theInstance;
        }
 
        /* handle window messages
 
    All messages to windows created by windex come here.
    The messages are passed on to be handled by the gui element for the window they are directed to
    */
        static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
        {
            auto w = get().myGui.find(hwnd);
            if (w != get().myGui.end())
            {
                if (uMsg == WM_GETDLGCODE)
                    return w->second->WindowMessageHandler(hwnd, uMsg, wParam, lParam);
 
                if (w->second->WindowMessageHandler(hwnd, uMsg, wParam, lParam))
                    return 0;
            }
 
            // run default message processing
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
 
        gui *Add(gui *g)
        {
            // delete any destroyed elements
            Delete();
 
            // provide reference to delete list, so new gui element can be removed after destruction
            g->delete_list(&myDeleteList);
 
            // add to existing gui elements
            myGui.insert(std::make_pair(g->handle(), g));
 
            // std::cout << "windexAdd " << myGui.size() <<" in "<< this << "\n";
 
            return g;
        }
 
        mgui_t myGui; 
    private:
        std::vector<HWND> myDeleteList; 
 
        windex()
        {
            // register a callback function
            // to be invoked every time a windex gui element receives a windows message
            WNDCLASS wc = {};
            wc.lpfnWndProc = &windex::WindowProc;
            wc.hInstance = NULL;
            wc.lpszClassName = "windex";
            wc.hbrBackground = CreateSolidBrush(0xc8c8c8);
            wc.style = CS_DBLCLKS;
            RegisterClass(&wc);
        }
 
        void Delete()
        {
            // std::cout << "windex::Delete " << myDeleteList.size() << "\n";
            for (auto h : myDeleteList)
            {
                auto i = myGui.find(h);
                if (i != myGui.end())
                    myGui.erase(i);
            }
            myDeleteList.clear();
        }
    };
 
    class menu
    {
    public:
        menu(gui &parent)
            : myM(CreatePopupMenu()), myParent(parent)
        {
        }
        ~menu()
        {
            DestroyMenu(myM);
        }
        void append(
            const std::string &title,
            const std::function<void(const std::string &)> &f = [](const std::string &title) {})
        {
            AppendMenu(
                myM,
                0,
                myParent.events().menuCommand(f, title),
                title.c_str());
        }
 
        void append(
            const std::string &title,
            menu &submenu)
        {
            AppendMenu(
                myM,
                MF_POPUP,
                (UINT_PTR)submenu.handle(),
                title.c_str());
        }
        void appendSeparator()
        {
            AppendMenu(
                myM,
                MF_SEPARATOR,
                0, "");
        }
 
        void popup(
            int x, int y)
        {
            TrackPopupMenu(
                myM,
                0,
                x, y,
                0,
                myParent.handle(),
                NULL);
        }
 
        HMENU handle()
        {
            return myM;
        }
        bool check(int index, bool f = true)
        {
            unsigned int uCheck;
            if (f)
                uCheck = MF_BYPOSITION | MF_CHECKED;
            else
                uCheck = MF_BYPOSITION | MF_UNCHECKED;
            return MF_CHECKED == CheckMenuItem(
                                     myM,
                                     index,
                                     uCheck);
        }
        int size()
        {
            return GetMenuItemCount(myM);
        }
 
    private:
        HMENU myM;
        gui &myParent;
    };
 
    class menubar
    {
    public:
        menubar(gui &parent)
            : myParent(parent), myM(CreateMenu())
        {
            // attach menu to window
            SetMenu(parent.handle(), myM);
        }
        void append(
            const std::string &title,
            menu &m)
        {
            AppendMenu(
                myM,
                MF_POPUP,
                (UINT_PTR)m.handle(),
                title.c_str());
            DrawMenuBar(myParent.handle());
        }
 
    private:
        gui &myParent;
        HMENU myM;
    };
    class timer
    {
    public:
        timer(gui &g, int intervalmsecs, int id = 1)
            : myGUI(g), myID(id)
        {
            SetTimer(
                myGUI.handle(),   // handle to  window
                myID,             // timer identifier
                intervalmsecs,    //  interval ms
                (TIMERPROC)NULL); // no timer callback
        }
        ~timer()
        {
            KillTimer(
                myGUI.handle(),
                myID);
        }
 
    private:
        gui &myGUI;
        int myID;
    };
}
 
#include "widgets.h"
 
namespace wex
{
 
    class maker
    {
    public:
        template <class W, class P>
        static W &make(P &parent)
        {
            return *((W *)windex::get().Add(new W((gui *)&parent)));
        }
 
        static gui &make()
        {
            datebox::init();
 
            return *windex::get().Add(new gui());
        }
    };
 
    class tabbed : public panel
    {
    public:
        tabbed(gui *parent)
            : panel(parent), myTabWidth(50)
        {
            tabChanging([](int tabIndex) {});
            tabChanged([](int tabIndex) {});
        }
        void add(
            const std::string &tabname,
            gui &panel)
        {
            // resize the child panel so it fits neatly under the tab buttons
            RECT rect;
            GetClientRect(myHandle, &rect);
            panel.move(0, 31, rect.right - rect.left, rect.bottom - rect.top - 30);
 
            button &btn = maker::make<button>(*this);
            btn.text(tabname);
            btn.move(myButton.size() * myTabWidth,
                     0, myTabWidth, 30);
            myButton.push_back(&btn);
            myPanel.push_back(&panel);
            int tabIndex = myButton.size() - 1;
 
            btn.events().click([this, tabIndex]()
                               {
                                   myTabChangingFn(tabIndex);
                                   select(tabIndex);
                                   myTabChangeFn(tabIndex); });
        }
        void select(int i)
        {
            std::cout << "select " << i << "\n";
 
            if (0 > i || i >= (int)myButton.size())
                return;
 
            for (auto b : myButton)
            {
                b->bgcolor(0xC8C8C8);
                b->update();
            }
            for (auto p : myPanel)
                p->show(false);
 
            myButton[i]->bgcolor(0xFFFFFF);
            myPanel[i]->show();
            update();
            mySelect = i;
        }
        int select() const
        {
            return mySelect;
        }
        void tabWidth(int w)
        {
            myTabWidth = w;
        }
        void tabChanging(std::function<void(int tabIndex)> f)
        {
            myTabChangingFn = f;
        }
        void tabChanged(std::function<void(int tabIndex)> f)
        {
            myTabChangeFn = f;
        }
 
    private:
        std::vector<button *> myButton;
        std::vector<gui *> myPanel;
        int myTabWidth;
        int mySelect;
        std::function<void(int tabIndex)> myTabChangingFn;
        std::function<void(int tabIndex)> myTabChangeFn;
    };
 
    class radiobuttonLayout : public layout
    {
    public:
        radiobuttonLayout(gui *parent)
            : layout(parent), myFirst(true)
        {
        }
        radiobutton &add()
        {
            wex::radiobutton &rb = wex::maker::make<wex::radiobutton>(*this);
            if (myFirst)
            {
                myFirst = false;
                rb.first();
 
                rb.text("AAA");
            }
            return rb;
        }
        int checked()
        {
            if (myFirst)
                return -1;
            return ((radiobutton *)children()[0])->checkedOffset();
        }
        void check(int i, bool f = true)
        {
            if (0 > i || i >= (int)children().size())
                return;
            ((radiobutton *)children()[i])->check();
        }
        void enable(bool f = true)
        {
            for (auto rb : children())
                ((radiobutton *)rb)->enable(f);
        }
 
    private:
        bool myFirst;
    };
    class printDoc
    {
    public:
        printDoc(const std::string &title = "printDoc")
        {
            // https://www.equestionanswers.com/vcpp/screen-dc-printer-dc.php
            PRINTDLG pdlg;
 
            /* Initialize the PRINTDLG structure. */
            memset(&pdlg, 0, sizeof(PRINTDLG));
            pdlg.lStructSize = sizeof(PRINTDLG);
            /* Set the flag to return printer DC. */
            pdlg.Flags = PD_RETURNDC;
 
            /* Invoke the printer dialog box. */
            PrintDlg(&pdlg);
 
            /* hDC member of the PRINTDLG structure contains the printer DC. */
            dc = pdlg.hDC;
            if (!dc)
                return;
 
            DOCINFO di;
            memset(&di, 0, sizeof(DOCINFO));
            /* Fill in the required members. */
            di.cbSize = sizeof(DOCINFO);
            di.lpszDocName = title.c_str();
 
            StartDoc(dc, &di);
        }
        ~printDoc()
        {
            EndDoc(dc);
            DeleteDC(dc);
        }
        bool isOpen()
        {
            return (bool)dc;
        }
        void pageStart()
        {
            StartPage(dc);
        }
        void pageEnd()
        {
            EndPage(dc);
        }
        void text(
            int x, int y,
            const std::string &s)
        {
            TextOut(
                dc,
                x, y,
                s.c_str(), s.length());
        }
 
    private:
        HDC dc;
    };
 
    struct free
    {
        static int startProcess(
            const std::string &command,
            std::string &error,
            bool fBlock = false)
        {
            STARTUPINFO si;
            PROCESS_INFORMATION pi;
 
            ZeroMemory(&si, sizeof(si));
            si.cb = sizeof(si);
            ZeroMemory(&pi, sizeof(pi));
 
            // Retain keyboard focus, minimize module2 window
            si.wShowWindow = SW_SHOWNOACTIVATE | SW_MINIMIZE;
            si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USEPOSITION;
            si.dwX = 600;
            si.dwY = 200;
 
            if (!CreateProcessA(
                    NULL,                   // No module name (use command line)
                    (LPSTR)command.c_str(), // Command line
                    NULL,                   // Process handle not inheritable
                    NULL,                   // Thread handle not inheritable
                    FALSE,                  // Set handle inheritance to FALSE
                    CREATE_NEW_CONSOLE,     //  creation flags
                    NULL,                   // Use parent's environment block
                    NULL,                   // Use parent's starting directory
                    &si,                    // Pointer to STARTUPINFO structure
                    &pi)                    // Pointer to PROCESS_INFORMATION structure
            )
            {
                int syserrno = GetLastError();
                if (syserrno == 2)
                {
                    error = "Cannot find executable file";
                    return 2;
                }
                char *lpMsgBuf;
                FormatMessageA(
                    FORMAT_MESSAGE_ALLOCATE_BUFFER |
                        FORMAT_MESSAGE_FROM_SYSTEM |
                        FORMAT_MESSAGE_IGNORE_INSERTS,
                    NULL,
                    (DWORD)syserrno,
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
                    (LPSTR)&lpMsgBuf,
                    0, NULL);
                error = lpMsgBuf;
                LocalFree(lpMsgBuf);
                return 1;
            }
 
            WaitForSingleObject(pi.hProcess, 10000);
 
            // Close process and thread handles.
            CloseHandle(pi.hProcess);
            CloseHandle(pi.hThread);
 
            error = "";
            return 0;
        }
    };
}