/* ARGSUSED */
void mpcstw_projDefaultCb ( Widget w, XtPointer clnt, XtPointer call )
/************************************************************************
* mpcstw_projDefaultCb *
* *
* This is the callback for the Default proj button *
* *
* void mpcstw_projDefaultCb(w, clnt, call) *
* *
* Input parameters: *
* w Widget calling widget ID *
* clnt XtPointer client data *
* call XtPointer never used *
* *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* S. Wang/GSC 09/96 *
***********************************************************************/
{
int i;
/*---------------------------------------------------------------------*/
for ( i =1; i<NAMEPROJSHOW; i++ )
XmToggleButtonSetState( _toggleBt[i], FALSE, FALSE );
XmToggleButtonSetState(_othersBt, FALSE, FALSE);
XmTextSetString( _projTextW, _projItem[0].gmpkname );
}
void update_nonl_frame(void)
{
int i;
if (nonl_frame) {
XmString str = XmStringCreateSimple(nonl_opts.title);
XtVaSetValues(nonl_title_item, XmNlabelString, str, NULL);
/*
* If I define only XmALIGNMENT_CENTER (default!) then it's ignored - bug in Motif???
*/
XtVaSetValues(nonl_title_item, XmNalignment, XmALIGNMENT_BEGINNING, NULL);
XtVaSetValues(nonl_title_item, XmNalignment, XmALIGNMENT_CENTER, NULL);
XmStringFree(str);
xv_setstr(nonl_formula_item, nonl_opts.formula);
sprintf(buf, "%g", nonl_opts.tolerance);
xv_setstr(nonl_tol_item, buf);
SetChoice(nonl_nparm_item, nonl_opts.parnum);
for (i = 0; i < MAXPARM; i++) {
sprintf(buf, "%g", nonl_parms[i].value);
xv_setstr(nonl_value_item[i], buf);
XmToggleButtonSetState(nonl_constr_item[i], nonl_parms[i].constr, False);
sprintf(buf, "%g", nonl_parms[i].min);
xv_setstr(nonl_lowb_item[i], buf);
XtSetSensitive(nonl_lowb_item[i], nonl_parms[i].constr);
sprintf(buf, "%g", nonl_parms[i].max);
xv_setstr(nonl_uppb_item[i], buf);
XtSetSensitive(nonl_uppb_item[i], nonl_parms[i].constr);
if (i < nonl_opts.parnum) {
if (!XtIsManaged (nonl_parm_item[i])) {
XtManageChild(nonl_parm_item[i]);
}
} else {
if (XtIsManaged (nonl_parm_item[i])) {
XtUnmanageChild(nonl_parm_item[i]);
}
}
}
XmToggleButtonSetState(nonl_autol_item, nonl_prefs.autoload, False);
for (i = 0; i < 3; i++) {
XmToggleButtonSetState(nonl_load_item[i], False, False);
}
XmToggleButtonSetState(nonl_load_item[nonl_prefs.load], True, False);
if (nonl_prefs.load == LOAD_FUNCTION) {
XtSetSensitive(nonl_fload_rc, True);
} else {
XtSetSensitive(nonl_fload_rc, False);
}
sprintf(buf, "%g", nonl_prefs.start);
xv_setstr(nonl_start_item, buf);
sprintf(buf, "%g", nonl_prefs.stop);
xv_setstr(nonl_stop_item, buf);
sprintf(buf, "%d", nonl_prefs.npoints);
xv_setstr(nonl_npts_item, buf);
}
}
/* ARGSUSED */
void mpcstw_projOthersCb ( Widget w, XtPointer clnt, XtPointer call )
/************************************************************************
* mpcstw_projOthersCb *
* *
* This is the callback for the proj Others button *
* *
* void mpcstw_projOthersCb(w, which, call) *
* *
* Input parameters: *
* w Widget calling widget ID *
* clnt XtPointer client data *
* call XtPointer never used *
* *
* Output parameters: *
* Return parameters: *
* NULL *
* *
** *
* Log: *
* S. Wang/GSC 09/96 *
***********************************************************************/
{
int i;
char temp[100];
/*---------------------------------------------------------------------*/
for ( i =1;i<NAMEPROJSHOW;i++ )
XmToggleButtonSetState( _toggleBt[i], FALSE, FALSE );
XmToggleButtonSetState( _defaultBt, FALSE, FALSE );
mpcstw_resetDefCon();
strcpy( temp, _projItem[_projOptInx].gmpkname );
strcat(temp, _projItem[_projOptInx].parm);
XmTextSetString( _projTextW, temp );
}
/* ARGSUSED */
void mpcstw_projToggleCb ( Widget w, long which, XtPointer call )
/************************************************************************
* mpcstw_projToggleCb *
* *
* This is the callback for the proj toggle buttons. *
* *
* void mpcstw_projToggleCb ( w, which, call ) *
* *
* Input parameters: *
* w Widget calling widget ID *
* which long client data *
* call XtPointer never used *
* *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* S. Wang/GSC 09/96 *
***********************************************************************/
{
XmToggleButtonSetState(_defaultBt, FALSE, FALSE);
mpcstw_resetDefCon();
XmToggleButtonSetState(_othersBt, FALSE, FALSE);
XmTextSetString(_projTextW, _projItem[which].gmpkname );
}
extern void
set_dssw_times(DSSW *dssw) {
XmString xmstr;
Props *p = (Props *)dssw->cal->properties;
DisplayType dt = get_int_prop(p, CP_DEFAULTDISP);
XtVaSetValues(dssw->start_text, XmNvalue, dssw->start_val.val,
NULL);
XtVaSetValues(dssw->stop_text, XmNvalue, dssw->stop_val.val,
NULL);
xmstr = XmStringCreateLocalized(dssw->start_val.val);
XtVaSetValues(XmOptionButtonGadget(dssw->start_menu),
XmNlabelString, xmstr,
NULL);
XmStringFree(xmstr);
xmstr = XmStringCreateLocalized(dssw->stop_val.val);
XtVaSetValues(XmOptionButtonGadget(dssw->stop_menu),
XmNlabelString, xmstr,
NULL);
XmStringFree(xmstr);
if (dt == HOUR12) {
if (dssw->start_val.block == TIME_AM)
XmToggleButtonSetState(dssw->start_am, True, True);
else
XmToggleButtonSetState(dssw->start_pm, True, True);
if (dssw->stop_val.block == TIME_AM)
XmToggleButtonSetState(dssw->stop_am, True, True);
else
XmToggleButtonSetState(dssw->stop_pm, True, True);
}
}
Boolean XkbEventHandler(XEvent *event)
{
XkbEvent *xkbEv = (XkbEvent *) event;
if (xkbEv->any.xkb_type==XkbIndicatorStateNotify) {
register int i;
register unsigned bit;
for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1)
if ((xkbEv->indicators.changed&bit)&&(leds[i]))
{
if (xkbEv->indicators.state&bit)
XmToggleButtonSetState(leds[i],True,False);
else
XmToggleButtonSetState(leds[i],False,False);
}
}
else if (xkbEv->any.xkb_type==XkbIndicatorMapNotify) {
unsigned change= xkbEv->indicators.changed;
if (XkbGetIndicatorMap(theDisplay,change,xkb_desc)!=Success)
fprintf(stderr,"Couldn't get changed indicator maps\n");
}
return True;
} /* XkbEventHandler */
static void
style_selected (Widget w, int i, XmToggleButtonCallbackStruct * cbs)
{
RouteStyleType *style;
int j, n;
if (cbs && cbs->set == 0)
{
XmToggleButtonSetState (w, 1, 0);
return;
}
style = PCB->RouteStyle + i;
SetLineSize (style->Thick);
SetViaSize (style->Diameter, true);
SetViaDrillingHole (style->Hole, true);
SetKeepawayWidth (style->Keepaway);
if (style_dialog)
{
for (j = 0; j < NUM_STYLES; j++)
if (j != i)
XmToggleButtonSetState (style_pb[j], 0, 0);
else
XmToggleButtonSetState (style_pb[j], 1, 0);
update_values ();
}
else
lesstif_update_status_line ();
for (n = 0; n < num_style_buttons; n++)
{
for (j = 0; j < NUM_STYLES; j++)
if (j != i)
XmToggleButtonSetState (style_button_list[n].w[j], 0, 0);
else
XmToggleButtonSetState (style_button_list[n].w[j], 1, 0);
}
}
void init_transform_interface(void)
/*************************************************************************/
{
XmToggleButtonSetState(widget_transform.TB_zyklus, FALSE, FALSE);
XmToggleButtonSetState(widget_transform.TB_achsez, TRUE, FALSE);
XtSetSensitive(widget_transform.T_anz_zyk, FALSE);
XtSetSensitive(widget_transform.AB_anzahl_plus, FALSE);
XtSetSensitive(widget_transform.AB_anzahl_minus, FALSE);
XtSetSensitive(widget_transform.T_winkel, FALSE);
XtSetSensitive(widget_transform.TB_achsex, FALSE);
XtSetSensitive(widget_transform.TB_achsey, FALSE);
XtSetSensitive(widget_transform.TB_achsez, FALSE);
XmToggleButtonSetState(widget_transform.TB_spiegeln, FALSE, FALSE);
XtSetSensitive(widget_transform.TB_ebenexy, FALSE);
XtSetSensitive(widget_transform.TB_ebenexz, FALSE);
XtSetSensitive(widget_transform.TB_ebeneyz, FALSE);
XmToggleButtonSetState(widget_transform.TB_schneiden, FALSE, FALSE);
XmToggleButtonSetState(widget_transform.TB_schneiden_aus, FALSE, FALSE);
XmToggleButtonSetState(widget_transform.TB_def_koord, FALSE, FALSE);
XmToggleButtonSetState(widget_transform.TB_def_nummer, FALSE, FALSE);
XtSetSensitive(widget_transform.TB_schneiden, TRUE);
XtSetSensitive(widget_transform.TB_schneiden_aus, FALSE);
XtSetSensitive(widget_transform.TB_def_plane, FALSE);
XtSetSensitive(widget_transform.TB_def_koord, FALSE);
XtSetSensitive(widget_transform.TB_def_nummer,FALSE);
XtSetSensitive(widget_transform.T_punkt1x, FALSE);
XtSetSensitive(widget_transform.T_punkt1y, FALSE);
XtSetSensitive(widget_transform.T_punkt1z, FALSE);
XtSetSensitive(widget_transform.T_punkt2x, FALSE);
XtSetSensitive(widget_transform.T_punkt2y, FALSE);
XtSetSensitive(widget_transform.T_punkt2z, FALSE);
XtSetSensitive(widget_transform.T_punkt3x, FALSE);
XtSetSensitive(widget_transform.T_punkt3y, FALSE);
XtSetSensitive(widget_transform.T_punkt3z, FALSE);
XtSetSensitive(widget_transform.T_punkt1nr, FALSE);
XtSetSensitive(widget_transform.T_punkt2nr, FALSE);
XtSetSensitive(widget_transform.T_punkt3nr, FALSE);
if (g_transform.zyklus_on)
{
XmToggleButtonSetState(widget_transform. TB_zyklus, TRUE, TRUE);
}
if (g_transform.spiegel_on)
{
XmToggleButtonSetState(widget_transform.TB_spiegeln, TRUE, TRUE);
}
if (g_transform.schneiden_on)
{
XmToggleButtonSetState(widget_transform.TB_schneiden, TRUE, TRUE);
}
b_init_transform = TRUE; /* Flagge dass Fenster initialisiert */
return;
}
static void update_special_items(int gno)
{
tickmarks t;
if (special_frame) {
get_graph_tickmarks(gno, &t, curaxis);
XmToggleButtonSetState(specticks, t.t_type == TYPE_SPEC, False);
XmToggleButtonSetState(specticklabels, t.tl_type == TYPE_SPEC, False);
}
}
void init_stoffe_interface(void)
/*************************************************************************/
{
XmToggleButtonSetState(widget_stoffe.TB_alle_stoffe, g_transform.alle_stoffe_on, FALSE);
XmToggleButtonSetState(widget_stoffe.TB_solid, FALSE, FALSE);
XmToggleButtonSetState(widget_stoffe.TB_netz, FALSE, FALSE);
XmToggleButtonSetState(widget_stoffe.TB_gitter, FALSE, FALSE);
XmToggleButtonSetState(widget_stoffe.TB_transparent, FALSE, FALSE);
XmToggleButtonSetState(widget_stoffe.TB_result, FALSE, FALSE);
XmToggleButtonSetState(widget_stoffe.TB_rahmen, TRUE, FALSE);
XmToggleButtonSetState(widget_stoffe.TB_absenken, FALSE, FALSE);
XmToggleButtonSetState(widget_stoffe.TB_stoffgruppen, FALSE, FALSE);
if (g_loesung.gescannt)
XtSetSensitive(widget_stoffe.TB_result, TRUE);
else
XtSetSensitive(widget_stoffe.TB_result, FALSE);
if (g_ofen.ex)
XtSetSensitive(widget_stoffe.TB_absenken, TRUE);
else
XtSetSensitive(widget_stoffe.TB_absenken, FALSE);
XtSetSensitive(widget_stoffe.TB_stoffgruppen, FALSE);
XtSetSensitive(widget_stoffe.TT_stoffgebiete, FALSE);
b_init_stoffe = TRUE; /* Flagge dass Fenster initialisiert */
return;
}
/*=== hide_aux_windows ======================================================
Callback for Hide button on main screen and View Hide All menu option.
Hides all the custaux windows and turns all toggles off.
===========================================================================*/
void
hide_aux_windows(Widget w,
XtPointer client_data,
XtPointer call_data)
{
/* popdown all the windows */
hide_window(ci_accountinfo_shell, ci_accountinfo_form) ;
hide_window(ci_addrinfo_shell, ci_addrinfo_form) ;
hide_window(ci_verifyinfo_shell, ci_verifyinfo_form) ;
hide_window(ci_contactinfo_shell, ci_contactinfo_form) ;
hide_window(ci_paymentinfo_shell, ci_paymentinfo_form) ;
hide_window(ci_billinfo_shell, ci_billinfo_form) ;
hide_window(ci_taxinfo_shell, ci_taxinfo_form) ;
hide_window(ci_miscinfo_shell, ci_miscinfo_form) ;
hide_window(cmf_sum_shell, cmf_sum_form) ;
/* if this was called from code and not activated by a pushbutton, then
don't reset toggles in view menu */
if (w == NULL)
return ;
/* Then turn all toggles off to refect the state of things. Pass FALSE
* as third parameter as to not activate the ValueChanged callbacks */
XmToggleButtonSetState(ci_view_acct_btn, FALSE, FALSE) ;
XmToggleButtonSetState(ci_view_addr_btn, FALSE, FALSE) ;
XmToggleButtonSetState(ci_view_verify_btn, FALSE, FALSE) ;
XmToggleButtonSetState(ci_view_contact_btn, FALSE, FALSE) ;
XmToggleButtonSetState(ci_view_payment_btn, FALSE, FALSE) ;
XmToggleButtonSetState(ci_view_bill_btn, FALSE, FALSE) ;
XmToggleButtonSetState(ci_view_summary_btn, FALSE, FALSE) ;
XmToggleButtonSetState(ci_view_tax_btn, FALSE, FALSE) ;
XmToggleButtonSetState(ci_view_general_btn, FALSE, FALSE) ;
}
void reset_manual_hold_filter(Widget w, XtPointer *client_data,
XmPushButtonCallbackStruct *call_data)
{
XmToggleButtonSetState (cc_comm_filter_tog, False, False);
XmToggleButtonSetState (cc_hard_dec_filter_tog, False, False);
XmToggleButtonSetState (cc_soft_dec_filter_tog, False, False);
XmToggleButtonSetState (cc_data_error_filter_tog, False, False);
XmToggleButtonSetState (cc_call_card_co_filter_tog, False, False);
XmTextSetString (cciu_account_id_txt,"");
} /* end reset_manual_hold_filter */
static void update_tickmark_items(int gno)
{
Arg a;
tickmarks t;
int iv;
if (tickmark_frame) {
get_graph_tickmarks(gno, &t, curaxis);
switch (t.t_inout) {
case TICKS_IN:
SetChoice(tinout, 0);
break;
case TICKS_OUT:
SetChoice(tinout, 1);
break;
case TICKS_BOTH:
SetChoice(tinout, 2);
break;
}
switch (t.t_op) {
case PLACE_LEFT:
SetChoice(tickop, 0);
break;
case PLACE_RIGHT:
SetChoice(tickop, 1);
break;
case PLACE_BOTTOM:
SetChoice(tickop, 0);
break;
case PLACE_TOP:
SetChoice(tickop, 1);
break;
case PLACE_BOTH:
SetChoice(tickop, 2);
break;
}
SetChoice(tgridcol, t.t_color);
SetChoice(tgridlinew, t.t_linew - 1);
SetChoice(tgridlines, t.t_lines - 1);
SetChoice(tmgridcol, t.t_mcolor);
SetChoice(tmgridlinew, t.t_mlinew - 1);
SetChoice(tmgridlines, t.t_mlines - 1);
iv = (int) (100 * t.t_size);
XtSetArg(a, XmNvalue, iv);
XtSetValues(tlen, &a, 1);
iv = (int) (100 * t.t_msize);
XtSetArg(a, XmNvalue, iv);
XtSetValues(tmlen, &a, 1);
XmToggleButtonSetState(tgrid, t.t_gridflag == TRUE, False);
XmToggleButtonSetState(tmgrid, t.t_mgridflag == TRUE, False);
}
}
void update_ticks_items(int gno)
{
tickmarks t;
if (ticks_frame) {
SetChoice(editaxis, curaxis);
get_graph_tickmarks(gno, &t, curaxis);
XmToggleButtonSetState(tlonoff, t.tl_flag == TRUE, False);
XmToggleButtonSetState(tonoff, t.t_flag == TRUE, False);
XmToggleButtonSetState(baronoff, t.t_drawbar == TRUE, False);
XmTextSetString(axislabel, t.label.s);
if (islogx(gno) && (curaxis % 2 == 0)) {
t.tmajor = (int) t.tmajor;
if (t.tmajor == 0) {
t.tmajor = 1;
}
sprintf(buf, "%.0f", t.tmajor);
} else if (islogy(gno) && (curaxis % 2 == 1)) {
t.tmajor = (int) t.tmajor;
if (t.tmajor == 0) {
t.tmajor = 1;
}
sprintf(buf, "%.0f", t.tmajor);
} else if (t.tmajor > 0) {
sprintf(buf, "%.5g", t.tmajor);
} else {
strcpy(buf, "UNDEFINED");
}
XmTextSetString(tmajor, buf);
if (islogx(gno) && (curaxis % 2 == 0)) {
t.tminor = (int) t.tminor;
if (t.tminor < 0 || t.tminor > 5) {
t.tminor = 0;
}
sprintf(buf, "%.0f", t.tminor);
} else if (islogy(gno) && (curaxis % 2 == 1)) {
t.tminor = (int) t.tminor;
if (t.tminor < 0 || t.tminor > 5) {
t.tminor = 0;
}
sprintf(buf, "%.0f", t.tminor);
} else if (t.tminor > 0) {
sprintf(buf, "%.5g", t.tminor);
} else {
strcpy(buf, "UNDEFINED");
}
XmTextSetString(tminor, buf);
}
}
void update_draw(void)
{
Arg a;
int iv;
if (draw_frame) {
XmToggleButtonSetState(linkscroll_item, scrolling_islinked == TRUE, False);
XmToggleButtonSetState(autoredraw_type_item, auto_redraw == TRUE, False);
XmToggleButtonSetState(autorefresh_type_item, allow_refresh == TRUE, False);
XmToggleButtonSetState(cursor_type_item, cursortype == TRUE, False);
iv = (int) (100 * scrollper);
XtSetArg(a, XmNvalue, iv);
XtSetValues(scrollper_item, &a, 1);
}
}
/*
* Set magstep and synchronize the widgets.
*
* If you are looking for a way to prevent high magsteps from griding your
* machine into the ground, this is the place for the limits. All of the
* magstep setting goes through here.
*/
int
mgv_ui_magnify(MGV *m, int magstep)
{
int different;
char s[64];
MGV_APP *r = mgv_appres(m->main);
different = mgv_magnify(m, r->magstep = magstep);
/*
* If the magstep is in the range of the radio buttons, we
* need to turn the correct one on and the old one off.
*/
if(magstep >= MGV_MAGMIN && magstep <= MGV_MAGMAX) {
sprintf(s, "*menuBar*magstep_pd*%d", magstep);
if(m->magsteptog != NULL)
XmToggleButtonSetState(m->magsteptog, False, False);
m->magsteptog = wl_find1(m->main, s);
XmToggleButtonSetState(m->magsteptog, True, False);
}
else {
if(m->magsteptog != NULL)
XmToggleButtonSetState(m->magsteptog, False, False);
m->magsteptog = NULL;
}
sprintf(s, "%+d", magstep);
/*
* Update the status line thingy.
*/
XtVaSetValues(wl_find1(m->main, "*statusLine*magstepFrame*value"),
XtVaTypedArg, XmNlabelString,
XtRString, s,
strlen(s) + 1,
NULL);
/*
* Update the magstep->set dialog (if it exists).
*/
if(m->magstep != NULL) {
Arg a;
XtSetArg(a, XmNvalue, s);
XtSetValues(wl_find1(m->magstep, "*text"), &a, 1);
}
return different;
}
void
init_notes_create_screen ()
{
/* Clear out fields on notes create screen and reset toggle buttons
* to default values.
*/
XmTextSetString (notes_equip_txt, "");
XmTextSetString (notes_type_txt, "");
if (user_note_duration == TEMP_NOTE)
XmToggleButtonSetState (notes_temp_tog, TRUE, TRUE);
else XmToggleButtonSetState (notes_perm_tog, TRUE, TRUE);
XmToggleButtonSetState (notes_tickler_tog, FALSE, FALSE);
XmTextSetString (notes_comment_txt, "");
XmTextSetString (notes_text_txt, "");
}
void init_vektor_interface(void)
/*************************************************************************/
{
char c_hilf[12];
b_init_vektor = TRUE; /* Flagge dass Fenster initialisiert */
if (g_animation.temp_on)
XmToggleButtonSetState(widget_vektor.TB_temperatur, TRUE, FALSE);
if (g_animation.spann_on)
XmToggleButtonSetState(widget_vektor.TB_spannung, TRUE, FALSE);
if (g_animation.stroem_on)
XmToggleButtonSetState(widget_vektor.TB_stroemung, TRUE, FALSE);
if (!XmToggleButtonGetState(widget_vektor.TB_spannung) &&
!XmToggleButtonGetState(widget_vektor.TB_stroemung))
{
XtSetSensitive(widget_vektor.L_sp_faktor, FALSE);
XtSetSensitive(widget_vektor.T_sp_faktor, FALSE);
XtSetSensitive(widget_vektor.L_st_faktor, FALSE);
XtSetSensitive(widget_vektor.T_st_faktor, FALSE);
XtSetSensitive(widget_vektor.RC_animation, FALSE);
}
else
{
sprintf(c_hilf, "%8.3f", g_spannung.factor);
XmTextFieldSetString(widget_vektor.T_sp_faktor, c_hilf);
sprintf(c_hilf, "%8.3f", g_stroemung.factor);
XmTextFieldSetString(widget_vektor.T_st_faktor, c_hilf);
}
if (g_loesung.gescannt)
XtSetSensitive(widget_vektor.TB_temperatur, TRUE);
else
XtSetSensitive(widget_vektor.TB_temperatur, FALSE);
if (g_spannung.vektor_gescannt)
XtSetSensitive(widget_vektor.TB_spannung, TRUE);
else
XtSetSensitive(widget_vektor.TB_spannung, FALSE);
if (g_stroemung.vektor_gescannt)
XtSetSensitive(widget_vektor.TB_stroemung, TRUE);
else
XtSetSensitive(widget_vektor.TB_stroemung, FALSE);
return;
}
void pgfilterw_popdown ( void )
/************************************************************************
* pgfilterw_popdown *
* *
* This function unmanages the display filter window. *
* *
* void pgfilterw_popdown ( void ) *
* *
* Input parameters: *
* Output parameters: *
* NONE *
* *
** *
* Log: *
* J. Wu/SAIC 07/04 initial coding *
***********************************************************************/
{
int ii;
/*---------------------------------------------------------------------*/
if ( XtIsManaged ( _filterForm ) ) {
XtUnmanageChild ( _filterForm );
}
/*
* Deactivate filter, so all elements could be displayed.
*/
_allOn = False;
for ( ii = 0; ii < _nFilTime[TIME_FILTER]; ii++ ) {
_filterStatus[ii] = False;
XmToggleButtonSetState ( _filterChkBtn[ii], False, False );
}
pgfilterw_updateFilter ();
}
int
options_radiobox_set_value(
Widget radiobox,
int value,
Boolean set_dirty_bit
)
{
int num_children = 0;
WidgetList children = NULL;
XtArgVal childval = 0;
Boolean found = FALSE;
int i = 0;
set_dirty_bit = set_dirty_bit;
XtVaGetValues(radiobox,
XtNnumChildren, &num_children,
XtNchildren, &children,
NULL);
for (i = 0; i < num_children; i++)
{
XtVaGetValues(children[i], XmNuserData, &childval, NULL);
XmToggleButtonSetState(children[i], childval == value? TRUE : FALSE, FALSE);
if (childval == value)
{
found = TRUE;
XtVaSetValues(radiobox, XmNuserData, (XtArgVal)value, NULL);
}
}
if (!found)
return ERROR;
return OK;
}
static void
color_pick_ok(int x, int y, unsigned char *pix, XtPointer data)
{
struct ida_coledit *me = data;
int max;
if (debug)
fprintf(stderr,"color_pick_ok: +%d+%d %d/%d/%d\n",
x,y, pix[0],pix[1],pix[2]);
max = 0;
if (max < pix[0])
max = pix[0];
if (max < pix[1])
max = pix[1];
if (max < pix[2])
max = pix[2];
XmToggleButtonSetState(me->toggle,False,True);
me->red.parm.right = (int)255 * pix[0] / max;
color_update(me,&me->red,1);
me->green.parm.right = (int)255 * pix[1] / max;
color_update(me,&me->green,1);
me->blue.parm.right = (int)255 * pix[2] / max;
color_update(me,&me->blue,1);
if (debug)
fprintf(stderr,"color_pick_ok: %d/%d/%d max=%d\n",
me->red.parm.right,
me->green.parm.right,
me->blue.parm.right,
max);
}
/* -------------------------------------------------------------------- */
void ToggleWaveLengthScale(Widget w, XtPointer client, XtPointer call)
{
if (((XmToggleButtonCallbackStruct *)call)->set)
{
if (!plotWaveNumber()) {
if (tas.data) {
delete [] tas.data;
tas.data = NULL;
}
if (LoadVariable(&tas, tasVarName) == ERR)
{
XmToggleButtonSetState(pmOptButt[5], false, false);
sprintf(buffer, "Can't locate True Airspeed variable %s.", tasVarName.c_str());
ShowError(buffer);
return;
}
}
}
else
{
if (!plotWaveNumber()) {
delete [] tas.data;
tas.data = NULL;
}
}
} /* END TOGGLEWAVELENGTHSCALE */
void wxCheckBox::DoSet3StateValue(wxCheckBoxState state)
{
m_inSetValue = true;
#if wxHAS_3STATE
unsigned char value;
switch (state)
{
case wxCHK_UNCHECKED: value = XmUNSET; break;
case wxCHK_CHECKED: value = XmSET; break;
case wxCHK_UNDETERMINED: value = XmINDETERMINATE; break;
default: wxASSERT(0); return;
}
XtVaSetValues( (Widget) m_mainWidget,
XmNset, value,
NULL );
#else
XmToggleButtonSetState ((Widget) m_mainWidget,
state == wxCHK_CHECKED, True);
#endif
m_inSetValue = false;
}
static void cb_optionChanged (GuiObject w, XtPointer void_me, XtPointer call) {
iam (GuiOptionMenu);
(void) call;
for (int i = 1; i <= my d_options -> size; i ++) {
GuiMenuItem item = static_cast <GuiMenuItem> (my d_options -> item [i]);
if (item -> d_widget == w) {
XtVaSetValues (my d_xmCascadeButton, XmNlabelString, Melder_peekWcsToUtf8 (item -> d_widget -> name), NULL);
XmToggleButtonSetState (item -> d_widget, TRUE, FALSE);
if (Melder_debug == 11) {
Melder_warning (i, " \"", item -> d_widget -> name, "\"");
}
} else {
XmToggleButtonSetState (item -> d_widget, FALSE, FALSE);
}
}
}
static void swing_callback(Widget w, XtPointer data, caddr_t cbs)
{
cd->swing = XmToggleButtonGetState(swing);
cd->loop = 0;
XmToggleButtonSetState(loop, 0, False);
cd->stop = !cd->swing;
}
void
update_ucr_sort_fields( Widget w,
XtPointer client_data,
XtPointer call_data)
{
int i;
if (((XmToggleButtonCallbackStruct *)call_data)->set){
if (!XtIsSensitive(*(((ucr_sort_btn_ptr)client_data)->asc_desc_btn))){
XtSetSensitive(*(((ucr_sort_btn_ptr)client_data)->asc_desc_btn), True);
}
num_ucr_sort_items++;
ucr_sort_fields[((ucr_sort_btn_ptr)client_data)->position] = num_ucr_sort_items;
}else{
if (XtIsSensitive(*(((ucr_sort_btn_ptr)client_data)->asc_desc_btn))){
XmToggleButtonSetState(*(((ucr_sort_btn_ptr)client_data)->asc_desc_btn),
False, True);
XtSetSensitive(*(((ucr_sort_btn_ptr)client_data)->asc_desc_btn), False);
}
for (i = 0; i < TOTAL_UCR_SORT_ITEMS; i++){
if (ucr_sort_fields[i]>ucr_sort_fields[((ucr_sort_btn_ptr)client_data)->position])
ucr_sort_fields[i]--;
}
ucr_sort_fields[((ucr_sort_btn_ptr)client_data)->position] = 0;
num_ucr_sort_items--;
}
build_ucr_sort_order();
}
void init_isolinien_interface(void)
/*************************************************************************/
{
char c_hilf[12];
b_init_tabelle = TRUE; /* Flagge dass Fenster initialisiert */
if (g_tabelle.ex)
{
if (g_tabelle.on)
{
XmToggleButtonSetState(widget_isolinien.TB_tabelle_zeichnen,
TRUE, FALSE);
XmToggleButtonSetState(widget_isolinien.TB_tabelle_nicht_zeichnen,
FALSE, FALSE);
}
else
{
XmToggleButtonSetState(widget_isolinien.TB_tabelle_zeichnen,
FALSE, FALSE);
XmToggleButtonSetState(widget_isolinien.TB_tabelle_nicht_zeichnen,
TRUE, FALSE);
}
switch(g_tabelle.art)
{
case 1:
XmToggleButtonSetState(widget_isolinien.TB_default, TRUE, FALSE);
break;
case 2:
XmToggleButtonSetState(widget_isolinien.TB_grau, TRUE, FALSE);
break;
case 3:
XmToggleButtonSetState(widget_isolinien.TB_raster, TRUE, FALSE);
break;
case 4:
XmToggleButtonSetState(widget_isolinien.TB_datei, TRUE, FALSE);
break;
}
XtSetSensitive(widget_isolinien.TB_tabelle_zeichnen, TRUE);
XtSetSensitive(widget_isolinien.TB_tabelle_nicht_zeichnen, TRUE);
XtSetSensitive(widget_isolinien.TB_default, TRUE);
XtSetSensitive(widget_isolinien.TB_grau, TRUE);
XtSetSensitive(widget_isolinien.TB_raster, TRUE);
XtSetSensitive(widget_isolinien.TB_datei, TRUE);
}
else
{
XtSetSensitive(widget_isolinien.TB_tabelle_zeichnen, FALSE);
XtSetSensitive(widget_isolinien.TB_tabelle_nicht_zeichnen, FALSE);
XtSetSensitive(widget_isolinien.TB_default, FALSE);
XtSetSensitive(widget_isolinien.TB_grau, FALSE);
XtSetSensitive(widget_isolinien.TB_raster, FALSE);
XtSetSensitive(widget_isolinien.TB_datei, FALSE);
}
}
void pgfilterw_stepOneUp ( void )
/************************************************************************
* pgfilterw_stepOneUp *
* *
* Moves up one filter from the highest one currently selected. *
* *
* void pgfilterw_stepOneUp ( ) *
* *
* Input parameters: *
* Output parameters: *
* none *
* *
** *
* Log: *
* J. Wu/SAIC 07/04 initial coding *
* J. Wu/SAIC 08/04 set _offByHotkey to True *
* J. Wu/SAIC 12/04 disable if the filter window is not up *
***********************************************************************/
{
int ii, highest;
/*---------------------------------------------------------------------*/
if ( !pgfilterw_isUp() ) return;
highest = 0;
for ( ii = 0; ii < _nFilTime[TIME_FILTER]; ii++ ) {
if ( _filterStatus[ii] && ii >= highest ) {
highest = ii + 1;
}
_filterStatus[ii] = False;
XmToggleButtonSetState ( _filterChkBtn[ii], False, False );
}
if ( highest >= (_nFilTime[TIME_FILTER]) ) {
highest = _nFilTime[TIME_FILTER] - 1;
}
_filterStatus[highest] = True;
XmToggleButtonSetState ( _filterChkBtn[highest], True, False );
_offByHotkey = True;
pgfilterw_updateFilter ( );
}
void WFoeMotif::set_mode_button_state( int mode, int state)
{
switch ( mode) {
case VIEW:
XmToggleButtonSetState( widgets.view_togg, state, 0);
break;
case EDIT:
XmToggleButtonSetState( widgets.edit_togg, state, 0);
break;
case TRACE:
XmToggleButtonSetState( widgets.trace_togg, state, 0);
break;
case SIMULATE:
XmToggleButtonSetState( widgets.simulate_togg, state, 0);
break;
}
}
void pgfilterw_stepOneDown ( void )
/************************************************************************
* pgfilterw_stepOneDown *
* *
* Moves down one filter from the lowest one currently selected. *
* *
* void pgfilterw_stepOnDown ( void ) *
* *
* Input parameters: *
* Output parameters: *
* none *
* *
** *
* Log: *
* J. Wu/SAIC 07/04 initial coding *
* J. Wu/SAIC 08/04 set _offByHotkey to True *
* J. Wu/SAIC 12/04 disable if the filter window is not up *
***********************************************************************/
{
int ii, lowest;
/*---------------------------------------------------------------------*/
if ( !pgfilterw_isUp() ) return;
lowest = _nFilTime[TIME_FILTER] - 1;
for ( ii = (_nFilTime[TIME_FILTER]-1); ii >= 0; ii-- ) {
if ( _filterStatus[ii] && ii <= lowest ) {
lowest = ii - 1;
}
_filterStatus[ii] = False;
XmToggleButtonSetState ( _filterChkBtn[ii], False, False );
}
if ( lowest <= 0 ) {
lowest = 0;
}
_filterStatus[lowest] = True;
XmToggleButtonSetState ( _filterChkBtn[lowest], True, False );
_offByHotkey = True;
pgfilterw_updateFilter ();
}
