ui_menu.c

seismic software,very useful

void      UIExit(void)
{

    DrawFreePixmaps();
    XCloseDisplay(UIDisplay());
    exit( 0 );

}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISaveChanges(void)
{

    Widget   widget;
    extern Data data;
    extern PikList pik;

    if (!data) {
        return;
    }
    widget = XmCreateWarningDialog(ui->application, "save", NULL, 0);
    XtVaSetValues(widget, XmNmessageString,
                  XmStringCreateSimple("Picks have not been saved"),
                  XmNokLabelString, XmStringCreateSimple("Save all"),
                  XmNhelpLabelString, XmStringCreateSimple("Do not save"),
                  NULL);

    XtAddCallback(widget, XmNokCallback, (XtCallbackProc) UISaveAll, NULL);
    XtAddCallback(widget, XmNhelpCallback, (XtCallbackProc) UIExit, NULL);
    XtAddCallback(widget, XmNcancelCallback, (XtCallbackProc) XtDestroyWidget,
                  NULL);
    XtManageChild(widget);
}

/* default orientation callback */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIOrient0(void)
{

    ViewOrient0();
}

/* dump axis callbacks */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIDownDump(void)
{

    extern View view;

    MapDump(ViewMap(view, AXIS_DOWN));
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIAcrossDump(void)
{

    extern View view;

    MapDump(ViewMap(view, AXIS_ACROSS));
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIDeepDump(void)
{

    extern View view;

    MapDump(ViewMap(view, AXIS_DEEP));
}

/* swap axis callbacks */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISwapFrontSide(void)
{

    ViewSwapAxis(AXIS_ACROSS, AXIS_DEEP);
    UISyzeReset();
    UIArrayReset(0);
    if (ui->style == VIEW_ARRAY) {
        UIArrayDraw();
    }
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISwapSideTop(void)
{

    ViewSwapAxis(AXIS_DOWN, AXIS_ACROSS);
    UISyzeReset();
    if (ui->style == VIEW_ARRAY) {
        UIArrayDraw();
    }
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISwapTopFront(void)
{

    ViewSwapAxis(AXIS_DOWN, AXIS_DEEP);
    UISyzeReset();
    UIArrayReset(0);
    if (ui->style == VIEW_ARRAY) {
        UIArrayDraw();
    }
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISwapFrontExtra(void)
{

    ViewSwapAxis(AXIS_DEEP, AXIS_4D);
    UISyzeReset();
    UIArrayReset(0);
    if (ui->style == VIEW_ARRAY) {
        UIArrayDraw();
    }
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISwapSideExtra(void)
{

    ViewSwapAxis(AXIS_ACROSS, AXIS_4D);
    UISyzeReset();
    UIArrayReset(0);
    if (ui->style == VIEW_ARRAY) {
        UIArrayDraw();
    }
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISwapTopExtra(void)
{

    ViewSwapAxis(AXIS_DOWN, AXIS_4D);
    UISyzeReset();
    UIArrayReset(0);
    if (ui->style == VIEW_ARRAY) {
        UIArrayDraw();
    }
}

/* axis flip callbacks */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIFlipDown(void)
{

    ViewFlipAxis(AXIS_DOWN);
    UISyzeReset();
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIFlipAcross(void)
{

    ViewFlipAxis(AXIS_ACROSS);
    UISyzeReset();
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIFlipDeep(void)
{

    ViewFlipAxis(AXIS_DEEP);
    UISyzeReset();
}

/* set shape callback */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISizeChoice(Widget widget, int item)
{

    WidgetList list;

    if (item > 2) {
        return;
    }

    XtVaGetValues(ui->menu, XmNchildren, &list, NULL);
    XtVaSetValues(list[(item + 1) % 3], XmNset, False, NULL);
    XtVaSetValues(list[(item + 2) % 3], XmNset, False, NULL);
    ViewSetShape(item);
}

/* interpolation choice callback */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIInterpolateToggle(Widget widget)
{

    RenderToggleInterp();
    ViewDrawAll();
}

/* default zoom callback */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISize0(void)
{

    RenderSetInterp(0);
    ViewRestoreSize();
    UISyzeReset();
}

/* default screen size callback ( doesn't work ) */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIScreen0(void)
{

    if (!ui) {
        return;
    }
    XtVaSetValues(ui->canvas, XmNwidth, ui->wide, XmNheight, ui->hite, NULL);
}

/* region smooth callback */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISubvolumeSmooth(void)
{

    extern Data data;

    DrawWatch(1);
    RegionSetValue(RegionBound(1), RegionBound(1));
    DataComputeHistogram(data);
    ViewDrawAll();
}

/* region smooth undo */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UISmoothUndo(void)
{

    extern Data data;

    DrawWatch(1);
    RegionRestoreValue();
    DataComputeHistogram(data);
    ViewDrawAll();
}

/* clear picks callback */

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIPickClear(Widget widget, XButtonEvent * event)
{

    PickClear0();
    RegionClear();
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIEditGrade(void)
{

    extern Data data;
    extern View view;

    DrawWatch(1);
    EditGrade(DataBuffer(data), ViewMap(view, AXIS_DOWN),
              ViewMap(view, AXIS_ACROSS), ViewMap(view, AXIS_DEEP));
    DataComputeHistogram(data);
    ViewDrawAll();
}

/*--------------------------------------------------------------------*\
\*--------------------------------------------------------------------*/

void      UIGradeUndo(void)
{

    extern Data data;

    DrawWatch(1);
    EditUndo(DataBuffer(data));
    DataComputeHistogram(data);
    ViewDrawAll();
}

/*--------------------------------------------------------------------*\
\*--------------