ui_panel.c

seismic software,very useful

            XtVaCreateManagedWidget("var", xmScaleWidgetClass, widget,
                                    XmNshowValue, True, XmNorientation,
                                    XmHORIZONTAL, NULL);
        XtAddCallback(ui->s_sizes[AXIS_DEEP], XmNdragCallback,
                      (XtCallbackProc) UISizeSlider, NULL);
        ui->s_sizev[AXIS_DEEP] =
            XtVaCreateManagedWidget("var1", xmTextFieldWidgetClass, widget,
                                    XmNcolumns, 6, NULL);
        XtAddCallback(ui->s_sizev[AXIS_DEEP], XmNactivateCallback,
                      (XtCallbackProc) UISizeText, NULL);
        XtManageChild(widget);
        ui->s_slist[ui->s_nslider] = ui->s_sizes[AXIS_DEEP];
        ui->s_vlist[ui->s_nslider] = ui->s_sizev[AXIS_DEEP];
        ui->s_alist[ui->s_nslider] = NO_INDEX;
        ui->s_nslider++;
    };
    {
        Widget   widget;

        widget =
            XtVaCreateManagedWidget("EXECUTE SETTINGS", xmPushButtonWidgetClass,
                                    parent, NULL);
        XtAddCallback(widget, XmNactivateCallback, (XtCallbackProc) UISizeDraw,
                      NULL);};
    {
        Widget   widget;

        widget =
            XtVaCreateManagedWidget("CURRENT SETTINGS", xmPushButtonWidgetClass,
                                    parent, NULL);
        XtAddCallback(widget, XmNactivateCallback, (XtCallbackProc) UISizeReset,
                      NULL);};
    {
        Widget   widget;

        widget =
            XtVaCreateManagedWidget("INITIAL SETTINGS", xmPushButtonWidgetClass,
                                    parent, NULL);
        XtAddCallback(widget, XmNactivateCallback,
                      (XtCallbackProc) UISizeInitial, NULL);
    };
    {
        Widget   widget;

        widget =
            XtVaCreateManagedWidget("CLOSE", xmPushButtonWidgetClass, parent,
                                    NULL);
            XtAddCallback(widget, XmNactivateCallback,
                          (XtCallbackProc) UISizeClose, NULL);
    };
    XtManageChild(ui->s_base);
}

/* size control panel draw callback */
void UISizeDraw(void)
{
    int      imap, first, last, frame, dframe, size;
    extern View view;

    for( imap = 1; imap < 4; imap++ ){
        XtVaGetValues(ui->s_mins[imap], XmNvalue, &first, NULL);
        XtVaGetValues(ui->s_maxs[imap], XmNvalue, &last, NULL);
        XtVaGetValues(ui->s_frames[imap], XmNvalue, &frame, NULL);
        XtVaGetValues(ui->s_dframes[imap], XmNvalue, &dframe, NULL);
        XtVaGetValues(ui->s_sizes[imap], XmNvalue, &size, NULL);
        MapSet(ViewMap(view, imap), MapAxis(ViewMap(view, imap)), size, first,
               last, first, last, dframe);
        MapSetFrame(ViewMap(view, imap), frame);
    }
    ViewDrawAll();
}

/* set size control panel to current image values */
void UISizeReset(void)
{
    int      imap, islider;
    extern View view;
    string   svalue;

    if( !ui->s_shell ){
        return;
    }
    for( imap = 1; imap < 4; imap++ ){
        sprintf(svalue, "%s:%s", MapName(ViewMap(view, imap)),
                AxisLabel(MapAxis(ViewMap(view, imap))));
        XtVaSetValues(ui->s_label[imap], XmNlabelString,
                      XmStringCreateSimple(svalue), NULL);
        XtVaSetValues(ui->s_mins[imap], XmNmaximum,
                      AxisSize(MapAxis(ViewMap(view, imap))) - 1, XmNvalue,
                      MapFirst(ViewMap(view, imap)), NULL);
        XtVaSetValues(ui->s_maxs[imap], XmNmaximum,
                      AxisSize(MapAxis(ViewMap(view, imap))) - 1, XmNvalue,
                      MapLast(ViewMap(view, imap)), NULL);
        XtVaSetValues(ui->s_frames[imap], XmNmaximum,
                      AxisSize(MapAxis(ViewMap(view, imap))) - 1, XmNvalue,
                      MapFrame(ViewMap(view, imap)), NULL);
        XtVaSetValues(ui->s_dframes[imap], XmNminimum, 1, XmNmaximum, 100,
                      XmNvalue, MapDmovie(ViewMap(view, imap)), NULL);
        XtVaSetValues(ui->s_sizes[imap], XmNminimum, 16, XmNmaximum, 1000,
                      XmNvalue, MapSize(ViewMap(view, imap)), NULL);
    }
    for( islider = 0; islider < ui->s_nslider; islider++ ){
        UISizeSlider(ui->s_slist[islider]);
    }
}

/* set size control panel to initial size values */
void UISizeInitial(void)
{
    int      imap, islider;
    extern View view;

    if( !ui->s_shell ){
        return;
    }
    for( imap = 1; imap < 4; imap++ ){
        XtVaSetValues(ui->s_mins[imap], XmNvalue, 0, NULL);
        XtVaSetValues(ui->s_maxs[imap], XmNvalue,
                      AxisSize(MapAxis(ViewMap(view, imap))) - 1, NULL);
        XtVaSetValues(ui->s_frames[imap], XmNvalue, 0, NULL);
    }
    for( islider = 0; islider < ui->s_nslider; islider++ ){
        UISizeSlider(ui->s_slist[islider]);
    }
}

/* close size control panel */
void UISizeClose(void)
{
    XtPopdown(ui->s_shell);
}

/* synchronize size slider with slider text */
void UISizeSlider(Widget widget)
{
    int      value;
    string   svalue;
    int      islider;
    extern View view;

    for( islider = 0; islider < ui->s_nslider; islider++ ){
        if( ui->s_slist[islider] == widget ){
            break;
        }
    }
    if( islider == ui->s_nslider ){
        return;
    }
    XtVaGetValues(widget, XmNvalue, &value, NULL);
    if( ui->s_alist[islider] == NO_INDEX ){
        sprintf(svalue, "%d", value);
    } else {
        sprintf(svalue, "%g",
                AxisValue(MapAxis(ViewMap(view, ui->s_alist[islider])), value));
    }
    XtVaSetValues(ui->s_vlist[islider], XmNvalue, svalue, NULL);
}

/* synchronize slider text with size slider */
void UISizeText(Widget widget)
{
    char    *svalue;
    int      islider, value;
    double   atof(const char *);
    extern View view;

    for( islider = 0; islider < ui->s_nslider; islider++ ){
        if( ui->s_vlist[islider] == widget ){
            break;
        }
    }
    XtVaGetValues(widget, XmNvalue, &svalue, NULL);
    if( ui->s_alist[islider] == NO_INDEX ){
        value = atoi(svalue);
    } else {
        value =
            AxisIndex(MapAxis(ViewMap(view, ui->s_alist[islider])),
                      atof(svalue));
    }
    XtVaSetValues(ui->s_slist[islider], XmNvalue, value, NULL);
}

/********************************* ARRAY PANEL ******************************/

/* initialize array control panel */
void UIArrayInit(void)
{
    extern Data data;
    extern View view;
    Widget   widget, parent;

    ui->across = 0;
    if( ui->a_shell ){
        return;
    }
    ui->a_shell =
        XtVaCreatePopupShell("array", xmDialogShellWidgetClass, ui->main,
                             XmNtitle, XmStringCreateSimple("ARRAY PARAMETERS"),
                             NULL);
    ui->a_base =
        XtVaCreateWidget("base", xmRowColumnWidgetClass, ui->a_shell,
                         XmNorientation, XmVERTICAL, NULL);
    XtVaCreateManagedWidget("ARRAY PARAMETERS:", xmLabelWidgetClass, ui->a_base,
                            NULL);
    ui->a_dir =
        XmVaCreateSimpleRadioBox(ui->a_base, "dir",
                                 AxisDir(MapAxis(ViewMap(view, AXIS_DEEP))) - 1,
                                 (XtCallbackProc) UIArrayDir, XmVaRADIOBUTTON,
                                 XmStringCreateSimple(AxisLabel
                                                      (DataAxis
                                                       (data, DATA_AXIS1))),
                                 NULL, NULL, NULL, XmVaRADIOBUTTON,
                                 XmStringCreateSimple(AxisLabel
                                                      (DataAxis
                                                       (data, DATA_AXIS2))),
                                 NULL, NULL, NULL, XmVaRADIOBUTTON,
                                 XmStringCreateSimple(AxisLabel
                                                      (DataAxis
                                                       (data, DATA_AXIS3))),
                                 NULL, NULL, NULL, XmVaRADIOBUTTON,
                                 XmStringCreateSimple(AxisLabel
                                                      (DataAxis
                                                       (data, DATA_AXIS4))),
                                 NULL, NULL, NULL, NULL);
    XtManageChild(ui->a_dir);
    parent = ui->a_dir;
    ui->a_across =
        XtVaCreateManagedWidget("across", xmScaleWidgetClass, ui->a_base,
                                XmNminimum, 1, XmNmaximum, 50, XmNwidth, 250,
                                XmNshowValue, True, XmNtitleString,
                                XmStringCreateSimple("ACROSS"), XmNorientation,
                                XmHORIZONTAL, NULL);
    XtAddCallback(ui->a_across, XmNvalueChangedCallback,
                  (XtCallbackProc) UIArrayEndAdjust, NULL);
    ui->a_down =
        XtVaCreateManagedWidget("down", xmScaleWidgetClass, ui->a_base,
                                XmNminimum, 1, XmNmaximum, 50, XmNwidth, 250,
                                XmNshowValue, True, XmNtitleString,
                                XmStringCreateSimple("DOWN"), XmNorientation,
                                XmHORIZONTAL, NULL);
    XtAddCallback(ui->a_down, XmNvalueChangedCallback,
                  (XtCallbackProc) UIArrayEndAdjust, NULL);
    ui->a_start =
        XtVaCreateManagedWidget("start", xmScaleWidgetClass, ui->a_base,
                                XmNwidth, 250, XmNshowValue, True,
                                XmNtitleString, XmStringCreateSimple("START"),
                                XmNorientation, XmHORIZONTAL, NULL);
    XtAddCallback(ui->a_start, XmNvalueChangedCallback,
                  (XtCallbackProc) UIArrayEndAdjust, NULL);
    ui->a_delta =
        XtVaCreateManagedWidget("delta", xmScaleWidgetClass, ui->a_base,
                                XmNminimum, 1, XmNmaximum, 50, XmNwidth, 250,
                                XmNvalue, ui->delta, XmNshowValue, True,
                                XmNtitleString, XmStringCreateSimple("DELTA"),
                                XmNorientation, XmHORIZONTAL, NULL);
    XtAddCallback(ui->a_delta, XmNvalueChangedCallback,
                  (XtCallbackProc) UIArrayEndAdjust, NULL);
    ui->a_end =
        XtVaCreateManagedWidget("end", xmScaleWidgetClass, ui->a_base,
                                XmNminimum, 0, XmNwidth, 250, XmNshowValue,
                                True, XmNtitleString,
                                XmStringCreateSimple("END"), XmNorientation,
                                XmHORIZONTAL, NULL);
    XtAddCallback(ui->a_end, XmNvalueChangedCallback,
                  (XtCallbackProc) UIArrayDeltaAdjust, NULL);
    XtVaCreateManagedWidget("line", xmSeparatorWidgetClass, ui->a_base, NULL);
    widget =
        XtVaCreateManagedWidget("DRAW", xmPushButtonWidgetClass, ui->a_base,
                                NULL);
    XtAddCallback(widget, XmNactivateCallback, (XtCallbackProc) UIArrayDraw,
                  NULL);
    widget =
        XtVaCreateManagedWidget("CLOSE", xmPushButtonWidgetClass, ui->a_base,
                                NULL);
    XtAddCallback(widget, XmNactivateCallback, (XtCallbackProc) UIArrayClose,
                  NULL);
    XtManageChild(ui->a_base);
    XtManageChild(ui->a_shell);
}

/* set array control panel direction when orientation changes */
void UIArrayDir(Widget widget, int item)
{
    if( XmToggleButtonGetState(widget) == True ){
        UIArrayReset(item + 1);
    }
}

/* fetch current array control panel settings */
void UIArrayRaise(void)
{
    UIArrayInit();
    UIArrayReset(0);
    ui->shell = ui->a_shell;
    XtPopup(ui->a_shell, XtGrabNone);
}

void UIArrayReset(int dir)
{
    extern View view;
    extern Data data;
    Axis     axis;
    Map      map;
    int      imap, delta;
    WidgetList list;

    if( ui->a_shell == 0 ){
        return;
    }
    if( !dir ){
        map = ViewMap(view, AXIS_DEEP);
        ui->dir = AxisDir(MapAxis(map));
        XtVaGetValues(ui->a_dir, XmNchildren, &list, NULL);
        dir = ui->dir - 1;
        XtVaSetValues(list[dir], XmNset, True, NULL);
        XtVaSetValues(list[(dir + 1) % 3], XmNset, False, NULL);
        XtVaSetValues(list[(dir + 2) % 3], XmNset, False, NULL);
    } else {
        ui->dir = dir;
        for( imap = 1; imap <= 3; imap++ ){
            if( ui->dir == AxisDir(MapAxis(map = view->map[imap])) ){
                break;
            }
        }
    }
    axis = DataAxis(data, ui->dir);
    UIArrayShape(MapNFrame(map), &ui->across, &ui->down);
    XtVaSetValues(ui->a_across, XmNvalue, ui->across, NULL);
    XtVaSetValues(ui->a_down, XmNvalue, ui->down, NULL);
    ui->delta = 1;
    ui->start = MapLow(map);
    delta = irint(AxisDelta(axis) * AxisScale(axis));
    XtVaSetValues(ui->a_delta,
                  XmNdecimalPoints, AxisPrec(axis),
                  XmNminimum, delta,
                  XmNmaximum, 50 * delta, XmNvalue, ui->delta * delta, NULL);
    XtVaSetValues(ui->a_start,
                  XmNdecimalPoints, AxisPrec(axis),
                  XmNminimum, AxisScaledValue(axis, 0),
                  XmNmaximum, AxisScaledValue(axis, AxisSize(axis) - 1),