src/bin/xeditor.c

/*************************************************************************

  XEDITOR.C -- Simple text editor for JSPICE3
  Copyright (C) Stephen R. Whiteley 1995, All rights reserved
  Version 1.0 1/17/95

 *************************************************************************/

#ifdef SPICE_MAKE
#include "spice.h"
#include "ftedefs.h"
#include "spfteext.h"
#else
#define HAVE_X11
#endif

#ifdef HAVE_X11

#include <stdio.h>
#include <signal.h>
#include <ctype.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pwd.h>

#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <X11/Xaw/Paned.h>
#include <X11/Xaw/AsciiText.h>
#include <X11/Xaw/Label.h>
#include <X11/Xaw/Viewport.h>
#include <X11/Xaw/Command.h>
#include <X11/Xaw/Box.h>
#include <X11/Shell.h>

typedef enum {QUIT, SAVE, SAVEAS, SOURCE, LOAD, TEXTMOD} event_type;

#ifdef STAND_ALONE
typedef enum {NOGO, NO_EXIST, READ_OK, WRITE_OK} check_type;
typedef struct {
    Widget shell;
    Widget form;
    Widget text;
    Widget title;
    Widget butbox;
    Widget popup;
    Widget popup_text;
    Widget message;
    Atom wm_delete;
    String *popup_sens_list;
    Bool TextChanged;
    event_type Last;
    String saved_as;
} widget_bag;

#else
#define XEDITOR
#include "x11util.h"
#endif

#ifdef __STDC__
extern int xeditor(char*);
#else
extern int xeditor();
#endif

#ifdef __STDC__
static char *nextarg(void);
static int  errorhandler(Display*, XErrorEvent*);
static void CRaction(Widget, XEvent*, String*, Cardinal*);
static void QUaction(Widget, XEvent*, String*, Cardinal*);
static void Quit(Widget, XtPointer, XtPointer);
static void Save(Widget, XtPointer, XtPointer);
static void SaveAs(Widget, XtPointer, XtPointer);
static void Source(Widget, XtPointer, XtPointer);
static void Load(Widget, XtPointer, XtPointer);
static void Change(Widget, XtPointer, XtPointer);
static void DoSaveAs(Widget, XtPointer, XtPointer);
static Bool same(char*, char*);
static void DoLoad(Widget, XtPointer, XtPointer);
#ifdef STAND_ALONE
static void PopUpInput(String, String, void(*)(), widget_bag*);
static void PopDownInput(Widget, XtPointer, XtPointer);
static void PopUpMessage(String, widget_bag*);
static void PopDownMessage(Widget, XtPointer, XtPointer);
static void CenterWidgetOnWidget(Widget, Widget);
static check_type CheckFile(char*, int, widget_bag*);
static void ToTop(Widget, XtPointer, XEvent*, Boolean*);
static char *tilde_expand(char*);
#endif
static void PopUpHelp(Widget, XtPointer, XtPointer);
static void PopDownHelp(Widget, XtPointer, XtPointer);

#else

static char *nextarg();
static int  errorhandler();
static void CRaction();
static void QUaction();
static void Quit();
static void Save();
static void SaveAs();
static void Source();
static void Load();
static void Change();
static void DoSaveAs();
static Bool same();
static void DoLoad();
#ifdef STAND_ALONE
static void PopUpInput();
static void PopDownInput();
static void PopUpMessage();
static void PopDownMessage();
static void CenterWidgetOnWidget();
static check_type CheckFile();
static void ToTop();
static char *tilde_expand();
#endif
static void PopUpHelp();
static void PopDownHelp();
#endif

#ifdef STAND_ALONE
Display *Xdisplay;
#else
extern Display *Xdisplay;
#endif

static char *oneLineTranslations =
    "<Key>Return: cr_action()\n<Key>Delete: delete-next-character()";
static char *textTranslations = "<Key>Delete: delete-next-character()";
static char *butTranslations = "<Btn1Up>: notify() reset()";
static char *wmTranslations = "<Message>WM_PROTOCOLS: quit_action()";
static char *sens_list[] = {"save_as", "load", 0};

#ifdef STAND_ALONE

static String fallback_resources[] = {

    "xeditor.xeditor.background: lightgrey",
    "xeditor.xeditor.buttonbox.background: lightblue",
    "xeditor.xeditor.buttonbox.Command.background: yellow",

    "xeditor.popup.form.background: lightblue",
    "xeditor.popup.form.Command.background: yellow",
    "xeditor.popup.form.Label.background: pink",

    "xeditor.popup_m.form_m.background: pink",
    "xeditor.popup_m.form_m.Command.background: yellow",

    "xeditor.popup_h.form_h.background: lightgrey",
    "xeditor.popup_h.form_h.buttonbox.background: lightblue",
    "xeditor.popup_h.form_h.buttonbox.Command.background: yellow",
    "xeditor.popup_h.form_h.buttonbox.Label.background: pink",
    NULL
};

static XtActionsRec actions[] = {
    {"cr_action", CRaction},
    {"quit_action", QUaction}
};

int  NumArgs;
char **Args;


int
main(argc, argv)

int argc;
char **argv;
{
    XtAppContext app_con;

    /* initialize X toolkit */
    XtToolkitInitialize();
    app_con = XtCreateApplicationContext();
    XtAppSetFallbackResources(app_con, fallback_resources);
    Xdisplay = XtOpenDisplay(app_con, NULL, NULL, "Xeditor", NULL, 0,
        &argc, argv);
    if (!Xdisplay) {
        fprintf(stderr, "Error: can't open display\n");
        exit(1);
    }
    XtAppAddActions(app_con, actions, XtNumber(actions));
    XSetErrorHandler(errorhandler);

    NumArgs = argc;
    Args = argv;
    if (NumArgs > 1) {
        Args++;
        NumArgs--;
        xeditor(*Args);
    }
    else
        xeditor(NULL);
    XtAppMainLoop(app_con);
    return (0);
}


static char *
nextarg()
{
    if (NumArgs > 1) {
        Args++;
        NumArgs--;
        return (*Args);
    }
    return ("");
}


static int
errorhandler(display, errorev)

Display *display;
XErrorEvent *errorev;
{
    char ErrorMessage[1024];

    XGetErrorText(display, errorev->error_code, ErrorMessage, 1024);
    printf(ErrorMessage);
    return (0);
}
#endif


static void
CRaction(caller, call_data, params, numparams)

Widget caller;
XEvent *call_data;
String *params;
Cardinal *numparams;
{
    /* simulate a button press when CR entered in text of popup */
    Widget action = XtNameToWidget(XtParent(caller), "action");

    if (action)
        XtCallCallbacks(action, XtNcallback, NULL);
}


static void
QUaction(caller, call_data, params, numparams)

Widget caller;
XEvent *call_data;
String *params;
Cardinal *numparams;
{
    /* simulate a Quit button press when DeleteWindow requested */
    Widget quit;

    quit = XtNameToWidget(caller, "xeditor.buttonbox.quit");
    if (!quit)
        quit = XtNameToWidget(caller, "form.cancel");
    if (!quit)
        quit = XtNameToWidget(caller, "form_h.buttonbox.cancel_h");
    if (!quit)
        quit = XtNameToWidget(caller, "form_m.cancel_m");

    if (quit)
        XtCallCallbacks(quit, XtNcallback, NULL);
}


int
xeditor(fname)
char *fname;

/* Create a new window... */
{
    Widget button;
    widget_bag *w;
    check_type which;
    char buf[256];
    static char tmpl[] = "/tmp/xeXXXXXX";

    /* Assume Xt toolkit is initialized! */
    w = (widget_bag*) XtMalloc(sizeof(widget_bag));

    w->shell = XtAppCreateShell(NULL, "Jspice3",
        applicationShellWidgetClass, Xdisplay, NULL, 0);
    XtOverrideTranslations(w->shell, XtParseTranslationTable(wmTranslations));
    w->form = XtVaCreateManagedWidget("xeditor", formWidgetClass,
        w->shell, NULL);

    w->butbox = XtVaCreateManagedWidget("buttonbox", boxWidgetClass,
        w->form,
        XtNwidth, 650,
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        XtNbottom, XtChainTop,
        XtNtop, XtChainTop,
        NULL);

    w->title = XtVaCreateManagedWidget("titlelabel", labelWidgetClass,
        w->form,
        XtNborderWidth, 0,
        XtNfromHoriz, w->butbox,
        XtNvertDistance, 10,
        XtNhorizDistance, 20,
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        XtNbottom, XtChainTop,
        XtNtop, XtChainTop,
        XtNresizable, True,
        NULL);

    button = XtVaCreateManagedWidget("quit", commandWidgetClass,
        w->butbox,
        XtNlabel, "Quit",
        NULL);
    XtAddCallback(button, XtNcallback, Quit, (XtPointer)w);
    XtOverrideTranslations(button, XtParseTranslationTable(butTranslations));

    button = XtVaCreateManagedWidget("save", commandWidgetClass,
        w->butbox,
        XtNlabel, "Save",
        NULL);
    XtAddCallback(button, XtNcallback, Save, (XtPointer)w);
    XtSetSensitive(button, False);

    button = XtVaCreateManagedWidget("save_as", commandWidgetClass,
        w->butbox,
        XtNlabel, "Save as",
        NULL);
    XtAddCallback(button, XtNcallback, SaveAs, (XtPointer)w);
    XtOverrideTranslations(button, XtParseTranslationTable(butTranslations));

#ifndef STAND_ALONE
    button = XtVaCreateManagedWidget("source", commandWidgetClass,
        w->butbox,
        XtNlabel, "Source",
        NULL);
    XtAddCallback(button, XtNcallback, Source, (XtPointer)w);
    XtOverrideTranslations(button, XtParseTranslationTable(butTranslations));
#endif

    button = XtVaCreateManagedWidget("load", commandWidgetClass,
        w->butbox,
        XtNlabel, "Load",
        NULL);
    XtAddCallback(button, XtNcallback, Load, (XtPointer)w);
    XtOverrideTranslations(button, XtParseTranslationTable(butTranslations));

    button = XtVaCreateManagedWidget("help", commandWidgetClass,
        w->butbox,
        XtNlabel, "Help",
        NULL);
#ifdef STAND_ALONE
    XtAddCallback(button, XtNcallback, PopUpHelp, (XtPointer)w);
    XtOverrideTranslations(button, XtParseTranslationTable(butTranslations));
#else
    XtAddCallback(button, XtNcallback, PopUpHelp, (XtPointer)"xeditor");
#endif

    w->text = XtVaCreateManagedWidget("main_text", asciiTextWidgetClass,
        w->form,
        XtNtype, XawAsciiFile,
        XtNeditType, XawtextRead,
        XtNallowResize, True,
        XtNscrollHorizontal, XawtextScrollWhenNeeded,
        XtNscrollVertical, XawtextScrollWhenNeeded,
        XtNfromVert, w->butbox,
        XtNwidth, 660,
        XtNheight, 350,
        XtNstring, "/dev/null",
        XtNtop, XtChainTop,
        NULL);
    XtAddCallback(XawTextGetSource(w->text), XtNcallback, Change,
        (XtPointer)w);
    XtOverrideTranslations(w->text, XtParseTranslationTable(textTranslations));

    XtRealizeWidget(w->shell);
    w->wm_delete = XInternAtom(Xdisplay, "WM_DELETE_WINDOW", False);
    XSetWMProtocols(Xdisplay, XtWindow(w->shell), &w->wm_delete, 1);

    if (fname && *fname) {
        strcpy(buf, fname);
        cp_pathfix(buf);
        fname = buf;
    }
    which = CheckFile(fname, R_OK, w);
    if (which == NOGO) {
        fname = (char*)mktemp(tmpl);
    }
    else if (which == READ_OK) {
        XtVaSetValues(w->text, XtNstring, fname, NULL);
        /* switch to edit mode, file may be read only in which
         * case the load will fail if in edit mode
         */
        XtVaSetValues(w->text, XtNeditType, XawtextEdit, NULL);
    }
    XtVaSetValues(w->title, XtNlabel, fname, NULL);
    w->TextChanged = False;
    w->popup = NULL;
    w->saved_as = NULL;
    w->Last = LOAD;
    w->popup_sens_list = sens_list;

    return (0);
}


/* ARGSUSED */
static void
Quit(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    widget_bag *w = (widget_bag*)client_data;

    if (w->TextChanged && (w->Last != QUIT)) {
        w->Last = QUIT;
        PopUpMessage(
            "Text has been modified.  Hit Quit again to quit", w);
        return;
    }
    XtDestroyWidget(w->shell);
    XtFree((char*)w);
#ifdef STAND_ALONE
    kill(0,SIGINT);
#endif
}


/* ARGSUSED */
static void
Save(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    widget_bag *w = (widget_bag*)client_data;
    Arg args[1];
    String fname;

    w->Last = SAVE;
    XtVaGetValues(w->title, XtNlabel, &fname, NULL);
    if (CheckFile(fname, W_OK, w) == NOGO)
        return;

    if (!XawAsciiSaveAsFile(XawTextGetSource(w->text), fname)) {
        PopUpMessage("Unknown error, text not saved", w);
        return;
    }
    PopUpMessage("Text saved", w);
    /* This can be called with TextChanged false if we saved
     * under a new name, and made no subsequent changes.
     */
    if (w->TextChanged) {
        w->TextChanged = False;
        XtAddCallback(XawTextGetSource(w->text), XtNcallback, Change,
            (XtPointer)w);
    }
    XtSetSensitive(caller, False);
    if (w->saved_as) {
        XtFree(w->saved_as);
        w->saved_as = NULL;
    }
}


/* ARGSUSED */
static void
SaveAs(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    widget_bag *w = (widget_bag*)client_data;
    String fname;
    XawTextPosition begin, end;

    w->Last = SAVEAS;
    XawTextGetSelectionPos(w->text, &begin, &end);
    if (begin == end) {
        XtVaGetValues(w->title, XtNlabel, &fname, NULL);
        PopUpInput(fname, "Save File", DoSaveAs, (widget_bag*)client_data);
    }
    else
        PopUpInput("", "Save Block", DoSaveAs, (widget_bag*)client_data);
}


#ifndef STAND_ALONE
/* ARGSUSED */
static void
Source(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    widget_bag *w = (widget_bag*)client_data;
    char *fname;
    FILE *fp;

    w->Last = SOURCE;
    if (w->TextChanged) {
        fname = smktemp("sp");
        if ((fp = inp_pathopen(fname, "w")) == NULL) {
            PopUpMessage("Unknown error, can't create temp file", w);
            return;
        }
        fclose(fp);
        if (!XawAsciiSaveAsFile(XawTextGetSource(w->text), fname)) {
            PopUpMessage("Unknown error, can't write temp file", w);
            return;
        }
        inp_srcedit(fname, False, False);
        PopUpMessage("Text sourced (temporary file)", w);
    }
    else {
        if (w->saved_as)
            fname = w->saved_as;
        else {
            XtVaGetValues(w->title, XtNlabel, &fname, NULL);
        }
        fname = copy(fname);
        inp_srcedit(fname, True, False);
        PopUpMessage("Text sourced (permanent file)", w);
    }
}
#endif


/* ARGSUSED */
static void
Load(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    widget_bag *w = (widget_bag*)client_data;
    char *newfname = NULL;

    if (w->TextChanged && (w->Last != LOAD)) {
        w->Last = LOAD;
        PopUpMessage(
            "Text has been modified.  Hit Load again to load", w);
        return;
    }
#ifdef STAND_ALONE
    newfname = nextarg();
#endif
    PopUpInput(newfname ? newfname : "", "Load file", DoLoad,
        (widget_bag*)client_data);
}


/* ARGSUSED */
static void
Change(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    widget_bag *w = (widget_bag*)client_data;

    w->Last = TEXTMOD;
    w->TextChanged = True;
    XtSetSensitive(XtNameToWidget(w->butbox, "save"), True);
    XtRemoveCallback(caller, XtNcallback, Change, (XtPointer)w);
}


/* ARGSUSED */
static void
DoSaveAs(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    String fname, oldfname;
    widget_bag *w = (widget_bag*)client_data;
    XawTextPosition begin, end;
    FILE *fp;
    String s, string;
    int len;
    String mesg;
    char buf[256];

    XtVaGetValues(w->popup_text, XtNstring, &fname, NULL);
    if (fname && *fname) {
        strcpy(buf, fname);
        cp_pathfix(buf);
        fname = buf;
    }
    if (CheckFile(fname, W_OK, w) == NOGO)
        return;

    XawTextGetSelectionPos(w->text, &begin, &end);
    if (begin == end) {
        /* no selected text */
        if (!XawAsciiSaveAsFile(XawTextGetSource(w->text), fname)) {
            PopUpMessage("Unknown error, text not saved", w);
            return;
        }
        XtVaGetValues(w->title, XtNlabel, &oldfname, NULL);
        if (same(fname, oldfname)) {
            if (!w->TextChanged) {
                PopUpMessage("Text not modified", w);
                return;
            }
            if (w->saved_as)
                XtFree(w->saved_as), w->saved_as = NULL;
            w->TextChanged = False;
            XtSetSensitive(XtNameToWidget(w->butbox, "save"), False);
            XtAddCallback(XawTextGetSource(w->text), XtNcallback, Change,
                (XtPointer)w);
            mesg = "Text saved";
        }
        else {
            if (w->saved_as)
                XtFree(w->saved_as);
            w->saved_as = XtMalloc(strlen(fname) + 1);
            strcpy(w->saved_as, fname);
            if (w->TextChanged) {
                w->TextChanged = False;
                XtAddCallback(XawTextGetSource(w->text), XtNcallback, Change,
                    (XtPointer)w);
            }
            mesg = "Text saved under new name";
        }
    }
    else {

        if ((fp = fopen(fname, "w")) == NULL) {
            PopUpMessage("Unknown error, block not saved", w);
            return;
        }
        string = XFetchBytes(Xdisplay, &len);
        for (s = string; len; s++,len--)
            putc(*s,fp);
        fclose(fp);
        XFree(string);
        mesg = "Selected block saved";
    }
    PopDownInput(caller, client_data, call_data);
    PopUpMessage(mesg, w);
}


static Bool
same(s, t)

char *s, *t;
{
    while (isspace(*s)) s++;
    while (isspace(*t)) t++;
    for (; *s && *t; s++, t++)
        if (*s != *t) return (False);
    if (*s && !isspace(*s)) return (False);
    if (*t && !isspace(*t)) return (False);
    return (True);
}


/* ARGSUSED */
static void
DoLoad(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    String fname;
    widget_bag *w = (widget_bag*)client_data;
    check_type which;
    char buf[256];

    XtVaGetValues(w->popup_text, XtNstring, &fname, NULL);
    if (fname && *fname) {
        strcpy(buf, fname);
        cp_pathfix(buf);
        fname = buf;
    }
    which = CheckFile(fname, R_OK, w);
    if (which == NOGO)
        return;
    XtVaSetValues(w->text, XtNeditType, XawtextRead, NULL);
    if (which == NO_EXIST)
        XtVaSetValues(w->text, XtNstring, "/dev/null", NULL);
    else
        XtVaSetValues(w->text, XtNstring, fname, NULL);
    XtVaSetValues(w->text, XtNeditType, XawtextEdit, NULL);

    /* ick! seems to be the only way to guarantee getting the
     * right label size after a window resize
     */
    XtDestroyWidget(w->title);
    w->title = XtVaCreateManagedWidget("titlelabel", labelWidgetClass,
        w->form,
        XtNborderWidth, 0,
        XtNfromHoriz, w->butbox,
        XtNvertDistance, 10,
        XtNhorizDistance, 20,
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        XtNbottom, XtChainTop,
        XtNtop, XtChainTop,
        XtNlabel, fname,
        NULL);

    PopDownInput(caller, client_data, call_data);
    if (w->TextChanged) {
        w->TextChanged = False;
        XtSetSensitive(XtNameToWidget(w->butbox, "save"), False);
        XtAddCallback(XawTextGetSource(w->text), XtNcallback, Change,
            (XtPointer)w);
    }
    if (w->saved_as) {
        XtFree(w->saved_as);
        w->saved_as = NULL;
    }
}

#ifdef STAND_ALONE

static void
PopUpInput(initial_str, action_str, action_callback, w)

String initial_str, action_str;
void (*action_callback)();
widget_bag *w;
{
    Widget form;
    Widget label;
    Widget cancel;
    Widget action;
    Dimension width, b_width, d;
    char **p;

    w->popup = XtVaCreatePopupShell("popup", transientShellWidgetClass,
        w->shell, NULL);
    XtOverrideTranslations(w->popup, XtParseTranslationTable(wmTranslations));
    XtAddEventHandler(w->popup, VisibilityChangeMask,
        False, ToTop, (XtPointer)w);

    form = XtVaCreateManagedWidget("form", formWidgetClass, w->popup,
        NULL);

    label = XtVaCreateManagedWidget("label", labelWidgetClass,
        form,
        XtNlabel, "Enter filename:                             ",
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        XtNresizable, TRUE,
        XtNborderWidth, 0,
        NULL);

    w->popup_text = XtVaCreateManagedWidget("text", asciiTextWidgetClass,
        form,
        XtNfromVert, label,
        XtNleft, XtChainLeft,
        XtNright, XtChainRight,
        XtNeditType, XawtextEdit,
        XtNresizable, TRUE,
        XtNresize, XawtextResizeWidth,
        XtNstring, initial_str,
        NULL);
    XtOverrideTranslations(w->popup_text,
        XtParseTranslationTable(oneLineTranslations));

    action = XtVaCreateManagedWidget("action", commandWidgetClass,
        form,
        XtNlabel, action_str,
        XtNfromVert, w->popup_text,
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        NULL);
    XtOverrideTranslations(action, XtParseTranslationTable(butTranslations));

    cancel = XtVaCreateManagedWidget("cancel", commandWidgetClass,
        form,
        XtNlabel, "Cancel",
        XtNfromVert, w->popup_text,
        XtNfromHoriz, action,
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        NULL);

    XtAddCallback(cancel, XtNcallback, PopDownInput, (XtPointer)w);
    XtAddCallback(action, XtNcallback, action_callback, (XtPointer)w);
    XtRealizeWidget(w->popup);
    XSetWMProtocols(Xdisplay, XtWindow(w->popup), &w->wm_delete, 1);
    CenterWidgetOnWidget(w->popup,w->shell);

    XtVaGetValues(form,
        XtNwidth, &width,
        XtNborderWidth, &b_width,
        XtNdefaultDistance, &d,
        NULL);
    width -= 2*(b_width + d + 1);
    XtVaSetValues(w->popup_text, XtNwidth, width, NULL);

    XtPopup(w->popup, XtGrabNone);
    XtSetKeyboardFocus(w->popup, w->popup_text);
    XtSetKeyboardFocus(w->shell, w->popup);
    for (p = w->popup_sens_list; *p; p++)
        XtSetSensitive(XtNameToWidget(w->butbox, *p), False);
}


/* ARGSUSED */
static void
PopDownInput(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    widget_bag *w = (widget_bag*)client_data;
    char **p;

    XtSetKeyboardFocus(w->shell, None);
    XtPopdown(w->popup);
    for (p = w->popup_sens_list; *p; p++)
        XtSetSensitive(XtNameToWidget(w->butbox, *p), True);
    w->popup = NULL;
}


static void
PopUpMessage(message_str, w)

String message_str;
widget_bag *w;
{
    Widget popup;
    Widget form;
    Widget label;
    Widget cancel;
    XColor visualcolor, exactcolor;

    popup = XtVaCreatePopupShell("popup_m", transientShellWidgetClass,
        w->shell, NULL);
    XtOverrideTranslations(popup, XtParseTranslationTable(wmTranslations));
    XtAddEventHandler(popup, VisibilityChangeMask,
        False, ToTop, (XtPointer)w);

    form = XtVaCreateManagedWidget("form_m", formWidgetClass, popup,
        NULL);

    cancel = XtVaCreateManagedWidget("cancel_m", commandWidgetClass,
        form,
        XtNlabel, "OK",
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        NULL);

    XAllocNamedColor(Xdisplay,
        DefaultColormap(Xdisplay, DefaultScreen(Xdisplay)),
        "red", &exactcolor, &visualcolor);
    label = XtVaCreateManagedWidget("label_m", labelWidgetClass,
        form,
        XtNlabel, message_str,
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        XtNfromHoriz, cancel,
        XtNresizable, TRUE,
        XtNborderWidth, 2,
        XtNborderColor, visualcolor.pixel,
        NULL);

    w->message = popup;
    XtAddCallback(cancel, XtNcallback, PopDownMessage, (XtPointer)w);
    XtAddEventHandler(form, KeyPressMask, False, (XtEventHandler)PopDownMessage,
        (XtPointer)w);
    XtRealizeWidget(popup);
    XSetWMProtocols(Xdisplay, XtWindow(popup), &w->wm_delete, 1);
    CenterWidgetOnWidget(popup, w->shell);
    if (w->popup)
        XtSetSensitive(w->popup, False);
    XtSetSensitive(w->form, False);
    XtSetKeyboardFocus(w->shell, form);
    XtPopup(popup, XtGrabExclusive);
}


/* ARGSUSED */
static void
PopDownMessage(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    widget_bag *w = (widget_bag*)client_data;

    if (w->popup) {
        XtSetKeyboardFocus(w->shell, w->popup);
        XtPopdown(w->message);
        XtSetSensitive(w->popup, True);
    }
    else {
        XtSetKeyboardFocus(w->shell, None);
        XtPopdown(w->message);
    }
    XtSetSensitive(w->form, True);
}


static void
CenterWidgetOnWidget(sub, master)

Widget sub, master;
{
    Dimension width, height, b_width;
    Position x, y, max_x, max_y;

    XtVaGetValues(master,
        XtNx, &x,
        XtNy, &y,
        XtNwidth, &width,
        XtNheight, &height,
        XtNborderWidth, &b_width,
        NULL);

    width += 2*b_width;
    height += 2*b_width;
    height += 2*b_width;
    x += (Position)width/2;
    y += (Position)height/2;

    XtVaGetValues(sub,
        XtNwidth, &width,
        XtNheight, &height,
        XtNborderWidth, &b_width,
        NULL);

    width += 2*b_width;
    height += 2*b_width;
    x -= (Position)width/2;
    if (x < 0) x = 0;
    y -= (Position)height/2;
    if (y < 0) y = 0;
    if (y > (max_y = (Position) (XtScreen(sub)->height - height))) y = max_y;

    XtVaSetValues(sub, XtNx, x, XtNy, y, NULL);
}


static check_type
CheckFile(fname, mode, w)

char *fname;
int mode;
widget_bag *w;
{
    char buf[512];
    struct stat st;
    FILE *fp;
    char *msg = "Error: can't %s file %s";

    /* check filename */
    if (!fname) return (NOGO);
    while (isspace(*fname)) fname++;
    if (!*fname) return (NOGO);

    if (!access(fname, F_OK)) {
        /* named file exists */
        if (stat(fname, &st))
            return (NOGO); /* shouldn't happen */

        if ((st.st_mode&S_IFMT) != S_IFLNK &&
                (st.st_mode&S_IFMT) != S_IFREG) goto bad;
            /* not a simple file or symbolic link */
    }

    switch (mode) {
    case R_OK:
        if (access(fname,R_OK)) {
            /* can't open for reading */
            if (!access(fname,F_OK)) goto bad; /* it exists, so error */
            return (NO_EXIST);
        }
        return (READ_OK);
    case W_OK:
        if (access(fname,W_OK)) {
            /* can't open for writing */
            if (!access(fname,F_OK)) goto bad; /* it exists, so error */
            fp = fopen(fname,"w");
            if (!fp) goto bad;
            fclose(fp);
        }
        return (WRITE_OK);
    }
bad:
    sprintf(buf, msg, (mode == R_OK) ? "read" : "write", fname);
    PopUpMessage(buf, w);
    return (NOGO);
}


/* ARGSUSED */
static void
ToTop(caller, clientdata, event, ctd)

Widget caller;
XtPointer clientdata;
XEvent *event;
Boolean *ctd;
{
    /*  prevent windows from disappearing */
    widget_bag *w = (widget_bag*)clientdata;

    XVisibilityEvent *vev = (XVisibilityEvent*)event;
    XWindowChanges xv;

    if (vev->state == VisibilityFullyObscured) {
        xv.sibling = XtWindow(w->shell);
        xv.stack_mode = Above;
        XReconfigureWMWindow(vev->display, vev->window,
            DefaultScreen(vev->display), CWSibling|CWStackMode, &xv);
    }
}


static char help_text[] = "\
Command buttons:\n\
  Quit:     Exit the editor\n\
  Save:     Save the current buffer to the named file\n\
  Save As:  Save the current buffer or marked block to a new file\n\
  Load:     Input a new text file for editing\n\
  Help:     Bring up help text\n\n\
Key bindings:\n\
  Ctrl-a   Beginning Of Line          Meta-b   Backward Word\n\
  Ctrl-b   Backward Character         Meta-f   Forward Word\n\
  Ctrl-d   Delete Next Character      Meta-i   Insert File\n\
  Ctrl-e   End Of Line                Meta-k   Kill To End Of Paragraph\n\
  Ctrl-f   Forward Character          Meta-q   Form Paragraph\n\
  Ctrl-g   Multiply Reset             Meta-v   Previous Page\n\
  Ctrl-h   Delete Previous Character  Meta-y   Insert Current Selection\n\
  Ctrl-j   Newline And Indent         Meta-z   Scroll One Line Down\n\
  Ctrl-k   Kill To End Of Line        Meta-d   Delete Next Word\n\
  Ctrl-l   Redraw Display             Meta-D   Kill Word\n\
  Ctrl-m   Newline                    Meta-h   Delete Previous Word\n\
  Ctrl-n   Next Line                  Meta-H   Backward Kill Word\n\
  Ctrl-o   Newline And Backup         Meta-<   Beginning Of File\n\
  Ctrl-p   Previous Line              Meta->   End Of File\n\
  Ctrl-r   Search/Replace Backward    Meta-]   Forward Paragraph\n\
  Ctrl-s   Search/Replace Forward     Meta-[   Backward Paragraph\n\
  Ctrl-t   Transpose Characters       Delete   Delete next character\n\
  Ctrl-u   Multiply by 4         Meta-Delete   Delete Previous Word\n\
  Ctrl-v   Next Page             Meta-Shift-Delete    Kill Previous Word\n\
  Ctrl-w   Kill Selection        Meta-Backspace       Delete Previous Word\n\
  Ctrl-y   Unkill                Meta-Shift-Backspace Kill Previous Word\n\
  Ctrl-z   Scroll One Line Up\n\n\
Pointer button bindings (cut and paste text):\n\
  Button 1 Down    Start Selection\n\
  Button 1 Motion  Adjust Selection\n\
  Button 1 Up      End Selection (cut)\n\n\
  Button 2 Down    Insert Current Selection (paste)\n\n\
  Button 3 Down    Extend Current Selection\n\
  Button 3 Motion  Adjust Selection\n\
  Button 3 Up      End Selection (cut)\n";


/* ARGSUSED */
static void
PopUpHelp(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    Widget popup;
    Widget form;
    Widget butbox;
    Widget label;
    Widget cancel;
    Widget text;
    widget_bag *w = (widget_bag*)client_data;
    Position x, y;
    Widget *wpass;

    XtVaGetValues(w->shell, XtNx, &x, XtNy, &y, NULL);


    popup = XtVaCreatePopupShell("popup_h", transientShellWidgetClass,
        w->shell,
        XtNx, x + 50,
        XtNy, y + 50,
        NULL);
    XtOverrideTranslations(popup, XtParseTranslationTable(wmTranslations));

    form = XtVaCreateManagedWidget("form_h", formWidgetClass, popup,
        NULL);

    butbox = XtVaCreateManagedWidget("buttonbox", boxWidgetClass,
        form,
        XtNwidth, 650,
        XtNleft, XtChainLeft,
        XtNright, XtChainLeft,
        XtNbottom, XtChainTop,
        XtNtop, XtChainTop,
        NULL);

    label = XtVaCreateManagedWidget("label_h", labelWidgetClass,
        butbox,
        XtNlabel, "Xeditor Help",
        XtNborderWidth, 2,
        NULL);

    cancel = XtVaCreateManagedWidget("cancel_h", commandWidgetClass,
        butbox,
        XtNlabel, "Cancel",
        XtNfromHoriz, label,
        NULL);

    text = XtVaCreateManagedWidget("text_h", asciiTextWidgetClass,
        form,
        XtNtype, XawAsciiString,
        XtNeditType, XawtextRead,
        XtNallowResize, True,
        XtNscrollHorizontal, XawtextScrollWhenNeeded,
        XtNscrollVertical, XawtextScrollWhenNeeded,
        XtNfromVert, butbox,
        XtNwidth, 600,
        XtNheight, 400,
        XtNstring, help_text,
        XtNdisplayCaret, False,
        NULL);

    wpass = (Widget*)XtMalloc(2*sizeof(Widget));
    wpass[0] = popup;
    wpass[1] = w->butbox;
    XtAddCallback(cancel, XtNcallback, PopDownHelp, (XtPointer)wpass);
    XtRealizeWidget(popup);
    XSetWMProtocols(Xdisplay, XtWindow(popup), &w->wm_delete, 1);
    XtPopup(popup, XtGrabNone);
    XtSetSensitive(XtNameToWidget(w->butbox, "help"), False);
}


/* ARGSUSED */
static void
PopDownHelp(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    Widget *w = (Widget*)client_data;

    XtPopdown(w[0]);
    XtSetSensitive(XtNameToWidget(w[1], "help"), True);
    XtFree((char*)w);
}


void
cp_pathfix(buf)

char *buf;
{
    char *s;

    if (index(buf,'~')) {
        s = tilde_expand(buf);
        if (s) {
            strcpy(buf,s);
            XtFree(s);
        }
    }
}


static char *
tilde_expand(string)

char *string;
{
    struct passwd *pw;
    char    *tail;
    char    buf[BSIZE_SP];
    char    *k, c;
    char    *ret;

    while (*string && isspace(*string))
    string++;

    if (*string != '~') {
        ret = XtMalloc(strlen(string) + 1);
        strcpy(ret, string);
        return (ret);
    }

    string += 1;

    if (!*string || *string == '/') {
        pw = getpwuid(getuid());
        *buf = 0;
    }
    else {
        k = buf;
        while ((c = *string) && c != '/')
            *k++ = c, string++;
        *k = 0;
        pw = getpwnam(buf);
    }

    if (pw) {
        strcpy(buf, pw->pw_dir);
        if (*string)
            strcat(buf, string);
    }
    else
        return (NULL);

    ret = XtMalloc(strlen(buf) + 1);
    strcpy(ret, buf);
    return (ret);
}


#else /* STAND_ALONE */

/* ARGSUSED */
static void
PopUpHelp(caller, client_data, call_data)

Widget caller;
XtPointer client_data, call_data;
{
    wordlist wl;

    wl.wl_prev = wl.wl_next = NULL;
    wl.wl_word = (char*)client_data;
    com_ghelp(&wl);
}


void
com_xeditor(wl)

wordlist *wl;
{
    if (wl)
        xeditor(wl->wl_word);
    else
        xeditor(NULL);
}


#endif /* STAND_ALONE */

#else /* HAVE_X11 */

#ifdef STAND_ALONE
main()
{ printf("This doesn't exist without X!\n"); }

#else

/* ARGSUSED */
int
xeditor(s)
char *s;
{ return (1); }


void
com_xeditor(wl)

wordlist *wl;
{
    fprintf(cp_err, "Xeditor is available under X only\n");
}

#endif /* STAND_ALONE */

#endif /* HAVE_X11 */