xenocara/xserver/hw/dmx/config/xdmxconfig.c

/*
 * Copyright 2002 Red Hat Inc., Durham, North Carolina.
 *
 * All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation on the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the
 * next paragraph) shall be included in all copies or substantial
 * portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NON-INFRINGEMENT.  IN NO EVENT SHALL RED HAT AND/OR THEIR SUPPLIERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

/*
 * Authors:
 *   Rickard E. (Rik) Faith <faith@redhat.com>
 *
 */


#include <stdio.h>
#include <stdlib.h>
#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Xaw/Form.h>
#include <X11/Xaw/Box.h>
/* #include <X11/Xaw/Paned.h> */
#include <X11/Xaw/Command.h>
#include <X11/Xaw/SimpleMenu.h>
#include <X11/Xaw/SmeBSB.h>
#include <X11/Xaw/MenuButton.h>
#include <X11/Xaw/Viewport.h>
#include <X11/Xaw/Dialog.h>
#include <X11/keysym.h>
#include "Canvas.h"

#include "dmxparse.h"
#include "dmxprint.h"
#include "dmxlog.h"

extern int yyparse(void);
extern int yydebug;
extern FILE *yyin;

#define DMX_INFO "xdmxconfig v0.9\nCopyright 2002 Red Hat Inc.\n"

#define DMX_MAIN_WIDTH    800
#define DMX_MAIN_HEIGHT   600
#define DMX_DATA_WIDTH    200
#define DMX_DATA_HEIGHT   200
#define DMX_CANVAS_WIDTH  400
#define DMX_CANVAS_HEIGHT 500

DMXConfigEntryPtr dmxConfigEntry;
static DMXConfigVirtualPtr dmxConfigCurrent, dmxConfigNewVirtual;
static DMXConfigDisplayPtr dmxConfigCurrentDisplay, dmxConfigNewDisplay;
static int dmxConfigGrabbed, dmxConfigGrabbedFine;
static int dmxConfigGrabbedX, dmxConfigGrabbedY;
static char *dmxConfigFilename;
static GC dmxConfigGC, dmxConfigGCRev, dmxConfigGCHL;
static int dmxConfigGCInit = 0;
static Dimension dmxConfigWidgetWidth, dmxConfigWidgetHeight;
static Dimension dmxConfigWallWidth, dmxConfigWallHeight;
static double dmxConfigScaleX, dmxConfigScaleY;
static int dmxConfigNotSaved;
static enum {
    dmxConfigStateOpen,
    dmxConfigStateSave
} dmxConfigState;

/* Global widgets */
static Widget canvas;
static Widget cnamebox, cdimbox;
static Widget openpopup, opendialog;
static Widget namebox, dimbox, rtbox, origbox;
static Widget okbutton, buttonpopup;
static Widget ecbutton, dcbutton;
static Widget ndbutton0, ndbutton1, edbutton, ddbutton;
static Widget ecpopup, ecdialog0, ecdialog1;
static Widget edpopup, eddialog0, eddialog1, eddialog2;
static Widget aboutpopup, quitpopup;

static void
dmxConfigCanvasGCs(void)
{
    Display *dpy = XtDisplay(canvas);
    Window win = XtWindow(canvas);
    XGCValues gcvals;
    unsigned long mask;
    Colormap colormap;
    XColor fg, bg, hl, tmp;

    if (dmxConfigGCInit++)
        return;

    XtVaGetValues(canvas, XtNcolormap, &colormap, NULL);
    XAllocNamedColor(XtDisplay(canvas), colormap, "black", &bg, &tmp);
    XAllocNamedColor(XtDisplay(canvas), colormap, "white", &fg, &tmp);
    XAllocNamedColor(XtDisplay(canvas), colormap, "red", &hl, &tmp);

    mask = (GCFunction | GCPlaneMask | GCClipMask | GCForeground |
            GCBackground | GCLineWidth | GCLineStyle | GCCapStyle |
            GCFillStyle);

    /* FIXME: copy this from widget */
    gcvals.function = GXcopy;
    gcvals.plane_mask = AllPlanes;
    gcvals.clip_mask = None;
    gcvals.foreground = fg.pixel;
    gcvals.background = bg.pixel;
    gcvals.line_width = 0;
    gcvals.line_style = LineSolid;
    gcvals.cap_style = CapNotLast;
    gcvals.fill_style = FillSolid;

    dmxConfigGC = XCreateGC(dpy, win, mask, &gcvals);
    gcvals.foreground = hl.pixel;
    dmxConfigGCHL = XCreateGC(dpy, win, mask, &gcvals);
    gcvals.foreground = bg.pixel;
    gcvals.background = fg.pixel;
    dmxConfigGCRev = XCreateGC(dpy, win, mask, &gcvals);
}

static void
dmxConfigGetDims(int *maxWidth, int *maxHeight)
{
    DMXConfigSubPtr pt;
    DMXConfigEntryPtr e;

    *maxWidth = dmxConfigWallWidth = 0;
    *maxHeight = dmxConfigWallHeight = 0;
    if (!dmxConfigCurrent)
        return;

    dmxConfigWallWidth = dmxConfigCurrent->width;
    dmxConfigWallHeight = dmxConfigCurrent->height;
    if (!dmxConfigWallWidth || !dmxConfigWallHeight) {
        for (pt = dmxConfigCurrent->subentry; pt; pt = pt->next) {
            if (pt->type == dmxConfigDisplay) {
                int x = pt->display->scrnWidth + pt->display->rootXOrigin;
                int y = pt->display->scrnHeight + pt->display->rootYOrigin;

                if (x > dmxConfigWallWidth)
                    dmxConfigWallWidth = x;
                if (y > dmxConfigWallHeight)
                    dmxConfigWallHeight = y;
            }
        }
    }
    /* Compute maximums */
    *maxWidth = *maxHeight = 0;
    for (e = dmxConfigEntry; e; e = e->next) {
        if (e->type != dmxConfigVirtual)
            continue;
        for (pt = e->virtual->subentry; pt; pt = pt->next) {
            if (pt->type == dmxConfigDisplay) {
                int x = pt->display->scrnWidth + pt->display->rootXOrigin;
                int y = pt->display->scrnHeight + pt->display->rootYOrigin;

                if (x > *maxWidth)
                    *maxWidth = x;
                if (y > *maxHeight)
                    *maxHeight = y;
            }
        }
    }
    if (dmxConfigWallWidth > *maxWidth)
        *maxWidth = dmxConfigWallWidth;
    if (dmxConfigWallHeight > *maxHeight)
        *maxHeight = dmxConfigWallHeight;
}

static int
scalex(int x)
{
    return (int) ((x * dmxConfigScaleX) + .5);
}

static int
scaley(int y)
{
    return (int) ((y * dmxConfigScaleY) + .5);
}

static int
unscalex(int x)
{
    return (int) ((x / dmxConfigScaleX) + .5);
}

static int
unscaley(int y)
{
    return (int) ((y / dmxConfigScaleY) + .5);
}

static void
dmxConfigDataUpdate(void)
{
    /* FIXME: could result in buffer overflows */
    char cnambuf[512];
    char cdimbuf[128];
    char nambuf[512];
    char dimbuf[128];
    char rtbuf[128];
    char offbuf[128];
    const char *name;

    if (!dmxConfigCurrent) {
        XtVaSetValues(cnamebox, XtNlabel, "", XtNsensitive, False, NULL);
        XtVaSetValues(cdimbox, XtNlabel, "", XtNsensitive, False, NULL);
        XtVaSetValues(ecbutton, XtNsensitive, False, NULL);
        XtVaSetValues(dcbutton, XtNsensitive, False, NULL);
        XtVaSetValues(ndbutton0, XtNsensitive, False, NULL);
        XtVaSetValues(ndbutton1, XtNsensitive, False, NULL);
    }
    else {
        name = dmxConfigCurrent->name;
        snprintf(cnambuf, sizeof(cnambuf), "%s", name ? name : "");
        snprintf(cdimbuf, sizeof(cdimbuf), "%dx%d",
                 dmxConfigWallWidth, dmxConfigWallHeight);
        XtVaSetValues(cnamebox, XtNlabel, cnambuf, XtNsensitive, True, NULL);
        XtVaSetValues(cdimbox, XtNlabel, cdimbuf, XtNsensitive, True, NULL);
        XtVaSetValues(ecbutton, XtNsensitive, True, NULL);
        XtVaSetValues(dcbutton, XtNsensitive, True, NULL);
        XtVaSetValues(ndbutton0, XtNsensitive, True, NULL);
        XtVaSetValues(ndbutton1, XtNsensitive, True, NULL);
    }

    if (!dmxConfigCurrentDisplay) {
        XtVaSetValues(namebox, XtNlabel, "", XtNsensitive, False, NULL);
        XtVaSetValues(dimbox, XtNlabel, "", XtNsensitive, False, NULL);
        XtVaSetValues(rtbox, XtNlabel, "", XtNsensitive, False, NULL);
        XtVaSetValues(origbox, XtNlabel, "", XtNsensitive, False, NULL);
        XtVaSetValues(edbutton, XtNsensitive, False, NULL);
        XtVaSetValues(ddbutton, XtNsensitive, False, NULL);
    }
    else {
        name = dmxConfigCurrentDisplay->name;
        snprintf(nambuf, sizeof(nambuf), "%s", name ? name : "");
        snprintf(dimbuf, sizeof(dimbuf), "%dx%d%c%d%c%d",
                 dmxConfigCurrentDisplay->scrnWidth,
                 dmxConfigCurrentDisplay->scrnHeight,
                 dmxConfigCurrentDisplay->scrnXSign < 0 ? '-' : '+',
                 dmxConfigCurrentDisplay->scrnX,
                 dmxConfigCurrentDisplay->scrnYSign < 0 ? '-' : '+',
                 dmxConfigCurrentDisplay->scrnY);
        snprintf(rtbuf, sizeof(dimbuf), "%dx%d%c%d%c%d",
                 dmxConfigCurrentDisplay->rootWidth,
                 dmxConfigCurrentDisplay->rootHeight,
                 dmxConfigCurrentDisplay->rootXSign < 0 ? '-' : '+',
                 dmxConfigCurrentDisplay->rootX,
                 dmxConfigCurrentDisplay->rootYSign < 0 ? '-' : '+',
                 dmxConfigCurrentDisplay->rootY);
        snprintf(offbuf, sizeof(offbuf), "@%dx%d",
                 dmxConfigCurrentDisplay->rootXOrigin,
                 dmxConfigCurrentDisplay->rootYOrigin);
        XtVaSetValues(namebox, XtNlabel, nambuf, XtNsensitive, True, NULL);
        XtVaSetValues(dimbox, XtNlabel, dimbuf, XtNsensitive, True, NULL);
        XtVaSetValues(rtbox, XtNlabel, rtbuf, XtNsensitive, True, NULL);
        XtVaSetValues(origbox, XtNlabel, offbuf, XtNsensitive, True, NULL);
        XtVaSetValues(edbutton, XtNsensitive, True, NULL);
        XtVaSetValues(ddbutton, XtNsensitive, True, NULL);
    }
}

static void
dmxConfigCanvasUpdate(void)
{
    DMXConfigSubPtr pt;
    Display *dpy = XtDisplay(canvas);
    Window win = XtWindow(canvas);
    GContext gcontext = XGContextFromGC(dmxConfigGC);
    XFontStruct *fs;
    int w, h;

    XFillRectangle(dpy, win, dmxConfigGCRev,
                   0, 0, dmxConfigWidgetWidth, dmxConfigWidgetHeight);
    dmxConfigDataUpdate();
    if (!dmxConfigCurrent)
        return;

    w = scalex(dmxConfigWallWidth);
    h = scaley(dmxConfigWallHeight);
    if (w > dmxConfigWidgetWidth - 1)
        w = dmxConfigWidgetWidth - 1;
    if (h > dmxConfigWidgetHeight - 1)
        h = dmxConfigWidgetHeight - 1;
    XDrawRectangle(dpy, win, dmxConfigGC, 0, 0, w, h);
    fs = XQueryFont(dpy, gcontext);
    for (pt = dmxConfigCurrent->subentry; pt; pt = pt->next) {
        int x, y, len;
        GC gc;

        if (pt->type != dmxConfigDisplay)
            continue;
        gc = (pt->display == dmxConfigCurrentDisplay
              ? dmxConfigGCHL : dmxConfigGC);
        x = scalex(pt->display->rootXOrigin);
        y = scaley(pt->display->rootYOrigin);
        w = scalex(pt->display->scrnWidth);
        h = scaley(pt->display->scrnHeight);
        len = pt->display->name ? strlen(pt->display->name) : 0;
        if (x > dmxConfigWidgetWidth - 1)
            x = dmxConfigWidgetWidth - 1;
        if (y > dmxConfigWidgetHeight - 1)
            y = dmxConfigWidgetHeight - 1;
        XDrawRectangle(dpy, win, gc, x, y, w, h);
        if (fs && len) {
            int xo = 3, yo = fs->ascent + fs->descent + 2;

            while (len && XTextWidth(fs, pt->display->name, len) >= w - 2 * xo)
                --len;
            if (len)
                XDrawString(dpy, win, gc, x + xo, y + yo, pt->display->name,
                            len);
        }
    }
    if (fs)
        XFreeFontInfo(NULL, fs, 0);
}

static void
dmxConfigCanvasDraw(Region region)
{
    Display *dpy = XtDisplay(canvas);
    int maxWidth, maxHeight;

    dmxConfigCanvasGCs();
    if (region) {
        XSetRegion(dpy, dmxConfigGC, region);
        XSetRegion(dpy, dmxConfigGCRev, region);
        XSetRegion(dpy, dmxConfigGCHL, region);
    }
    XtVaGetValues(canvas,
                  XtNwidth, &dmxConfigWidgetWidth,
                  XtNheight, &dmxConfigWidgetHeight, NULL);
    dmxConfigGetDims(&maxWidth, &maxHeight);
    dmxConfigScaleX = (double) dmxConfigWidgetWidth / maxWidth;
    dmxConfigScaleY = (double) dmxConfigWidgetHeight / maxHeight;
    if (dmxConfigScaleX > dmxConfigScaleY)
        dmxConfigScaleX = dmxConfigScaleY;
    if (dmxConfigScaleY > dmxConfigScaleX)
        dmxConfigScaleY = dmxConfigScaleX;
    dmxConfigCanvasUpdate();
    if (region) {
        XSetClipMask(dpy, dmxConfigGC, None);
        XSetClipMask(dpy, dmxConfigGCRev, None);
        XSetClipMask(dpy, dmxConfigGCHL, None);
    }
}

static void
dmxConfigSelectCallback(Widget w, XtPointer closure, XtPointer callData)
{
    dmxConfigCurrent = closure;
    dmxConfigVirtualPrint(stdout, dmxConfigCurrent);
    dmxConfigCanvasDraw(NULL);
}

static void
dmxConfigCopystrings(void)
{
    DMXConfigEntryPtr pt;
    DMXConfigSubPtr sub;

    if (!dmxConfigCurrent)
        return;

    /* FIXME: this is all a per-config file
     * memory leak */
    for (pt = dmxConfigEntry; pt; pt = pt->next) {
        if (pt->type == dmxConfigVirtual) {
            pt->virtual->name = XtNewString(pt->virtual->name
                                            ? pt->virtual->name : "");

            for (sub = pt->virtual->subentry; sub; sub = sub->next) {
                if (sub->type != dmxConfigDisplay)
                    continue;
                sub->display->name = XtNewString(sub->display->name
                                                 ? sub->display->name : "");
            }
        }
    }
}

static void
dmxConfigGetValueString(char **d, Widget w)
{
    const char *tmp = XawDialogGetValueString(w);

    if (*d)
        XtFree(*d);
    *d = XtNewString(tmp);
}

static void
dmxConfigSetupCnamemenu(void)
{
    static Widget cnamemenu = NULL;
    Widget w;
    DMXConfigEntryPtr pt;

    if (cnamemenu)
        XtDestroyWidget(cnamemenu);
    cnamemenu = NULL;

    if (!dmxConfigCurrent)
        return;
    cnamemenu = XtVaCreatePopupShell("cnamemenu", simpleMenuWidgetClass,
                                     cnamebox, NULL);

    for (pt = dmxConfigEntry; pt; pt = pt->next) {
        if (pt->type == dmxConfigVirtual) {
            w = XtVaCreateManagedWidget(pt->virtual->name
                                        ? pt->virtual->name
                                        : "",
                                        smeBSBObjectClass, cnamemenu, NULL);
            XtAddCallback(w, XtNcallback, dmxConfigSelectCallback, pt->virtual);
        }
    }
}

static void
dmxConfigReadFile(void)
{
    FILE *str;
    DMXConfigEntryPtr pt;

    if (!(str = fopen(dmxConfigFilename, "r"))) {
        dmxLog(dmxWarning, "Unable to read configuration file %s\n",
               dmxConfigFilename);
        return;
    }
    yyin = str;
    yydebug = 0;
    yyparse();
    fclose(str);
    dmxLog(dmxInfo, "Read configuration file %s\n", dmxConfigFilename);

    for (pt = dmxConfigEntry; pt; pt = pt->next) {
        if (pt->type == dmxConfigVirtual) {
            dmxConfigCurrent = pt->virtual;
            break;
        }
    }

    if (XtIsRealized(canvas)) {
        dmxConfigCopystrings();
        dmxConfigSetupCnamemenu();
        dmxConfigCanvasDraw(NULL);
    }
    dmxConfigVirtualPrint(stdout, dmxConfigCurrent);
}

static void
dmxConfigWriteFile(void)
{
    FILE *str;

    if (!(str = fopen(dmxConfigFilename, "w"))) {
        dmxLog(dmxWarning, "Unable to write configuration file %s\n",
               dmxConfigFilename);
        return;
    }
    dmxConfigPrint(str, dmxConfigEntry);
    fclose(str);
}

static DMXConfigDisplayPtr
dmxConfigFindDisplay(int x, int y)
{
    DMXConfigSubPtr pt;

    if (!dmxConfigCurrent)
        return NULL;
    for (pt = dmxConfigCurrent->subentry; pt; pt = pt->next) {
        DMXConfigDisplayPtr d = pt->display;

        if (pt->type != dmxConfigDisplay)
            continue;
        if (x >= scalex(d->rootXOrigin)
            && x <= scalex(d->rootXOrigin + d->scrnWidth)
            && y >= scaley(d->rootYOrigin)
            && y <= scaley(d->rootYOrigin + d->scrnHeight))
            return d;
    }
    return NULL;
}

static void
dmxConfigSetPopupPosition(Widget popup)
{
    Position x, y;
    Window t1, t2;
    int root_x, root_y;
    int temp_x, temp_y;
    unsigned int temp;

    XtRealizeWidget(popup);
    if (!XQueryPointer(XtDisplay(popup), XtWindow(popup), &t1, &t2,
                       &root_x, &root_y, &temp_x, &temp_y, &temp))
        root_x = root_y = 0;

    x = root_x - 5;
    y = root_y - 5;
    XtVaSetValues(popup, XtNx, x, XtNy, y, NULL);
}

static void
dmxConfigPlaceMenu(Widget w, XEvent * event,
                   String * params, Cardinal * num_params)
{
    dmxConfigSetPopupPosition(buttonpopup);
}

static void
dmxConfigMove(int deltaX, int deltaY)
{
    dmxConfigCurrentDisplay->rootXOrigin += deltaX;
    dmxConfigCurrentDisplay->rootYOrigin += deltaY;
    if (dmxConfigCurrentDisplay->rootXOrigin < 0)
        dmxConfigCurrentDisplay->rootXOrigin = 0;
    if (dmxConfigCurrentDisplay->rootYOrigin < 0)
        dmxConfigCurrentDisplay->rootYOrigin = 0;
    if (dmxConfigWallWidth && dmxConfigWallHeight) {
        if (dmxConfigCurrentDisplay->rootXOrigin >= dmxConfigWallWidth)
            dmxConfigCurrentDisplay->rootXOrigin = dmxConfigWallWidth - 1;
        if (dmxConfigCurrentDisplay->rootYOrigin >= dmxConfigWallHeight)
            dmxConfigCurrentDisplay->rootYOrigin = dmxConfigWallHeight - 1;
    }
    dmxConfigCanvasUpdate();
    dmxConfigNotSaved = 1;
}

static void
dmxConfigCanvasInput(Widget w, XtPointer closure, XtPointer callData)
{
    XEvent *e = (XEvent *) callData;
    DMXConfigDisplayPtr display = NULL;

    switch (e->type) {
    case ButtonPress:
        if (e->xbutton.button == Button1) {
            dmxConfigGrabbed = 1;
            dmxConfigGrabbedFine = 0;
            dmxConfigGrabbedX = e->xbutton.x;
            dmxConfigGrabbedY = e->xbutton.y;
        }
        if (e->xbutton.button == Button2) {
            dmxConfigGrabbed = 1;
            dmxConfigGrabbedFine = 1;
            dmxConfigGrabbedX = e->xbutton.x;
            dmxConfigGrabbedY = e->xbutton.y;
        }
        break;
    case ButtonRelease:
        if (e->xbutton.button == Button1)
            dmxConfigGrabbed = 0;
        if (e->xbutton.button == Button2)
            dmxConfigGrabbed = 0;
        break;
    case MotionNotify:
        if (dmxConfigGrabbed && dmxConfigCurrentDisplay) {
            int deltaX = e->xmotion.x - dmxConfigGrabbedX;
            int deltaY = e->xmotion.y - dmxConfigGrabbedY;

            dmxConfigMove(dmxConfigGrabbedFine ? deltaX : unscalex(deltaX),
                          dmxConfigGrabbedFine ? deltaY : unscaley(deltaY));
            dmxConfigGrabbedX = e->xmotion.x;
            dmxConfigGrabbedY = e->xmotion.y;
        }
        else {
            display = dmxConfigFindDisplay(e->xmotion.x, e->xmotion.y);
            if (display != dmxConfigCurrentDisplay) {
                dmxConfigCurrentDisplay = display;
                dmxConfigCanvasUpdate();
            }
        }
        break;
    case KeyPress:
        switch (XLookupKeysym(&e->xkey, 0)) {
        case XK_Right:
            dmxConfigMove(1, 0);
            break;
        case XK_Left:
            dmxConfigMove(-1, 0);
            break;
        case XK_Down:
            dmxConfigMove(0, 1);
            break;
        case XK_Up:
            dmxConfigMove(0, -1);
            break;
        }
        break;
    }
}

static void
dmxConfigCanvasResize(Widget w, XtPointer closure, XtPointer callData)
{
    dmxConfigCanvasDraw(NULL);
}

static void
dmxConfigCanvasExpose(Widget w, XtPointer closure, XtPointer callData)
{
    CanvasExposeDataPtr data = (CanvasExposeDataPtr) callData;

    dmxConfigCanvasDraw(data->region);
}

static void
dmxConfigOpenCallback(Widget w, XtPointer closure, XtPointer callData)
{
    dmxConfigState = dmxConfigStateOpen;
    XtVaSetValues(okbutton, XtNlabel, "Open", NULL);
    dmxConfigSetPopupPosition(openpopup);
    XtPopup(openpopup, XtGrabExclusive);
}

static void
dmxConfigSaveCallback(Widget w, XtPointer closure, XtPointer callData)
{
    dmxConfigState = dmxConfigStateSave;
    XtVaSetValues(okbutton, XtNlabel, "Save", NULL);
    dmxConfigSetPopupPosition(openpopup);
    XtPopup(openpopup, XtGrabExclusive);
}

static void
dmxConfigOkCallback(Widget w, XtPointer closure, XtPointer callData)
{
    dmxConfigGetValueString(&dmxConfigFilename, opendialog);
    XtPopdown(openpopup);
    if (dmxConfigState == dmxConfigStateOpen)
        dmxConfigReadFile();
    else
        dmxConfigWriteFile();
    dmxConfigNotSaved = 0;
}

static void
dmxConfigCanCallback(Widget w, XtPointer closure, XtPointer callData)
{
    XtPopdown(openpopup);
}

static void
dmxConfigECCallback(Widget w, XtPointer closure, XtPointer callData)
{
    char buf[256];              /* RATS: Only used in snprintf */

    if (!dmxConfigCurrent)
        return;
    dmxConfigSetPopupPosition(ecpopup);
    XtVaSetValues(ecdialog0, XtNvalue,
                  dmxConfigCurrent->name ? dmxConfigCurrent->name : "", NULL);
    snprintf(buf, sizeof(buf), "%dx%d",
             dmxConfigCurrent->width, dmxConfigCurrent->height);
    XtVaSetValues(ecdialog1, XtNvalue, buf, NULL);
    XtPopup(ecpopup, XtGrabExclusive);
}

static void
dmxConfigNCCallback(Widget w, XtPointer closure, XtPointer callData)
{
    int width = 1280 * 2, height = 1024 * 2;

    if (dmxConfigCurrent) {
        width = dmxConfigCurrent->width;
        height = dmxConfigCurrent->height;
    }

    dmxConfigCurrent = dmxConfigCreateVirtual(NULL, NULL, NULL,
                                              NULL, NULL, NULL);
    dmxConfigNewVirtual = dmxConfigCurrent;
    dmxConfigCurrent->width = width;
    dmxConfigCurrent->height = height;
    dmxConfigEntry = dmxConfigAddEntry(dmxConfigEntry, dmxConfigVirtual, NULL,
                                       dmxConfigCurrent);
    dmxConfigECCallback(w, closure, callData);
}

static void
dmxConfigDCCallback(Widget w, XtPointer closure, XtPointer callData)
{
    DMXConfigEntryPtr pt;

    if (!dmxConfigEntry)
        return;
    if (dmxConfigEntry
        && dmxConfigEntry->type == dmxConfigVirtual
        && dmxConfigEntry->virtual == dmxConfigCurrent) {
        dmxConfigEntry = dmxConfigEntry->next;
    }
    else {
        for (pt = dmxConfigEntry; pt && pt->next; pt = pt->next)
            if (pt->next->type == dmxConfigVirtual
                && pt->next->virtual == dmxConfigCurrent) {
                pt->next = pt->next->next;
                break;
            }
    }
    dmxConfigFreeVirtual(dmxConfigCurrent);
    dmxConfigCurrent = NULL;
    dmxConfigCurrentDisplay = NULL;

    /* Make the first entry current */
    for (pt = dmxConfigEntry; pt; pt = pt->next) {
        if (pt->type == dmxConfigVirtual) {
            dmxConfigCurrent = pt->virtual;
            break;
        }
    }

    dmxConfigSetupCnamemenu();
    dmxConfigCanvasDraw(NULL);
}

static void
dmxConfigECOkCallback(Widget w, XtPointer closure, XtPointer callData)
{
    const char *value;
    char *endpt;

    dmxConfigGetValueString((char **) &dmxConfigCurrent->name, ecdialog0);
    value = XawDialogGetValueString(ecdialog1);
    dmxConfigCurrent->width = strtol(value, &endpt, 10);
    dmxConfigCurrent->height = strtol(endpt + 1, NULL, 10);
    XtPopdown(ecpopup);
    dmxConfigCurrentDisplay = NULL;
    dmxConfigNewVirtual = NULL;
    dmxConfigSetupCnamemenu();
    dmxConfigCanvasDraw(NULL);
    dmxConfigNotSaved = 1;
}

static void
dmxConfigECCanCallback(Widget w, XtPointer closure, XtPointer callData)
{
    if (dmxConfigNewVirtual)
        dmxConfigDCCallback(w, closure, callData);
    dmxConfigNewVirtual = NULL;
    XtPopdown(ecpopup);
}

static void
dmxConfigEDCallback(Widget w, XtPointer closure, XtPointer callData)
{
    char buf[256];              /* RATS: Only used in snprintf */

    if (!dmxConfigCurrent || !dmxConfigCurrentDisplay)
        return;
    dmxConfigSetPopupPosition(edpopup);
    XtVaSetValues(eddialog0, XtNvalue,
                  dmxConfigCurrentDisplay->name
                  ? dmxConfigCurrentDisplay->name : "", NULL);
    snprintf(buf, sizeof(buf), "%dx%d%c%d%c%d",
             dmxConfigCurrentDisplay->scrnWidth,
             dmxConfigCurrentDisplay->scrnHeight,
             dmxConfigCurrentDisplay->scrnXSign < 0 ? '-' : '+',
             dmxConfigCurrentDisplay->scrnY,
             dmxConfigCurrentDisplay->scrnYSign < 0 ? '-' : '+',
             dmxConfigCurrentDisplay->scrnY);
    XtVaSetValues(eddialog1, XtNvalue, buf, NULL);
    snprintf(buf, sizeof(buf), "@%dx%d",
             dmxConfigCurrentDisplay->rootXOrigin,
             dmxConfigCurrentDisplay->rootYOrigin);
    XtVaSetValues(eddialog2, XtNvalue, buf, NULL);
    XtPopup(edpopup, XtGrabExclusive);
}

static void
dmxConfigNDCallback(Widget w, XtPointer closure, XtPointer callData)
{
    int width = 1280, height = 1024;

    if (!dmxConfigCurrent)
        return;
    if (dmxConfigCurrentDisplay) {
        width = dmxConfigCurrentDisplay->scrnWidth;
        height = dmxConfigCurrentDisplay->scrnHeight;
    }
    dmxConfigCurrentDisplay = dmxConfigCreateDisplay(NULL, NULL, NULL,
                                                     NULL, NULL);
    dmxConfigNewDisplay = dmxConfigCurrentDisplay;
    dmxConfigCurrentDisplay->scrnWidth = width;
    dmxConfigCurrentDisplay->scrnHeight = height;

    dmxConfigCurrent->subentry
        = dmxConfigAddSub(dmxConfigCurrent->subentry,
                          dmxConfigSubDisplay(dmxConfigCurrentDisplay));
    dmxConfigEDCallback(w, closure, callData);
}

static void
dmxConfigDDCallback(Widget w, XtPointer closure, XtPointer callData)
{
    DMXConfigSubPtr pt;

    if (!dmxConfigCurrent || !dmxConfigCurrentDisplay)
        return;
    /* First */
    if (dmxConfigCurrent->subentry
        && dmxConfigCurrent->subentry->type == dmxConfigDisplay
        && dmxConfigCurrent->subentry->display == dmxConfigCurrentDisplay) {
        dmxConfigCurrent->subentry = dmxConfigCurrent->subentry->next;
    }
    else {
        for (pt = dmxConfigCurrent->subentry; pt && pt->next; pt = pt->next)
            if (pt->next->type == dmxConfigDisplay
                && pt->next->display == dmxConfigCurrentDisplay) {
                pt->next = pt->next->next;
                break;
            }
    }
    dmxConfigFreeDisplay(dmxConfigCurrentDisplay);
    dmxConfigCurrentDisplay = NULL;
    dmxConfigSetupCnamemenu();
    dmxConfigCanvasDraw(NULL);
}

static void
dmxConfigAboutCallback(Widget w, XtPointer closure, XtPointer callData)
{
    dmxConfigSetPopupPosition(aboutpopup);
    XtPopup(aboutpopup, XtGrabExclusive);
}

static void
dmxConfigAboutOkCallback(Widget w, XtPointer closure, XtPointer CallData)
{
    XtPopdown(aboutpopup);
}

static void
dmxConfigQuitCallback(Widget w, XtPointer closure, XtPointer callData)
{
    if (dmxConfigNotSaved) {
        dmxConfigSetPopupPosition(quitpopup);
        XtPopup(quitpopup, XtGrabExclusive);
        return;
    }
    exit(0);
}

static void
dmxConfigQuitOkCallback(Widget w, XtPointer closure, XtPointer callData)
{
    XtPopdown(quitpopup);
    exit(0);
}

static void
dmxConfigQuitCanCallback(Widget w, XtPointer closure, XtPointer callData)
{
    XtPopdown(quitpopup);
}

static void
dmxConfigEDOkCallback(Widget w, XtPointer closure, XtPointer callData)
{
    char *value;
    char *endpt;

    dmxConfigNewDisplay = NULL;
    dmxConfigGetValueString((char **) &dmxConfigCurrentDisplay->name,
                            eddialog0);
    value = XawDialogGetValueString(eddialog1);
    if (*value == '-' || *value == '+') {
        dmxConfigCurrentDisplay->scrnWidth = 0;
        dmxConfigCurrentDisplay->scrnHeight = 0;
        endpt = value;
    }
    else {
        dmxConfigCurrentDisplay->scrnWidth = strtol(value, &endpt, 10);
        dmxConfigCurrentDisplay->scrnHeight = strtol(endpt + 1, &endpt, 10);
    }
    if (*endpt) {
        dmxConfigCurrentDisplay->scrnXSign = (*endpt == '-') ? -1 : 1;
        dmxConfigCurrentDisplay->scrnX = strtol(endpt + 1, &endpt, 10);
        dmxConfigCurrentDisplay->scrnYSign = (*endpt == '-') ? -1 : 1;
        dmxConfigCurrentDisplay->scrnY = strtol(endpt + 1, NULL, 10);
    }
    if (dmxConfigCurrentDisplay->scrnX < 0)
        dmxConfigCurrentDisplay->scrnX = -dmxConfigCurrentDisplay->scrnX;
    if (dmxConfigCurrentDisplay->scrnY < 0)
        dmxConfigCurrentDisplay->scrnY = -dmxConfigCurrentDisplay->scrnY;
    value = XawDialogGetValueString(eddialog2);
    dmxConfigCurrentDisplay->rootXOrigin = strtol(value + 1, &endpt, 10);
    dmxConfigCurrentDisplay->rootYOrigin = strtol(endpt + 1, NULL, 10);
    XtPopdown(edpopup);
    dmxConfigSetupCnamemenu();
    dmxConfigCanvasDraw(NULL);
    dmxConfigNotSaved = 1;
}

static void
dmxConfigEDCanCallback(Widget w, XtPointer closure, XtPointer callData)
{
    if (dmxConfigNewDisplay)
        dmxConfigDDCallback(w, closure, callData);
    dmxConfigNewDisplay = NULL;
    XtPopdown(edpopup);
}

static void
dmxConfigOkAction(Widget w, XEvent * event,
                  String * params, Cardinal * num_params)
{
    Widget p = XtParent(w);
    Widget t;

    if (p == opendialog)
        dmxConfigOkCallback(w, NULL, NULL);

    if (p == ecdialog0) {
        t = XtNameToWidget(ecdialog1, "value");
        XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
    }
    if (p == ecdialog1)
        dmxConfigECOkCallback(w, NULL, NULL);

    if (p == eddialog0) {
        t = XtNameToWidget(eddialog1, "value");
        XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
    }
    if (p == eddialog1) {
        t = XtNameToWidget(eddialog2, "value");
        XWarpPointer(XtDisplay(t), None, XtWindow(t), 0, 0, 0, 0, 0, 10);
    }
    if (p == eddialog2)
        dmxConfigEDOkCallback(w, NULL, NULL);
}

int
main(int argc, char **argv)
{
    XtAppContext appContext;
    Widget toplevel;
    Widget parent, menubox, bottombox, databox, canvasbox;
    Widget filebutton, helpbutton;
    Widget filemenu, openbutton, savebutton, quitbutton;
    Widget helpmenu, aboutbutton, aboutbox, aboutok;
    Widget quitbox, quitok, quitcan;
    Widget ncbutton;
    Widget canbutton;
    Widget ecbox, ecokbutton, eccanbutton;
    Widget edbox, edokbutton;
    Widget edcanbutton;

    /* FIXME: add meta-i, ctrl,meta-z,v? */
    const char *opentrans = "<Key>Return: openOk()\n\
                                 <Key>Linefeed: openOk()\n\
                                 Ctrl<Key>M: openOk()\n\
                                 Ctrl<Key>J: openOk()\n\
                                 Ctrl<Key>O: noop()\n\
                                 Ctrl<Key>N: noop()\n\
                                 Ctrl<Key>P: noop()";
    const char *canvastrans =
        "<Btn3Down>: placeMenu() XtMenuPopup(buttonpopup)";
    XtActionsRec actiontable[] = {
        {(char *) "openOk", dmxConfigOkAction},
        {(char *) "placeMenu", dmxConfigPlaceMenu},
        {(char *) "noop", NULL}
    };

    dmxConfigFilename = XtNewString((argc >= 2) ? argv[1] : "");

    toplevel = XtVaAppInitialize(&appContext, "XDmxconfig",
                                 NULL, 0, &argc, argv, NULL, NULL);

    /* Main boxes */
    parent = XtVaCreateManagedWidget("parent", formWidgetClass, toplevel,
                                     XtNorientation, XtorientVertical,
                                     XtNwidth, DMX_MAIN_WIDTH,
                                     XtNheight, DMX_MAIN_HEIGHT, NULL);
    menubox = XtVaCreateManagedWidget("menubox", boxWidgetClass, parent,
                                      XtNborderWidth, 0,
                                      XtNorientation, XtorientHorizontal,
                                      XtNtop, XtChainTop, NULL);
    bottombox = XtVaCreateManagedWidget("bottombox", formWidgetClass, parent,
                                        XtNborderWidth, 0,
                                        XtNfromVert, menubox,
                                        XtNorientation, XtorientHorizontal,
                                        NULL);
    databox = XtVaCreateManagedWidget("databox", formWidgetClass,
                                      bottombox,
                                      XtNborderWidth, 0,
                                      XtNhorizDistance, 0,
                                      XtNwidth, DMX_DATA_WIDTH,
                                      XtNheight, DMX_DATA_HEIGHT,
                                      XtNleft, XtChainLeft,
                                      XtNorientation, XtorientVertical, NULL);

    /* Data */
    cnamebox = XtVaCreateManagedWidget("cnamebox", menuButtonWidgetClass,
                                       databox,
                                       XtNtop, XtChainTop,
                                       XtNjustify, XtJustifyLeft,
                                       XtNwidth, DMX_DATA_WIDTH,
                                       XtNlabel, "",
                                       XtNmenuName, "cnamemenu", NULL);
    cdimbox = XtVaCreateManagedWidget("cdimbox", labelWidgetClass,
                                      databox,
                                      XtNfromVert, cnamebox,
                                      XtNjustify, XtJustifyLeft,
                                      XtNwidth, DMX_DATA_WIDTH,
                                      XtNlabel, "", NULL);
    namebox = XtVaCreateManagedWidget("namebox", labelWidgetClass, databox,
                                      XtNfromVert, cdimbox,
                                      XtNjustify, XtJustifyLeft,
                                      XtNwidth, DMX_DATA_WIDTH,
                                      XtNlabel, "", NULL);
    dimbox = XtVaCreateManagedWidget("dimbox", labelWidgetClass,
                                     databox,
                                     XtNfromVert, namebox,
                                     XtNjustify, XtJustifyLeft,
                                     XtNwidth, DMX_DATA_WIDTH,
                                     XtNlabel, "", NULL);
    rtbox = XtVaCreateManagedWidget("rtbox", labelWidgetClass,
                                    databox,
                                    XtNfromVert, dimbox,
                                    XtNjustify, XtJustifyLeft,
                                    XtNwidth, DMX_DATA_WIDTH,
                                    XtNlabel, "", NULL);
    origbox = XtVaCreateManagedWidget("origbox", labelWidgetClass,
                                      databox,
                                      XtNfromVert, rtbox,
                                      XtNjustify, XtJustifyLeft,
                                      XtNwidth, DMX_DATA_WIDTH,
                                      XtNlabel, "", NULL);

    /* Canvas */
    canvasbox = XtVaCreateManagedWidget("canvasbox", boxWidgetClass,
                                        bottombox,
                                        XtNborderWidth, 0,
                                        XtNwidth, DMX_CANVAS_WIDTH,
                                        XtNheight, DMX_CANVAS_HEIGHT,
                                        XtNfromHoriz, databox, NULL);

    canvas = XtVaCreateManagedWidget("canvas", canvasWidgetClass,
                                     canvasbox,
                                     XtNwidth, DMX_CANVAS_WIDTH,
                                     XtNheight, DMX_CANVAS_HEIGHT, NULL);

    /* Main menu buttons */
    filebutton = XtVaCreateManagedWidget("File", menuButtonWidgetClass,
                                         menubox,
                                         XtNmenuName, "filemenu", NULL);
    helpbutton = XtVaCreateManagedWidget("Help", menuButtonWidgetClass,
                                         menubox,
                                         XtNmenuName, "helpmenu", NULL);

    /* File submenu buttons */
    filemenu = XtVaCreatePopupShell("filemenu", simpleMenuWidgetClass,
                                    filebutton, NULL);
    openbutton = XtVaCreateManagedWidget("Open File", smeBSBObjectClass,
                                         filemenu, NULL);
    savebutton = XtVaCreateManagedWidget("Save File", smeBSBObjectClass,
                                         filemenu, NULL);
    ncbutton = XtVaCreateManagedWidget("New Global", smeBSBObjectClass,
                                       filemenu, NULL);
    ecbutton = XtVaCreateManagedWidget("Edit Global", smeBSBObjectClass,
                                       filemenu, NULL);
    dcbutton = XtVaCreateManagedWidget("Delete Global", smeBSBObjectClass,
                                       filemenu, NULL);
    ndbutton0 = XtVaCreateManagedWidget("New Display", smeBSBObjectClass,
                                        filemenu, NULL);
    quitbutton = XtVaCreateManagedWidget("Quit", smeBSBObjectClass,
                                         filemenu, NULL);

    /* Help submenu button */
    helpmenu = XtVaCreatePopupShell("helpmenu", simpleMenuWidgetClass,
                                    helpbutton, NULL);
    aboutbutton = XtVaCreateManagedWidget("About", smeBSBObjectClass,
                                          helpmenu, NULL);

    /* Open popup */
    openpopup = XtVaCreatePopupShell("openpopup", transientShellWidgetClass,
                                     toplevel, NULL);
    opendialog = XtVaCreateManagedWidget("opendialog", dialogWidgetClass,
                                         openpopup,
                                         XtNlabel, "Filename: ",
                                         XtNvalue, dmxConfigFilename, NULL);
    okbutton = XtVaCreateManagedWidget("Open", commandWidgetClass,
                                       opendialog, NULL);
    canbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
                                        opendialog, NULL);

    /* EC popup */
    ecpopup = XtVaCreatePopupShell("ecpopup", transientShellWidgetClass,
                                   toplevel, NULL);
    ecbox = XtVaCreateManagedWidget("ecbox", boxWidgetClass, ecpopup, NULL);
    ecdialog0 = XtVaCreateManagedWidget("ecdialog0", dialogWidgetClass,
                                        ecbox,
                                        XtNlabel, "Name:              ",
                                        XtNvalue, "", NULL);
    ecdialog1 = XtVaCreateManagedWidget("ecdialog1", dialogWidgetClass,
                                        ecbox,
                                        XtNlabel, "Dimension:         ",
                                        XtNvalue, "", NULL);
    ecokbutton = XtVaCreateManagedWidget("OK", commandWidgetClass, ecbox, NULL);
    eccanbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
                                          ecbox, NULL);

    /* ED popup */
    edpopup = XtVaCreatePopupShell("edpopup", transientShellWidgetClass,
                                   toplevel, NULL);
    edbox = XtVaCreateManagedWidget("edbox", boxWidgetClass, edpopup, NULL);
    eddialog0 = XtVaCreateManagedWidget("eddialog0", dialogWidgetClass,
                                        edbox,
                                        XtNlabel, "Display Name:      ",
                                        XtNvalue, "", NULL);
    eddialog1 = XtVaCreateManagedWidget("eddialog1", dialogWidgetClass,
                                        edbox,
                                        XtNlabel, "Geometry:          ",
                                        XtNvalue, "", NULL);
    eddialog2 = XtVaCreateManagedWidget("eddialog2", dialogWidgetClass,
                                        edbox,
                                        XtNlabel, "Offset:            ",
                                        XtNvalue, "", NULL);
    edokbutton = XtVaCreateManagedWidget("OK", commandWidgetClass, edbox, NULL);
    edcanbutton = XtVaCreateManagedWidget("Cancel", commandWidgetClass,
                                          edbox, NULL);

    /* About popup */
    aboutpopup = XtVaCreatePopupShell("aboutpopup", transientShellWidgetClass,
                                      toplevel, NULL);
    aboutbox = XtVaCreateManagedWidget("aboutbox", boxWidgetClass,
                                       aboutpopup, NULL);
    XtVaCreateManagedWidget("abouttext", labelWidgetClass,
                            aboutbox, XtNlabel, DMX_INFO, NULL);
    aboutok = XtVaCreateManagedWidget("OK", commandWidgetClass, aboutbox, NULL);

    /* Quit popup */
    quitpopup = XtVaCreatePopupShell("quitpopup", transientShellWidgetClass,
                                     toplevel, NULL);
    quitbox = XtVaCreateManagedWidget("quitbox", boxWidgetClass,
                                      quitpopup, NULL);
    XtVaCreateManagedWidget("quittext", labelWidgetClass,
                            quitbox,
                            XtNlabel,
                            "Changes to the configuration\n"
                            "been made that have not yet\n"
                            "been saved.  Do you want to\n"
                            "quit without saving?", NULL);
    quitok = XtVaCreateManagedWidget("Quit WITHOUT Saving",
                                     commandWidgetClass, quitbox, NULL);
    quitcan = XtVaCreateManagedWidget("Continue Editing",
                                      commandWidgetClass, quitbox, NULL);

    /* Button popup */
    buttonpopup = XtVaCreatePopupShell("buttonpopup", simpleMenuWidgetClass,
                                       toplevel, NULL);
    ndbutton1 = XtVaCreateManagedWidget("New Display", smeBSBObjectClass,
                                        buttonpopup, NULL);
    edbutton = XtVaCreateManagedWidget("Edit Display", smeBSBObjectClass,
                                       buttonpopup, NULL);
    ddbutton = XtVaCreateManagedWidget("Delete Display", smeBSBObjectClass,
                                       buttonpopup, NULL);

    /* Callbacks */
    XtAddCallback(openbutton, XtNcallback, dmxConfigOpenCallback, NULL);
    XtAddCallback(savebutton, XtNcallback, dmxConfigSaveCallback, NULL);
    XtAddCallback(okbutton, XtNcallback, dmxConfigOkCallback, NULL);
    XtAddCallback(canbutton, XtNcallback, dmxConfigCanCallback, NULL);

    XtAppAddActions(appContext, actiontable, XtNumber(actiontable));
    XtOverrideTranslations(canvas, XtParseTranslationTable(canvastrans));
    XtOverrideTranslations(XtNameToWidget(opendialog, "value"),
                           XtParseTranslationTable(opentrans));
    XtOverrideTranslations(XtNameToWidget(ecdialog0, "value"),
                           XtParseTranslationTable(opentrans));
    XtOverrideTranslations(XtNameToWidget(ecdialog1, "value"),
                           XtParseTranslationTable(opentrans));
    XtOverrideTranslations(XtNameToWidget(eddialog0, "value"),
                           XtParseTranslationTable(opentrans));
    XtOverrideTranslations(XtNameToWidget(eddialog1, "value"),
                           XtParseTranslationTable(opentrans));
    XtOverrideTranslations(XtNameToWidget(eddialog2, "value"),
                           XtParseTranslationTable(opentrans));

    XtAddCallback(ncbutton, XtNcallback, dmxConfigNCCallback, NULL);
    XtAddCallback(ecbutton, XtNcallback, dmxConfigECCallback, NULL);
    XtAddCallback(ecokbutton, XtNcallback, dmxConfigECOkCallback, NULL);
    XtAddCallback(eccanbutton, XtNcallback, dmxConfigECCanCallback, NULL);
    XtAddCallback(dcbutton, XtNcallback, dmxConfigDCCallback, NULL);

    XtAddCallback(ndbutton0, XtNcallback, dmxConfigNDCallback, NULL);
    XtAddCallback(ndbutton1, XtNcallback, dmxConfigNDCallback, NULL);
    XtAddCallback(edbutton, XtNcallback, dmxConfigEDCallback, NULL);
    XtAddCallback(ddbutton, XtNcallback, dmxConfigDDCallback, NULL);
    XtAddCallback(edokbutton, XtNcallback, dmxConfigEDOkCallback, NULL);
    XtAddCallback(edcanbutton, XtNcallback, dmxConfigEDCanCallback, NULL);

    XtAddCallback(aboutbutton, XtNcallback, dmxConfigAboutCallback, NULL);
    XtAddCallback(aboutok, XtNcallback, dmxConfigAboutOkCallback, NULL);
    XtAddCallback(quitok, XtNcallback, dmxConfigQuitOkCallback, NULL);
    XtAddCallback(quitcan, XtNcallback, dmxConfigQuitCanCallback, NULL);

    XtAddCallback(quitbutton, XtNcallback, dmxConfigQuitCallback, NULL);

    XtAddCallback(canvas, XtNcallback, dmxConfigCanvasInput, NULL);
    XtAddCallback(canvas, XtNcanvasExposeCallback, dmxConfigCanvasExpose, NULL);
    XtAddCallback(canvas, XtNcanvasResizeCallback, dmxConfigCanvasResize, NULL);

    if (dmxConfigFilename)
        dmxConfigReadFile();

    XtRealizeWidget(toplevel);
    dmxConfigCopystrings();
    dmxConfigSetupCnamemenu();
    XtAppMainLoop(appContext);
    return 0;
}