native/pmwin.c

/**
 * 2ine; an OS/2 emulator for Linux.
 *
 * Please see the file LICENSE.txt in the source's root directory.
 *
 *  This file written by Ryan C. Gordon.
 */

#include "os2native.h"
#include "pmwin.h"
#include "SDL.h"

#include "pmwin-lx.h"

// NOTE: PM reference manual says OS/2 generally ignores the HAB you pass
//  to functions, instead getting that info from the current thread, but
//  other IBM platforms might not do that, so programs should always pass
//  a valid HAB to everything. Things like WinCreateWindow() probably rely
//  on the current thread's HAB without requiring the API call to specify
//  it in any case.
// So current approach: keep a pointer to the anchor block in the TIB, and
//  the anchor block keeps a copy of it's HAB. When the anchor block is
//  needed, we pull it from the TIB directly, and if it's in a function
//  where a HAB is specified, we fail if the handles don't match.
// If I later find out that OS/2 doesn't even care even if you give it a
//  bogus HAB, we can relax this check.


// !!! FIXME: You can send messages to HWNDs on a different thread, which
// !!! FIXME:  means HWND values must be unique across threads. Technically,
// !!! FIXME:  they have to be unique across processes, too.  :/


#define FIRST_HWND_VALUE 10
#define FIRST_HPS_VALUE 10

// This is the keyname we use on an heavyweight SDL window to find our
//  associated Window*.
#define WINDATA_WINDOWPTR_NAME "2ine_windowptr"

static SDL_atomic_t GHABCounter;
static SDL_atomic_t GHMQCounter;

typedef struct WindowClass
{
    char *name;
    PFNWP window_proc;
    ULONG style;
    ULONG data_len;
    struct WindowClass *next;
} WindowClass;

// these get shared with all children, but they're owned by the topmost parent.
typedef struct
{
    SDL_Window *window;
    SDL_Renderer *renderer;
    SDL_Texture *texture;
} HeavyWeightWindow;

typedef struct Window
{
    PFNWP window_proc;
    HeavyWeightWindow heavy;
    struct Window *parent;
    struct Window *children;
    struct Window *sibling;
    struct Window *owner;
    const char *window_class_name;  // Class at creation time. styles and window procs might change later, though! This is just to make debugging easier.
    char *text;
    void *data;
    size_t data_len;
    ULONG id;
    ULONG class_style;
    ULONG style;
    HWND hwnd;
    LONG x;
    LONG y;
    LONG w;
    LONG h;
    BOOL enabled;
} Window;

typedef struct MessageQueueItem
{
    QMSG qmsg;
    struct MessageQueueItem *next;
} MessageQueueItem;

typedef struct
{
    HMQ hmq;
    MessageQueueItem *head;
    MessageQueueItem *tail;
    MessageQueueItem *free_pool;
} MessageQueue;

typedef struct
{
    HPS hps;
    Window *window;
    // !!! FIXME: this is gonna be WAY more complicated.
} PresentationSpace;

typedef struct
{
    HAB hab;  // actual HAB value for this block, for comparison.
    ERRORID last_error;
    WindowClass *registered_classes;
    MessageQueue message_queue;
    Window *windows;
    size_t windows_array_len;
    PresentationSpace *pres_spaces;
    size_t pres_spaces_array_len;
} AnchorBlock;

#define SET_WIN_ERROR_AND_RETURN(anchor, err, rc) { anchor->last_error = (err); return (rc); }

static Window desktop_window;  // !!! FIXME: initialize and upkeep on this.

static inline AnchorBlock *getAnchorBlockNoHAB(void)
{
    return (AnchorBlock *) LX_GETPOSTTIB()->anchor_block;
} // getAnchorBlockNoHAB

static AnchorBlock *getAnchorBlock(const HAB hab)
{
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return NULL;
    } else if (anchor->hab != hab) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HAB, NULL);
    }
    return anchor;
} // getAnchorBlock

static Window *getWindowFromHWND(const AnchorBlock *anchor, const HWND hwnd)
{
    if (hwnd >= FIRST_HWND_VALUE) {
        const size_t idx = (size_t) (hwnd - FIRST_HWND_VALUE);
        if (idx >= anchor->windows_array_len) {
            return NULL;
        }
        Window *win = &anchor->windows[idx];
        return (win->hwnd == hwnd) ? win : NULL;
    } else if (hwnd == HWND_DESKTOP) {
        return &desktop_window;
    }
    return NULL;
} // getWindowFromHWND

static PresentationSpace *getPresentationSpaceFromHPS(const AnchorBlock *anchor, const HPS hps)
{
    if (hps >= FIRST_HPS_VALUE) {
        const size_t idx = (size_t) (hps - FIRST_HPS_VALUE);
        if (idx >= anchor->pres_spaces_array_len) {
            return NULL;
        }
        PresentationSpace *ps = &anchor->pres_spaces[idx];
        return (ps->hps == hps) ? ps : NULL;
    }
    return NULL;
} // getPresentationSpaceFromHPS

static const char *messageName(const ULONG msg)
{
    switch (msg) {
        #define MSGCASE(m) case m: return #m
        MSGCASE(WM_NULL);
        MSGCASE(WM_CREATE);
        MSGCASE(WM_DESTROY);
        MSGCASE(WM_ENABLE);
        MSGCASE(WM_SHOW);
        MSGCASE(WM_MOVE);
        MSGCASE(WM_SIZE);
        MSGCASE(WM_ADJUSTWINDOWPOS);
        MSGCASE(WM_CALCVALIDRECTS);
        MSGCASE(WM_SETWINDOWPARAMS);
        MSGCASE(WM_QUERYWINDOWPARAMS);
        MSGCASE(WM_HITTEST);
        MSGCASE(WM_ACTIVATE);
        MSGCASE(WM_SETFOCUS);
        MSGCASE(WM_SETSELECTION);
        MSGCASE(WM_PPAINT);
        MSGCASE(WM_PSETFOCUS);
        MSGCASE(WM_PSYSCOLORCHANGE);
        MSGCASE(WM_PSIZE);
        MSGCASE(WM_PACTIVATE);
        MSGCASE(WM_PCONTROL);
        MSGCASE(WM_COMMAND);
        MSGCASE(WM_SYSCOMMAND);
        MSGCASE(WM_HELP);
        MSGCASE(WM_PAINT);
        MSGCASE(WM_TIMER);
        MSGCASE(WM_SEM1);
        MSGCASE(WM_SEM2);
        MSGCASE(WM_SEM3);
        MSGCASE(WM_SEM4);
        MSGCASE(WM_CLOSE);
        MSGCASE(WM_QUIT);
        MSGCASE(WM_SYSCOLORCHANGE);
        MSGCASE(WM_SYSVALUECHANGED);
        MSGCASE(WM_APPTERMINATENOTIFY);
        MSGCASE(WM_PRESPARAMCHANGED);
        MSGCASE(WM_CONTROL);
        MSGCASE(WM_VSCROLL);
        MSGCASE(WM_HSCROLL);
        MSGCASE(WM_INITMENU);
        MSGCASE(WM_MENUSELECT);
        MSGCASE(WM_MENUEND);
        MSGCASE(WM_DRAWITEM);
        MSGCASE(WM_MEASUREITEM);
        MSGCASE(WM_CONTROLPOINTER);
        MSGCASE(WM_QUERYDLGCODE);
        MSGCASE(WM_INITDLG);
        MSGCASE(WM_SUBSTITUTESTRING);
        MSGCASE(WM_MATCHMNEMONIC);
        MSGCASE(WM_SAVEAPPLICATION);
        MSGCASE(WM_FLASHWINDOW);
        MSGCASE(WM_FORMATFRAME);
        MSGCASE(WM_UPDATEFRAME);
        MSGCASE(WM_FOCUSCHANGE);
        MSGCASE(WM_SETBORDERSIZE);
        MSGCASE(WM_TRACKFRAME);
        MSGCASE(WM_MINMAXFRAME);
        MSGCASE(WM_SETICON);
        MSGCASE(WM_QUERYICON);
        MSGCASE(WM_SETACCELTABLE);
        MSGCASE(WM_QUERYACCELTABLE);
        MSGCASE(WM_TRANSLATEACCEL);
        MSGCASE(WM_QUERYTRACKINFO);
        MSGCASE(WM_QUERYBORDERSIZE);
        MSGCASE(WM_NEXTMENU);
        MSGCASE(WM_ERASEBACKGROUND);
        MSGCASE(WM_QUERYFRAMEINFO);
        MSGCASE(WM_QUERYFOCUSCHAIN);
        MSGCASE(WM_OWNERPOSCHANGE);
        MSGCASE(WM_CALCFRAMERECT);
        MSGCASE(WM_WINDOWPOSCHANGED);
        MSGCASE(WM_ADJUSTFRAMEPOS);
        MSGCASE(WM_QUERYFRAMECTLCOUNT);
        MSGCASE(WM_QUERYHELPINFO);
        MSGCASE(WM_SETHELPINFO);
        MSGCASE(WM_ERROR);
        MSGCASE(WM_REALIZEPALETTE);
        MSGCASE(WM_RENDERFMT);
        MSGCASE(WM_RENDERALLFMTS);
        MSGCASE(WM_DESTROYCLIPBOARD);
        MSGCASE(WM_PAINTCLIPBOARD);
        MSGCASE(WM_SIZECLIPBOARD);
        MSGCASE(WM_HSCROLLCLIPBOARD);
        MSGCASE(WM_VSCROLLCLIPBOARD);
        MSGCASE(WM_DRAWCLIPBOARD);
        MSGCASE(WM_MOUSEMOVE);
        MSGCASE(WM_BUTTON1DOWN);
        MSGCASE(WM_BUTTON1UP);
        MSGCASE(WM_BUTTON1DBLCLK);
        MSGCASE(WM_BUTTON2DOWN);
        MSGCASE(WM_BUTTON2UP);
        MSGCASE(WM_BUTTON2DBLCLK);
        MSGCASE(WM_BUTTON3DOWN);
        MSGCASE(WM_BUTTON3UP);
        MSGCASE(WM_BUTTON3DBLCLK);
        MSGCASE(WM_CHAR);
        MSGCASE(WM_VIOCHAR);
        MSGCASE(WM_JOURNALNOTIFY);
        MSGCASE(WM_MOUSEMAP);
        MSGCASE(WM_VRNDISABLED);
        MSGCASE(WM_VRNENABLED);
        MSGCASE(WM_DDE_INITIATE);
        MSGCASE(WM_DDE_REQUEST);
        MSGCASE(WM_DDE_ACK);
        MSGCASE(WM_DDE_DATA);
        MSGCASE(WM_DDE_ADVISE);
        MSGCASE(WM_DDE_UNADVISE);
        MSGCASE(WM_DDE_POKE);
        MSGCASE(WM_DDE_EXECUTE);
        MSGCASE(WM_DDE_TERMINATE);
        MSGCASE(WM_DDE_INITIATEACK);
        MSGCASE(WM_QUERYCONVERTPOS);
        MSGCASE(WM_MSGBOXINIT);
        MSGCASE(WM_MSGBOXDISMISS);
        MSGCASE(WM_CTLCOLORCHANGE);
        MSGCASE(WM_QUERYCTLTYPE);
        MSGCASE(WM_CHORD);
        MSGCASE(WM_BUTTON1MOTIONSTART);
        MSGCASE(WM_BUTTON1MOTIONEND);
        MSGCASE(WM_BUTTON1CLICK);
        MSGCASE(WM_BUTTON2MOTIONSTART);
        MSGCASE(WM_BUTTON2MOTIONEND);
        MSGCASE(WM_BUTTON2CLICK);
        MSGCASE(WM_BUTTON3MOTIONSTART);
        MSGCASE(WM_BUTTON3MOTIONEND);
        MSGCASE(WM_BUTTON3CLICK);
        MSGCASE(WM_BEGINDRAG);
        MSGCASE(WM_ENDDRAG);
        MSGCASE(WM_SINGLESELECT);
        MSGCASE(WM_OPEN);
        MSGCASE(WM_CONTEXTMENU);
        MSGCASE(WM_CONTEXTHELP);
        MSGCASE(WM_TEXTEDIT);
        MSGCASE(WM_BEGINSELECT);
        MSGCASE(WM_ENDSELECT);
        MSGCASE(WM_PICKUP);
        MSGCASE(WM_SEMANTICEVENT);
        MSGCASE(WM_USER);
        #undef MSGCASE
        default: break;
    }

    return "???";
} // messageName

static WindowClass *findRegisteredClass(AnchorBlock *anchor, const char *classname)
{
    const ULONG intclass = (ULONG) (size_t) classname;
    if ((intclass >= 0xffff0001) && (intclass <= 0xffff0070)) {
        // built-in class, like WC_BUTTON or whatever.
        switch (intclass) {
            // !!! FIXME: write me.
            case WC_FRAME:
            case WC_COMBOBOX:
            case WC_BUTTON:
            case WC_MENU:
            case WC_STATIC:
            case WC_ENTRYFIELD:
            case WC_LISTBOX:
            case WC_SCROLLBAR:
            case WC_TITLEBAR:
            case WC_MLE:
            case WC_APPSTAT:
            case WC_KBDSTAT:
            case WC_PECIC:
            case WC_DBE_KKPOPUP:
            case WC_SPINBUTTON:
            case WC_CONTAINER:
            case WC_SLIDER:
            case WC_VALUESET:
            case WC_NOTEBOOK:
            case WC_CIRCULARSLIDER:
            default:
                return NULL;
        }
    } else {
        for (WindowClass *i = anchor->registered_classes; i; i = i->next) {
            if (strcmp(i->name, classname) == 0) {
                return i;
            }
        }
    }
    return NULL;
} // findRegisteredClass

static ULONG currentSystemTicks(void)
{
    FIXME("this isn't correct");  // see notes in processSDLEvent() for details.
    return SDL_GetTicks();
} // currentSystemTicks

HAB WinInitialize(ULONG flOptions)
{
    TRACE_NATIVE("WinInitialize(%u)", (uint) flOptions);

    if (flOptions != 0) {
        return NULLHANDLE;  // reserved; must be zero.
    }

    LxPostTIB *posttib = LX_GETPOSTTIB();
    if (posttib->anchor_block != NULL) {
        return NULLHANDLE;  // fail if thread already has a HAB
    }

    if (!SDL_WasInit(SDL_INIT_VIDEO)) {
        if (SDL_Init(SDL_INIT_VIDEO) == -1) {
            fprintf(stderr, "SDL_INIT_VIDEO failed: %s\n", SDL_GetError());
            return NULLHANDLE;
        }
    }

    FIXME("OS/2 doesn't support multi-monitor");  // this might not be true, actually.
    SDL_Rect desktoprect;
    SDL_GetDisplayBounds(0, &desktoprect);
    desktop_window.hwnd = HWND_DESKTOP;
    desktop_window.w = desktoprect.w;
    desktop_window.h = desktoprect.h;

    AnchorBlock *anchor = calloc(1, sizeof (AnchorBlock));
    if (anchor == NULL) {
        return NULLHANDLE;
    }

    anchor->windows_array_len = 16;
    anchor->windows = (Window *) malloc(sizeof (Window) * anchor->windows_array_len);
    if (!anchor->windows) {
        free(anchor);
        return NULLHANDLE;
    }
    memset(anchor->windows, '\0', sizeof (Window) * anchor->windows_array_len);

    anchor->pres_spaces_array_len = 16;
    anchor->pres_spaces = (PresentationSpace *) malloc(sizeof (PresentationSpace) * anchor->pres_spaces_array_len);
    if (!anchor->pres_spaces) {
        free(anchor->windows);
        free(anchor);
        return NULLHANDLE;
    }
    memset(anchor->pres_spaces, '\0', sizeof (PresentationSpace) * anchor->pres_spaces_array_len);

    const int ihab = SDL_AtomicAdd(&GHABCounter, 1) + 1;
    if (ihab <= 0) {  // this is clearly a pathological program.
        free(anchor->pres_spaces);
        free(anchor->windows);
        free(anchor);
        return NULLHANDLE;
    }

    const HAB hab = (HAB) ihab;
    anchor->hab = hab;
    posttib->anchor_block = anchor;

    return hab;
} // WinInitialize

static MRESULT sendMessage(Window *win, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    PFNWP winproc = win->window_proc;
    if (!winproc) {
        winproc = WinDefWindowProc;
    }
    TRACE_EVENT("EVENT SEND { hwnd=%u, msg=%u (%s), mp1=%p, mp2=%p, proc=%p }", (uint) win->hwnd, (uint) msg, messageName(msg), mp1, mp2, winproc);
    return winproc(win->hwnd, msg, mp1, mp2);
} // sendMessage

static BOOL destroyMessageQueue(AnchorBlock *anchor)
{
    MessageQueueItem *next = NULL;
    for (MessageQueueItem *i = anchor->message_queue.head; i; i = next) {
        next = i->next;
        free(i);
    }
    for (MessageQueueItem *i = anchor->message_queue.free_pool; i; i = next) {
        next = i->next;
        free(i);
    }
    TRACE_EVENT("HMQ %u destroyed", (uint) anchor->message_queue.hmq);
    memset(&anchor->message_queue, '\0', sizeof (MessageQueue));
    return TRUE;
} // destroyMessageQueue

static void destroyWindow(AnchorBlock *anchor, Window *win)
{
    if (!win || (win->hwnd == NULLHANDLE)) {
        return;
    }

    // !!! FIXME: hide window first, and optionally send WM_ACTIVATE message if losing focus.
    // !!! FIXME: send WM_RENDERALLFMTS if we are clipboard owner and unrendered formats are in the clipboard.

    // send WM_DESTROY. This is a simple notification, and cannot prevent destruction.
    sendMessage(win, WM_DESTROY, 0, 0);

    // Next, destroy all child windows.
    Window *next = NULL;
    for (Window *i = win->children; i != NULL; i = next) {
        next = i->sibling;
        destroyWindow(anchor, i);
    }

    // !!! FIXME: see notes in SDK reference about disassociating/destroying HPS objects.

    // if this is a heavyweight window, destroy those parts.
    if (win->parent == &desktop_window) {
        SDL_DestroyTexture(win->heavy.texture);
        SDL_DestroyRenderer(win->heavy.renderer);
        SDL_DestroyWindow(win->heavy.window);
    }

    if (win->parent->children == win) {
        win->parent->children = win->sibling;
    } else {
        for (Window *i = win->parent->children; i != NULL; i = i->sibling) {
            assert(i != win);
            if (i->sibling == win) {
                i->sibling = win->sibling;
                break;
            }
        }
    }
    free(win->text);
    free(win->data);
    memset(win, '\0', sizeof (*win));
} // destroyWindow

static void destroyPresentationSpace(AnchorBlock *anchor, PresentationSpace *ps)
{
    if (!ps || (ps->hps == NULLHANDLE)) {
        return;
    }
    FIXME("this will be more complicated later");
    memset(ps, '\0', sizeof (*ps));
} // destroyPresentationSpace

BOOL WinTerminate(HAB hab)
{
    TRACE_NATIVE("WinTerminate(%u)", (uint) hab);
    AnchorBlock *anchor = getAnchorBlock(hab);
    if (!anchor) {
        return FALSE;
    }

    for (size_t i = 0; i < anchor->pres_spaces_array_len; i++) {
        destroyPresentationSpace(anchor, &anchor->pres_spaces[i]);
    }
    free(anchor->pres_spaces);

    for (size_t i = 0; i < anchor->windows_array_len; i++) {
        destroyWindow(anchor, &anchor->windows[i]);
    }
    free(anchor->windows);

    WindowClass *winclassnext = NULL;
    for (WindowClass *i = anchor->registered_classes; i; i = winclassnext) {
        winclassnext = i->next;
        free(i->name);
        free(i);
    }

    if (anchor->message_queue.hmq != NULLHANDLE) {
        destroyMessageQueue(anchor);
    }

    free(anchor);
    LX_GETPOSTTIB()->anchor_block = NULL;

    SDL_Quit();  // !!! FIXME: does this reference count?

    return TRUE;
} // WinTerminate

ERRORID WinGetLastError(HAB hab)
{
    TRACE_NATIVE("WinGetLastError(%u)", (uint) hab);
    AnchorBlock *anchor = getAnchorBlock(hab);
    if (!anchor) {
        return PMERR_INVALID_HAB;
    }
    const ERRORID retval = anchor->last_error;
    SET_WIN_ERROR_AND_RETURN(anchor, NO_ERROR, retval);
} // WinGetLastError

HMQ WinCreateMsgQueue(HAB hab, LONG cmsg)
{
    TRACE_NATIVE("WinCreateMsgQueue(%u, %d)", (uint) hab, (int) cmsg);
    AnchorBlock *anchor = getAnchorBlock(hab);
    if (!anchor) {
        return NULLHANDLE;
    } else if (anchor->message_queue.hmq != NULLHANDLE) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_MSG_QUEUE_ALREADY_EXISTS, NULLHANDLE);
    }

    // as of OS/2 Warp 4.0, cmsg is ignored (the queue is always dynamically allocated), so we ignore it too.

    assert(anchor->message_queue.head == NULL);
    assert(anchor->message_queue.tail == NULL);
    assert(anchor->message_queue.free_pool == NULL);

    const int ihmq = SDL_AtomicAdd(&GHMQCounter, 1) + 1;
    if (ihmq <= 0) {  // this is clearly a pathological program.
        return NULLHANDLE;
    }

    const HMQ hmq = (HMQ) ihmq;
    anchor->message_queue.hmq = hmq;
    TRACE_EVENT("HMQ %u created", (uint) hmq);
    return hmq;
} // WinCreateMsgQueue

static ERRORID postMessage(AnchorBlock *anchor, const QMSG *qmsg)
{
    TRACE_EVENT("EVENT POST { hwnd=%u, msg=%u (%s), mp1=%p, mp2=%p, time=%u, ptl={%d,%d}, reserved=%u }", (uint) qmsg->hwnd, (uint) qmsg->msg, messageName(qmsg->msg), qmsg->mp1, qmsg->mp2, (uint) qmsg->time, (int) qmsg->ptl.x, (int) qmsg->ptl.y, (uint) qmsg->reserved);

    MessageQueueItem *item = anchor->message_queue.free_pool;
    if (item) {
        anchor->message_queue.free_pool = item->next;
    } else {
        item = (MessageQueueItem *) malloc(sizeof (*item));
        if (item == NULL) {
            return FALSE;
        }
    }

    memcpy(&item->qmsg, qmsg, sizeof (*qmsg));
    item->next = NULL;

    assert(!anchor->message_queue.head == !anchor->message_queue.tail);
    if (anchor->message_queue.tail) {
        anchor->message_queue.tail->next = item;
    } else {
        anchor->message_queue.head = item;
    }
    anchor->message_queue.tail = item;

    return TRUE;
} // postMessage

static inline Window *getWindowFromSDLWindow(SDL_Window *sdlwin)
{
    return (Window *) sdlwin ? SDL_GetWindowData(sdlwin, WINDATA_WINDOWPTR_NAME) : NULL;
} // getWindowFromSDLWindow


#if 0
static Window *hittestWindow(SDL_Window *sdlwin, int x, int y)
{
    if (!sdlwin) {
        return NULL;
    }

    Window *win = getWindowFromSDLWindow(sdlwin);
    if (!win) {
        return NULL;
    }

    // (win) is currently the oldest parent, which is associated with the
    //  SDL_Window. We need to see which lightweight child window, if any,
    //  this event was meant for.

    // y coordinates are flipped on OS/2. zero is the bottom of the window.
    y = sdlwin->h - y;
// !!! FIXME WRITE ME
    for (Window *i =
    if (win->class_style & CS_HITTEST) {
        sendMessage(win, WM_HITTEST,
    }

} // findWindowFromSDL
#endif

static BOOL postTimestampedMsg(AnchorBlock *anchor, HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2, ULONG ticks)
{
    const QMSG qmsg = { hwnd, msg, mp1, mp2, currentSystemTicks(), { 0, 0 }, 0 };
    return postMessage(anchor, &qmsg);
} // postTimestampedMsg

#if 0
static BOOL postSimpleMsg(AnchorBlock *anchor, HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    return postTimestampedMsg(anchor, hwnd, msg, mp1, mp2, currentSystemTicks());
} // postSimpleMsg

#endif

static BOOL postExposedMessages(AnchorBlock *anchor, Window *win, const ULONG ticks)
{
    FIXME("this should WinInvalidateRect() the windows, not send paint messages");
    FIXME("this is a recursive hell");  // we need to start at the end of the sibling list, which is the bottom of the stack.
    BOOL retval = FALSE;
    if (win) {
        retval |= postExposedMessages(anchor, win->sibling, ticks);
        if (win->style & WS_VISIBLE) {
            FIXME("for CS_SYNCPAINT classes, this should send the WM_PAINT message right now instead of posting");
            retval |= postTimestampedMsg(anchor, win->hwnd, WM_PAINT, 0, 0, ticks);
            retval |= postExposedMessages(anchor, win->children, ticks);
        }
    }
    return retval;
} // postExposedMessages


static const char *sdlEventName(const SDL_EventType ev)
{
    switch (ev) {
        #define EVCASE(m) case m: return #m
        EVCASE(SDL_QUIT);
        EVCASE(SDL_APP_TERMINATING);
        EVCASE(SDL_APP_LOWMEMORY);
        EVCASE(SDL_APP_WILLENTERBACKGROUND);
        EVCASE(SDL_APP_DIDENTERBACKGROUND);
        EVCASE(SDL_APP_WILLENTERFOREGROUND);
        EVCASE(SDL_APP_DIDENTERFOREGROUND);
        EVCASE(SDL_WINDOWEVENT);
        EVCASE(SDL_SYSWMEVENT);
        EVCASE(SDL_KEYDOWN);
        EVCASE(SDL_KEYUP);
        EVCASE(SDL_TEXTEDITING);
        EVCASE(SDL_TEXTINPUT);
        EVCASE(SDL_KEYMAPCHANGED);
        EVCASE(SDL_MOUSEMOTION);
        EVCASE(SDL_MOUSEBUTTONDOWN);
        EVCASE(SDL_MOUSEBUTTONUP);
        EVCASE(SDL_MOUSEWHEEL);
        EVCASE(SDL_JOYAXISMOTION);
        EVCASE(SDL_JOYBALLMOTION);
        EVCASE(SDL_JOYHATMOTION);
        EVCASE(SDL_JOYBUTTONDOWN);
        EVCASE(SDL_JOYBUTTONUP);
        EVCASE(SDL_JOYDEVICEADDED);
        EVCASE(SDL_JOYDEVICEREMOVED);
        EVCASE(SDL_CONTROLLERAXISMOTION);
        EVCASE(SDL_CONTROLLERBUTTONDOWN);
        EVCASE(SDL_CONTROLLERBUTTONUP);
        EVCASE(SDL_CONTROLLERDEVICEADDED);
        EVCASE(SDL_CONTROLLERDEVICEREMOVED);
        EVCASE(SDL_CONTROLLERDEVICEREMAPPED);
        EVCASE(SDL_FINGERDOWN);
        EVCASE(SDL_FINGERUP);
        EVCASE(SDL_FINGERMOTION);
        EVCASE(SDL_DOLLARGESTURE);
        EVCASE(SDL_DOLLARRECORD);
        EVCASE(SDL_MULTIGESTURE);
        EVCASE(SDL_CLIPBOARDUPDATE);
        EVCASE(SDL_DROPFILE);
        EVCASE(SDL_DROPTEXT);
        EVCASE(SDL_DROPBEGIN);
        EVCASE(SDL_DROPCOMPLETE);
        EVCASE(SDL_AUDIODEVICEADDED);
        EVCASE(SDL_AUDIODEVICEREMOVED);
        EVCASE(SDL_RENDER_TARGETS_RESET);
        EVCASE(SDL_RENDER_DEVICE_RESET);
        EVCASE(SDL_USEREVENT);
        #undef EVCASE
        default: break;
    }
    return "???";
} // sdlEventName

static const char *sdlWindowEventName(const SDL_WindowEventID ev)
{
    switch (ev) {
        #define EVCASE(m) case m: return #m
        EVCASE(SDL_WINDOWEVENT_SHOWN);
        EVCASE(SDL_WINDOWEVENT_HIDDEN);
        EVCASE(SDL_WINDOWEVENT_EXPOSED);
        EVCASE(SDL_WINDOWEVENT_MOVED);
        EVCASE(SDL_WINDOWEVENT_RESIZED);
        EVCASE(SDL_WINDOWEVENT_SIZE_CHANGED);
        EVCASE(SDL_WINDOWEVENT_MINIMIZED);
        EVCASE(SDL_WINDOWEVENT_MAXIMIZED);
        EVCASE(SDL_WINDOWEVENT_RESTORED);
        EVCASE(SDL_WINDOWEVENT_ENTER);
        EVCASE(SDL_WINDOWEVENT_LEAVE);
        EVCASE(SDL_WINDOWEVENT_FOCUS_GAINED);
        EVCASE(SDL_WINDOWEVENT_FOCUS_LOST);
        EVCASE(SDL_WINDOWEVENT_CLOSE);
        EVCASE(SDL_WINDOWEVENT_TAKE_FOCUS);
        EVCASE(SDL_WINDOWEVENT_HIT_TEST);
        #undef EVCASE
        default: break;
    }
    return "???";
} // sdlWindowEventName

static BOOL processSDLEvent(AnchorBlock *anchor, const SDL_Event *sdlevent)
{
    // !!! FIXME: we just drop events if we run out of memory, etc.

    // !!! FIXME: QMSG::time appears to be milliseconds since the system
    // !!! FIXME:  booted (presumably rolling over every 38 days). SDL's
    // !!! FIXME:  event timestamps (and SDL_GetTicks()) are milliseconds
    // !!! FIXME:  since SDL_Init(), which is more or less since app startup.
    // !!! FIXME:  We might need a way to map these, so they're consistent
    // !!! FIXME:  across processes.
    // !!! FIXME: Also, it's well known that SDL event timestamps are when
    // !!! FIXME:  SDL gets the event from the OS, not the timestamp of when
    // !!! FIXME:  the OS generated it, which might be a problem.

/*
sdfsdf
    HWND    hwnd;
    ULONG   msg;
    MPARAM  mp1;
    MPARAM  mp2;
    ULONG   time;
    POINTL  ptl;
    ULONG   reserved;
sdfsdf
*/

//SDL_GetWindowFromID(window) sdfsdf

    const ULONG ticks = (ULONG) sdlevent->common.timestamp;

    TRACE_EVENT("EVENT SDL { type=0x%X (%s) }", (uint) sdlevent->type, sdlEventName(sdlevent->type));

    switch (sdlevent->type) {
        case SDL_QUIT:
            return postTimestampedMsg(anchor, NULLHANDLE, WM_QUIT, 0, 0, ticks);

        case SDL_WINDOWEVENT:
            TRACE_EVENT("EVENT SDL WINDOW { type=0x%X (%s) }", (uint) sdlevent->window.event, sdlWindowEventName(sdlevent->window.event));
            switch (sdlevent->window.event) {
                case SDL_WINDOWEVENT_SHOWN:
                case SDL_WINDOWEVENT_EXPOSED: {
                    // maybe this doesn't matter in a world of compositing window managers, but it would be nice to completely avoid sending WM_PAINT to child windows that otherwise don't apply.
                    //  This only applies for heavyweight windows the OS is marking as exposed, not OS/2 apps marking OS/2 HWNDs as invalid for various reasons.
                    FIXME("SDL doesn't report invalid subregions, just that a window needs repainting");
                    Window *win = getWindowFromSDLWindow(SDL_GetWindowFromID(sdlevent->window.windowID));
                    if (!win) {
                        return FALSE;
                    }
                    return postExposedMessages(anchor, win, ticks);
                }

                default: break;  // not (currently) supported.
            }
            return FALSE;


#if 0
                case SDL_WINDOWEVENT_SHOWN:
                case SDL_WINDOWEVENT_HIDDEN:
                case SDL_WINDOWEVENT_MOVED,          /**< Window has been moved to data1, data2
                                     */
                case SDL_WINDOWEVENT_RESIZED,        /**< Window has been resized to data1xdata2 */
                case SDL_WINDOWEVENT_SIZE_CHANGED,   /**< The window size has changed, either as
                                         a result of an API call or through the
                                         system or user changing the window size. */
                case SDL_WINDOWEVENT_MINIMIZED,      /**< Window has been minimized */
                case SDL_WINDOWEVENT_MAXIMIZED,      /**< Window has been maximized */
                case SDL_WINDOWEVENT_RESTORED,       /**< Window has been restored to normal size
                                         and position */
                case SDL_WINDOWEVENT_ENTER,          /**< Window has gained mouse focus */
                case SDL_WINDOWEVENT_LEAVE,          /**< Window has lost mouse focus */
                case SDL_WINDOWEVENT_FOCUS_GAINED,   /**< Window has gained keyboard focus */
                case SDL_WINDOWEVENT_FOCUS_LOST,     /**< Window has lost keyboard focus */
                case SDL_WINDOWEVENT_CLOSE,          /**< The window manager requests that the window be closed */
                case SDL_WINDOWEVENT_TAKE_FOCUS,     /**< Window is being offered a focus (should SetWindowInputFocus() on itself or a subwindow, or ignore) */
                //case SDL_WINDOWEVENT_HIT_TEST        /**< Window had a hit test that wasn't SDL_HITTEST_NORMAL. */


//    SDL_MOUSEMOTION    = 0x400, /**< Mouse moved */
//    SDL_MOUSEBUTTONDOWN,        /**< Mouse button pressed */
//    SDL_MOUSEBUTTONUP,          /**< Mouse button released */
//    SDL_MOUSEWHEEL,             /**< Mouse wheel motion */
//    SDL_KEYDOWN        = 0x300, /**< Key pressed */
//    SDL_KEYUP,                  /**< Key released */
//    SDL_TEXTINPUT,              /**< Keyboard text input */
//    SDL_CLIPBOARDUPDATE = 0x900, /**< The clipboard changed */
//    SDL_DROPFILE        = 0x1000, /**< The system requests a file open */
//    SDL_DROPTEXT,                 /**< text/plain drag-and-drop event */
//    SDL_DROPBEGIN,                /**< A new set of drops is beginning (NULL filename) */
//    SDL_DROPCOMPLETE,             /**< Current set of drops is now complete (NULL filename) */


        case SDL_MOUSEBUTTONDOWN:
            
        case SDL_MOUSEBUTTONUP:
            if (sdlevent->button.clicks == 1) {}
#endif


        default: return FALSE;  // not (currently) supported.
    }

    assert(!"shouldn't hit this");
    return TRUE;
} // processSDLEvent

static void pumpEvents(AnchorBlock *anchor)
{
    SDL_Event sdlevent;
    BOOL queued = FALSE;

    // run through anything pending. If we don't post anything to the OS/2
    //  event queue, we need to block until we do, though, so then we'll use
    //  SDL_WaitEvent() in hopes that someday it's fully waitable.
    while (SDL_PollEvent(&sdlevent)) {
        queued |= processSDLEvent(anchor, &sdlevent);
    }

    while (!queued) {  // block until stuff shows up.
        while (!SDL_WaitEvent(&sdlevent)) {
            SDL_Delay(10);  // dunno what else to do here...
        }
        queued |= processSDLEvent(anchor, &sdlevent);
        while (SDL_PollEvent(&sdlevent)) {  // catch anything else pending.
            queued |= processSDLEvent(anchor, &sdlevent);
        }
    }
} // waitForMessage

static BOOL skipMessage(const PQMSG qmsg, HWND hwndFilter, ULONG msgFilterFirst, ULONG msgFilterLast)
{
    if (hwndFilter && (qmsg->hwnd != hwndFilter)) {
        return TRUE;
    } else if (msgFilterFirst || msgFilterLast) {
        const ULONG msg = qmsg->msg;
        if (msgFilterFirst > msgFilterLast) {  // reject if between first and last.
            if ((msg >= msgFilterLast) && (msg <= msgFilterFirst)) return TRUE;
        } else {  // reject if not between first and last.
            if ((msg < msgFilterFirst) || (msg > msgFilterLast)) return TRUE;
        }
    }
    return FALSE;
} // skipMessage

BOOL WinGetMsg(HAB hab, PQMSG pqmsg, HWND hwndFilter, ULONG msgFilterFirst, ULONG msgFilterLast)
{
    TRACE_NATIVE("WinGetMsg(%u, %p, %u, %u, %u)", (uint) hab, pqmsg, (uint) hwndFilter, (uint) msgFilterFirst, (uint) msgFilterLast);
    const BOOL bIsFiltering = (hwndFilter || msgFilterFirst || msgFilterLast);
    AnchorBlock *anchor = getAnchorBlock(hab);
    if (!anchor) {
        return FALSE;
    } else if (hwndFilter) {
        FIXME("fail with PMERR_INVALID_HWND if this is a bogus HWND.");
    }

    while (1) {
        MessageQueueItem *prev = NULL;
        MessageQueueItem *i = anchor->message_queue.head;
        if (bIsFiltering) {
            for (; i != NULL; prev = i, i = i->next) {
                if (!skipMessage(&i->qmsg, hwndFilter, msgFilterFirst, msgFilterLast)) {
                    break;
                }
            }
        }

        // Found an event? Remove from queue, return that info.
        if (i != NULL) {
            memcpy(pqmsg, &i->qmsg, sizeof (QMSG));

            TRACE_EVENT("EVENT GET { hwnd=%u, msg=%u (%s), mp1=%p, mp2=%p, time=%u, ptl={%d,%d}, reserved=%u }", (uint) pqmsg->hwnd, (uint) pqmsg->msg, messageName(pqmsg->msg), pqmsg->mp1, pqmsg->mp2, (uint) pqmsg->time, (int) pqmsg->ptl.x, (int) pqmsg->ptl.y, (uint) pqmsg->reserved);

            if (prev) {
                prev->next = i->next;
            } else {
                anchor->message_queue.head = i->next;
            }

            if (!anchor->message_queue.head) {
                assert(anchor->message_queue.tail == i);
                anchor->message_queue.tail = NULL;
            }

            i->next = anchor->message_queue.free_pool;
            anchor->message_queue.free_pool = i;

            return (pqmsg->msg != WM_QUIT) ? TRUE : FALSE;
        }

        pumpEvents(anchor);  // may block.
    }

    assert(!"shouldn't hit this.");
    return TRUE;  // shouldn't hit this.
} // WinGetMsg

MRESULT WinDispatchMsg(HAB hab, PQMSG pqmsg)
{
    TRACE_NATIVE("WinDispatchMsg(%u, %p)", (uint) hab, pqmsg);
    AnchorBlock *anchor = getAnchorBlock(hab);
    if (anchor) {
        Window *win = getWindowFromHWND(anchor, pqmsg->hwnd);
        if (win) {
            return sendMessage(win, pqmsg->msg, pqmsg->mp1, pqmsg->mp2);
        }
    }
    return 0;
} // WinDispatchMsg

BOOL WinDestroyMsgQueue(HMQ hmq)
{
    TRACE_NATIVE("WinDestroyMsgQueue(%u)", (uint) hmq);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return FALSE;
    } else if ((hmq == NULLHANDLE) || (anchor->message_queue.hmq != hmq))  {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HMQ, FALSE);
    }

    return destroyMessageQueue(anchor);
} // WinDestroyMsgQueue

BOOL WinRegisterClass(HAB hab, PSZ pszClassName, PFNWP pfnWndProc, ULONG flStyle, ULONG cbWindowData)
{
    TRACE_NATIVE("WinRegisterClass(%u, '%s', %p, %u, %u)", (uint) hab, pszClassName, pfnWndProc, (uint) flStyle, (uint) cbWindowData);

    AnchorBlock *anchor = getAnchorBlock(hab);
    if (!anchor) {
        return FALSE;
    }

    WindowClass *winclass = findRegisteredClass(anchor, pszClassName);
    if (!winclass) {  // PM docs say this call can replace existing class.
        winclass = (WindowClass *) malloc(sizeof (WindowClass));
        if (!winclass) {
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_HEAP_OUT_OF_MEMORY, FALSE);
        } else if ((winclass->name = strdup(pszClassName)) == NULL) {
            free(winclass);
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_HEAP_OUT_OF_MEMORY, FALSE);
        }
        winclass->next = anchor->registered_classes;
        anchor->registered_classes = winclass;
    }

    winclass->window_proc = pfnWndProc;
    winclass->style = flStyle;
    winclass->data_len = cbWindowData;

    return TRUE;
} // WinRegisterClass

MRESULT WinSendMsg(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    // !!! FIXME: This needs to be able to send to windows in different
    // !!! FIXME:  threads (and processes!), so this will need some effort to
    // !!! FIXME:  support.

    TRACE_NATIVE("WinSendMsg(%u, %u, %p, %p)", (uint) hwnd, (uint) msg, mp1, mp2);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (anchor) {
        Window *win = getWindowFromHWND(anchor, hwnd);
        if (win) {
            return sendMessage(win, msg, mp1, mp2);
        }
    }
    return (MRESULT) 0;
} // WinSendMsg

BOOL WinPostMsg(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    // !!! FIXME: SDL docs say you can call this, but not WinSendMsg() if
    // !!! FIXME:  the thread doesn't have a message queue, but that has to
    // !!! FIXME:  be a typo, right? How do you post a message to a queue that
    // !!! FIXME:  doesn't exist? But one could call a window procedure
    // !!! FIXME:  directly...

    // !!! FIXME: This needs to be able to post to windows in different
    // !!! FIXME:  threads (and processes!), so this will need some effort to
    // !!! FIXME:  support.

    TRACE_NATIVE("WinPostMsg(%u, %u, %p, %p)", (uint) hwnd, (uint) msg, mp1, mp2);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return FALSE;
    }
    if (anchor->message_queue.hmq == NULLHANDLE) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_NO_MSG_QUEUE, FALSE);
    }

    Window *win = getWindowFromHWND(anchor, hwnd);
    if (!win) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, FALSE);
    }

    int mousex, mousey;
    SDL_GetGlobalMouseState(&mousex, &mousey);  FIXME("track this ourselves?");
    const QMSG qmsg = { hwnd, msg, mp1, mp2, currentSystemTicks(), { mousex, mousey }, 0 };
    const ERRORID rc = postMessage(anchor, &qmsg);
    if (rc) {
        SET_WIN_ERROR_AND_RETURN(anchor, rc, FALSE);
    }

    return TRUE;
} // WinPostMsg

BOOL WinPostQueueMsg(HMQ hmq, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    TRACE_NATIVE("WinPostMsgQueue(%u, %u, %p, %p)", (uint) hmq, (uint) msg, mp1, mp2);
    // I assume this works like win32's PostThreadMessage(), in that there
    //  isn't a target HWND, so the target thread would have to deal with this
    //  message after a call to WinGetMsg() and not in a window procedure
    //  during a call to WinDispatchMsg().

    // (!!! FIXME: right now these are stored on the anchor block and not
    //             anywhere global I can reach it.)
    FIXME("need to be able to access other threads' message queues");
    return FALSE;
} // WinPostQueueMsg

HWND WinCreateWindow(HWND hwndParent, PSZ pszClass, PSZ pszName, ULONG flStyle, LONG x, LONG y, LONG cx, LONG cy, HWND hwndOwner, HWND hwndInsertBehind, ULONG id, PVOID pCtlData, PVOID pPresParams)
{
    TRACE_NATIVE("WinCreateWindow(%u, '%s', '%s', %u, %d, %d, %d, %d, %u, %u, %u, %p, %p)", (uint) hwndParent, pszClass, pszName, (uint) flStyle, (int) x, (int) y, (int) cx, (int) cy, (uint) hwndOwner, hwndInsertBehind, (uint) id, pCtlData, pPresParams);

    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return NULLHANDLE;
    }

    if (anchor->message_queue.hmq == NULLHANDLE) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_NO_MSG_QUEUE, NULLHANDLE);
    }

    const WindowClass *winclass = findRegisteredClass(anchor, pszClass);
    if (!winclass) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_PARM, NULLHANDLE);
    }

    Window *parent = getWindowFromHWND(anchor, hwndParent);
    if (!parent) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, NULLHANDLE);
    }

    Window *owner = NULL;
    if (hwndOwner != NULLHANDLE) {
        owner = getWindowFromHWND(anchor, hwndParent);
        if (!owner) {
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, NULLHANDLE);
        }
    }

    // make space for the new window struct in the anchor block
    Window *win = NULL;
    FIXME("optimize this");
    for (size_t i = 0; i < anchor->windows_array_len; i++) {
        if (anchor->windows[i].hwnd == NULLHANDLE) {
            win = &anchor->windows[i];
            break;
        }
    }

    if (!win) {
        const size_t len = anchor->windows_array_len;
        void *ptr = realloc(anchor->windows, sizeof (Window) * len * 2);
        if (!ptr) {
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_HEAP_OUT_OF_MEMORY, NULLHANDLE);
        }
        anchor->windows = (Window *) ptr;
        memset(&anchor->windows[len], '\0', sizeof (Window) * len);
        win = &anchor->windows[len];
        anchor->windows_array_len *= 2;
    }

    char *text = NULL;
    if (pszName) {
        // !!! FIXME: text isn't necessarily a string. It's window-class-specific data.
        text = strdup(pszName);
        if (!text) {
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_HEAP_OUT_OF_MEMORY, NULLHANDLE);
        }
    }

    void *data = NULL;
    if (winclass->data_len > 0) {
        data = malloc(winclass->data_len);
        if (!data) {
            free(text);
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_HEAP_OUT_OF_MEMORY, NULLHANDLE);
        }
    }

    if (hwndParent == HWND_DESKTOP) {  // toplevel? build a heavy weight window.
        Uint32 sdlflags = SDL_WINDOW_HIDDEN | SDL_WINDOW_BORDERLESS;
        // !!! FIXME   SDL_WINDOW_SKIP_TASKBAR  = 0x00010000,      /**< window should not be added to the taskbar */
        // !!! FIXME: text isn't necessarily a string. It's window-class-specific data.
        // The Y coordinate is the bottom of the window, counted from the bottom of the parent window (desktop, in this case) :/
        SDL_Window *window = SDL_CreateWindow(text ? text : "", x, (desktop_window.h - y) - cy, cx, cy, sdlflags);
        if (!window) {
            free(text);
            free(data);
            FIXME("error code?");
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INTERNAL_ERROR_1, NULLHANDLE);
        }

        SDL_SetWindowData(window, WINDATA_WINDOWPTR_NAME, win);

        SDL_Renderer *renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_TARGETTEXTURE);
        if (!renderer) {
            free(text);
            free(data);
            SDL_DestroyWindow(window);
            FIXME("error code?");
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INTERNAL_ERROR_1, NULLHANDLE);
        }

        SDL_RendererInfo info;
        SDL_GetRendererInfo(renderer, &info);  FIXME("handle failure here");

        SDL_Texture *texture = SDL_CreateTexture(renderer, info.texture_formats[0], SDL_TEXTUREACCESS_TARGET, cx, cy);
        if (!texture) {
            free(text);
            free(data);
            SDL_DestroyRenderer(renderer);
            SDL_DestroyWindow(window);
            FIXME("error code?");
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INTERNAL_ERROR_1, NULLHANDLE);
        }

        SDL_SetRenderTarget(renderer, texture);

        win->heavy.window = window;
        win->heavy.renderer = renderer;
        win->heavy.texture = texture;
    } else {  // use same heavy as parent.
        win->heavy.window = parent->heavy.window;
        win->heavy.renderer = parent->heavy.renderer;
        win->heavy.texture = parent->heavy.texture;
    }

    win->parent = parent;
    win->children = NULL;
    win->hwnd = (HWND) (((size_t) (win - anchor->windows)) + FIRST_HWND_VALUE);
    win->window_class_name = winclass->name;  // this pointer lives until Anchor Block terminates.
    win->data = data;
    win->text = text;
    win->data_len = winclass->data_len;
    win->window_proc = winclass->window_proc;
    win->class_style = winclass->style;
    win->style = flStyle;
    win->id = id;
    win->owner = owner;
    win->sibling = NULL;  // we'll insert this later.
    win->x = win->y = win->w = win->h = 0;  // we'll set these later.

    // we're ready, send WM_CREATE. Note that pCtlData has to be a pointer (not
    //  an integer cast to a pointer), because OS/2 would dereference it, and the
    //  16 bits at the start of the data it points to tell you how many bytes are
    //  pointed at, so it could deal with 16-bit code. We don't (currently) care,
    //  so just pass it on.
    if (sendMessage(win, WM_CREATE, pCtlData, pPresParams) != FALSE) {
        // response to WM_CREATE was to cancel window creation!!
        destroyWindow(anchor, win);
        return NULLHANDLE;
    }

    FIXME("should I set swp.fl here?");
    SWP swp = { 0, cy, cx, y, x, hwndInsertBehind, win->hwnd, 0, 0 };
    MRESULT adjust = sendMessage(win, WM_ADJUSTWINDOWPOS, &swp, 0);

    (void) adjust; FIXME("adjust based on WM_ADJUSTWINDOWPOS message result");

    win->x = swp.x;
    win->y = swp.y;
    win->w = swp.cx;
    win->h = swp.cy;
    hwndInsertBehind = swp.hwndInsertBehind;

    Window *insertBehind = NULL;
    if ((hwndInsertBehind != HWND_TOP) && (hwndInsertBehind != HWND_BOTTOM)) {
        insertBehind = getWindowFromHWND(anchor, hwndInsertBehind);
        if (!insertBehind || (insertBehind->parent != parent)) {
            FIXME("should we fail or just insert at top/bottom?");
            hwndInsertBehind = HWND_BOTTOM;
            insertBehind = NULL;
        }
    }

    if (parent->children == NULL) {  // nothing to insert behind, just make it the only child.
        parent->children = win;
    } else if (hwndInsertBehind == HWND_TOP) {
        win->sibling = parent->children;
        parent->children = win;
    } else if (hwndInsertBehind == HWND_BOTTOM) {
        Window *prev = NULL;
        for (Window *i = parent->children; i != NULL; i = i->sibling) {
            prev = i;
        }
        prev->sibling = win;
    } else {  // insert behind a specific window.
        win->sibling = insertBehind->sibling;
        insertBehind->sibling = win;
    }

    if (hwndParent == HWND_DESKTOP) {
        SDL_SetWindowPosition(win->heavy.window, win->x, (parent->h - win->y) - win->h);
        SDL_SetWindowSize(win->heavy.window, win->w, win->h);
        if (win->style & WS_VISIBLE) {
            // !!! FIXME: mark window region invalid
            SDL_ShowWindow(win->heavy.window);
        }
    }

    return win->hwnd;
} // WinCreateWindow

HWND WinCreateStdWindow(HWND hwndParent, ULONG flStyle, PULONG pflCreateFlags, PSZ pszClientClass, PSZ pszTitle, ULONG styleClient, HMODULE hmod, ULONG idResources, PHWND phwndClient)
{
    TRACE_NATIVE("WinCreateStdWindow(%u, %u, %p, '%s', '%s', %u, %u, %u, %p)", (uint) hwndParent, (uint) flStyle, pflCreateFlags, pszClientClass, pszTitle, (uint) styleClient, (uint) hmod, (uint) idResources, phwndClient);

    if (phwndClient) {
        *phwndClient = NULLHANDLE;
    }

    FRAMECDATA fcd = { sizeof (FRAMECDATA), *pflCreateFlags, hmod, idResources };
    HWND retval = WinCreateWindow(hwndParent, (PSZ) WC_FRAME, pszTitle, 0, 0, 0, 0, 0, NULLHANDLE, HWND_TOP, idResources, &fcd, NULL);
    if (!retval) {
        return NULLHANDLE;
    }

    if (pszClientClass) {
        HWND clientwin = WinCreateWindow(retval, pszClientClass, NULL, 0, 0, 0, 0, 0, retval, HWND_BOTTOM, FID_CLIENT, NULL, NULL);
        if (!clientwin) {
            WinDestroyWindow(retval);
            return NULLHANDLE;
        }
        if (phwndClient) {
            *phwndClient = clientwin;
        }
    }

    return retval;
} // WinCreateStdWindow

BOOL WinDestroyWindow(HWND hwnd)
{
    TRACE_NATIVE("WinDestroyWindow(%u)", (uint) hwnd);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return FALSE;
    }

    Window *win = getWindowFromHWND(anchor, hwnd);
    if (!win) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, FALSE);
    }

    destroyWindow(anchor, win);

    return TRUE;
} // WinDestroyWindow

MRESULT WinDefWindowProc(HWND hwnd, ULONG msg, MPARAM mp1, MPARAM mp2)
{
    TRACE_NATIVE("WinDefWindowProc(%u, %u, %p, %p)", (uint) hwnd, (uint) msg, mp1, mp2);

    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return (MRESULT) 0;
    }
    Window *win = getWindowFromHWND(anchor, hwnd);
    if (!win) {
        return (MRESULT) 0;
    }

    switch (msg) {
        // this whole block just returns zero without further processing.
        case WM_ACTIVATE:
        case WM_APPTERMINATENOTIFY:
        case WM_ADJUSTWINDOWPOS:
        case WM_CALCFRAMERECT:
        case WM_COMMAND:
        case WM_CONTROL:
        case WM_CREATE:
        case WM_CTLCOLORCHANGE:
        case WM_DESTROY:
        case WM_DRAWITEM:
        case WM_ENABLE:
        case WM_ERASEBACKGROUND:
        case WM_ERROR:
        case WM_FORMATFRAME:
        case WM_HSCROLL:
        case WM_INITDLG:
        case WM_INITMENU:
        case WM_JOURNALNOTIFY:
        case WM_MATCHMNEMONIC:
        case WM_MEASUREITEM:
        case WM_MENUEND:
        case WM_MINMAXFRAME:
        case WM_MOUSEMAP:
        case WM_MOVE:
        case WM_NEXTMENU:
        case WM_NULL:
        case WM_PCONTROL:
        case WM_PRESPARAMCHANGED:
        case WM_PSETFOCUS:
        case WM_PSIZE:
        case WM_PSYSCOLORCHANGE:
        case WM_QUERYACCELTABLE:
        case WM_QUIT:
        case WM_SAVEAPPLICATION:
        case WM_SEM1:
        case WM_SEM2:
        case WM_SEM3:
        case WM_SEM4:
        case WM_SETACCELTABLE:
        case WM_SETFOCUS:
        case WM_SETHELPINFO:
        case WM_SETSELECTION:
        case WM_SETWINDOWPARAMS:
        case WM_SHOW:
        case WM_SIZE:
        case WM_SUBSTITUTESTRING:
        case WM_SYSCOLORCHANGE:
        case WM_SYSCOMMAND:
        case WM_SYSVALUECHANGED:
        case WM_TIMER:
        case WM_TRACKFRAME:
        case WM_TRANSLATEACCEL:
        //case WM_TRANSLATEMNEMONIC:  // !!! FIXME: this is in the SDK reference but not the SDK headers.
        case WM_UPDATEFRAME:
        case WM_VRNDISABLED:
        case WM_VRNENABLED:
        case WM_VSCROLL:

        // the SDK reference manual doesn't list default actions for these messages, but it's probably just "return zero".
        case WM_MSGBOXINIT:
        case WM_MSGBOXDISMISS:

            return (MRESULT) 0;

        // this whole block just returns one without further processing.
        case WM_MENUSELECT:
            return (MRESULT) 1;

        // this block sends the message to the window owner (if one exists), or otherwise returns 0.
        case WM_BEGINDRAG:
        case WM_BEGINSELECT:
        case WM_BUTTON1CLICK:
        case WM_BUTTON1DBLCLK:
        case WM_BUTTON1MOTIONSTART:
        case WM_BUTTON1MOTIONEND:
        case WM_BUTTON1UP:
        case WM_BUTTON2CLICK:
        case WM_BUTTON2DBLCLK:
        case WM_BUTTON2MOTIONSTART:
        case WM_BUTTON2MOTIONEND:
        case WM_BUTTON2UP:
        case WM_BUTTON3CLICK:
        case WM_BUTTON3DBLCLK:
        case WM_BUTTON3MOTIONSTART:
        case WM_BUTTON3MOTIONEND:
        case WM_BUTTON3UP:
        case WM_CHAR:
        case WM_CHORD:
        case WM_CONTEXTMENU:
        case WM_ENDDRAG:
        case WM_ENDSELECT:
        case WM_OPEN:
        case WM_PACTIVATE:
        case WM_QUERYCTLTYPE:
        case WM_QUERYHELPINFO:
        case WM_QUERYTRACKINFO:
        case WM_SINGLESELECT:
        case WM_TEXTEDIT:
            return win->owner ? sendMessage(win->owner, msg, mp1, mp2) : (MRESULT) 0;

        // These messages actually do something specific in default processing...
        case WM_HITTEST:
            return HT_NORMAL;

        case WM_BUTTON1DOWN:
        case WM_BUTTON2DOWN:
        case WM_BUTTON3DOWN:
        case WM_CALCVALIDRECTS:
        case WM_CLOSE:
        case WM_CONTROLPOINTER:
        case WM_FOCUSCHANGE:
        case WM_HELP:
        case WM_MOUSEMOVE:
        case WM_PAINT:
        case WM_PPAINT:
        case WM_QUERYCONVERTPOS:
        case WM_QUERYWINDOWPARAMS:
        case WM_REALIZEPALETTE:
        case WM_WINDOWPOSCHANGED:
            fprintf(stderr, "Message that doesn't something other than return 0, %u, in WinDefWindowProc!\n", (uint) msg);
            break;

        default:
            fprintf(stderr, "Unhandled message %u in WinDefWindowProc!\n", (uint) msg);
            break;
    }

    return (MRESULT) 0;
} // WinDefWindowProc

HPS WinBeginPaint(HWND hwnd, HPS hps, PRECTL prclPaint)
{
    TRACE_NATIVE("WinBeginPaint(%u, %u, %p)", (uint) hwnd, (uint) hps, prclPaint);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return NULLHANDLE;
    }
    Window *win = getWindowFromHWND(anchor, hwnd);
    if (!win) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, NULLHANDLE);
    }

    PresentationSpace *ps = NULL;
    if (hps != NULLHANDLE) {
        ps = getPresentationSpaceFromHPS(anchor, hps);
        if (!ps) {
            SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INV_HPS, NULLHANDLE);
        }
        FIXME("check if this is already assigned to this drawable");
    } else {
        // make space for the new presentation struct in the anchor block
        FIXME("optimize this");
        FIXME("cut-and-paste from WinCreateWindow");
        for (size_t i = 0; i < anchor->pres_spaces_array_len; i++) {
            if (anchor->pres_spaces[i].hps == NULLHANDLE) {
                ps = &anchor->pres_spaces[i];
                break;
            }
        }

        if (!ps) {
            const size_t len = anchor->pres_spaces_array_len;
            void *ptr = realloc(anchor->pres_spaces, sizeof (PresentationSpace) * len * 2);
            if (!ptr) {
                SET_WIN_ERROR_AND_RETURN(anchor, PMERR_HEAP_OUT_OF_MEMORY, NULLHANDLE);
            }
            anchor->pres_spaces = (PresentationSpace *) ptr;
            memset(&anchor->pres_spaces[len], '\0', sizeof (PresentationSpace) * len);
            ps = &anchor->pres_spaces[len];
            anchor->pres_spaces_array_len *= 2;
        }
        hps = (HPS) (((size_t) (ps - anchor->pres_spaces)) + FIRST_HPS_VALUE);
    }

    ps->hps = hps;
    ps->window = win;

    if (prclPaint) {
        FIXME("report the update region, not the whole window");
        prclPaint->xLeft = 0;
        prclPaint->yBottom = 0;
        prclPaint->xRight = win->w;
        prclPaint->yTop = win->h;
    }

    return hps;
} // WinBeginPaint

BOOL WinEndPaint(HPS hps)
{
    TRACE_NATIVE("WinEndPaint(%u)", (uint) hps);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return NULLHANDLE;
    }
    PresentationSpace *ps = getPresentationSpaceFromHPS(anchor, hps);
    if (!ps) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INV_HPS, NULLHANDLE);
    }

    Window *win = ps->window;
    SDL_Renderer *renderer = win->heavy.renderer;
    SDL_Texture *texture = win->heavy.texture;
    assert(SDL_GetRenderTarget(renderer) == texture);
    SDL_SetRenderTarget(renderer, NULL);
    SDL_RenderCopy(renderer, texture, NULL, NULL);
    SDL_RenderPresent(renderer);
    SDL_SetRenderTarget(renderer, texture);

    destroyPresentationSpace(anchor, ps);
    return TRUE;
} // WinEndPaint

static void os2ColorIndexToRGB(const LONG os2color, Uint8 *r, Uint8 *g, Uint8 *b)
{
    assert(r != NULL); assert(g != NULL); assert(b != NULL);
    #define RETURNRGB(rr,gg,bb) { *r = rr; *g = gg; *b = bb; return; }
    switch (os2color) {
        case CLR_FALSE: FIXME("this should reverse on a printer"); RETURNRGB(0x00, 0x00, 0x00);
        case CLR_TRUE: FIXME("this should reverse on a printer"); RETURNRGB(0xFF, 0xFF, 0xFF);
        case CLR_DEFAULT: FIXME("Let users specify this on command line or system-wide .ini?"); RETURNRGB(0x00, 0x00, 0x00);
        case CLR_WHITE: RETURNRGB(0xFF, 0xFF, 0xFF);
        case CLR_BLACK: RETURNRGB(0x00, 0x00, 0x00);
        case CLR_BACKGROUND: FIXME("Let users specify this on command line or system-wide .ini?"); RETURNRGB(0xFF, 0xFF, 0xFF);
        case CLR_BLUE: RETURNRGB(0x00, 0x00, 0xFF);
        case CLR_RED: RETURNRGB(0xFF, 0x00, 0x00);
        case CLR_PINK: RETURNRGB(0xFF, 0x00, 0xFF);
        case CLR_GREEN: RETURNRGB(0x00, 0xFF, 0x00);
        case CLR_CYAN: RETURNRGB(0x00, 0xFF, 0xFF);
        case CLR_YELLOW: RETURNRGB(0xFF, 0xFF, 0x00);
        case CLR_NEUTRAL: FIXME("Let users specify this on command line or system-wide .ini?"); RETURNRGB(0x00, 0x00, 0x00);
        case CLR_DARKGRAY: RETURNRGB(0x80, 0x80, 0x80);
        case CLR_DARKBLUE: RETURNRGB(0x00, 0x00, 0x80);
        case CLR_DARKRED: RETURNRGB(0x80, 0x00, 0x00);
        case CLR_DARKPINK: RETURNRGB(0x80, 0x00, 0x80);
        case CLR_DARKGREEN: RETURNRGB(0x00, 0x80, 0x00);
        case CLR_DARKCYAN: RETURNRGB(0x00, 0x80, 0x80);
        case CLR_BROWN: RETURNRGB(0x80, 0x80, 0x00);
        case CLR_PALEGRAY: RETURNRGB(0xCC, 0xCC, 0xCC);
        default: break;
    }

    FIXME("unknown color index");
    RETURNRGB(0x00, 0x00, 0x00);
    #undef RETURNRGB
} // os2ColorIndexToRGB

static void calcHeavyweightRect(const Window *win, SDL_Rect* rect)
{
    int x = 0, y = 0;

    rect->w = win->w;
    rect->h = win->h;

    while (win->parent != &desktop_window) {
        x += win->x;
        y += win->y;
        win = win->parent;
    }

    rect->x = x;
    rect->y = (win->h - y) - rect->h;
} // calcHeavyweightRect

BOOL WinFillRect(HPS hps, PRECTL prcl, LONG lColor)
{
    TRACE_NATIVE("WinFillRect(%u, %p, %d)", (uint) hps, prcl, (int) lColor);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        return NULLHANDLE;
    }
    PresentationSpace *ps = getPresentationSpaceFromHPS(anchor, hps);
    if (!ps) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INV_HPS, NULLHANDLE);
    }
    Window *win = ps->window;
    SDL_Renderer *renderer = win->heavy.renderer;
    assert(SDL_GetRenderTarget(renderer) == win->heavy.texture);

    SDL_Rect cliprect;
    calcHeavyweightRect(win, &cliprect);

    SDL_Rect rect;
    rect.x = cliprect.x + prcl->xLeft;
    rect.y = cliprect.y + (cliprect.h - prcl->yTop);
    rect.w = prcl->xRight - prcl->xLeft;
    rect.h = prcl->yTop - prcl->yBottom;

    Uint8 r, g, b;
    os2ColorIndexToRGB(lColor, &r, &g, &b);

    //printf("fill { x=%d, y=%d, w=%d, h=%d, r=0x%X, g=0x%X, b=0x%X }\n", (int) rect.x, (int) rect.y, (int) rect.w, (int) rect.h, (uint) r, (uint) g, (uint) b);
    SDL_RenderSetClipRect(renderer, &cliprect);
    SDL_SetRenderDrawColor(renderer, r, g, b, 0xFF);
    SDL_RenderFillRect(renderer, &rect);
    SDL_RenderSetClipRect(renderer, NULL);
    return TRUE;
} // WinFillRect

BOOL WinIsWindow(HAB hab, HWND hwnd)
{
    TRACE_NATIVE("WinIsWindow(%u, %u)", (uint) hab, (uint) hwnd);
    FIXME("this 'get the anchor, get the window, set errors' code is repeated a lot");
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, FALSE);
    }

    Window *win = getWindowFromHWND(anchor, hwnd);
    if (!win) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, FALSE);
    }

    return TRUE;
} // WinIsWindow

BOOL WinIsWindowEnabled(HWND hwnd)
{
    TRACE_NATIVE("WinIsWindowEnabled(%u)", (uint) hwnd);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, FALSE);
    }

    Window *win = getWindowFromHWND(anchor, hwnd);
    if (!win) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, FALSE);
    }

    return win->enabled;
} // WinIsWindowEnabled

BOOL WinIsWindowVisible(HWND hwnd)
{
    TRACE_NATIVE("WinIsWindowVisible(%u)", (uint) hwnd);
    AnchorBlock *anchor = getAnchorBlockNoHAB();
    if (!anchor) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, FALSE);
    }

    Window *win = getWindowFromHWND(anchor, hwnd);
    if (!win) {
        SET_WIN_ERROR_AND_RETURN(anchor, PMERR_INVALID_HWND, FALSE);
    }

    return ((win->style & WS_VISIBLE) == WS_VISIBLE) ? TRUE : FALSE;
} // WinIsWindowVisible


// end of pmwin.c ...