Widget theContainer;
Widget          inputText;
Widget          theDialog;
Widget          mainShell;
XtAppContext    appContext;
Display        *display;
short           widths[1] = {12};
char           *options[] = {"meters", "kilometers", "feet", "miles"};
char           *cmd = "r.buffer";
char           *in_p;
char           *out_p;
char           *distance_p;
char           *unit_p;
char          **values;
Widget          shell, buffer_dialog;
Widget          Create_Buffer_Dialog(), Create_Input_Cell(), Create_Output_Cell();
Widget          Create_Unit_Cell(), Create_Assign_Cell();
void            DoBufferDialog(), CallFile(), CallUnit(), CallInputOutput(), UpdateCommand();
void            CallOk(), CallCancel(), CallReset(), CallAccept();
char           *namestring = "helvb12", *zonestring = "helvb14";
Widget          inputField;


static XrmOptionDescRec initTable[] = {
{"-title",	"*title",	XrmoptionSepArg, (caddr_t)"XGRASS Buffer"},
{"-font",	"*fontList",	XrmoptionSepArg, (caddr_t)"fixed"},
{"-fn",		"*fontList",	XrmoptionSepArg, (caddr_t)"fixed"},
};

char           *
XbaeMatrixGetColumn(tb, column, rows, columns, separator)
    Widget          tb;
    int             column;
    int             rows;
    int             columns;
    int             separator;
{
    char          **rowtext;
    char           *text;
    Arg             targs[2];
    int             element;
    int             bytes = 0;
    int             i;

    rowtext = (char **) XtCalloc(rows, sizeof(char *));
    bzero((char *) rowtext, rows * sizeof(char *));

    for (i = 0; i < rows; i++) {
        rowtext[i] = XbaeMatrixGetCell(tb, i, column);
        bytes += strlen(rowtext[i]) + 2;
    }
    text = XtMalloc(bytes);
    for (i = 0; i < rows; i++) {
        if (i == 0)
            strcpy(text, rowtext[i]);
        else
            strcat(text, rowtext[i]);
        if ((i != (columns - 1) || columns == 1) &&
            i != (rows - 1))
            if (separator == '\0')
                strcat(text, " ");
            else {
                char            sep[1];

                sprintf(sep, "%c", separator);
                strcat(text, sep);
            }
    }
    XtFree(rowtext);

    return text;
}

main(argc, argv)
    int             argc;
    char           *argv[];
{
    Widget          area, dialog;
    Arg             al[10];
    int             ac;

    out_p = (char *) malloc(300 * sizeof(char));
    in_p = (char *) malloc(300 * sizeof(char));
    distance_p = (char *) malloc(500 * sizeof(char));
    unit_p = (char *) malloc(300 * sizeof(char));
    strcpy(out_p, "output=");
    strcpy(in_p, "inp=");
    strcpy(distance_p, "distances=");
    strcpy(unit_p, "units=");
    G_gisinit(argv[0]);
    mainShell = shell = XtAppInitialize(&appContext, "XGrass",
					initTable, XtNumber(initTable),
					&argc, argv, NULL, NULL, 0);

    display = XtDisplay(shell);

    dialog = Create_Buffer_Dialog(shell);

    XtRealizeWidget(shell);
    XtAppMainLoop(appContext);
}

void 
DoBufferDialog(w, dialog, ca)
    Widget          w, dialog;
    XtPointer       ca;
{
    XtManageChild(dialog);
}

Widget 
Create_Buffer_Dialog(parent)
    Widget          parent;
{
    Widget          global_board;
    Widget          board_1, io_frame, input_board, output_board;
    Widget          board_2, unit_board, assign_board;
    Arg             al[10];
    int             ac;

    ac = 0;
    XtSetArg(al[ac], XmNautoUnmanage, FALSE);
    ac++;
    theDialog = buffer_dialog = XgCreateInteractor(parent, "Perform Buffering Operation", al, ac);
    XmRemoveTabGroup(buffer_dialog);

    XtAddCallback(buffer_dialog, XmNokCallback, CallOk, NULL);
    XtAddCallback(buffer_dialog, XmNcancelCallback, CallCancel, NULL);

    theContainer = XtVaCreateManagedWidget("xgbuffer_container",xmRowColumnWidgetClass,buffer_dialog,
	XmNorientation,XmVERTICAL,
	XmNpacking,XmPACK_TIGHT,
	NULL);

    global_board = XmCreateRowColumn(theContainer, "global_board", NULL, 0);

    io_frame = XmCreateFrame(global_board, "io_frame", NULL, 0);
    XtManageChild(io_frame);
    ac = 0;
    XtSetArg(al[ac], XmNpacking, XmPACK_COLUMN);
    ac++;
    board_1 = XmCreateRowColumn(io_frame, "board_1", al, ac);
    XtManageChild(board_1);
    input_board = Create_Input_Cell(board_1);
    output_board = Create_Output_Cell(board_1);

    ac = 0;
    XtSetArg(al[ac], XmNorientation, XmHORIZONTAL);
    ac++;
    board_2 = XmCreateRowColumn(global_board, "board_2", al, ac);
    XtManageChild(board_2);
    unit_board = Create_Unit_Cell(board_2);
    assign_board = Create_Assign_Cell(board_2);

    theCommand = XtVaCreateManagedWidget("xgbuffer_command",xmTextFieldWidgetClass,theContainer,
	XmNvalue,"r.buffer input= output= distances= units=",
	NULL);

    XtManageChild(theDialog);
    XtManageChild(global_board);
    return (buffer_dialog);
}

Widget 
Create_Assign_Cell(parent)
    Widget          parent;
{
    Widget          assignRC, labelRC, znLB, disLB, table, optionRC, acceptB,
                    resetB;
    char          **headings = (char **) XtCalloc(60, sizeof(char *));
    Display        *dpy = XtDisplay(shell);
    char            name[12];
    Arg             al[10];
    int             ac, i, scr = DefaultScreen(dpy);

    assignRC = XmCreateRowColumn(parent, "assignRC", NULL, 0);
    XtManageChild(assignRC);

    ac = 0;
    XtSetArg(al[ac], XmNpacking, XmPACK_NONE);
    ac++;
    labelRC = XmCreateRowColumn(assignRC, "labelRC", al, ac);
    XtManageChild(labelRC);

    ac = 0;
    XtSetArg(al[ac], XmNlabelString,
             XmStringCreate("zone", XmSTRING_DEFAULT_CHARSET));
    ac++;
    znLB = XmCreateLabel(labelRC, "znLB", al, ac);
    XtManageChild(znLB);

    ac = 0;
    XtSetArg(al[ac], XmNlabelString,
             XmStringCreate("distances", XmSTRING_DEFAULT_CHARSET));
    ac++;
    XtSetArg(al[ac], XmNx, 80);
    ac++;
    disLB = XmCreateLabel(labelRC, "disLB", al, ac);
    XtManageChild(disLB);

    ac = 0;
    for (i = 0; i < 60; i++) {
        sprintf(name, "%3d", i + 1);
        headings[i] = XtNewString(name);
    }
    XtSetArg(al[ac], XmNrowLabels, headings);
    ac++;
    XtSetArg(al[ac], XmNrows, 60);
    ac++;
    XtSetArg(al[ac], XmNmarginWidth, 2);
    ac++;
    XtSetArg(al[ac], XmNcolumns, 1);
    ac++;
    XtSetArg(al[ac], XmNvisibleRows, 4);
    ac++;
    XtSetArg(al[ac], XmNcolumnWidths, widths);
    ac++;
    XtSetArg(al[ac], XmNtraversalOn, True);
    ac++;
    XtSetArg(al[ac], XmNnavigationType, XmSTICKY_TAB_GROUP);
    ++ac;

    table = XtCreateManagedWidget("table", xbaeMatrixWidgetClass, assignRC, al, ac);

    values = (char **) XtMalloc(60 * sizeof(char *));
    for (i = 0; i < 60; i++) {
        values[i] = XtMalloc(10);
        sprintf(values[i], "0");
        XbaeMatrixSetCell(table, i, 0, "0");
    }

    ac = 0;
    XtSetArg(al[ac], XmNorientation, XmHORIZONTAL);
    ac++;
    optionRC = XmCreateForm(assignRC, "optionRC", al, ac);
    XtManageChild(optionRC);

    ac = 0;
    XtSetArg(al[ac], XmNlabelString,
             XmStringCreate("Accept", XmSTRING_DEFAULT_CHARSET));
    ac++;
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM);
    ac++;
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION);
    ac++;
    XtSetArg(al[ac], XmNrightPosition, 49);
    ac++;
    acceptB = XmCreatePushButton(optionRC, "acceptB", al, ac);
    XmAddTabGroup(acceptB);
    XtManageChild(acceptB);
    XtAddCallback(acceptB, XmNactivateCallback, CallAccept, table);

    ac = 0;
    XtSetArg(al[ac], XmNlabelString,
             XmStringCreate("Reset", XmSTRING_DEFAULT_CHARSET));
    ac++;
    XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET);
    ac++;
    XtSetArg(al[ac], XmNleftWidget, acceptB);
    ac++;
    XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM);
    ac++;
    resetB = XmCreatePushButton(optionRC, "resetB", al, ac);
    XmAddTabGroup(resetB);
    XtManageChild(resetB);
    XtAddCallback(resetB, XmNactivateCallback, CallReset, table);

    return (assignRC);
}

Widget 
Create_Unit_Cell(parent)
    Widget          parent;
{
    Widget          frame, rowcol, browser, unit_label;
    WidgetList      buttons;
    Arg             al[10];
    int             ac, i;

    ac = 0;
    XtSetArg(al[ac], XmNspacing, 7);
    ac++;
    rowcol = XtCreateManagedWidget("rowcol",
                                   xmRowColumnWidgetClass, parent, al, ac);

    ac = 0;
    XtSetArg(al[ac], XmNlabelString,
             XmStringCreate("unit", XmSTRING_DEFAULT_CHARSET));
    ac++;
    unit_label = XtCreateManagedWidget("unit_label",
                                       xmLabelWidgetClass, rowcol, al, ac);

    frame = XtCreateManagedWidget("unitframe",
                                  xmFrameWidgetClass, rowcol, NULL, 0);

    buttons = (WidgetList) XtMalloc(4 * sizeof(Widget));
    ac = 0;
    XtSetArg(al[ac], XmNspacing, 14);
    ac++;
    browser = XmCreateRadioBox(frame, "browser", al, ac);
    for (i = 0; i < 4; i++) {
        ac = 0;
        XtSetArg(al[ac], XmNlabelString,
                 XmStringCreate(options[i], XmSTRING_DEFAULT_CHARSET));
        ac++;
        buttons[i] = XtCreateManagedWidget(options[i],
                                xmToggleButtonWidgetClass, browser, al, ac);
        XtAddCallback(buttons[i], XmNarmCallback, CallUnit, i);
        XmAddTabGroup(buttons[i]);
    }
    XtManageChild(browser);
    return (rowcol);
}
