Merge tag 'tags/0.78'HEADmaster

1 files changed, 2658 insertions, 0 deletions

diff --git a/windows/controls.c b/windows/controls.c
new file mode 100644
index 00000000..ce3638e4
--- /dev/null
+++ b/windows/controls.c
@@ -0,0 +1,2658 @@
+/*
+ * controls.c: routines to self-manage the controls in a dialog
+ * box.
+ */
+
+/*
+ * Possible TODO in new cross-platform config box stuff:
+ *
+ *  - When lining up two controls alongside each other, I wonder if
+ *    we could conveniently arrange to centre them vertically?
+ *    Particularly ugly in the current setup is the `Add new
+ *    forwarded port:' static next to the rather taller `Remove'
+ *    button.
+ */
+
+#include <assert.h>
+#include <ctype.h>
+
+#include "putty.h"
+#include "misc.h"
+#include "dialog.h"
+
+#include <commctrl.h>
+
+#define GAPBETWEEN 3
+#define GAPWITHIN 1
+#define GAPXBOX 7
+#define GAPYBOX 4
+#define DLGWIDTH 168
+#define STATICHEIGHT 8
+#define TITLEHEIGHT 12
+#define CHECKBOXHEIGHT 8
+#define RADIOHEIGHT 8
+#define EDITHEIGHT 12
+#define LISTHEIGHT 11
+#define LISTINCREMENT 8
+#define COMBOHEIGHT 12
+#define PUSHBTNHEIGHT 14
+#define PROGBARHEIGHT 14
+
+DECL_WINDOWS_FUNCTION(static, void, InitCommonControls, (void));
+DECL_WINDOWS_FUNCTION(static, BOOL, MakeDragList, (HWND));
+DECL_WINDOWS_FUNCTION(static, int, LBItemFromPt, (HWND, POINT, BOOL));
+DECL_WINDOWS_FUNCTION(static, void, DrawInsert, (HWND, HWND, int));
+
+void init_common_controls(void)
+{
+    HMODULE comctl32_module = load_system32_dll("comctl32.dll");
+    GET_WINDOWS_FUNCTION(comctl32_module, InitCommonControls);
+    GET_WINDOWS_FUNCTION(comctl32_module, MakeDragList);
+    GET_WINDOWS_FUNCTION(comctl32_module, LBItemFromPt);
+    GET_WINDOWS_FUNCTION(comctl32_module, DrawInsert);
+    p_InitCommonControls();
+}
+
+void ctlposinit(struct ctlpos *cp, HWND hwnd,
+                int leftborder, int rightborder, int topborder)
+{
+    RECT r, r2;
+    cp->hwnd = hwnd;
+    cp->font = SendMessage(hwnd, WM_GETFONT, 0, 0);
+    cp->ypos = topborder;
+    GetClientRect(hwnd, &r);
+    r2.left = r2.top = 0;
+    r2.right = 4;
+    r2.bottom = 8;
+    MapDialogRect(hwnd, &r2);
+    cp->dlu4inpix = r2.right;
+    cp->width = (r.right * 4) / (r2.right) - 2 * GAPBETWEEN;
+    cp->xoff = leftborder;
+    cp->width -= leftborder + rightborder;
+}
+
+HWND doctl(struct ctlpos *cp, RECT r, const char *wclass, int wstyle,
+           int exstyle, const char *wtext, int wid)
+{
+    HWND ctl;
+    /*
+     * Note nonstandard use of RECT. This is deliberate: by
+     * transforming the width and height directly we arrange to
+     * have all supposedly same-sized controls really same-sized.
+     */
+
+    r.left += cp->xoff;
+    MapDialogRect(cp->hwnd, &r);
+
+    /*
+     * We can pass in cp->hwnd == NULL, to indicate a dry run
+     * without creating any actual controls.
+     */
+    if (cp->hwnd) {
+        ctl = CreateWindowEx(exstyle, wclass, wtext, wstyle,
+                             r.left, r.top, r.right, r.bottom,
+                             cp->hwnd, (HMENU)(ULONG_PTR)wid, hinst, NULL);
+        SendMessage(ctl, WM_SETFONT, cp->font, MAKELPARAM(true, 0));
+
+        if (!strcmp(wclass, "LISTBOX")) {
+            /*
+             * Bizarre Windows bug: the list box calculates its
+             * number of lines based on the font it has at creation
+             * time, but sending it WM_SETFONT doesn't cause it to
+             * recalculate. So now, _after_ we've sent it
+             * WM_SETFONT, we explicitly resize it (to the same
+             * size it was already!) to force it to reconsider.
+             */
+            SetWindowPos(ctl, NULL, 0, 0, r.right, r.bottom,
+                         SWP_NOACTIVATE | SWP_NOCOPYBITS |
+                         SWP_NOMOVE | SWP_NOZORDER);
+        }
+    } else
+        ctl = NULL;
+    return ctl;
+}
+
+/*
+ * A title bar across the top of a sub-dialog.
+ */
+void bartitle(struct ctlpos *cp, const char *name, int id)
+{
+    RECT r;
+
+    r.left = GAPBETWEEN;
+    r.right = cp->width;
+    r.top = cp->ypos;
+    r.bottom = STATICHEIGHT;
+    cp->ypos += r.bottom + GAPBETWEEN;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, name, id);
+}
+
+/*
+ * Begin a grouping box, with or without a group title.
+ */
+void beginbox(struct ctlpos *cp, const char *name, int idbox)
+{
+    cp->boxystart = cp->ypos;
+    if (!name)
+        cp->boxystart -= STATICHEIGHT / 2;
+    if (name)
+        cp->ypos += STATICHEIGHT;
+    cp->ypos += GAPYBOX;
+    cp->width -= 2 * GAPXBOX;
+    cp->xoff += GAPXBOX;
+    cp->boxid = idbox;
+    cp->boxtext = name;
+}
+
+/*
+ * End a grouping box.
+ */
+void endbox(struct ctlpos *cp)
+{
+    RECT r;
+    cp->xoff -= GAPXBOX;
+    cp->width += 2 * GAPXBOX;
+    cp->ypos += GAPYBOX - GAPBETWEEN;
+    r.left = GAPBETWEEN;
+    r.right = cp->width;
+    r.top = cp->boxystart;
+    r.bottom = cp->ypos - cp->boxystart;
+    doctl(cp, r, "BUTTON", BS_GROUPBOX | WS_CHILD | WS_VISIBLE, 0,
+          cp->boxtext ? cp->boxtext : "", cp->boxid);
+    cp->ypos += GAPYBOX;
+}
+
+/*
+ * A static line, followed by a full-width edit box.
+ */
+void editboxfw(struct ctlpos *cp, bool password, bool readonly,
+               const char *text, int staticid, int editid)
+{
+    RECT r;
+
+    r.left = GAPBETWEEN;
+    r.right = cp->width;
+
+    if (text) {
+        r.top = cp->ypos;
+        r.bottom = STATICHEIGHT;
+        doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, text, staticid);
+        cp->ypos += STATICHEIGHT + GAPWITHIN;
+    }
+    r.top = cp->ypos;
+    r.bottom = EDITHEIGHT;
+    doctl(cp, r, "EDIT",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL |
+          (password ? ES_PASSWORD : 0) |
+          (readonly ? ES_READONLY : 0),
+          WS_EX_CLIENTEDGE, "", editid);
+    cp->ypos += EDITHEIGHT + GAPBETWEEN;
+}
+
+/*
+ * A static line, followed by a full-width combo box.
+ */
+void combobox(struct ctlpos *cp, const char *text, int staticid, int listid)
+{
+    RECT r;
+
+    r.left = GAPBETWEEN;
+    r.right = cp->width;
+
+    if (text) {
+        r.top = cp->ypos;
+        r.bottom = STATICHEIGHT;
+        doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, text, staticid);
+        cp->ypos += STATICHEIGHT + GAPWITHIN;
+    }
+    r.top = cp->ypos;
+    r.bottom = COMBOHEIGHT * 10;
+    doctl(cp, r, "COMBOBOX",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL |
+          CBS_DROPDOWN | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", listid);
+    cp->ypos += COMBOHEIGHT + GAPBETWEEN;
+}
+
+struct radio { const char *text; int id; };
+
+static void radioline_common(struct ctlpos *cp, const char *text, int id,
+                             int nacross, struct radio *buttons, int nbuttons)
+{
+    RECT r;
+    int group;
+    int i;
+    int j;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    if (text) {
+        r.right = cp->width;
+        r.bottom = STATICHEIGHT;
+        cp->ypos += r.bottom + GAPWITHIN;
+        doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, text, id);
+    } else {
+        r.right = r.bottom = 0;
+    }
+
+    group = WS_GROUP;
+    i = 0;
+    for (j = 0; j < nbuttons; j++) {
+        const char *btext = buttons[j].text;
+        int bid = buttons[j].id;
+
+        if (i == nacross) {
+            cp->ypos += r.bottom + (nacross > 1 ? GAPBETWEEN : GAPWITHIN);
+            i = 0;
+        }
+        r.left = GAPBETWEEN + i * (cp->width + GAPBETWEEN) / nacross;
+        if (j < nbuttons-1)
+            r.right =
+                (i + 1) * (cp->width + GAPBETWEEN) / nacross - r.left;
+        else
+            r.right = cp->width - r.left;
+        r.top = cp->ypos;
+        r.bottom = RADIOHEIGHT;
+        doctl(cp, r, "BUTTON",
+              BS_NOTIFY | BS_AUTORADIOBUTTON | WS_CHILD |
+              WS_VISIBLE | WS_TABSTOP | group, 0, btext, bid);
+        group = 0;
+        i++;
+    }
+    cp->ypos += r.bottom + GAPBETWEEN;
+}
+
+/*
+ * A set of radio buttons on the same line, with a static above
+ * them. `nacross' dictates how many parts the line is divided into
+ * (you might want this not to equal the number of buttons if you
+ * needed to line up some 2s and some 3s to look good in the same
+ * panel).
+ *
+ * There's a bit of a hack in here to ensure that if nacross
+ * exceeds the actual number of buttons, the rightmost button
+ * really does get all the space right to the edge of the line, so
+ * you can do things like
+ *
+ * (*) Button1  (*) Button2  (*) ButtonWithReallyLongTitle
+ */
+void radioline(struct ctlpos *cp, const char *text, int id, int nacross, ...)
+{
+    va_list ap;
+    struct radio *buttons;
+    int i, nbuttons;
+
+    va_start(ap, nacross);
+    nbuttons = 0;
+    while (1) {
+        const char *btext = va_arg(ap, const char *);
+        if (!btext)
+            break;
+        (void) va_arg(ap, int); /* id */
+        nbuttons++;
+    }
+    va_end(ap);
+    buttons = snewn(nbuttons, struct radio);
+    va_start(ap, nacross);
+    for (i = 0; i < nbuttons; i++) {
+        buttons[i].text = va_arg(ap, const char *);
+        buttons[i].id = va_arg(ap, int);
+    }
+    va_end(ap);
+    radioline_common(cp, text, id, nacross, buttons, nbuttons);
+    sfree(buttons);
+}
+
+/*
+ * A set of radio buttons on the same line, without a static above
+ * them. Otherwise just like radioline.
+ */
+void bareradioline(struct ctlpos *cp, int nacross, ...)
+{
+    va_list ap;
+    struct radio *buttons;
+    int i, nbuttons;
+
+    va_start(ap, nacross);
+    nbuttons = 0;
+    while (1) {
+        const char *btext = va_arg(ap, const char *);
+        if (!btext)
+            break;
+        (void) va_arg(ap, int); /* id */
+        nbuttons++;
+    }
+    va_end(ap);
+    buttons = snewn(nbuttons, struct radio);
+    va_start(ap, nacross);
+    for (i = 0; i < nbuttons; i++) {
+        buttons[i].text = va_arg(ap, const char *);
+        buttons[i].id = va_arg(ap, int);
+    }
+    va_end(ap);
+    radioline_common(cp, NULL, 0, nacross, buttons, nbuttons);
+    sfree(buttons);
+}
+
+/*
+ * A set of radio buttons on multiple lines, with a static above
+ * them.
+ */
+void radiobig(struct ctlpos *cp, const char *text, int id, ...)
+{
+    va_list ap;
+    struct radio *buttons;
+    int i, nbuttons;
+
+    va_start(ap, id);
+    nbuttons = 0;
+    while (1) {
+        const char *btext = va_arg(ap, const char *);
+        if (!btext)
+            break;
+        (void) va_arg(ap, int); /* id */
+        nbuttons++;
+    }
+    va_end(ap);
+    buttons = snewn(nbuttons, struct radio);
+    va_start(ap, id);
+    for (i = 0; i < nbuttons; i++) {
+        buttons[i].text = va_arg(ap, const char *);
+        buttons[i].id = va_arg(ap, int);
+    }
+    va_end(ap);
+    radioline_common(cp, text, id, 1, buttons, nbuttons);
+    sfree(buttons);
+}
+
+/*
+ * A single standalone checkbox.
+ */
+void checkbox(struct ctlpos *cp, const char *text, int id)
+{
+    RECT r;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = CHECKBOXHEIGHT;
+    cp->ypos += r.bottom + GAPBETWEEN;
+    doctl(cp, r, "BUTTON",
+          BS_NOTIFY | BS_AUTOCHECKBOX | WS_CHILD | WS_VISIBLE | WS_TABSTOP, 0,
+          text, id);
+}
+
+/*
+ * Wrap a piece of text for a static text control. Returns the
+ * wrapped text (a malloc'ed string containing \ns), and also
+ * returns the number of lines required.
+ */
+char *staticwrap(struct ctlpos *cp, HWND hwnd, const char *text, int *lines)
+{
+    HDC hdc = GetDC(hwnd);
+    int width, nlines, j;
+    INT *pwidths, nfit;
+    SIZE size;
+    const char *p;
+    char *ret, *q;
+    RECT r;
+    HFONT oldfont, newfont;
+
+    ret = snewn(1+strlen(text), char);
+    p = text;
+    q = ret;
+    pwidths = snewn(1+strlen(text), INT);
+
+    /*
+     * Work out the width the text will need to fit in, by doing
+     * the same adjustment that the `statictext' function itself
+     * will perform.
+     */
+    SetMapMode(hdc, MM_TEXT);          /* ensure logical units == pixels */
+    r.left = r.top = r.bottom = 0;
+    r.right = cp->width;
+    MapDialogRect(hwnd, &r);
+    width = r.right;
+
+    nlines = 1;
+
+    /*
+     * We must select the correct font into the HDC before calling
+     * GetTextExtent*, or silly things will happen.
+     */
+    newfont = (HFONT)SendMessage(hwnd, WM_GETFONT, 0, 0);
+    oldfont = SelectObject(hdc, newfont);
+
+    while (*p) {
+        if (!GetTextExtentExPoint(hdc, p, strlen(p), width,
+                                  &nfit, pwidths, &size) ||
+            (size_t)nfit >= strlen(p)) {
+            /*
+             * Either GetTextExtentExPoint returned failure, or the
+             * whole of the rest of the text fits on this line.
+             * Either way, we stop wrapping, copy the remainder of
+             * the input string unchanged to the output, and leave.
+             */
+            strcpy(q, p);
+            break;
+        }
+
+        /*
+         * Now we search backwards along the string from `nfit',
+         * looking for a space at which to break the line. If we
+         * don't find one at all, that's fine - we'll just break
+         * the line at `nfit'.
+         */
+        for (j = nfit; j > 0; j--) {
+            if (isspace((unsigned char)p[j])) {
+                nfit = j;
+                break;
+            }
+        }
+
+        strncpy(q, p, nfit);
+        q[nfit] = '\n';
+        q += nfit+1;
+
+        p += nfit;
+        while (*p && isspace((unsigned char)*p))
+            p++;
+
+        nlines++;
+    }
+
+    SelectObject(hdc, oldfont);
+    ReleaseDC(cp->hwnd, hdc);
+
+    if (lines) *lines = nlines;
+
+    sfree(pwidths);
+
+    return ret;
+}
+
+/*
+ * A single standalone static text control.
+ */
+void statictext(struct ctlpos *cp, const char *text, int lines, int id)
+{
+    RECT r;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = STATICHEIGHT * lines;
+    cp->ypos += r.bottom + GAPBETWEEN;
+    doctl(cp, r, "STATIC",
+          WS_CHILD | WS_VISIBLE | SS_LEFTNOWORDWRAP,
+          0, text, id);
+}
+
+/*
+ * An owner-drawn static text control for a panel title.
+ */
+void paneltitle(struct ctlpos *cp, int id)
+{
+    RECT r;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = TITLEHEIGHT;
+    cp->ypos += r.bottom + GAPBETWEEN;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE | SS_OWNERDRAW,
+          0, NULL, id);
+}
+
+/*
+ * A button on the right hand side, with a static to its left.
+ */
+void staticbtn(struct ctlpos *cp, const char *stext, int sid,
+               const char *btext, int bid)
+{
+    const int height = (PUSHBTNHEIGHT > STATICHEIGHT ?
+                        PUSHBTNHEIGHT : STATICHEIGHT);
+    RECT r;
+    int lwid, rwid, rpos;
+
+    rpos = GAPBETWEEN + 3 * (cp->width + GAPBETWEEN) / 4;
+    lwid = rpos - 2 * GAPBETWEEN;
+    rwid = cp->width + GAPBETWEEN - rpos;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos + (height - STATICHEIGHT) / 2;
+    r.right = lwid;
+    r.bottom = STATICHEIGHT;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+
+    r.left = rpos;
+    r.top = cp->ypos + (height - PUSHBTNHEIGHT) / 2;
+    r.right = rwid;
+    r.bottom = PUSHBTNHEIGHT;
+    doctl(cp, r, "BUTTON",
+          BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+          0, btext, bid);
+
+    cp->ypos += height + GAPBETWEEN;
+}
+
+/*
+ * A simple push button.
+ */
+void button(struct ctlpos *cp, const char *btext, int bid, bool defbtn)
+{
+    RECT r;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = PUSHBTNHEIGHT;
+
+    /* Q67655: the _dialog box_ must know which button is default
+     * as well as the button itself knowing */
+    if (defbtn && cp->hwnd)
+        SendMessage(cp->hwnd, DM_SETDEFID, bid, 0);
+
+    doctl(cp, r, "BUTTON",
+          BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP |
+          (defbtn ? BS_DEFPUSHBUTTON : 0) | BS_PUSHBUTTON,
+          0, btext, bid);
+
+    cp->ypos += PUSHBTNHEIGHT + GAPBETWEEN;
+}
+
+/*
+ * Like staticbtn, but two buttons.
+ */
+void static2btn(struct ctlpos *cp, const char *stext, int sid,
+                const char *btext1, int bid1, const char *btext2, int bid2)
+{
+    const int height = (PUSHBTNHEIGHT > STATICHEIGHT ?
+                        PUSHBTNHEIGHT : STATICHEIGHT);
+    RECT r;
+    int lwid, rwid1, rwid2, rpos1, rpos2;
+
+    rpos1 = GAPBETWEEN + (cp->width + GAPBETWEEN) / 2;
+    rpos2 = GAPBETWEEN + 3 * (cp->width + GAPBETWEEN) / 4;
+    lwid = rpos1 - 2 * GAPBETWEEN;
+    rwid1 = rpos2 - rpos1 - GAPBETWEEN;
+    rwid2 = cp->width + GAPBETWEEN - rpos2;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos + (height - STATICHEIGHT) / 2;
+    r.right = lwid;
+    r.bottom = STATICHEIGHT;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+
+    r.left = rpos1;
+    r.top = cp->ypos + (height - PUSHBTNHEIGHT) / 2;
+    r.right = rwid1;
+    r.bottom = PUSHBTNHEIGHT;
+    doctl(cp, r, "BUTTON",
+          BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+          0, btext1, bid1);
+
+    r.left = rpos2;
+    r.top = cp->ypos + (height - PUSHBTNHEIGHT) / 2;
+    r.right = rwid2;
+    r.bottom = PUSHBTNHEIGHT;
+    doctl(cp, r, "BUTTON",
+          BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+          0, btext2, bid2);
+
+    cp->ypos += height + GAPBETWEEN;
+}
+
+/*
+ * An edit control on the right hand side, with a static to its left.
+ */
+static void staticedit_internal(struct ctlpos *cp, const char *stext,
+                                int sid, int eid, int percentedit,
+                                int style)
+{
+    const int height = (EDITHEIGHT > STATICHEIGHT ?
+                        EDITHEIGHT : STATICHEIGHT);
+    RECT r;
+    int lwid, rwid, rpos;
+
+    rpos =
+        GAPBETWEEN + (100 - percentedit) * (cp->width + GAPBETWEEN) / 100;
+    lwid = rpos - 2 * GAPBETWEEN;
+    rwid = cp->width + GAPBETWEEN - rpos;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos + (height - STATICHEIGHT) / 2;
+    r.right = lwid;
+    r.bottom = STATICHEIGHT;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+
+    r.left = rpos;
+    r.top = cp->ypos + (height - EDITHEIGHT) / 2;
+    r.right = rwid;
+    r.bottom = EDITHEIGHT;
+    doctl(cp, r, "EDIT",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL | style,
+          WS_EX_CLIENTEDGE, "", eid);
+
+    cp->ypos += height + GAPBETWEEN;
+}
+
+void staticedit(struct ctlpos *cp, const char *stext,
+                int sid, int eid, int percentedit)
+{
+    staticedit_internal(cp, stext, sid, eid, percentedit, 0);
+}
+
+void staticpassedit(struct ctlpos *cp, const char *stext,
+                    int sid, int eid, int percentedit)
+{
+    staticedit_internal(cp, stext, sid, eid, percentedit, ES_PASSWORD);
+}
+
+/*
+ * A drop-down list box on the right hand side, with a static to
+ * its left.
+ */
+void staticddl(struct ctlpos *cp, const char *stext,
+               int sid, int lid, int percentlist)
+{
+    const int height = (COMBOHEIGHT > STATICHEIGHT ?
+                        COMBOHEIGHT : STATICHEIGHT);
+    RECT r;
+    int lwid, rwid, rpos;
+
+    rpos =
+        GAPBETWEEN + (100 - percentlist) * (cp->width + GAPBETWEEN) / 100;
+    lwid = rpos - 2 * GAPBETWEEN;
+    rwid = cp->width + GAPBETWEEN - rpos;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos + (height - STATICHEIGHT) / 2;
+    r.right = lwid;
+    r.bottom = STATICHEIGHT;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+
+    r.left = rpos;
+    r.top = cp->ypos + (height - EDITHEIGHT) / 2;
+    r.right = rwid;
+    r.bottom = COMBOHEIGHT*4;
+    doctl(cp, r, "COMBOBOX",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL |
+          CBS_DROPDOWNLIST | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", lid);
+
+    cp->ypos += height + GAPBETWEEN;
+}
+
+/*
+ * A combo box on the right hand side, with a static to its left.
+ */
+void staticcombo(struct ctlpos *cp, const char *stext,
+                 int sid, int lid, int percentlist)
+{
+    const int height = (COMBOHEIGHT > STATICHEIGHT ?
+                        COMBOHEIGHT : STATICHEIGHT);
+    RECT r;
+    int lwid, rwid, rpos;
+
+    rpos =
+        GAPBETWEEN + (100 - percentlist) * (cp->width + GAPBETWEEN) / 100;
+    lwid = rpos - 2 * GAPBETWEEN;
+    rwid = cp->width + GAPBETWEEN - rpos;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos + (height - STATICHEIGHT) / 2;
+    r.right = lwid;
+    r.bottom = STATICHEIGHT;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+
+    r.left = rpos;
+    r.top = cp->ypos + (height - EDITHEIGHT) / 2;
+    r.right = rwid;
+    r.bottom = COMBOHEIGHT*10;
+    doctl(cp, r, "COMBOBOX",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL |
+          CBS_DROPDOWN | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", lid);
+
+    cp->ypos += height + GAPBETWEEN;
+}
+
+/*
+ * A static, with a full-width drop-down list box below it.
+ */
+void staticddlbig(struct ctlpos *cp, const char *stext,
+                  int sid, int lid)
+{
+    RECT r;
+
+    if (stext) {
+        r.left = GAPBETWEEN;
+        r.top = cp->ypos;
+        r.right = cp->width;
+        r.bottom = STATICHEIGHT;
+        doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+        cp->ypos += STATICHEIGHT;
+    }
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = COMBOHEIGHT*4;
+    doctl(cp, r, "COMBOBOX",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL |
+          CBS_DROPDOWNLIST | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", lid);
+    cp->ypos += COMBOHEIGHT + GAPBETWEEN;
+}
+
+/*
+ * A big multiline edit control with a static labelling it.
+ */
+void bigeditctrl(struct ctlpos *cp, const char *stext,
+                 int sid, int eid, int lines)
+{
+    RECT r;
+
+    if (stext) {
+        r.left = GAPBETWEEN;
+        r.top = cp->ypos;
+        r.right = cp->width;
+        r.bottom = STATICHEIGHT;
+        cp->ypos += r.bottom + GAPWITHIN;
+        doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+    }
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = EDITHEIGHT + (lines - 1) * STATICHEIGHT;
+    cp->ypos += r.bottom + GAPBETWEEN;
+    doctl(cp, r, "EDIT",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL | ES_MULTILINE,
+          WS_EX_CLIENTEDGE, "", eid);
+}
+
+/*
+ * A list box with a static labelling it.
+ */
+void listbox(struct ctlpos *cp, const char *stext,
+             int sid, int lid, int lines, bool multi)
+{
+    RECT r;
+
+    if (stext != NULL) {
+        r.left = GAPBETWEEN;
+        r.top = cp->ypos;
+        r.right = cp->width;
+        r.bottom = STATICHEIGHT;
+        cp->ypos += r.bottom + GAPWITHIN;
+        doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+    }
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = LISTHEIGHT + (lines - 1) * LISTINCREMENT;
+    cp->ypos += r.bottom + GAPBETWEEN;
+    doctl(cp, r, "LISTBOX",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | WS_VSCROLL |
+          LBS_NOTIFY | LBS_HASSTRINGS | LBS_USETABSTOPS |
+          (multi ? LBS_MULTIPLESEL : 0),
+          WS_EX_CLIENTEDGE, "", lid);
+}
+
+/*
+ * A tab-control substitute when a real tab control is unavailable.
+ */
+void ersatztab(struct ctlpos *cp, const char *stext, int sid, int lid,
+               int s2id)
+{
+    const int height = (COMBOHEIGHT > STATICHEIGHT ?
+                        COMBOHEIGHT : STATICHEIGHT);
+    RECT r;
+    int bigwid, lwid, rwid, rpos;
+    static const int BIGGAP = 15;
+    static const int MEDGAP = 3;
+
+    bigwid = cp->width + 2 * GAPBETWEEN - 2 * BIGGAP;
+    cp->ypos += MEDGAP;
+    rpos = BIGGAP + (bigwid + BIGGAP) / 2;
+    lwid = rpos - 2 * BIGGAP;
+    rwid = bigwid + BIGGAP - rpos;
+
+    r.left = BIGGAP;
+    r.top = cp->ypos + (height - STATICHEIGHT) / 2;
+    r.right = lwid;
+    r.bottom = STATICHEIGHT;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+
+    r.left = rpos;
+    r.top = cp->ypos + (height - COMBOHEIGHT) / 2;
+    r.right = rwid;
+    r.bottom = COMBOHEIGHT * 10;
+    doctl(cp, r, "COMBOBOX",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP |
+          CBS_DROPDOWNLIST | CBS_HASSTRINGS, WS_EX_CLIENTEDGE, "", lid);
+
+    cp->ypos += height + MEDGAP + GAPBETWEEN;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = 2;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE | SS_ETCHEDHORZ,
+          0, "", s2id);
+}
+
+/*
+ * A static line, followed by an edit control on the left hand side
+ * and a button on the right.
+ */
+void editbutton(struct ctlpos *cp, const char *stext, int sid,
+                int eid, const char *btext, int bid)
+{
+    const int height = (EDITHEIGHT > PUSHBTNHEIGHT ?
+                        EDITHEIGHT : PUSHBTNHEIGHT);
+    RECT r;
+    int lwid, rwid, rpos;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = STATICHEIGHT;
+    cp->ypos += r.bottom + GAPWITHIN;
+    doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+
+    rpos = GAPBETWEEN + 3 * (cp->width + GAPBETWEEN) / 4;
+    lwid = rpos - 2 * GAPBETWEEN;
+    rwid = cp->width + GAPBETWEEN - rpos;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos + (height - EDITHEIGHT) / 2;
+    r.right = lwid;
+    r.bottom = EDITHEIGHT;
+    doctl(cp, r, "EDIT",
+          WS_CHILD | WS_VISIBLE | WS_TABSTOP | ES_AUTOHSCROLL,
+          WS_EX_CLIENTEDGE, "", eid);
+
+    r.left = rpos;
+    r.top = cp->ypos + (height - PUSHBTNHEIGHT) / 2;
+    r.right = rwid;
+    r.bottom = PUSHBTNHEIGHT;
+    doctl(cp, r, "BUTTON",
+          BS_NOTIFY | WS_CHILD | WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON,
+          0, btext, bid);
+
+    cp->ypos += height + GAPBETWEEN;
+}
+
+/*
+ * A special control for manipulating an ordered preference list
+ * (eg. for cipher selection).
+ * XXX: this is a rough hack and could be improved.
+ */
+void prefslist(struct prefslist *hdl, struct ctlpos *cp, int lines,
+               const char *stext, int sid, int listid, int upbid, int dnbid)
+{
+    const static int percents[] = { 5, 75, 20 };
+    RECT r;
+    int xpos, percent = 0, i;
+    int listheight = LISTHEIGHT + (lines - 1) * LISTINCREMENT;
+    const int BTNSHEIGHT = 2*PUSHBTNHEIGHT + GAPBETWEEN;
+    int totalheight, buttonpos;
+
+    /* Squirrel away IDs. */
+    hdl->listid = listid;
+    hdl->upbid  = upbid;
+    hdl->dnbid  = dnbid;
+
+    /* The static label. */
+    if (stext != NULL) {
+        r.left = GAPBETWEEN;
+        r.top = cp->ypos;
+        r.right = cp->width;
+        r.bottom = STATICHEIGHT;
+        cp->ypos += r.bottom + GAPWITHIN;
+        doctl(cp, r, "STATIC", WS_CHILD | WS_VISIBLE, 0, stext, sid);
+    }
+
+    if (listheight > BTNSHEIGHT) {
+        totalheight = listheight;
+        buttonpos = (listheight - BTNSHEIGHT) / 2;
+    } else {
+        totalheight = BTNSHEIGHT;
+        buttonpos = 0;
+    }
+
+    for (i=0; i<3; i++) {
+        int left, wid;
+        xpos = (cp->width + GAPBETWEEN) * percent / 100;
+        left = xpos + GAPBETWEEN;
+        percent += percents[i];
+        xpos = (cp->width + GAPBETWEEN) * percent / 100;
+        wid = xpos - left;
+
+        switch (i) {
+          case 1: {
+            /* The drag list box. */
+            r.left = left; r.right = wid;
+            r.top = cp->ypos; r.bottom = listheight;
+            HWND ctl = doctl(cp, r, "LISTBOX",
+                             WS_CHILD | WS_VISIBLE | WS_TABSTOP |
+                             WS_VSCROLL | LBS_HASSTRINGS | LBS_USETABSTOPS,
+                             WS_EX_CLIENTEDGE,
+                             "", listid);
+            p_MakeDragList(ctl);
+            break;
+          }
+
+          case 2:
+            /* The "Up" and "Down" buttons. */
+            /* XXX worry about accelerators if we have more than one
+             * prefslist on a panel */
+            r.left = left; r.right = wid;
+            r.top = cp->ypos + buttonpos; r.bottom = PUSHBTNHEIGHT;
+            doctl(cp, r, "BUTTON",
+                  BS_NOTIFY | WS_CHILD | WS_VISIBLE |
+                  WS_TABSTOP | BS_PUSHBUTTON,
+                  0, "&Up", upbid);
+
+            r.left = left; r.right = wid;
+            r.top = cp->ypos + buttonpos + PUSHBTNHEIGHT + GAPBETWEEN;
+            r.bottom = PUSHBTNHEIGHT;
+            doctl(cp, r, "BUTTON",
+                  BS_NOTIFY | WS_CHILD | WS_VISIBLE |
+                  WS_TABSTOP | BS_PUSHBUTTON,
+                  0, "&Down", dnbid);
+
+            break;
+
+        }
+    }
+
+    cp->ypos += totalheight + GAPBETWEEN;
+
+}
+
+/*
+ * Helper function for prefslist: move item in list box.
+ */
+static void pl_moveitem(HWND hwnd, int listid, int src, int dst)
+{
+    int tlen, val;
+    char *txt;
+    /* Get the item's data. */
+    tlen = SendDlgItemMessage (hwnd, listid, LB_GETTEXTLEN, src, 0);
+    txt = snewn(tlen+1, char);
+    SendDlgItemMessage (hwnd, listid, LB_GETTEXT, src, (LPARAM) txt);
+    val = SendDlgItemMessage (hwnd, listid, LB_GETITEMDATA, src, 0);
+    /* Deselect old location. */
+    SendDlgItemMessage (hwnd, listid, LB_SETSEL, false, src);
+    /* Delete it at the old location. */
+    SendDlgItemMessage (hwnd, listid, LB_DELETESTRING, src, 0);
+    /* Insert it at new location. */
+    SendDlgItemMessage (hwnd, listid, LB_INSERTSTRING, dst,
+                        (LPARAM) txt);
+    SendDlgItemMessage (hwnd, listid, LB_SETITEMDATA, dst,
+                        (LPARAM) val);
+    /* Set selection. */
+    SendDlgItemMessage (hwnd, listid, LB_SETCURSEL, dst, 0);
+    sfree (txt);
+}
+
+int pl_itemfrompt(HWND hwnd, POINT cursor, bool scroll)
+{
+    int ret;
+    POINT uppoint, downpoint;
+    int updist, downdist, upitem, downitem, i;
+
+    /*
+     * Ghastly hackery to try to figure out not which
+     * _item_, but which _gap between items_, the user
+     * is pointing at. We do this by first working out
+     * which list item is under the cursor, and then
+     * working out how far the cursor would have to
+     * move up or down before the answer was different.
+     * Then we put the insertion point _above_ the
+     * current item if the upper edge is closer than
+     * the lower edge, or _below_ it if vice versa.
+     */
+    ret = p_LBItemFromPt(hwnd, cursor, scroll);
+    if (ret == -1)
+        return ret;
+    ret = p_LBItemFromPt(hwnd, cursor, false);
+    updist = downdist = 0;
+    for (i = 1; i < 4096 && (!updist || !downdist); i++) {
+        uppoint = downpoint = cursor;
+        uppoint.y -= i;
+        downpoint.y += i;
+        upitem = p_LBItemFromPt(hwnd, uppoint, false);
+        downitem = p_LBItemFromPt(hwnd, downpoint, false);
+        if (!updist && upitem != ret)
+            updist = i;
+        if (!downdist && downitem != ret)
+            downdist = i;
+    }
+    if (downdist < updist)
+        ret++;
+    return ret;
+}
+
+/*
+ * Handler for prefslist above.
+ *
+ * Return value has bit 0 set if the dialog box procedure needs to
+ * return true from handling this message; it has bit 1 set if a
+ * change may have been made in the contents of the list.
+ */
+int handle_prefslist(struct prefslist *hdl,
+                     int *array, int maxmemb,
+                     bool is_dlmsg, HWND hwnd,
+                     WPARAM wParam, LPARAM lParam)
+{
+    int i;
+    int ret = 0;
+
+    if (is_dlmsg) {
+
+        if ((int)wParam == hdl->listid) {
+            DRAGLISTINFO *dlm = (DRAGLISTINFO *)lParam;
+            int dest = 0;              /* initialise to placate gcc */
+            switch (dlm->uNotification) {
+              case DL_BEGINDRAG:
+                /* Add a dummy item to make pl_itemfrompt() work
+                 * better.
+                 * FIXME: this causes scrollbar glitches if the count of
+                 *        listbox contains >= its height. */
+                hdl->dummyitem =
+                    SendDlgItemMessage(hwnd, hdl->listid,
+                                       LB_ADDSTRING, 0, (LPARAM) "");
+
+                hdl->srcitem = p_LBItemFromPt(dlm->hWnd, dlm->ptCursor, true);
+                hdl->dragging = false;
+                /* XXX hack Q183115 */
+                SetWindowLongPtr(hwnd, DWLP_MSGRESULT, true);
+                ret |= 1; break;
+              case DL_CANCELDRAG:
+                p_DrawInsert(hwnd, dlm->hWnd, -1);     /* Clear arrow */
+                SendDlgItemMessage(hwnd, hdl->listid,
+                                   LB_DELETESTRING, hdl->dummyitem, 0);
+                hdl->dragging = false;
+                ret |= 1; break;
+              case DL_DRAGGING:
+                hdl->dragging = true;
+                dest = pl_itemfrompt(dlm->hWnd, dlm->ptCursor, true);
+                if (dest > hdl->dummyitem) dest = hdl->dummyitem;
+                p_DrawInsert (hwnd, dlm->hWnd, dest);
+                if (dest >= 0)
+                    SetWindowLongPtr(hwnd, DWLP_MSGRESULT, DL_MOVECURSOR);
+                else
+                    SetWindowLongPtr(hwnd, DWLP_MSGRESULT, DL_STOPCURSOR);
+                ret |= 1; break;
+              case DL_DROPPED:
+                if (hdl->dragging) {
+                    dest = pl_itemfrompt(dlm->hWnd, dlm->ptCursor, true);
+                    if (dest > hdl->dummyitem) dest = hdl->dummyitem;
+                    p_DrawInsert (hwnd, dlm->hWnd, -1);
+                }
+                SendDlgItemMessage(hwnd, hdl->listid,
+                                   LB_DELETESTRING, hdl->dummyitem, 0);
+                if (hdl->dragging) {
+                    hdl->dragging = false;
+                    if (dest >= 0) {
+                        /* Correct for "missing" item. */
+                        if (dest > hdl->srcitem) dest--;
+                        pl_moveitem(hwnd, hdl->listid, hdl->srcitem, dest);
+                    }
+                    ret |= 2;
+                }
+                ret |= 1; break;
+            }
+        }
+
+    } else {
+
+        if (((LOWORD(wParam) == hdl->upbid) ||
+             (LOWORD(wParam) == hdl->dnbid)) &&
+            ((HIWORD(wParam) == BN_CLICKED) ||
+             (HIWORD(wParam) == BN_DOUBLECLICKED))) {
+            /* Move an item up or down the list. */
+            /* Get the current selection, if any. */
+            int selection = SendDlgItemMessage (hwnd, hdl->listid, LB_GETCURSEL, 0, 0);
+            if (selection == LB_ERR) {
+                MessageBeep(0);
+            } else {
+                int nitems;
+                /* Get the total number of items. */
+                nitems = SendDlgItemMessage (hwnd, hdl->listid, LB_GETCOUNT, 0, 0);
+                /* Should we do anything? */
+                if (LOWORD(wParam) == hdl->upbid && (selection > 0))
+                    pl_moveitem(hwnd, hdl->listid, selection, selection - 1);
+                else if (LOWORD(wParam) == hdl->dnbid && (selection < nitems - 1))
+                    pl_moveitem(hwnd, hdl->listid, selection, selection + 1);
+                ret |= 2;
+            }
+
+        }
+
+    }
+
+    if (array) {
+        /* Update array to match the list box. */
+        for (i=0; i < maxmemb; i++)
+            array[i] = SendDlgItemMessage (hwnd, hdl->listid, LB_GETITEMDATA,
+                                           i, 0);
+    }
+
+    return ret;
+}
+
+/*
+ * A progress bar (from Common Controls). We like our progress bars
+ * to be smooth and unbroken, without those ugly divisions; some
+ * older compilers may not support that, but that's life.
+ */
+void progressbar(struct ctlpos *cp, int id)
+{
+    RECT r;
+
+    r.left = GAPBETWEEN;
+    r.top = cp->ypos;
+    r.right = cp->width;
+    r.bottom = PROGBARHEIGHT;
+    cp->ypos += r.bottom + GAPBETWEEN;
+
+    doctl(cp, r, PROGRESS_CLASS, WS_CHILD | WS_VISIBLE
+#ifdef PBS_SMOOTH
+          | PBS_SMOOTH
+#endif
+          , WS_EX_CLIENTEDGE, "", id);
+}
+
+/* ----------------------------------------------------------------------
+ * Platform-specific side of portable dialog-box mechanism.
+ */
+
+/*
+ * This function takes a string, escapes all the ampersands, and
+ * places a single (unescaped) ampersand in front of the first
+ * occurrence of the given shortcut character (which may be
+ * NO_SHORTCUT).
+ *
+ * Return value is a malloc'ed copy of the processed version of the
+ * string.
+ */
+static char *shortcut_escape(const char *text, char shortcut)
+{
+    char *ret;
+    char const *p;
+    char *q;
+
+    if (!text)
+        return NULL;                   /* sfree won't choke on this */
+
+    ret = snewn(2*strlen(text)+1, char);   /* size potentially doubles! */
+    shortcut = tolower((unsigned char)shortcut);
+
+    p = text;
+    q = ret;
+    while (*p) {
+        if (shortcut != NO_SHORTCUT &&
+            tolower((unsigned char)*p) == shortcut) {
+            *q++ = '&';
+            shortcut = NO_SHORTCUT;    /* stop it happening twice */
+        } else if (*p == '&') {
+            *q++ = '&';
+        }
+        *q++ = *p++;
+    }
+    *q = '\0';
+    return ret;
+}
+
+void winctrl_add_shortcuts(struct dlgparam *dp, struct winctrl *c)
+{
+    int i;
+    for (i = 0; i < lenof(c->shortcuts); i++)
+        if (c->shortcuts[i] != NO_SHORTCUT) {
+            unsigned char s = tolower((unsigned char)c->shortcuts[i]);
+            assert(!dp->shortcuts[s]);
+            dp->shortcuts[s] = true;
+        }
+}
+
+void winctrl_rem_shortcuts(struct dlgparam *dp, struct winctrl *c)
+{
+    int i;
+    for (i = 0; i < lenof(c->shortcuts); i++)
+        if (c->shortcuts[i] != NO_SHORTCUT) {
+            unsigned char s = tolower((unsigned char)c->shortcuts[i]);
+            assert(dp->shortcuts[s]);
+            dp->shortcuts[s] = false;
+        }
+}
+
+static int winctrl_cmp_byctrl(void *av, void *bv)
+{
+    struct winctrl *a = (struct winctrl *)av;
+    struct winctrl *b = (struct winctrl *)bv;
+    if (a->ctrl < b->ctrl)
+        return -1;
+    else if (a->ctrl > b->ctrl)
+        return +1;
+    else
+        return 0;
+}
+static int winctrl_cmp_byid(void *av, void *bv)
+{
+    struct winctrl *a = (struct winctrl *)av;
+    struct winctrl *b = (struct winctrl *)bv;
+    if (a->base_id < b->base_id)
+        return -1;
+    else if (a->base_id > b->base_id)
+        return +1;
+    else
+        return 0;
+}
+static int winctrl_cmp_byctrl_find(void *av, void *bv)
+{
+    dlgcontrol *a = (dlgcontrol *)av;
+    struct winctrl *b = (struct winctrl *)bv;
+    if (a < b->ctrl)
+        return -1;
+    else if (a > b->ctrl)
+        return +1;
+    else
+        return 0;
+}
+static int winctrl_cmp_byid_find(void *av, void *bv)
+{
+    int *a = (int *)av;
+    struct winctrl *b = (struct winctrl *)bv;
+    if (*a < b->base_id)
+        return -1;
+    else if (*a >= b->base_id + b->num_ids)
+        return +1;
+    else
+        return 0;
+}
+
+void winctrl_init(struct winctrls *wc)
+{
+    wc->byctrl = newtree234(winctrl_cmp_byctrl);
+    wc->byid = newtree234(winctrl_cmp_byid);
+}
+void winctrl_cleanup(struct winctrls *wc)
+{
+    struct winctrl *c;
+
+    while ((c = index234(wc->byid, 0)) != NULL) {
+        winctrl_remove(wc, c);
+        sfree(c->data);
+        sfree(c);
+    }
+
+    freetree234(wc->byctrl);
+    freetree234(wc->byid);
+    wc->byctrl = wc->byid = NULL;
+}
+
+void winctrl_add(struct winctrls *wc, struct winctrl *c)
+{
+    struct winctrl *ret;
+    if (c->ctrl) {
+        ret = add234(wc->byctrl, c);
+        assert(ret == c);
+    }
+    ret = add234(wc->byid, c);
+    assert(ret == c);
+}
+
+void winctrl_remove(struct winctrls *wc, struct winctrl *c)
+{
+    struct winctrl *ret;
+    ret = del234(wc->byctrl, c);
+    ret = del234(wc->byid, c);
+    assert(ret == c);
+}
+
+struct winctrl *winctrl_findbyctrl(struct winctrls *wc, dlgcontrol *ctrl)
+{
+    return find234(wc->byctrl, ctrl, winctrl_cmp_byctrl_find);
+}
+
+struct winctrl *winctrl_findbyid(struct winctrls *wc, int id)
+{
+    return find234(wc->byid, &id, winctrl_cmp_byid_find);
+}
+
+struct winctrl *winctrl_findbyindex(struct winctrls *wc, int index)
+{
+    return index234(wc->byid, index);
+}
+
+static void move_windows(HWND hwnd, int base_id, int num_ids, LONG dy)
+{
+    if (!dy)
+        return;
+    for (int i = 0; i < num_ids; i++) {
+        HWND win = GetDlgItem(hwnd, base_id + i);
+
+        RECT rect;
+        if (!GetWindowRect(win, &rect))
+            continue;
+
+        POINT p;
+        p.x = rect.left;
+        p.y = rect.top + dy;
+        if (!ScreenToClient(hwnd, &p))
+            continue;
+
+        SetWindowPos(win, NULL, p.x, p.y, 0, 0,
+                     SWP_NOACTIVATE | SWP_NOSIZE | SWP_NOZORDER);
+    }
+}
+
+void winctrl_layout(struct dlgparam *dp, struct winctrls *wc,
+                    struct ctlpos *cp, struct controlset *s, int *id)
+{
+    struct ctlpos columns[16];
+    int ncols, colstart, colspan;
+
+    struct ctlpos tabdelays[16];
+    dlgcontrol *tabdelayed[16];
+    int ntabdelays;
+
+    struct ctlpos pos;
+
+    char shortcuts[MAX_SHORTCUTS_PER_CTRL];
+    int nshortcuts;
+    char *escaped;
+    int i, actual_base_id, base_id, num_ids, align_id_relative;
+    void *data;
+
+    base_id = *id;
+
+    ctrlset_normalise_aligns(s);
+
+    /* Start a containing box, if we have a boxname. */
+    if (s->boxname && *s->boxname) {
+        struct winctrl *c = snew(struct winctrl);
+        c->ctrl = NULL;
+        c->base_id = c->align_id = base_id;
+        c->num_ids = 1;
+        c->data = NULL;
+        memset(c->shortcuts, NO_SHORTCUT, lenof(c->shortcuts));
+        winctrl_add(wc, c);
+        beginbox(cp, s->boxtitle, base_id);
+        base_id++;
+    }
+
+    /* Draw a title, if we have one. */
+    if (!s->boxname && s->boxtitle) {
+        struct winctrl *c = snew(struct winctrl);
+        c->ctrl = NULL;
+        c->base_id = c->align_id = base_id;
+        c->num_ids = 1;
+        c->data = dupstr(s->boxtitle);
+        memset(c->shortcuts, NO_SHORTCUT, lenof(c->shortcuts));
+        winctrl_add(wc, c);
+        paneltitle(cp, base_id);
+        base_id++;
+    }
+
+    /* Initially we have just one column. */
+    ncols = 1;
+    columns[0] = *cp;                  /* structure copy */
+
+    /* And initially, there are no pending tab-delayed controls. */
+    ntabdelays = 0;
+
+    /* Loop over each control in the controlset. */
+    for (i = 0; i < s->ncontrols; i++) {
+        dlgcontrol *ctrl = s->ctrls[i];
+
+        /*
+         * Generic processing that pertains to all control types.
+         * At the end of this if statement, we'll have produced
+         * `ctrl' (a pointer to the control we have to create, or
+         * think about creating, in this iteration of the loop),
+         * `pos' (a suitable ctlpos with which to position it), and
+         * `c' (a winctrl structure to receive details of the
+         * dialog IDs). Or we'll have done a `continue', if it was
+         * CTRL_COLUMNS and doesn't require any control creation at
+         * all.
+         */
+        if (ctrl->type == CTRL_COLUMNS) {
+            assert((ctrl->columns.ncols == 1) ^ (ncols == 1));
+
+            if (ncols == 1) {
+                /*
+                 * We're splitting into multiple columns.
+                 */
+                int lpercent, rpercent, lx, rx, i;
+
+                ncols = ctrl->columns.ncols;
+                assert(ncols <= lenof(columns));
+                for (i = 1; i < ncols; i++)
+                    columns[i] = columns[0];   /* structure copy */
+
+                lpercent = 0;
+                for (i = 0; i < ncols; i++) {
+                    rpercent = lpercent + ctrl->columns.percentages[i];
+                    lx = columns[i].xoff + lpercent *
+                        (columns[i].width + GAPBETWEEN) / 100;
+                    rx = columns[i].xoff + rpercent *
+                        (columns[i].width + GAPBETWEEN) / 100;
+                    columns[i].xoff = lx;
+                    columns[i].width = rx - lx - GAPBETWEEN;
+                    lpercent = rpercent;
+                }
+            } else {
+                /*
+                 * We're recombining the various columns into one.
+                 */
+                int maxy = columns[0].ypos;
+                int i;
+                for (i = 1; i < ncols; i++)
+                    if (maxy < columns[i].ypos)
+                        maxy = columns[i].ypos;
+                ncols = 1;
+                columns[0] = *cp;      /* structure copy */
+                columns[0].ypos = maxy;
+            }
+
+            continue;
+        } else if (ctrl->type == CTRL_TABDELAY) {
+            int i;
+
+            assert(!ctrl->delay_taborder);
+            ctrl = ctrl->tabdelay.ctrl;
+
+            for (i = 0; i < ntabdelays; i++)
+                if (tabdelayed[i] == ctrl)
+                    break;
+            assert(i < ntabdelays);    /* we have to have found it */
+
+            pos = tabdelays[i];        /* structure copy */
+
+            colstart = colspan = -1;   /* indicate this was tab-delayed */
+
+        } else {
+            /*
+             * If it wasn't one of those, it's a genuine control;
+             * so we'll have to compute a position for it now, by
+             * checking its column span.
+             */
+            int col;
+
+            colstart = COLUMN_START(ctrl->column);
+            colspan = COLUMN_SPAN(ctrl->column);
+
+            pos = columns[colstart];   /* structure copy */
+            pos.width = columns[colstart+colspan-1].width +
+                (columns[colstart+colspan-1].xoff - columns[colstart].xoff);
+
+            for (col = colstart; col < colstart+colspan; col++)
+                if (pos.ypos < columns[col].ypos)
+                    pos.ypos = columns[col].ypos;
+
+            /*
+             * If this control is to be tabdelayed, add it to the
+             * tabdelay list, and unset pos.hwnd to inhibit actual
+             * control creation.
+             */
+            if (ctrl->delay_taborder) {
+                assert(ntabdelays < lenof(tabdelays));
+                tabdelays[ntabdelays] = pos;   /* structure copy */
+                tabdelayed[ntabdelays] = ctrl;
+                ntabdelays++;
+                pos.hwnd = NULL;
+            }
+        }
+
+        /* Most controls don't need anything in c->data. */
+        data = NULL;
+
+        /* And they all start off with no shortcuts registered. */
+        memset(shortcuts, NO_SHORTCUT, lenof(shortcuts));
+        nshortcuts = 0;
+
+        /* Almost all controls start at base_id. */
+        actual_base_id = base_id;
+
+        /* For vertical alignment purposes, the most relevant control
+         * in a group is usually the last one. But that can be
+         * overridden occasionally. */
+        align_id_relative = -1;
+
+        /*
+         * Now we're ready to actually create the control, by
+         * switching on its type.
+         */
+        switch (ctrl->type) {
+          case CTRL_TEXT:
+            if (ctrl->text.wrap) {
+                char *wrapped, *escaped;
+                int lines;
+                num_ids = 1;
+                wrapped = staticwrap(&pos, cp->hwnd,
+                                     ctrl->label, &lines);
+                escaped = shortcut_escape(wrapped, NO_SHORTCUT);
+                statictext(&pos, escaped, lines, base_id);
+                sfree(escaped);
+                sfree(wrapped);
+            } else {
+                num_ids = 1;
+                editboxfw(&pos, false, true, NULL, 0, base_id);
+                SetDlgItemText(pos.hwnd, base_id, ctrl->label);
+                MakeDlgItemBorderless(pos.hwnd, base_id);
+            }
+            break;
+          case CTRL_EDITBOX:
+            num_ids = 2;               /* static, edit */
+            escaped = shortcut_escape(ctrl->label,
+                                      ctrl->editbox.shortcut);
+            shortcuts[nshortcuts++] = ctrl->editbox.shortcut;
+            if (ctrl->editbox.percentwidth == 100) {
+                if (ctrl->editbox.has_list)
+                    combobox(&pos, escaped,
+                             base_id, base_id+1);
+                else
+                    editboxfw(&pos, ctrl->editbox.password, false, escaped,
+                              base_id, base_id+1);
+            } else {
+                if (ctrl->editbox.has_list) {
+                    staticcombo(&pos, escaped, base_id, base_id+1,
+                                ctrl->editbox.percentwidth);
+                } else {
+                    (ctrl->editbox.password ? staticpassedit : staticedit)
+                        (&pos, escaped, base_id, base_id+1,
+                         ctrl->editbox.percentwidth);
+                }
+            }
+            sfree(escaped);
+            break;
+          case CTRL_RADIO: {
+            num_ids = ctrl->radio.nbuttons + 1;   /* label as well */
+            struct radio *buttons;
+            int i;
+
+            escaped = shortcut_escape(ctrl->label,
+                                      ctrl->radio.shortcut);
+            shortcuts[nshortcuts++] = ctrl->radio.shortcut;
+
+            buttons = snewn(ctrl->radio.nbuttons, struct radio);
+
+            for (i = 0; i < ctrl->radio.nbuttons; i++) {
+                buttons[i].text =
+                    shortcut_escape(ctrl->radio.buttons[i],
+                                    (char)(ctrl->radio.shortcuts ?
+                                           ctrl->radio.shortcuts[i] :
+                                           NO_SHORTCUT));
+                buttons[i].id = base_id + 1 + i;
+                if (ctrl->radio.shortcuts) {
+                    assert(nshortcuts < MAX_SHORTCUTS_PER_CTRL);
+                    shortcuts[nshortcuts++] = ctrl->radio.shortcuts[i];
+                }
+            }
+
+            radioline_common(&pos, escaped, base_id,
+                             ctrl->radio.ncolumns,
+                             buttons, ctrl->radio.nbuttons);
+
+            for (i = 0; i < ctrl->radio.nbuttons; i++) {
+                sfree((char *)buttons[i].text);
+            }
+            sfree(buttons);
+            sfree(escaped);
+            break;
+          }
+          case CTRL_CHECKBOX:
+            num_ids = 1;
+            escaped = shortcut_escape(ctrl->label,
+                                      ctrl->checkbox.shortcut);
+            shortcuts[nshortcuts++] = ctrl->checkbox.shortcut;
+            checkbox(&pos, escaped, base_id);
+            sfree(escaped);
+            break;
+          case CTRL_BUTTON:
+            escaped = shortcut_escape(ctrl->label,
+                                      ctrl->button.shortcut);
+            shortcuts[nshortcuts++] = ctrl->button.shortcut;
+            if (ctrl->button.iscancel)
+                actual_base_id = IDCANCEL;
+            num_ids = 1;
+            button(&pos, escaped, actual_base_id, ctrl->button.isdefault);
+            sfree(escaped);
+            break;
+          case CTRL_LISTBOX:
+            num_ids = 2;
+            escaped = shortcut_escape(ctrl->label,
+                                      ctrl->listbox.shortcut);
+            shortcuts[nshortcuts++] = ctrl->listbox.shortcut;
+            if (ctrl->listbox.draglist) {
+                data = snew(struct prefslist);
+                num_ids = 4;
+                prefslist(data, &pos, ctrl->listbox.height, escaped,
+                          base_id, base_id+1, base_id+2, base_id+3);
+                shortcuts[nshortcuts++] = 'u';   /* Up */
+                shortcuts[nshortcuts++] = 'd';   /* Down */
+            } else if (ctrl->listbox.height == 0) {
+                /* Drop-down list. */
+                if (ctrl->listbox.percentwidth == 100) {
+                    staticddlbig(&pos, escaped,
+                                 base_id, base_id+1);
+                } else {
+                    staticddl(&pos, escaped, base_id,
+                              base_id+1, ctrl->listbox.percentwidth);
+                }
+            } else {
+                /* Ordinary list. */
+                listbox(&pos, escaped, base_id, base_id+1,
+                        ctrl->listbox.height, ctrl->listbox.multisel);
+            }
+            if (ctrl->listbox.ncols) {
+                /*
+                 * This method of getting the box width is a bit of
+                 * a hack; we'd do better to try to retrieve the
+                 * actual width in dialog units from doctl() just
+                 * before MapDialogRect. But that's going to be no
+                 * fun, and this should be good enough accuracy.
+                 */
+                int width = cp->width * ctrl->listbox.percentwidth;
+                int *tabarray;
+                int i, percent;
+
+                tabarray = snewn(ctrl->listbox.ncols-1, int);
+                percent = 0;
+                for (i = 0; i < ctrl->listbox.ncols-1; i++) {
+                    percent += ctrl->listbox.percentages[i];
+                    tabarray[i] = width * percent / 10000;
+                }
+                SendDlgItemMessage(cp->hwnd, base_id+1, LB_SETTABSTOPS,
+                                   ctrl->listbox.ncols-1, (LPARAM)tabarray);
+                sfree(tabarray);
+            }
+            sfree(escaped);
+            break;
+          case CTRL_FILESELECT:
+            escaped = shortcut_escape(ctrl->label, ctrl->fileselect.shortcut);
+            shortcuts[nshortcuts++] = ctrl->fileselect.shortcut;
+            num_ids = 3;
+            if (!ctrl->fileselect.just_button) {
+                editbutton(&pos, escaped, base_id, base_id+1,
+                           "Browse...", base_id+2);
+            } else {
+                button(&pos, escaped, base_id+2, false);
+            }
+            sfree(escaped);
+            break;
+          case CTRL_FONTSELECT:
+            num_ids = 3;
+            escaped = shortcut_escape(ctrl->label,
+                                      ctrl->fontselect.shortcut);
+            shortcuts[nshortcuts++] = ctrl->fontselect.shortcut;
+            statictext(&pos, escaped, 1, base_id);
+            staticbtn(&pos, "", base_id+1, "Change...", base_id+2);
+            data = fontspec_new("", false, 0, 0);
+            sfree(escaped);
+            break;
+          default:
+            unreachable("bad control type in winctrl_layout");
+        }
+
+        /* Translate the original align_id_relative of -1 into n-1 */
+        if (align_id_relative < 0)
+            align_id_relative += num_ids;
+
+        /*
+         * Create a `struct winctrl' for this control, and advance
+         * the dialog ID counter, if it's actually been created
+         * (and isn't tabdelayed).
+         */
+        if (pos.hwnd) {
+            struct winctrl *c = snew(struct winctrl);
+
+            c->ctrl = ctrl;
+            c->base_id = actual_base_id;
+            c->align_id = c->base_id + align_id_relative;
+            c->num_ids = num_ids;
+            c->data = data;
+            memcpy(c->shortcuts, shortcuts, sizeof(shortcuts));
+            winctrl_add(wc, c);
+            winctrl_add_shortcuts(dp, c);
+            if (actual_base_id == base_id)
+                base_id += num_ids;
+
+            if (ctrl->align_next_to) {
+                /*
+                 * Implement align_next_to by looking at the y extents
+                 * of the two controls now that both are created, and
+                 * moving one or the other downwards so that they're
+                 * centred on a common horizontal line.
+                 */
+                LONG mid2 = 0;
+                for (dlgcontrol *thisctrl = ctrl; thisctrl;
+                     thisctrl = thisctrl->align_next_to) {
+                    struct winctrl *thisc = winctrl_findbyctrl(wc, thisctrl);
+                    assert(thisc);
+
+                    HWND win = GetDlgItem(pos.hwnd, thisc->align_id);
+                    assert(win);
+
+                    RECT rect;
+                    if (!GetWindowRect(win, &rect))
+                        continue;
+                    if (mid2 < rect.top + rect.bottom)
+                        mid2 = rect.top + rect.bottom;
+                }
+
+                for (dlgcontrol *thisctrl = ctrl; thisctrl;
+                     thisctrl = thisctrl->align_next_to) {
+                    struct winctrl *thisc = winctrl_findbyctrl(wc, thisctrl);
+                    assert(thisc);
+
+                    HWND win = GetDlgItem(pos.hwnd, thisc->align_id);
+                    assert(win);
+
+                    RECT rect;
+                    if (!GetWindowRect(win, &rect))
+                        continue;
+
+                    LONG dy = (mid2 - (rect.top + rect.bottom)) / 2;
+                    move_windows(pos.hwnd, thisc->base_id, thisc->num_ids, dy);
+                }
+            }
+        } else {
+            sfree(data);
+        }
+
+        if (colstart >= 0) {
+            /*
+             * Update the ypos in all columns crossed by this
+             * control.
+             */
+            int i;
+            for (i = colstart; i < colstart+colspan; i++)
+                columns[i].ypos = pos.ypos;
+        }
+    }
+
+    /*
+     * We've now finished laying out the controls; so now update
+     * the ctlpos and control ID that were passed in, terminate
+     * any containing box, and return.
+     */
+    for (i = 0; i < ncols; i++)
+        if (cp->ypos < columns[i].ypos)
+            cp->ypos = columns[i].ypos;
+    *id = base_id;
+
+    if (s->boxname && *s->boxname)
+        endbox(cp);
+}
+
+static void winctrl_set_focus(dlgcontrol *ctrl, struct dlgparam *dp,
+                              bool has_focus)
+{
+    if (has_focus) {
+        if (dp->focused)
+            dp->lastfocused = dp->focused;
+        dp->focused = ctrl;
+    } else if (!has_focus && dp->focused == ctrl) {
+        dp->lastfocused = dp->focused;
+        dp->focused = NULL;
+    }
+}
+
+dlgcontrol *dlg_last_focused(dlgcontrol *ctrl, dlgparam *dp)
+{
+    return dp->focused == ctrl ? dp->lastfocused : dp->focused;
+}
+
+/*
+ * The dialog-box procedure calls this function to handle Windows
+ * messages on a control we manage.
+ */
+bool winctrl_handle_command(struct dlgparam *dp, UINT msg,
+                            WPARAM wParam, LPARAM lParam)
+{
+    struct winctrl *c;
+    dlgcontrol *ctrl;
+    int i, id;
+    bool ret;
+    static UINT draglistmsg = WM_NULL;
+
+    /*
+     * Filter out pointless window messages. Our interest is in
+     * WM_COMMAND and the drag list message, and nothing else.
+     */
+    if (draglistmsg == WM_NULL)
+        draglistmsg = RegisterWindowMessage (DRAGLISTMSGSTRING);
+
+    if (msg != draglistmsg && msg != WM_COMMAND && msg != WM_DRAWITEM)
+        return false;
+
+    /*
+     * Look up the control ID in our data.
+     */
+    c = NULL;
+    for (i = 0; i < dp->nctrltrees; i++) {
+        c = winctrl_findbyid(dp->controltrees[i], LOWORD(wParam));
+        if (c)
+            break;
+    }
+    if (!c)
+        return false;                  /* we have nothing to do */
+
+    if (msg == WM_DRAWITEM) {
+        /*
+         * Owner-draw request for a panel title.
+         */
+        LPDRAWITEMSTRUCT di = (LPDRAWITEMSTRUCT) lParam;
+        HDC hdc = di->hDC;
+        RECT r = di->rcItem;
+        SIZE s;
+
+        SetMapMode(hdc, MM_TEXT);      /* ensure logical units == pixels */
+
+        GetTextExtentPoint32(hdc, (char *)c->data,
+                             strlen((char *)c->data), &s);
+        DrawEdge(hdc, &r, EDGE_ETCHED, BF_ADJUST | BF_RECT);
+        TextOut(hdc,
+                r.left + (r.right-r.left-s.cx)/2,
+                r.top + (r.bottom-r.top-s.cy)/2,
+                (char *)c->data, strlen((char *)c->data));
+
+        return true;
+    }
+
+    ctrl = c->ctrl;
+    id = LOWORD(wParam) - c->base_id;
+
+    if (!ctrl || !ctrl->handler)
+        return false;                  /* nothing we can do here */
+
+    /*
+     * From here on we do not issue `return' statements until the
+     * very end of the dialog box: any event handler is entitled to
+     * ask for a colour selector, so we _must_ always allow control
+     * to reach the end of this switch statement so that the
+     * subsequent code can test dp->coloursel_wanted().
+     */
+    ret = false;
+    dp->coloursel_wanted = false;
+
+    /*
+     * Now switch on the control type and the message.
+     */
+    switch (ctrl->type) {
+      case CTRL_EDITBOX:
+        if (msg == WM_COMMAND && !ctrl->editbox.has_list &&
+            (HIWORD(wParam) == EN_SETFOCUS || HIWORD(wParam) == EN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == EN_SETFOCUS);
+        if (msg == WM_COMMAND && ctrl->editbox.has_list &&
+            (HIWORD(wParam)==CBN_SETFOCUS || HIWORD(wParam)==CBN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == CBN_SETFOCUS);
+
+        if (msg == WM_COMMAND && !ctrl->editbox.has_list &&
+            HIWORD(wParam) == EN_CHANGE)
+            ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+        if (msg == WM_COMMAND &&
+            ctrl->editbox.has_list) {
+            if (HIWORD(wParam) == CBN_SELCHANGE) {
+                int index, len;
+                char *text;
+
+                index = SendDlgItemMessage(dp->hwnd, c->base_id+1,
+                                           CB_GETCURSEL, 0, 0);
+                len = SendDlgItemMessage(dp->hwnd, c->base_id+1,
+                                         CB_GETLBTEXTLEN, index, 0);
+                text = snewn(len+1, char);
+                SendDlgItemMessage(dp->hwnd, c->base_id+1, CB_GETLBTEXT,
+                                   index, (LPARAM)text);
+                SetDlgItemText(dp->hwnd, c->base_id+1, text);
+                sfree(text);
+                ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+            } else if (HIWORD(wParam) == CBN_EDITCHANGE) {
+                ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+            } else if (HIWORD(wParam) == CBN_KILLFOCUS) {
+                ctrl->handler(ctrl, dp, dp->data, EVENT_REFRESH);
+            }
+
+        }
+        break;
+      case CTRL_RADIO:
+        if (msg == WM_COMMAND &&
+            (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
+        /*
+         * We sometimes get spurious BN_CLICKED messages for the
+         * radio button that is just about to _lose_ selection, if
+         * we're switching using the arrow keys. Therefore we
+         * double-check that the button in wParam is actually
+         * checked before generating an event.
+         */
+        if (msg == WM_COMMAND &&
+            (HIWORD(wParam) == BN_CLICKED ||
+             HIWORD(wParam) == BN_DOUBLECLICKED) &&
+            IsDlgButtonChecked(dp->hwnd, LOWORD(wParam))) {
+            ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+        }
+        break;
+      case CTRL_CHECKBOX:
+        if (msg == WM_COMMAND &&
+            (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
+        if (msg == WM_COMMAND &&
+            (HIWORD(wParam) == BN_CLICKED ||
+             HIWORD(wParam) == BN_DOUBLECLICKED)) {
+            ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+        }
+        break;
+      case CTRL_BUTTON:
+        if (msg == WM_COMMAND &&
+            (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
+        if (msg == WM_COMMAND &&
+            (HIWORD(wParam) == BN_CLICKED ||
+             HIWORD(wParam) == BN_DOUBLECLICKED)) {
+            ctrl->handler(ctrl, dp, dp->data, EVENT_ACTION);
+        }
+        break;
+      case CTRL_LISTBOX:
+        if (msg == WM_COMMAND && ctrl->listbox.height != 0 &&
+            (HIWORD(wParam)==LBN_SETFOCUS || HIWORD(wParam)==LBN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == LBN_SETFOCUS);
+        if (msg == WM_COMMAND && ctrl->listbox.height == 0 &&
+            (HIWORD(wParam)==CBN_SETFOCUS || HIWORD(wParam)==CBN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == CBN_SETFOCUS);
+        if (msg == WM_COMMAND && id >= 2 &&
+            (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
+        if (ctrl->listbox.draglist) {
+            int pret;
+            pret = handle_prefslist(c->data, NULL, 0, (msg != WM_COMMAND),
+                                    dp->hwnd, wParam, lParam);
+            if (pret & 2)
+                ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+            ret = pret & 1;
+        } else {
+            if (msg == WM_COMMAND && HIWORD(wParam) == LBN_DBLCLK) {
+                SetCapture(dp->hwnd);
+                ctrl->handler(ctrl, dp, dp->data, EVENT_ACTION);
+            } else if (msg == WM_COMMAND && HIWORD(wParam) == LBN_SELCHANGE) {
+                ctrl->handler(ctrl, dp, dp->data, EVENT_SELCHANGE);
+            }
+        }
+        break;
+      case CTRL_FILESELECT:
+        if (msg == WM_COMMAND && id == 1 &&
+            (HIWORD(wParam) == EN_SETFOCUS || HIWORD(wParam) == EN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == EN_SETFOCUS);
+        if (msg == WM_COMMAND && id == 2 &&
+            (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
+        if (msg == WM_COMMAND && id == 1 && HIWORD(wParam) == EN_CHANGE)
+            ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+        if (id == 2 &&
+            (msg == WM_COMMAND &&
+             (HIWORD(wParam) == BN_CLICKED ||
+              HIWORD(wParam) == BN_DOUBLECLICKED))) {
+            OPENFILENAME of;
+            char filename[FILENAME_MAX];
+
+            memset(&of, 0, sizeof(of));
+            of.hwndOwner = dp->hwnd;
+            if (ctrl->fileselect.filter)
+                of.lpstrFilter = ctrl->fileselect.filter;
+            else
+                of.lpstrFilter = "All Files (*.*)\0*\0\0\0";
+            of.lpstrCustomFilter = NULL;
+            of.nFilterIndex = 1;
+            of.lpstrFile = filename;
+            if (!ctrl->fileselect.just_button) {
+                GetDlgItemText(dp->hwnd, c->base_id+1,
+                               filename, lenof(filename));
+                filename[lenof(filename)-1] = '\0';
+            } else {
+                *filename = '\0';
+            }
+            of.nMaxFile = lenof(filename);
+            of.lpstrFileTitle = NULL;
+            of.lpstrTitle = ctrl->fileselect.title;
+            of.Flags = 0;
+            if (request_file(NULL, &of, false, ctrl->fileselect.for_writing)) {
+                if (!ctrl->fileselect.just_button) {
+                    SetDlgItemText(dp->hwnd, c->base_id + 1, filename);
+                    ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+                } else {
+                    assert(!c->data);
+                    c->data = filename;
+                    ctrl->handler(ctrl, dp, dp->data, EVENT_ACTION);
+                    c->data = NULL;
+                }
+            }
+        }
+        break;
+      case CTRL_FONTSELECT:
+        if (msg == WM_COMMAND && id == 2 &&
+            (HIWORD(wParam) == BN_SETFOCUS || HIWORD(wParam) == BN_KILLFOCUS))
+            winctrl_set_focus(ctrl, dp, HIWORD(wParam) == BN_SETFOCUS);
+        if (id == 2 &&
+            (msg == WM_COMMAND &&
+             (HIWORD(wParam) == BN_CLICKED ||
+              HIWORD(wParam) == BN_DOUBLECLICKED))) {
+            CHOOSEFONT cf;
+            LOGFONT lf;
+            HDC hdc;
+            FontSpec *fs = (FontSpec *)c->data;
+
+            hdc = GetDC(0);
+            lf.lfHeight = -MulDiv(fs->height,
+                                  GetDeviceCaps(hdc, LOGPIXELSY), 72);
+            ReleaseDC(0, hdc);
+            lf.lfWidth = lf.lfEscapement = lf.lfOrientation = 0;
+            lf.lfItalic = lf.lfUnderline = lf.lfStrikeOut = 0;
+            lf.lfWeight = (fs->isbold ? FW_BOLD : 0);
+            lf.lfCharSet = fs->charset;
+            lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
+            lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
+            lf.lfQuality = DEFAULT_QUALITY;
+            lf.lfPitchAndFamily = FIXED_PITCH | FF_DONTCARE;
+            strncpy(lf.lfFaceName, fs->name,
+                    sizeof(lf.lfFaceName) - 1);
+            lf.lfFaceName[sizeof(lf.lfFaceName) - 1] = '\0';
+
+            cf.lStructSize = sizeof(cf);
+            cf.hwndOwner = dp->hwnd;
+            cf.lpLogFont = &lf;
+            cf.Flags = (dp->fixed_pitch_fonts ? CF_FIXEDPITCHONLY : 0) |
+                CF_FORCEFONTEXIST | CF_INITTOLOGFONTSTRUCT | CF_SCREENFONTS;
+
+            if (ChooseFont(&cf)) {
+                fs = fontspec_new(lf.lfFaceName, (lf.lfWeight == FW_BOLD),
+                                  cf.iPointSize / 10, lf.lfCharSet);
+                dlg_fontsel_set(ctrl, dp, fs);
+                fontspec_free(fs);
+
+                ctrl->handler(ctrl, dp, dp->data, EVENT_VALCHANGE);
+            }
+        }
+        break;
+    }
+
+    /*
+     * If the above event handler has asked for a colour selector,
+     * now is the time to generate one.
+     */
+    if (dp->coloursel_wanted) {
+        static CHOOSECOLOR cc;
+        static DWORD custom[16] = { 0 };    /* zero initialisers */
+        cc.lStructSize = sizeof(cc);
+        cc.hwndOwner = dp->hwnd;
+        cc.hInstance = (HWND) hinst;
+        cc.lpCustColors = custom;
+        cc.rgbResult = RGB(dp->coloursel_result.r,
+                           dp->coloursel_result.g,
+                           dp->coloursel_result.b);
+        cc.Flags = CC_FULLOPEN | CC_RGBINIT;
+        if (ChooseColor(&cc)) {
+            dp->coloursel_result.r =
+                (unsigned char) (cc.rgbResult & 0xFF);
+            dp->coloursel_result.g =
+                (unsigned char) (cc.rgbResult >> 8) & 0xFF;
+            dp->coloursel_result.b =
+                (unsigned char) (cc.rgbResult >> 16) & 0xFF;
+            dp->coloursel_result.ok = true;
+        } else
+            dp->coloursel_result.ok = false;
+        ctrl->handler(ctrl, dp, dp->data, EVENT_CALLBACK);
+    }
+
+    return ret;
+}
+
+/*
+ * This function can be called to produce context help on a
+ * control. Returns true if it has actually launched some help.
+ */
+bool winctrl_context_help(struct dlgparam *dp, HWND hwnd, int id)
+{
+    int i;
+    struct winctrl *c;
+
+    /*
+     * Look up the control ID in our data.
+     */
+    c = NULL;
+    for (i = 0; i < dp->nctrltrees; i++) {
+        c = winctrl_findbyid(dp->controltrees[i], id);
+        if (c)
+            break;
+    }
+    if (!c)
+        return false;                  /* we have nothing to do */
+
+    /*
+     * This is the Windows front end, so we're allowed to assume
+     * `helpctx' is a context string.
+     */
+    if (!c->ctrl || !c->ctrl->helpctx)
+        return false;            /* no help available for this ctrl */
+
+    launch_help(hwnd, c->ctrl->helpctx);
+    return true;
+}
+
+/*
+ * Now the various functions that the platform-independent
+ * mechanism can call to access the dialog box entries.
+ */
+
+static struct winctrl *dlg_findbyctrl(struct dlgparam *dp, dlgcontrol *ctrl)
+{
+    int i;
+
+    for (i = 0; i < dp->nctrltrees; i++) {
+        struct winctrl *c = winctrl_findbyctrl(dp->controltrees[i], ctrl);
+        if (c)
+            return c;
+    }
+    return NULL;
+}
+
+bool dlg_is_visible(dlgcontrol *ctrl, dlgparam *dp)
+{
+    /*
+     * In this implementation of the dialog box, we physically
+     * uncreate controls that aren't in a visible panel of the config
+     * box. So we can tell if a control is visible just by checking if
+     * it _exists_.
+     */
+    return dlg_findbyctrl(dp, ctrl) != NULL;
+}
+
+void dlg_radiobutton_set(dlgcontrol *ctrl, dlgparam *dp, int whichbutton)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_RADIO);
+    CheckRadioButton(dp->hwnd,
+                     c->base_id + 1,
+                     c->base_id + c->ctrl->radio.nbuttons,
+                     c->base_id + 1 + whichbutton);
+}
+
+int dlg_radiobutton_get(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int i;
+    assert(c && c->ctrl->type == CTRL_RADIO);
+    for (i = 0; i < c->ctrl->radio.nbuttons; i++)
+        if (IsDlgButtonChecked(dp->hwnd, c->base_id + 1 + i))
+            return i;
+    unreachable("no radio button was checked");
+}
+
+void dlg_checkbox_set(dlgcontrol *ctrl, dlgparam *dp, bool checked)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_CHECKBOX);
+    CheckDlgButton(dp->hwnd, c->base_id, checked);
+}
+
+bool dlg_checkbox_get(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_CHECKBOX);
+    return 0 != IsDlgButtonChecked(dp->hwnd, c->base_id);
+}
+
+void dlg_editbox_set(dlgcontrol *ctrl, dlgparam *dp, char const *text)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_EDITBOX);
+    SetDlgItemText(dp->hwnd, c->base_id+1, text);
+}
+
+char *dlg_editbox_get(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_EDITBOX);
+    return GetDlgItemText_alloc(dp->hwnd, c->base_id+1);
+}
+
+void dlg_editbox_select_range(dlgcontrol *ctrl, dlgparam *dp,
+                              size_t start, size_t len)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_EDITBOX);
+    SendDlgItemMessage(dp->hwnd, c->base_id+1, EM_SETSEL, start, start+len);
+}
+
+/* The `listbox' functions can also apply to combo boxes. */
+void dlg_listbox_clear(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int msg;
+    assert(c &&
+           (c->ctrl->type == CTRL_LISTBOX ||
+            (c->ctrl->type == CTRL_EDITBOX &&
+             c->ctrl->editbox.has_list)));
+    msg = (c->ctrl->type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
+           LB_RESETCONTENT : CB_RESETCONTENT);
+    SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, 0, 0);
+}
+
+void dlg_listbox_del(dlgcontrol *ctrl, dlgparam *dp, int index)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int msg;
+    assert(c &&
+           (c->ctrl->type == CTRL_LISTBOX ||
+            (c->ctrl->type == CTRL_EDITBOX &&
+             c->ctrl->editbox.has_list)));
+    msg = (c->ctrl->type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
+           LB_DELETESTRING : CB_DELETESTRING);
+    SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, index, 0);
+}
+
+void dlg_listbox_add(dlgcontrol *ctrl, dlgparam *dp, char const *text)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int msg;
+    assert(c &&
+           (c->ctrl->type == CTRL_LISTBOX ||
+            (c->ctrl->type == CTRL_EDITBOX &&
+             c->ctrl->editbox.has_list)));
+    msg = (c->ctrl->type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
+           LB_ADDSTRING : CB_ADDSTRING);
+    SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, 0, (LPARAM)text);
+}
+
+/*
+ * Each listbox entry may have a numeric id associated with it.
+ * Note that some front ends only permit a string to be stored at
+ * each position, which means that _if_ you put two identical
+ * strings in any listbox then you MUST not assign them different
+ * IDs and expect to get meaningful results back.
+ */
+void dlg_listbox_addwithid(dlgcontrol *ctrl, dlgparam *dp,
+                           char const *text, int id)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int msg, msg2, index;
+    assert(c &&
+           (c->ctrl->type == CTRL_LISTBOX ||
+            (c->ctrl->type == CTRL_EDITBOX &&
+             c->ctrl->editbox.has_list)));
+    msg = (c->ctrl->type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
+           LB_ADDSTRING : CB_ADDSTRING);
+    msg2 = (c->ctrl->type==CTRL_LISTBOX && c->ctrl->listbox.height!=0 ?
+            LB_SETITEMDATA : CB_SETITEMDATA);
+    index = SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, 0, (LPARAM)text);
+    SendDlgItemMessage(dp->hwnd, c->base_id+1, msg2, index, (LPARAM)id);
+}
+
+int dlg_listbox_getid(dlgcontrol *ctrl, dlgparam *dp, int index)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int msg;
+    assert(c && c->ctrl->type == CTRL_LISTBOX);
+    msg = (c->ctrl->listbox.height != 0 ? LB_GETITEMDATA : CB_GETITEMDATA);
+    return
+        SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, index, 0);
+}
+
+/* dlg_listbox_index returns <0 if no single element is selected. */
+int dlg_listbox_index(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int msg, ret;
+    assert(c && c->ctrl->type == CTRL_LISTBOX);
+    if (c->ctrl->listbox.multisel) {
+        assert(c->ctrl->listbox.height != 0); /* not combo box */
+        ret = SendDlgItemMessage(dp->hwnd, c->base_id+1, LB_GETSELCOUNT, 0, 0);
+        if (ret == LB_ERR || ret > 1)
+            return -1;
+    }
+    msg = (c->ctrl->listbox.height != 0 ? LB_GETCURSEL : CB_GETCURSEL);
+    ret = SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, 0, 0);
+    if (ret == LB_ERR)
+        return -1;
+    else
+        return ret;
+}
+
+bool dlg_listbox_issel(dlgcontrol *ctrl, dlgparam *dp, int index)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_LISTBOX &&
+           c->ctrl->listbox.multisel &&
+           c->ctrl->listbox.height != 0);
+    return
+        SendDlgItemMessage(dp->hwnd, c->base_id+1, LB_GETSEL, index, 0);
+}
+
+void dlg_listbox_select(dlgcontrol *ctrl, dlgparam *dp, int index)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int msg;
+    assert(c && c->ctrl->type == CTRL_LISTBOX &&
+           !c->ctrl->listbox.multisel);
+    msg = (c->ctrl->listbox.height != 0 ? LB_SETCURSEL : CB_SETCURSEL);
+    SendDlgItemMessage(dp->hwnd, c->base_id+1, msg, index, 0);
+}
+
+void dlg_text_set(dlgcontrol *ctrl, dlgparam *dp, char const *text)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_TEXT);
+    SetDlgItemText(dp->hwnd, c->base_id, text);
+}
+
+void dlg_label_change(dlgcontrol *ctrl, dlgparam *dp, char const *text)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    char *escaped = NULL;
+    int id = -1;
+
+    assert(c);
+    switch (c->ctrl->type) {
+      case CTRL_EDITBOX:
+        escaped = shortcut_escape(text, c->ctrl->editbox.shortcut);
+        id = c->base_id;
+        break;
+      case CTRL_RADIO:
+        escaped = shortcut_escape(text, c->ctrl->radio.shortcut);
+        id = c->base_id;
+        break;
+      case CTRL_CHECKBOX:
+        escaped = shortcut_escape(text, ctrl->checkbox.shortcut);
+        id = c->base_id;
+        break;
+      case CTRL_BUTTON:
+        escaped = shortcut_escape(text, ctrl->button.shortcut);
+        id = c->base_id;
+        break;
+      case CTRL_LISTBOX:
+        escaped = shortcut_escape(text, ctrl->listbox.shortcut);
+        id = c->base_id;
+        break;
+      case CTRL_FILESELECT:
+        escaped = shortcut_escape(text, ctrl->fileselect.shortcut);
+        if (ctrl->fileselect.just_button)
+            id = c->base_id + 2;       /* the button */
+        else
+            id = c->base_id;           /* the label */
+        break;
+      case CTRL_FONTSELECT:
+        escaped = shortcut_escape(text, ctrl->fontselect.shortcut);
+        id = c->base_id;
+        break;
+      default:
+        unreachable("bad control type in label_change");
+    }
+    if (escaped) {
+        SetDlgItemText(dp->hwnd, id, escaped);
+        sfree(escaped);
+    }
+}
+
+void dlg_filesel_set(dlgcontrol *ctrl, dlgparam *dp, Filename *fn)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c);
+    assert(c->ctrl->type == CTRL_FILESELECT);
+    assert(!c->ctrl->fileselect.just_button);
+    SetDlgItemText(dp->hwnd, c->base_id+1, fn->path);
+}
+
+Filename *dlg_filesel_get(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    char *tmp;
+    Filename *ret;
+    assert(c);
+    assert(c->ctrl->type == CTRL_FILESELECT);
+    if (!c->ctrl->fileselect.just_button) {
+        tmp = GetDlgItemText_alloc(dp->hwnd, c->base_id+1);
+        ret = filename_from_str(tmp);
+        sfree(tmp);
+        return ret;
+    } else {
+        return filename_from_str(c->data);
+    }
+}
+
+void dlg_fontsel_set(dlgcontrol *ctrl, dlgparam *dp, FontSpec *fs)
+{
+    char *buf, *boldstr;
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_FONTSELECT);
+
+    fontspec_free((FontSpec *)c->data);
+    c->data = fontspec_copy(fs);
+
+    boldstr = (fs->isbold ? "bold, " : "");
+    if (fs->height == 0)
+        buf = dupprintf("Font: %s, %sdefault height", fs->name, boldstr);
+    else
+        buf = dupprintf("Font: %s, %s%d-%s", fs->name, boldstr,
+                        (fs->height < 0 ? -fs->height : fs->height),
+                        (fs->height < 0 ? "pixel" : "point"));
+    SetDlgItemText(dp->hwnd, c->base_id+1, buf);
+    sfree(buf);
+
+    dlg_auto_set_fixed_pitch_flag(dp);
+}
+
+FontSpec *dlg_fontsel_get(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    assert(c && c->ctrl->type == CTRL_FONTSELECT);
+    return fontspec_copy((FontSpec *)c->data);
+}
+
+/*
+ * Bracketing a large set of updates in these two functions will
+ * cause the front end (if possible) to delay updating the screen
+ * until it's all complete, thus avoiding flicker.
+ */
+void dlg_update_start(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    if (c && c->ctrl->type == CTRL_LISTBOX) {
+        SendDlgItemMessage(dp->hwnd, c->base_id+1, WM_SETREDRAW, false, 0);
+    }
+}
+
+void dlg_update_done(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    if (c && c->ctrl->type == CTRL_LISTBOX) {
+        HWND hw = GetDlgItem(dp->hwnd, c->base_id+1);
+        SendMessage(hw, WM_SETREDRAW, true, 0);
+        InvalidateRect(hw, NULL, true);
+    }
+}
+
+void dlg_set_focus(dlgcontrol *ctrl, dlgparam *dp)
+{
+    struct winctrl *c = dlg_findbyctrl(dp, ctrl);
+    int id;
+    HWND ctl;
+    if (!c)
+        return;
+    switch (ctrl->type) {
+      case CTRL_EDITBOX: id = c->base_id + 1; break;
+      case CTRL_RADIO:
+        for (id = c->base_id + ctrl->radio.nbuttons; id > 1; id--)
+            if (IsDlgButtonChecked(dp->hwnd, id))
+                break;
+        /*
+         * In the theoretically-unlikely case that no button was
+         * selected, id should come out of this as 1, which is a
+         * reasonable enough choice.
+         */
+        break;
+      case CTRL_CHECKBOX: id = c->base_id; break;
+      case CTRL_BUTTON: id = c->base_id; break;
+      case CTRL_LISTBOX: id = c->base_id + 1; break;
+      case CTRL_FILESELECT: id = c->base_id + 1; break;
+      case CTRL_FONTSELECT: id = c->base_id + 2; break;
+      default: id = c->base_id; break;
+    }
+    ctl = GetDlgItem(dp->hwnd, id);
+    SetFocus(ctl);
+}
+
+/*
+ * During event processing, you might well want to give an error
+ * indication to the user. dlg_beep() is a quick and easy generic
+ * error; dlg_error() puts up a message-box or equivalent.
+ */
+void dlg_beep(dlgparam *dp)
+{
+    MessageBeep(0);
+}
+
+void dlg_error_msg(dlgparam *dp, const char *msg)
+{
+    MessageBox(dp->hwnd, msg,
+               dp->errtitle ? dp->errtitle : NULL,
+               MB_OK | MB_ICONERROR);
+}
+
+/*
+ * This function signals to the front end that the dialog's
+ * processing is completed, and passes an integer value (typically
+ * a success status).
+ */
+void dlg_end(dlgparam *dp, int value)
+{
+    dp->ended = true;
+    dp->endresult = value;
+}
+
+void dlg_refresh(dlgcontrol *ctrl, dlgparam *dp)
+{
+    int i, j;
+    struct winctrl *c;
+
+    if (!ctrl) {
+        /*
+         * Send EVENT_REFRESH to absolutely everything.
+         */
+        for (j = 0; j < dp->nctrltrees; j++) {
+            for (i = 0;
+                 (c = winctrl_findbyindex(dp->controltrees[j], i)) != NULL;
+                 i++) {
+                if (c->ctrl && c->ctrl->handler != NULL)
+                    c->ctrl->handler(c->ctrl, dp,
+                                     dp->data, EVENT_REFRESH);
+            }
+        }
+    } else {
+        /*
+         * Send EVENT_REFRESH to a specific control.
+         */
+        if (ctrl->handler != NULL)
+            ctrl->handler(ctrl, dp, dp->data, EVENT_REFRESH);
+    }
+}
+
+void dlg_coloursel_start(dlgcontrol *ctrl, dlgparam *dp, int r, int g, int b)
+{
+    dp->coloursel_wanted = true;
+    dp->coloursel_result.r = r;
+    dp->coloursel_result.g = g;
+    dp->coloursel_result.b = b;
+}
+
+bool dlg_coloursel_results(dlgcontrol *ctrl, dlgparam *dp,
+                           int *r, int *g, int *b)
+{
+    if (dp->coloursel_result.ok) {
+        *r = dp->coloursel_result.r;
+        *g = dp->coloursel_result.g;
+        *b = dp->coloursel_result.b;
+        return true;
+    } else
+        return false;
+}
+
+void dlg_auto_set_fixed_pitch_flag(dlgparam *dp)
+{
+    Conf *conf = (Conf *)dp->data;
+    FontSpec *fs;
+    int quality;
+    HFONT hfont;
+    HDC hdc;
+    TEXTMETRIC tm;
+    bool is_var;
+
+    /*
+     * Attempt to load the current font, and see if it's
+     * variable-pitch. If so, start off the fixed-pitch flag for the
+     * dialog box as false.
+     *
+     * We assume here that any client of the dlg_* mechanism which is
+     * using font selectors at all is also using a normal 'Conf *'
+     * as dp->data.
+     */
+
+    quality = conf_get_int(conf, CONF_font_quality);
+    fs = conf_get_fontspec(conf, CONF_font);
+
+    hfont = CreateFont(0, 0, 0, 0, FW_DONTCARE, false, false, false,
+                       DEFAULT_CHARSET, OUT_DEFAULT_PRECIS,
+                       CLIP_DEFAULT_PRECIS, FONT_QUALITY(quality),
+                       FIXED_PITCH | FF_DONTCARE, fs->name);
+    hdc = GetDC(NULL);
+    if (hdc && SelectObject(hdc, hfont) && GetTextMetrics(hdc, &tm)) {
+        /* Note that the TMPF_FIXED_PITCH bit is defined upside down :-( */
+        is_var = (tm.tmPitchAndFamily & TMPF_FIXED_PITCH);
+    } else {
+        is_var = false;                /* assume it's basically normal */
+    }
+    if (hdc)
+        ReleaseDC(NULL, hdc);
+    if (hfont)
+        DeleteObject(hfont);
+
+    if (is_var)
+        dp->fixed_pitch_fonts = false;
+}
+
+bool dlg_get_fixed_pitch_flag(dlgparam *dp)
+{
+    return dp->fixed_pitch_fonts;
+}
+
+void dlg_set_fixed_pitch_flag(dlgparam *dp, bool flag)
+{
+    dp->fixed_pitch_fonts = flag;
+}
+
+void dp_init(struct dlgparam *dp)
+{
+    dp->nctrltrees = 0;
+    dp->data = NULL;
+    dp->ended = false;
+    dp->focused = dp->lastfocused = NULL;
+    memset(dp->shortcuts, 0, sizeof(dp->shortcuts));
+    dp->hwnd = NULL;
+    dp->wintitle = dp->errtitle = NULL;
+    dp->fixed_pitch_fonts = true;
+}
+
+void dp_add_tree(struct dlgparam *dp, struct winctrls *wc)
+{
+    assert(dp->nctrltrees < lenof(dp->controltrees));
+    dp->controltrees[dp->nctrltrees++] = wc;
+}
+
+void dp_cleanup(struct dlgparam *dp)
+{
+    sfree(dp->wintitle);
+    sfree(dp->errtitle);
+}