ToggleButtonInterface::ToggleButtonInterface (
Widget parent,
Cmd *cmd
) : CmdInterface ( cmd )
{
// We need to generate a button name that doesn't have illegal characters.
//
char *w_name = new char[200];
strcpy(w_name, _name);
for (char * cur = w_name; *cur; cur++) {
if (isspace(*cur) || *cur == ',') {
*cur = '_';
continue;
}
if (*cur == '.') {
*cur = 0;
break;
}
}
XmString label = XmStringCreateLocalized(cmd->getLabel());
if (0 == strcmp(cmd->className(),"ToggleButtonCmd"))
{
ToggleButtonCmd *tbc = (ToggleButtonCmd*) cmd;
Boolean visible_when_off = tbc->visibleWhenOff();
unsigned char indicator_type = tbc->indicatorType();
_w = XtVaCreateWidget (w_name,
xmToggleButtonWidgetClass,
parent,
XmNlabelString, label,
XmNvisibleWhenOff, visible_when_off,
XmNindicatorType, indicator_type,
NULL);
}
else
_w = XtVaCreateWidget (w_name,
xmToggleButtonWidgetClass,
parent,
XmNlabelString, label,
XmNvisibleWhenOff, TRUE,
NULL);
XmStringFree(label);
printHelpId("_w", _w);
// XtAddCallback(_w, XmNhelpCallback, HelpCB, helpId);
// free(helpId);
installDestroyHandler();
// The _active member is set when each instance is registered
// with an associated Cmd object. Now that a widget exists,
// set the widget's sensitivity according to its active state.
if ( _active )
activate();
else
deactivate();
#ifdef GNU_CC // No idea what the right ifdef is for automatically recognizing g++
// G++ reportedly doesn't like the form expected by cfront. I'm
// told this will work, but I haven't tested it myself.
XtAddCallback ( _w,
XmNvalueChangedCallback,
executeCmdCallback,
(XtPointer) this );
#else
XtAddCallback ( _w,
XmNvalueChangedCallback,
&CmdInterface::executeCmdCallback,
(XtPointer) this );
#endif
delete [] w_name;
}
static int PM_RMT_transfer_callback( rmt_transfer_event_t *event )
{
int bytes_transferred;
char temp_buf[PM_MAX_LABEL_SIZE];
double new_time;
struct timeval tv;
XmString label;
/* Get time info and convert to seconds. Use gettimeofday() in lieu
of time() to get finer resolution. Convert microseconds to fractional
seconds. */
gettimeofday( &tv, NULL );
new_time = tv.tv_sec + tv.tv_usec/1000000.0;
/* If debugging, print event info. */
if( Debug_flag == HCI_YES_FLAG )
{
Print_event( event );
}
if( event->event != RMT_DATA_SENT && event->event != RMT_DATA_RECEIVED )
{
/* Ignore events that aren't send or receive. */
return 0;
}
if( ( bytes_transferred = event->no_of_bytes ) > 0 )
{
Running_sum_of_bytes += bytes_transferred;
if( ( new_time - Previous_update_time ) > PM_UPDATE_INTERVAL )
{
Previous_update_time = new_time;
if( HCI_is_minimized() == HCI_NO_FLAG )
{
sprintf( temp_buf, "Transferred %d bytes", Running_sum_of_bytes );
if( strlen( temp_buf ) < PM_MAX_LABEL_SIZE )
{
strcpy( Transfer_bytes_label_buf, temp_buf );
}
else
{
strncpy( Transfer_bytes_label_buf, temp_buf, PM_MAX_LABEL_SIZE );
Transfer_bytes_label_buf[PM_MAX_LABEL_SIZE-1] = '\0';
}
label = XmStringCreateLocalized( Transfer_bytes_label_buf );
XtVaSetValues( Transfer_bytes_label, XmNlabelString, label, NULL );
XmStringFree( label );
PM_popup();
}
}
}
if( Simulation_flag == HCI_YES_FLAG )
{
PM_simulation_sleep( event );
}
return 0;
}
Widget CDeleteVariableAction::GetAttributesArea(Widget parent, symbolPtr* pSym){
XmString labelStr;
Widget area = XtVaCreateWidget("area",
xmFormWidgetClass, parent,
XmNwidth, 450,
XmNheight, 30,
XmNnumColumns, 2,
XmNpacking, XmPACK_COLUMN,
XmNorientation, XmVERTICAL,
NULL);
string result;
string command;
string id = prepareQuery(CEntityInfo::etag(pSym));
setWait(true);
CEntityInfo::exec("printformat \"%s\t%s\" name etag;", result);
command = string("GetFunctionsUsingLocal " + id);
CEntityInfo::exec("source_dis impacts.dis", result);
CEntityInfo::exec(command,result);
m_pClasses = new CQueryResult();
string cleanResult;
cleanResult = m_pClasses->cleanUpResult(result, "(funct)");
if (cleanResult.size() >= 1) {
m_pClasses->parse(cleanResult);
if(m_pClasses->getRecordsCount()>0 ) {
labelStr = XmStringCreateLocalized("Functions:");
Widget labelWidget = XtVaCreateManagedWidget("label_1",xmLabelGadgetClass, area,
XmNlabelString, labelStr,
XmNwidth, 100,
XmNtopAttachment,XmATTACH_FORM,
XmNleftAttachment,XmATTACH_FORM,
XmNbottomAttachment,XmATTACH_FORM,
NULL);
XmStringFree(labelStr);
m_ClassesList = XtVaCreateManagedWidget("Functions",
dtComboBoxWidgetClass, area,
XmNtopAttachment,XmATTACH_FORM,
XmNleftAttachment,XmATTACH_WIDGET,
XmNleftWidget, labelWidget,
XmNrightAttachment,XmATTACH_FORM,
XmNbottomAttachment,XmATTACH_FORM,
NULL);
TRecordSetIterator iter = m_pClasses->getStartRecord();
TRecordSetIterator end = m_pClasses->getEndRecord();
while(iter!=end) {
TRecord* pRecord = *iter;
labelStr = XmStringCreateLocalized((char*)(*pRecord)[1]->c_str());
DtComboBoxAddItem(m_ClassesList, labelStr, 0, false);
XmStringFree(labelStr);
iter++;
} //while
setWait(false);
return area;
}
setWait(false);
} else {
XmString labelStr;
labelStr = XmStringCreateLocalized("Deleting this variable requires changing the the functions arguments.\nPlease run Change Arguments instead.");
Widget labelWidget =
XtVaCreateManagedWidget("label_1", xmLabelGadgetClass, area,
XmNlabelString, labelStr,
XmNwidth, 150,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
XmStringFree(labelStr);
}
setWait(false);
return area;
}
/* ARGSUSED */
void show_textCb ( Widget w, XtPointer clnt,
XmDrawingAreaCallbackStruct *call )
/********************************************************************************
* *
** *
* *
* T. Piper/SAIC 1/02 Freed xfle, xmfl, & text_font as necessary *
* T. Piper/SAIC 2/02 Added 2nd argument, XtPointer client_data *
* *
********************************************************************************/
{
static Widget textpane, textform, textdialog_cancel, textbutton_form, textdialog_save;
XmString tstr;
XmFontList xmfl;
XmFontListEntry xfle;
Arg args[10];
Cardinal argcnt;
/*----------------------------------------------------------------------------*/
if( ! text_dialog)
{
text_dialog = XmCreateBulletinBoardDialog(toplevel, "textdialog_panel", NULL, 0);
tstr = XmStringCreateLocalized( "Sounding Text" );
XtVaSetValues( text_dialog, XmNdialogTitle, tstr, NULL);
XmStringFree(tstr);
textpane = XtVaCreateManagedWidget("text_pane",
xmPanedWindowWidgetClass,
text_dialog,
XmNsashWidth, 1,
XmNsashHeight, 1,
NULL);
textform = XtVaCreateWidget("textform", xmFormWidgetClass,
textpane, XmNwidth, 650, XmNheight, 800,
XmNfractionBase, 10, NULL );
argcnt = 0;
XtSetArg(args[argcnt],XmNscrollBarDisplayPolicy,XmAS_NEEDED); argcnt++;
XtSetArg(args[argcnt],XmNscrollingPolicy,XmAUTOMATIC); argcnt++;
XtSetArg(args[argcnt],XmNheight,800); argcnt++;
XtSetArg(args[argcnt],XmNwidth,650); argcnt++;
textfield = XmCreateScrolledText(textform,"textform_text",
args, argcnt);
if ( text_font ) XFreeFont ( XtDisplay(toplevel), text_font );
text_font = XLoadQueryFont(XtDisplay(toplevel),"-adobe-courier-bold-r-normal--14-100-100-100-m-90-iso8859-1");
xfle = XmFontListEntryCreate(XmFONTLIST_DEFAULT_TAG, XmFONT_IS_FONT, (XtPointer)text_font );
xmfl = XmFontListAppendEntry(NULL, xfle);
XtFree ( (XtPointer)xfle );
XtVaSetValues(textfield, XmNeditMode, XmMULTI_LINE_EDIT,
XmNeditable, False,
XmNfontList, xmfl,
NULL );
XmFontListFree ( xmfl );
XtManageChild ( textfield );
XtManageChild ( textform );
textbutton_form = XtVaCreateWidget("textbuttonform", xmFormWidgetClass,
textpane, XmNwidth, 650, XmNfractionBase, 10, NULL );
textdialog_save = XtVaCreateManagedWidget ("SAVE",
xmPushButtonWidgetClass, textbutton_form,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 3,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 5,
NULL );
XtAddCallback(textdialog_save, XmNactivateCallback,
(XtCallbackProc)textdialog_save_cb, NULL);
textdialog_cancel = XtVaCreateManagedWidget ("CLOSE",
xmPushButtonWidgetClass, textbutton_form,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 5,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 7,
NULL );
XtAddCallback(textdialog_cancel, XmNactivateCallback,
(XtCallbackProc)textdialog_cancel_cb, NULL);
XtManageChild ( textbutton_form );
XtManageChild ( textpane );
XtManageChild ( text_dialog );
}
else
XtManageChild ( text_dialog );
update_text_values();
}
void iupmotSetString(Widget w, const char *resource, const char* value)
{
XmString xm_str = XmStringCreateLocalized((String)value);
XtVaSetValues(w, resource, xm_str, NULL);
XmStringFree(xm_str);
}
int WNavMotif::confirm_dialog( char *title, char *text, int display_cancel,
int *cancel)
{
Widget dialog;
XmString text_str;
XmString title_str;
XmString no_str;
XmString yes_str;
XmString cancel_str;
Arg args[14];
int i;
XEvent Event;
text_str = XmStringCreateLocalized( wnav_dialog_convert_text(text));
title_str = XmStringCreateLocalized( title);
no_str = XmStringCreateLocalized( (char*) "No");
yes_str = XmStringCreateLocalized( (char*) "Yes");
cancel_str = XmStringCreateLocalized( (char*) "Cancel");
i = 0;
XtSetArg( args[i], XmNmessageString, text_str);
i++;
XtSetArg( args[i], XmNdialogTitle, title_str);
i++;
XtSetArg( args[i], XmNcancelLabelString, no_str);
i++;
XtSetArg( args[i], XmNokLabelString, yes_str);
i++;
XtSetArg( args[i], XmNhelpLabelString, cancel_str);
i++;
XtSetArg( args[i], XmNdialogType, XmDIALOG_WARNING);
i++;
if ( dialog_width && dialog_height)
{
XtSetArg( args[i], XmNwidth, dialog_width);
i++;
XtSetArg( args[i], XmNheight, dialog_height);
i++;
XtSetArg( args[i], XmNx, dialog_x);
i++;
XtSetArg( args[i], XmNy, dialog_y);
i++;
}
dialog = XmCreateInformationDialog( parent_wid, (char*) "Info", args, i);
XmStringFree( text_str);
XmStringFree( title_str);
XmStringFree( no_str);
XmStringFree( yes_str);
XmStringFree( cancel_str);
if ( !display_cancel)
XtUnmanageChild( XmMessageBoxGetChild( dialog, XmDIALOG_HELP_BUTTON));
XtAddCallback( dialog, XmNokCallback, wnav_message_dialog_ok, this);
XtAddCallback( dialog, XmNcancelCallback, wnav_message_dialog_cancel, this);
XtAddCallback( dialog, XmNhelpCallback, wnav_message_dialog_help, this);
// Connect the window manager close-button to exit
if ( !display_cancel)
flow_AddCloseVMProtocolCb( XtParent(dialog),
(XtCallbackProc)wnav_message_dialog_cancel, this);
else
flow_AddCloseVMProtocolCb( XtParent(dialog),
(XtCallbackProc)wnav_message_dialog_help, this);
XtManageChild( dialog);
XtPopup( XtParent(dialog), XtGrabNone);
dialog_ok = 0;
dialog_cancel = 0;
dialog_help = 0;
for (;;)
{
XtAppNextEvent( XtWidgetToApplicationContext( dialog), &Event);
XtDispatchEvent( &Event);
if ( dialog_ok)
{
if ( display_cancel)
*cancel = 0;
return 1;
}
if ( dialog_cancel)
{
if ( display_cancel)
*cancel = 0;
return 0;
}
if ( dialog_help)
{
*cancel = 1;
XtDestroyWidget( dialog);
return 0;
}
}
}
int WNavMotif::prompt_dialog( char *title, char *text, char **value)
{
Widget dialog;
XmString text_str;
XmString title_str;
Arg args[10];
int i;
XEvent Event;
text_str = XmStringCreateLocalized( wnav_dialog_convert_text(text));
title_str = XmStringCreateLocalized( title);
i = 0;
XtSetArg( args[i], XmNselectionLabelString, text_str);
i++;
XtSetArg( args[i], XmNdialogTitle, title_str);
i++;
if ( dialog_width && dialog_height)
{
XtSetArg( args[i], XmNwidth, dialog_width);
i++;
XtSetArg( args[i], XmNheight, dialog_height);
i++;
XtSetArg( args[i], XmNx, dialog_x);
i++;
XtSetArg( args[i], XmNy, dialog_y);
i++;
}
// XtSetArg( args[i], XmNautoUnmanage, False); i++;
dialog = XmCreatePromptDialog( parent_wid, (char*) "Info", args, i);
XmStringFree( text_str);
XmStringFree( title_str);
XtUnmanageChild( XmSelectionBoxGetChild( dialog, XmDIALOG_HELP_BUTTON));
XtAddCallback( dialog, XmNokCallback, wnav_message_dialog_read, this);
XtAddCallback( dialog, XmNcancelCallback, wnav_message_dialog_cancel, this);
// Connect the window manager close-button to exit
flow_AddCloseVMProtocolCb( XtParent(dialog),
(XtCallbackProc)wnav_message_dialog_cancel, this);
XtManageChild( dialog);
XtPopup( XtParent(dialog), XtGrabNone);
dialog_ok = 0;
dialog_cancel = 0;
dialog_help = 0;
for (;;)
{
XtAppNextEvent( XtWidgetToApplicationContext( dialog), &Event);
XtDispatchEvent( &Event);
if ( dialog_ok)
{
*value = dialog_value;
XtDestroyWidget( dialog);
return 1;
}
if ( dialog_cancel)
{
strcpy( dialog_value, "");
*value = dialog_value;
XtDestroyWidget( dialog);
return 0;
}
}
}
static void
ToolTipPost (XtPointer client_data,
XtIntervalId * id)
{
Widget w = (Widget) client_data;
int rx,
ry,
x,
y;
unsigned int key;
Window root,
child;
XtWidgetGeometry geo;
Position destX,
destY;
XmToolTipConfigTrait ttp; /* ToolTip pointer */
ttp = ToolTipGetData (w);
if (ttp == NULL)
{
XtWarning ("ToolTipGetData() returned NULL in ToolTipPost()");
return;
}
ttp->timer = (XtIntervalId) NULL;
XQueryPointer (XtDisplay (w),
XtWindow (w), &root, &child, &rx, &ry, &x, &y, &key);
if (ttp->duration_timer != (XtIntervalId) NULL)
{
XtRemoveTimeOut (ttp->duration_timer);
ttp->duration_timer = (XtIntervalId) NULL;
}
if (XmIsPrimitive(w) || XmIsGadget(w))
{
XtVaSetValues (ttp->label,
XmNlabelString,
XmGetToolTipString(w),
NULL);
}
else
{
XmString string;
string = XmStringCreateLocalized (XtName (w));
XtVaSetValues (ttp->label, XmNlabelString, string, NULL);
XmStringFree (string);
}
XtQueryGeometry (ttp->label, NULL, &geo);
/* rws 25 Feb 2001
Fix for Bug #1153
Don't let the tip be off the right/bottom of the screen
*/
destX = rx + (XmIsGadget (w) ? XtX (w) : 0) - x + XtWidth (w) / 2;
if (destX + geo.width > WidthOfScreen (XtScreen (w)))
{
destX = WidthOfScreen (XtScreen (w)) - geo.width;
}
destY = ry + (XmIsGadget (w) ? XtY (w) : 0) - y + XtHeight (w);
if (destY + geo.height > HeightOfScreen (XtScreen (w)))
{
destY = ry + (XmIsGadget (w) ? XtY (w) : 0) - y - geo.height;
}
XtVaSetValues (XtParent (ttp->label),
XmNx, rx + 1,
XmNy, ry + 1, XmNwidth, 1, XmNheight, 1, NULL);
ttp->slider =
XtVaCreateWidget ("ToolTipSlider", xmSlideContextWidgetClass,
XmGetXmDisplay (XtDisplay (w)), XmNslideWidget,
XtParent (ttp->label),
XmNslideDestX, destX,
XmNslideDestY, destY,
XmNslideDestWidth, geo.width,
XmNslideDestHeight, geo.height, NULL);
XtAddCallback (ttp->slider, XmNslideFinishCallback,
(XtCallbackProc) ToolTipPostFinish, ttp);
XtPopup (XtParent (ttp->label), XtGrabNone);
}
extern void
make_browselist(Calendar *c)
{
int ac;
Arg args[15];
XmString label_str;
Widget separator,
button_form;
Browselist *bl = (Browselist *)c->browselist;
Dimension label_width;
char *title;
if (!bl)
return;
title = XtNewString(catgets(c->DT_catd, 1, 963,
"Calendar : Menu Editor"));
bl->frame = XtVaCreatePopupShell("menu_editor_frame",
xmDialogShellWidgetClass, c->frame,
XmNdeleteResponse, XmDO_NOTHING,
XmNtitle, title,
XmNallowShellResize, True,
XmNmappedWhenManaged, False,
NULL);
setup_quit_handler(bl->frame, blist_quit_handler, (caddr_t)bl);
XtFree(title);
bl->form = XtVaCreateWidget("menu_editor_form",
xmFormWidgetClass, bl->frame,
XmNautoUnmanage, False,
XmNfractionBase, 5,
NULL);
label_str = XmStringCreateLocalized(
catgets(c->DT_catd, 1, 410, "User Name:"));
bl->username_label = XtVaCreateWidget("name_label",
xmLabelGadgetClass, bl->form,
XmNlabelString, label_str,
NULL);
XmStringFree(label_str);
ac = 0;
XtSetArg(args[ac], XmNorientation, XmVERTICAL); ++ac;
XtSetArg(args[ac], XmNpacking, XmPACK_COLUMN); ++ac;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ++ac;
XtSetArg(args[ac], XmNtopOffset, 6); ++ac;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ++ac;
XtSetArg(args[ac], XmNrightOffset, 5); ++ac;
bl->edit_rc_mgr = XmCreateRowColumn(bl->form, "edit_rc_mgr", args, ac);
label_str = XmStringCreateLocalized(
catgets(c->DT_catd, 1, 686, "Add Name"));
bl->add_button = XtVaCreateWidget("add_button",
xmPushButtonWidgetClass, bl->edit_rc_mgr,
XmNlabelString, label_str,
XmNnavigationType, XmTAB_GROUP,
NULL);
XmStringFree(label_str);
XtAddCallback(bl->add_button, XmNactivateCallback,
blist_addname, (XtPointer)c);
label_str = XmStringCreateLocalized(
catgets(c->DT_catd, 1, 687, "Remove Name"));
bl->remove_button = XtVaCreateWidget("remove_button",
xmPushButtonWidgetClass, bl->edit_rc_mgr,
XmNlabelString, label_str,
XmNnavigationType, XmTAB_GROUP,
NULL);
XmStringFree(label_str);
XtAddCallback(bl->remove_button, XmNactivateCallback,
blist_removenames, (XtPointer)c);
ManageChildren(bl->edit_rc_mgr);
XtVaGetValues(bl->username_label, XmNwidth, &label_width, NULL);
bl->username = XtVaCreateWidget("username",
xmTextFieldWidgetClass, bl->form,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, label_width + 15,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, bl->edit_rc_mgr,
XmNrightOffset, 5,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 5,
XmNcolumns, 40,
NULL);
XtAddCallback(bl->username, XmNactivateCallback, blist_addname,
(XtPointer)c);
XtAddCallback(bl->username, XmNvalueChangedCallback,
bl_pending_change, (XtPointer)c);
XtVaSetValues(bl->username_label,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, bl->username,
XmNbottomOffset, 5,
XmNrightAttachment, XmATTACH_WIDGET,
XmNrightWidget, bl->username,
XmNrightOffset, 5,
NULL);
label_str = XmStringCreateLocalized(
catgets(c->DT_catd, 1, 688, "Browse Menu Items"));
bl->list_label = XtVaCreateWidget("list_label",
xmLabelWidgetClass, bl->form,
XmNlabelString, label_str,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, bl->username,
XmNtopOffset, 10,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
NULL);
XmStringFree(label_str);
bl->message = XtVaCreateWidget("message_text",
xmLabelGadgetClass,
bl->form,
XmNalignment, XmALIGNMENT_BEGINNING,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 5,
NULL);
button_form = XtVaCreateWidget("menu_editor_button_form_mgr",
xmFormWidgetClass,
bl->form,
XmNautoUnmanage, False,
XmNfractionBase, 5,
XmNhorizontalSpacing, 5,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, bl->message,
XmNbottomOffset, 5,
NULL);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 655, "OK"));
bl->ok_button = XtVaCreateWidget("ok_button",
xmPushButtonWidgetClass,
button_form,
XmNlabelString, label_str,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 0,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 1,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XmStringFree(label_str);
XtAddCallback(bl->ok_button, XmNactivateCallback, blist_ok,
(XtPointer)c);
label_str = XmStringCreateLocalized(
catgets(c->DT_catd, 1, 460, "Apply"));
bl->apply_button = XtVaCreateWidget("apply_button",
xmPushButtonWidgetClass,
button_form,
XmNlabelString, label_str,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 1,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 2,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XmStringFree(label_str);
XtAddCallback(bl->apply_button, XmNactivateCallback, blist_apply,
(XtPointer)c);
label_str = XmStringCreateLocalized(
catgets(c->DT_catd, 1, 691, "Reset"));
bl->reset_button = XtVaCreateWidget("reset_button",
xmPushButtonWidgetClass,
button_form,
XmNlabelString, label_str,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 2,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 3,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XmStringFree(label_str);
XtAddCallback(bl->reset_button, XmNactivateCallback,
blist_reset_cb, (XtPointer)c);
label_str = XmStringCreateLocalized(
catgets(c->DT_catd, 1, 923, "Cancel"));
bl->cancel_button = XtVaCreateWidget("cancel_button",
xmPushButtonWidgetClass,
button_form,
XmNlabelString, label_str,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 3,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 4,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XmStringFree(label_str);
XtAddCallback(bl->cancel_button, XmNactivateCallback, blist_cancel_cb,
(XtPointer)c);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 77, "Help"));
bl->help_button = XtVaCreateWidget("help_button",
xmPushButtonWidgetClass,
button_form,
XmNlabelString, label_str,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 4,
XmNleftOffset, 5,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 5,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XmStringFree(label_str);
XtAddCallback(bl->help_button, XmNactivateCallback,
(XtCallbackProc)help_cb, MENU_EDITOR_HELP_BUTTON);
XtAddCallback(bl->form, XmNhelpCallback,
(XtCallbackProc)help_cb, (XtPointer) MENU_EDITOR_HELP_BUTTON);
ManageChildren(button_form);
separator = XtVaCreateWidget("separator",
xmSeparatorGadgetClass,
bl->form,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, button_form,
XmNbottomOffset, 5,
NULL);
ac = 0;
XtSetArg(args[ac], XmNvisibleItemCount, 8); ++ac;
XtSetArg(args[ac], XmNselectionPolicy, XmMULTIPLE_SELECT); ++ac;
XtSetArg(args[ac], XmNdoubleClickInterval, 5); ++ac;
bl->browse_list = (Widget)XmCreateScrolledList(bl->form, "browse_list",
args, ac);
bl->browse_list_sw = XtParent(bl->browse_list);
XtVaSetValues(bl->browse_list_sw,
XmNvisualPolicy, XmVARIABLE,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, bl->list_label,
XmNtopOffset, 5,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, bl->list_label,
XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNrightWidget, bl->username,
XmNrightOffset, 5,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, separator,
XmNbottomOffset, 5,
XmNwidth, 50,
NULL);
XtManageChild(bl->browse_list);
XtAddCallback(bl->browse_list, XmNmultipleSelectionCallback,
bl_list_selection_cb, (XtPointer)c);
ManageChildren(bl->form);
XtManageChild(bl->form);
/*
* Set default button
*/
XtVaSetValues(bl->form, XmNcancelButton, bl->cancel_button, NULL);
XmProcessTraversal(bl->username, XmTRAVERSE_CURRENT);
XtVaSetValues(bl->form, XmNinitialFocus, bl->username, NULL);
/*
* For storing the list of names
*/
if (!bl->blist_data)
bl->blist_data = CmDataListCreate();
}
Widget
MenuBar::createPulldown (
Widget parent,
CmdList *list,
Boolean help ,
unsigned char type)
{
int i;
Widget pulldown, cascade;
Arg args2[2];
char * helpId;
XmString label_str;
if(type != XmMENU_POPUP)
type = XmMENU_BAR;
// Create a pulldown menu pane for this list of commands
if( type == XmMENU_BAR) {
pulldown = XmCreatePulldownMenu( parent,
(char *) list->name(), NULL, 0 );
label_str = XmStringCreateLocalized(list->getLabel());
XtVaSetValues(pulldown,
XmNlabelString, label_str,
NULL);
printHelpId("pulldown", pulldown);
/* install callback */
// XtAddCallback(pulldown, XmNhelpCallback, HelpCB, helpId);
// Each entry in the menu bar must have a cascade button
// from which the user can pull down the pane
XtSetArg(args2[0], XmNsubMenuId, pulldown);
cascade = XtCreateWidget ( list->name(),
xmCascadeButtonWidgetClass,
parent,
args2, 1);
XtVaSetValues(cascade,
XmNlabelString, label_str,
NULL);
if (help) {
XtSetArg (args2[0], XmNmenuHelpWidget, cascade);
XtSetValues (parent, args2, 1);
}
XtManageChild ( cascade );
printHelpId("cascade", cascade);
/* install callback */
// Install callbacks for each of the
// pulldown menus so we can get
// On Item help for them.
helpId = XtName(cascade);
if (helpId == "Mailbox") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILCONTAINERMENUID);
} else if (helpId == "Edit") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILEDITMENUID);
} else if (helpId == "Message") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILMESSAGEMENUID);
} else if (helpId == "Attachments") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILATTACHMENUID);
} else if (helpId == "View") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILVIEWMENUID);
} else if (helpId == "Compose") {
XtAddCallback(cascade, XmNhelpCallback,
HelpCB, (void *)DTMAILCOMPOSEMENUID);
}
} else
pulldown = _w;
// Loop through the cmdList, creating a menu
// entry for each command.
for ( i = 0; i < list->size(); i++)
{
if(!strcmp((*list)[i]->className(), "CmdList")) {
Widget pane = createPulldown(pulldown,
(CmdList*) (*list)[i], FALSE, XmMENU_BAR);
((CmdList *)(*list)[i])->setPaneWidget(pane);
label_str = XmStringCreateLocalized((*list)[i]->getLabel());
XtVaSetValues(pane,
XmNlabelString, label_str,
NULL);
} else {
if ( !strcmp((*list)[i]->className(),"SeparatorCmd")) {
XtCreateManagedWidget ( (*list)[i]->name(),
xmSeparatorWidgetClass,
pulldown,
NULL, 0);
} else if (!strcmp((*list)[i]->className(),"ToggleButtonCmd")) {
CmdInterface *ci;
ci = new ToggleButtonInterface(pulldown, (*list)[i]);
ci->manage();
} else if(!strcmp((*list)[i]->className(),"LabelCmd")) {
Widget _i18n;
Arg _args[1];
XmString xms;
_i18n = XtCreateManagedWidget(
(*list)[i]->name(),
xmLabelWidgetClass,
pulldown,
NULL, 0
);
xms = XmStringCreateLocalized((char*) (*list)[i]->getLabel());
XtSetArg( _args[0], XmNlabelString, xms );
XtSetValues( _i18n, _args, 1 );
XmStringFree(xms);
} else {
CmdInterface *ci;
ci = new ButtonInterface ( pulldown, (*list)[i] );
ci->manage();
}
}
}
return(pulldown);
}
Widget
MenuBar::addCommands(
Widget pulldown,
CmdList *new_list
)
{
// if(isValidMenuPane(pulldown) == FALSE)
// return NULL;
int i, num_children;
WidgetList children;
Boolean haveNoSeparator;
int newItemIndex, numPBUnmanaged, tmpPBUnmanaged;
XtVaGetValues(pulldown,
XmNnumChildren, &num_children,
NULL);
children = (WidgetList)XtMalloc(sizeof(Widget) * num_children);
XtVaGetValues(pulldown,
XmNchildren, &children,
NULL);
// Handle the creation or management of the Separator.
haveNoSeparator = TRUE;
numPBUnmanaged = 0;
for (i=0; (i < num_children); i++) {
Widget wid = (Widget) children[i];
if (XtIsSubclass(wid, xmSeparatorWidgetClass)) {
XtManageChild(wid);
haveNoSeparator = FALSE;
}
else if (XtIsSubclass(wid, xmPushButtonWidgetClass)) {
if (!XtIsManaged(wid)) { // If widget is unmanaged
numPBUnmanaged++;
}
}
}
if (haveNoSeparator) {
XtCreateManagedWidget ("Separator",
xmSeparatorWidgetClass,
pulldown,
NULL, 0);
haveNoSeparator = FALSE;
}
// Now handle the pushButton case
newItemIndex = 0;
tmpPBUnmanaged = 0;
// Loop through the cmdList, creating a menu
// entry for each command.
for (newItemIndex = 0; newItemIndex < new_list->size(); newItemIndex++) {
tmpPBUnmanaged = numPBUnmanaged;
if (numPBUnmanaged > 0) { // If there exists unmanaged PBs
for (i = 0;
(i < num_children) &&
(tmpPBUnmanaged == numPBUnmanaged);
i++) {
Widget wid = (Widget) children[i];
if (XtIsSubclass(wid, xmPushButtonWidgetClass)) {
if (!XtIsManaged(wid)) {
// If widget is unmanaged
// Set its label to be the newItemIndex widget's.
// Manage it.
// Bump up newItemIndex
XtVaSetValues(wid,
XmNlabelString, XmStringCreateLocalized(
(char *) (*new_list)[newItemIndex]->getLabel()),
NULL);
XtManageChild(wid);
numPBUnmanaged--;
}
}
}
}
else { // No unmanaged push buttons available
CmdInterface *ci;
ci = new ButtonInterface (
pulldown, (*new_list)[newItemIndex]
);
ci->manage();
}
}
return(pulldown);
}
{
/* Invalid password */
Widget err;
int n;
Arg args[10];
XmString okLabel;
XmString message;
char * template;
char * title;
char * master;
okLabel = XmStringCreateLocalized(GETMESSAGE(1, 2, "OK"));
template = (GETMESSAGE(1,3, "The password you entered does not match\nthe password for user %s.\n\nPlease reenter the password, or select the\nCancel button to terminate the operation."));
master = XtMalloc(strlen(template) + strlen(appArgs.user) + 10);
sprintf(master, template, appArgs.user);
message = XmStringCreateLocalized(master);
title = (GETMESSAGE(1,4, "Action Invoker - Password Error"));
/* Post an error dialog */
n = 0;
XtSetArg(args[n], XmNtitle, title); n++;
XtSetArg(args[n], XmNmessageString, message); n++;
XtSetArg(args[n], XmNokLabelString, okLabel); n++;
err = XmCreateErrorDialog(dlog, "err", args, n);
XtUnmanageChild(XmMessageBoxGetChild(err, XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(err, XmDIALOG_HELP_BUTTON));
XtManageChild(err);
XtAddCallback(err, XmNokCallback, ErrOkCallback, err);
XFlush(XtDisplay(dlog));
XmUpdateDisplay(dlog);
/* ARGSUSED */
void mpcstw_textCb ( Widget w, long flag, XtPointer call )
/************************************************************************
* mpcstw_textCb *
* *
* This is the callback for the proj Text field widget *
* *
* void mpcstw_textCb(w, flag, call) *
* *
* Input parameters: *
* w Widget calling widget ID *
* flag long = 1 draw map, = 0 do not draw map *
* call XtPointer never used *
* *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* S. Wang/GSC 09/96 projTextCb and gareaTextCb *
* C. Lin/EAI 11/96 combine projTextCb and gareaTextCb together *
* C. Lin/EAI 02/97 bug fix in freeing string 'text' *
* C. Lin/EAI 07/97 call new mapw module *
* S. Jacobs/NCEP 10/99 Added current loop to setting map proj *
* E. Safford/GSC 10/99 dataw_getCurLoop -> loop_getCurLoop *
* M. Li/GSC 03/01 removed mapw_getDEFproj and mapw_setMap *
* E. Safford/GSC 05/01 added mpcstw_updtMapDvr *
* J. Wu/GSC 05/01 free XmStrings *
***********************************************************************/
{
int ignore;
char *text;
unsigned char shadow_char;
XmString str_def_con;
/*---------------------------------------------------------------------*/
/*
* get the PROJ input
*/
text = XmTextFieldGetString(_projTextW);
if ( (strlen(text)==(size_t)0) || (strcmp( _projCopy, "SAT" ) == 0) ) {
strcpy( _projEdit, _projCopy);
XmTextSetString( _projTextW, _projEdit );
}
else {
strcpy( _projEdit, text );
}
if ( text ) XtFree(text);
/*
* get the GAREA input
*/
text = XmTextFieldGetString(_gareaTextW);
if ( strlen(text)==(size_t)0 ) {
strcpy( _gareaEdit, _gareaCopy );
XmTextSetString( _gareaTextW, _gareaEdit );
}
else {
strcpy( _gareaEdit, text );
}
XtVaGetValues(_defaultConFrame, XmNshadowType, &shadow_char, NULL);
if ( shadow_char == XmSHADOW_IN ) {
str_def_con = XmStringCreateLocalized( _curDef );
XtVaSetValues(_defaultConLabel,
XmNlabelString, str_def_con,
NULL);
XmStringFree ( str_def_con );
}
if ( text ) XtFree(text);
mpcstw_updtMapDvr( );
if ( flag == 1 ) {
gclear( &ignore );
mapw_redrawMap();
}
}
void mpcstw_projCreate ( Widget parent )
/************************************************************************
* mpcstw_projCreate *
* *
* This function creates proj area *
* *
* void mpcstw_projCreate(parent) *
* *
* Input parameters: *
* parent Widget parent form widget ID *
* *
* Output parameters: *
* NULL *
* *
* Return parameters: *
* NULL *
* *
** *
* Log: *
* C. Lin/EAI 04/96 *
* S. Wang/GSC 09/96 Add others selections *
* S. Wang/GSC 10/96 Add DEF selection and content *
* G. Krueger/EAI 10/97 NxmFrameLabel->NxmLabel_createFrameLbl *
***********************************************************************/
{
int nn;
long ii;
Widget frame, rc0, rc, pane_fr;
Widget menu, rowcol;
XmString xmstr ;
Arg args[5] ;
/*---------------------------------------------------------------------*/
frame = XtVaCreateWidget("mpcstw_projFrame",
xmFrameWidgetClass, parent,
NULL);
pane_fr = XtVaCreateManagedWidget("mpcstw_projFrame",
xmPanedWindowWidgetClass, frame,
XmNsashWidth, 1,
XmNsashHeight, 1,
NULL);
NxmLabel_createFrameLbl("Projection", pane_fr, frame);
/*
* create a parent row column widget for projection selection
* panel
*/
rc0 = XtVaCreateWidget("rc",
xmRowColumnWidgetClass, pane_fr,
XmNorientation, XmVERTICAL,
NULL);
/*
* create GEMPAK PROJ input string area
*/
rc = XtVaCreateWidget("mpcstw_projGEMPAKRc",
xmRowColumnWidgetClass, rc0,
XmNorientation, XmHORIZONTAL,
NULL);
XtVaCreateManagedWidget("PROJ",
xmLabelGadgetClass, rc,
NULL);
_projTextW = XtVaCreateManagedWidget("txt",
xmTextFieldWidgetClass, rc,
XmNcolumns, 35,
XmNmarginHeight, 0,
NULL);
XtAddCallback(_projTextW, XmNactivateCallback,
(XtCallbackProc)mpcstw_textCb, (XtPointer)1);
XtManageChild(rc);
rc = XtVaCreateWidget("mpcstw_projRc",
xmRowColumnWidgetClass, rc0,
XmNorientation, XmVERTICAL,
XmNradioBehavior, True,
XmNspacing, 0,
NULL);
/*
* create default projection button and label
*/
rowcol = XtVaCreateManagedWidget( "orc",
xmRowColumnWidgetClass, rc,
XmNorientation, XmHORIZONTAL,
XmNradioBehavior, True,
XmNspacing, 60,
NULL );
_defaultBt = XtVaCreateManagedWidget( _projItem[0].name,
xmToggleButtonWidgetClass, rowcol,
XmNradioBehavior, True,
NULL );
XtAddCallback( _defaultBt, XmNarmCallback,
(XtCallbackProc)mpcstw_projDefaultCb,
(XtPointer)0 );
/*
* create default projection show content button
*/
_defaultConFrame = XtVaCreateManagedWidget("mpcstw_defFrame",
xmFrameWidgetClass, rowcol,
XmNshadowType, XmSHADOW_OUT,
XmNshadowThickness, 2,
NULL);
xmstr = XmStringCreateLocalized(" DEF Content ");
_defaultConLabel = XtVaCreateManagedWidget( "mpcstw_defLabel",
xmLabelWidgetClass, _defaultConFrame,
XmNlabelString, xmstr,
XmNrecomputeSize, False,
XmNheight, 4,
XmNwidth, 85,
NULL);
XmStringFree(xmstr);
XtAddEventHandler( _defaultConLabel,
ButtonReleaseMask, FALSE,
(XtEventHandler)mpcstw_defConCb,
(XtPointer)0);
/*
* create commonly used projection radio button group
*/
for ( ii = 1; ii < NAMEPROJSHOW; ii++ ) {
_toggleBt[ii] = XtVaCreateManagedWidget( _projItem[ii].name,
xmToggleButtonWidgetClass, rc,
XmNmarginHeight, 0,
NULL );
XtAddCallback( _toggleBt[ii], XmNarmCallback,
(XtCallbackProc)mpcstw_projToggleCb,
(XtPointer)ii );
}
XtManageChild(rc);
rowcol = XtVaCreateManagedWidget("orc",
xmRowColumnWidgetClass, rc,
XmNorientation, XmHORIZONTAL,
XmNradioBehavior, TRUE,
XmNpacking, XmPACK_TIGHT,
NULL);
_othersBt = XtVaCreateManagedWidget("Others:",
xmToggleButtonWidgetClass, rowcol,
NULL );
XtAddCallback(_othersBt, XmNarmCallback,
(XtCallbackProc)mpcstw_projOthersCb,
(XtPointer)NAMEPROJSHOW);
/*
* create other projection option menu
*/
menu = XmCreatePulldownMenu(rowcol, "mpcstw_projOptMenu", NULL, 0);
nn = 0;
xmstr = XmStringCreateLocalized("");
XtSetArg(args[nn], XmNsubMenuId, menu); nn++;
XtSetArg(args[nn], XmNlabelString, xmstr); nn++;
_projOption = XmCreateOptionMenu(rowcol, "mpcstw_projOpt", args, nn);
XmStringFree(xmstr);
for (ii = NAMEPROJSHOW; ii < (long)XtNumber(_projItem); ii++) {
_optButton[ii] = XtVaCreateManagedWidget(_projItem[ii].name,
xmPushButtonGadgetClass, menu,
NULL );
XtAddCallback(_optButton[ii], XmNactivateCallback,
(XtCallbackProc)mpcstw_projOptionCb,
(XtPointer)ii);
}
_projOptInx = NAMEPROJSHOW;
XtManageChild(_projOption);
XtManageChild(rc0);
XtManageChild(frame);
}
/*######################## popup_event_reason() #########################*/
void
popup_event_reason(int x_root, int y_root, int host_no)
{
if (event_reason_shell != NULL)
{
destroy_event_reason();
}
if ((fsa[host_no].host_status & HOST_ERROR_ACKNOWLEDGED) ||
(fsa[host_no].host_status & HOST_ERROR_OFFLINE) ||
(fsa[host_no].host_status & HOST_ERROR_ACKNOWLEDGED_T) ||
(fsa[host_no].host_status & HOST_ERROR_OFFLINE_T) ||
((fsa[host_no].host_status & HOST_ERROR_OFFLINE_STATIC) &&
(fsa[host_no].error_counter > fsa[host_no].max_errors)))
{
char event_reason[MAX_USER_NAME_LENGTH + 2 + MAX_EVENT_REASON_LENGTH + 1];
event_reason[0] = '\0';
if (fsa[host_no].host_status & HOST_ERROR_OFFLINE_STATIC)
{
(void)strcpy(event_reason, STATIC_EVENT_REASON);
}
else
{
get_event_reason(event_reason, fsa[host_no].host_alias);
}
if (event_reason[0] != '\0')
{
Widget event_reason_label,
form;
XmString x_string;
int display_height,
display_width,
lines,
max_length,
over_hang,
str_length;
char *ptr;
/* Lets determine how many lines we are able to display. */
display_height = DisplayHeight(display, DefaultScreen(display));
max_length = lines = 0;
ptr = event_reason;
while (*ptr != '\0')
{
str_length = 0;
while ((*(ptr + str_length) != '\n') &&
(*(ptr + str_length) != '\0'))
{
str_length++;
}
if (*(ptr + str_length) == '\n')
{
str_length++;
}
lines++;
if (str_length > max_length)
{
max_length = str_length;
}
ptr += str_length;
}
event_reason_shell = XtVaCreatePopupShell("event_reason_shell",
topLevelShellWidgetClass, appshell,
XtNoverrideRedirect, True,
XtNallowShellResize, True,
XtNmappedWhenManaged, False,
XtNsensitive, True,
XtNwidth, 1,
XtNheight, 1,
XtNborderWidth, 0,
NULL);
XtManageChild(event_reason_shell);
XtAddEventHandler(event_reason_shell,
ButtonPressMask | Button1MotionMask, False,
(XtEventHandler)er_input, NULL);
form = XtVaCreateWidget("event_reason_box",
xmFormWidgetClass, event_reason_shell, NULL);
XtManageChild(form);
display_width = DisplayWidth(display, DefaultScreen(display));
over_hang = display_width - (x_root + (max_length * glyph_width));
if (over_hang < 0)
{
x_root += over_hang;
}
over_hang = display_height - (y_root + (lines * glyph_height));
if (over_hang < 0)
{
y_root += over_hang;
}
XMoveResizeWindow(display, XtWindow(event_reason_shell),
x_root, y_root, max_length * glyph_width,
lines * glyph_height);
x_string = XmStringCreateLocalized(event_reason);
event_reason_label = XtVaCreateWidget("event_reason_label",
xmLabelWidgetClass, form,
XmNfontList, fontlist,
XmNlabelString, x_string,
XtNbackground, color_pool[WHITE],
XtNforeground, color_pool[BLACK],
NULL);
XtManageChild(event_reason_label);
XmStringFree(x_string);
XtAddEventHandler(event_reason_label,
ButtonPressMask | LeaveWindowMask, False,
(XtEventHandler)destroy_event_reason, NULL);
XtPopup(event_reason_shell, XtGrabNone);
XRaiseWindow(display, XtWindow(event_reason_shell));
}
}
else
{
destroy_event_reason();
}
return;
}
Widget
_DtCreateMenuSystem(
Widget parent,
char * menuBarName,
XtCallbackProc helpCallback,
XtPointer helpData,
Boolean createSharedComponents,
MenuDesc * menuDesc,
int numMenuComponents,
void (*getMenuDataProc)(),
void (*setMenuSensitivity)(),
void (*restoreMenuSensitivity)() )
{
int n;
int i;
Arg args[20];
Widget menubar;
Widget lastCascadeBtn = NULL;
Widget lastMenuPane = NULL;
char lastMenuPaneType = MENU_PANE;
Boolean firstMenuPane = True;
Widget child;
XmString labelString;
int pulldownIndex = 1;
int menuPaneIndex = 1;
int menuBtnIndex = 1;
/* Use our own menu control functions, if none specified */
if (setMenuSensitivity == NULL)
setMenuSensitivity = _DtGlobalSetMenuSensitivity;
if (restoreMenuSensitivity == NULL)
restoreMenuSensitivity = _DtGlobalRestoreMenuSensitivity;
/* Create the pulldown menu */
n = 0;
XtSetArg(args[n], XmNorientation, XmHORIZONTAL); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
menubar = XmCreateMenuBar(parent, menuBarName, args, n);
XtManageChild(menubar);
if (helpCallback)
XtAddCallback(menubar, XmNhelpCallback, helpCallback, helpData);
for (i = 0; i < numMenuComponents; i++)
{
n = 0;
switch (menuDesc[i].type)
{
case MENU_PULLDOWN_BUTTON:
{
labelString = XmStringCreateLocalized(menuDesc[i].label);
XtSetArg(args[n], XmNlabelString, labelString); n++;
if (menuDesc[i].mnemonic)
{
XtSetArg(args[n], XmNmnemonic, menuDesc[i].mnemonic[0]); n++;
}
XtSetArg(args[n], XmNmarginWidth, 6); n++;
child = XmCreateCascadeButtonGadget(menubar, menuDesc[i].name,
args, n);
if (menuDesc[i].helpCallback)
{
XtAddCallback(child, XmNhelpCallback,
menuDesc[i].helpCallback, menuDesc[i].helpData);
}
if (menuDesc[i].isHelpBtn)
{
XtSetArg(args[0], XmNmenuHelpWidget, child);
XtSetValues(menubar, args, 1);
}
XtManageChild(child);
XmStringFree(labelString);
lastCascadeBtn = menuDesc[i].widget = child;
pulldownIndex++;
break;
}
case SHARED_MENU_PANE:
case MENU_PANE:
{
if (createSharedComponents || (menuDesc[i].type == MENU_PANE))
{
child = XmCreatePulldownMenu(menubar, menuDesc[i].name, NULL, 0);
if (firstMenuPane)
{
XtAddCallback(XtParent(child), XmNpopupCallback,
setMenuSensitivity,
(XtPointer)getMenuDataProc);
XtAddCallback(XtParent(child), XmNpopdownCallback,
restoreMenuSensitivity,
(XtPointer)getMenuDataProc);
firstMenuPane = False;
}
if (menuDesc[i].helpCallback)
{
XtAddCallback(child, XmNhelpCallback,
menuDesc[i].helpCallback, menuDesc[i].helpData);
}
menuDesc[i].widget = child;
}
lastMenuPane = menuDesc[i].widget;
lastMenuPaneType = menuDesc[i].type;
XtSetArg(args[0], XmNsubMenuId, lastMenuPane);
XtSetValues(lastCascadeBtn, args, 1);
menuBtnIndex = 1;
menuPaneIndex++;
break;
}
case MENU_TOGGLE_BUTTON:
case MENU_BUTTON:
{
/* Need to always make btns for non-shared menupanes */
if ((createSharedComponents) || (lastMenuPaneType == MENU_PANE))
{
child = CreateMenuBtn (lastMenuPane,
(menuDesc[i].type == MENU_BUTTON),
menuDesc + i, menuBtnIndex);
XtManageChild(child);
menuDesc[i].widget = child;
}
menuBtnIndex++;
break;
}
case MENU_SEPARATOR:
{
/* Need to always make components for non-shared menupanes */
if ((createSharedComponents) || (lastMenuPaneType == MENU_PANE))
{
child = XmCreateSeparatorGadget(lastMenuPane, menuDesc[i].name,
NULL, 0);
XtManageChild(child);
menuDesc[i].widget = child;
}
break;
}
}
}
return(menubar);
}
/*
** Functions to build and popup the postup reminder
*/
extern void
postup_show_proc(Calendar *c, CSA_reminder_reference *r) {
int start_hr, stop_hr;
char text[BUFSIZ];
time_t st, sp = 0;
Lines *lines, *l = NULL;
Props *p = (Props *)c->properties;
Widget pu_frame, pu_base_form,
pu_text_form, separator,
pu_form, button_form, pu_date,
pu_range, pu_image, pu_close, line, last_line;
Boolean start_am, stop_am;
XmString xmstr;
CSA_return_code stat;
DisplayType dis_t = get_int_prop(p, CP_DEFAULTDISP);
OrderingType ord_t = get_int_prop(p, CP_DATEORDERING);
SeparatorType sep_t = get_int_prop(p, CP_DATESEPARATOR);
Dtcm_appointment *appt;
char *title;
if (!c->postup)
c->postup = XtAppCreateShell("calendar_postup", "Dtcm",
xmDialogShellWidgetClass, c->xcontext->display,
NULL, 0);
/*
** Create the Motif objects
*/
title = XtNewString(catgets(c->DT_catd, 1, 839, "Calendar : Reminder"));
pu_frame = XtVaCreatePopupShell("pu_frame",
topLevelShellWidgetClass, c->postup,
XmNtitle, title,
XmNmwmFunctions, MWM_FUNC_MOVE | MWM_FUNC_CLOSE,
XmNdeleteResponse, XmDESTROY,
NULL);
XtFree(title);
pu_base_form = XtVaCreateWidget("pu_base_form",
xmFormWidgetClass, pu_frame,
NULL);
pu_text_form = XtVaCreateWidget("pu_test_form",
xmFormWidgetClass, pu_base_form,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNleftOffset, 1,
XmNrightOffset, 1,
XmNtopOffset, 1,
NULL);
pu_image = XtVaCreateWidget("pu_image",
xmLabelGadgetClass, pu_text_form,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 5,
XmNlabelType, XmPIXMAP,
XmNlabelPixmap, ((Props_pu *)c->properties_pu)->postup_pixmap,
NULL);
button_form = XtVaCreateWidget("pu_form",
xmFormWidgetClass, pu_base_form,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 2,
XmNleftOffset, 1,
XmNrightOffset, 1,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNfractionBase, 3,
NULL);
xmstr = XmStringCreateLocalized(catgets(c->DT_catd, 1, 680, "Close"));
pu_close = XtVaCreateManagedWidget("close",
xmPushButtonWidgetClass, button_form,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNrightAttachment, XmATTACH_POSITION,
XmNleftPosition, 1,
XmNrightPosition, 2,
XmNbottomOffset, 1,
XmNlabelString, xmstr,
NULL);
XmStringFree(xmstr);
separator = XtVaCreateWidget("separator",
xmSeparatorGadgetClass,
pu_base_form,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, button_form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, pu_text_form,
XmNtopOffset, 1,
NULL);
pu_form = XtVaCreateWidget("pu_form",
xmFormWidgetClass, pu_text_form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 1,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, pu_image,
XmNverticalSpacing, 10,
NULL);
pu_date = XtVaCreateWidget("pu_date",
xmLabelGadgetClass, pu_form,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
NULL);
pu_range = XtVaCreateWidget("pu_range",
xmLabelGadgetClass, pu_form,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, pu_date,
XmNtopOffset, 8,
NULL);
XtAddCallback(pu_close, XmNactivateCallback, close_cb, pu_frame);
appt = allocate_appt_struct(appt_read,
c->general->version,
CSA_ENTRY_ATTR_START_DATE_I,
CSA_ENTRY_ATTR_END_DATE_I,
CSA_ENTRY_ATTR_SUMMARY_I,
CSA_X_DT_ENTRY_ATTR_SHOWTIME_I,
NULL);
stat = query_appt_struct(c->cal_handle, r->entry, appt);
backend_err_msg(c->frame, c->calname, stat,
((Props_pu *)c->properties_pu)->xm_error_pixmap);
if (stat != CSA_SUCCESS) {
free_appt_struct(&appt);
return;
}
_csa_iso8601_to_tick(appt->time->value->item.date_time_value, &st);
if (appt->end_time)
_csa_iso8601_to_tick(appt->end_time->value->\
item.date_time_value, &sp);
l = lines = text_to_lines(appt->what->value->item.string_value, 5);
last_line = 0;
while (l) {
xmstr = XmStringCreateLocalized(l->s);
line = XtVaCreateWidget("text_line",
xmLabelGadgetClass, pu_text_form,
XmNlabelString, xmstr,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, pu_form,
XmNleftOffset, 15,
NULL);
XmStringFree(xmstr);
if (last_line)
XtVaSetValues(line,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, last_line,
XmNtopOffset, 8,
NULL);
else
XtVaSetValues(line,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 8,
NULL);
last_line = line;
l = l->next;
}
if (lines)
destroy_lines(lines);
/*
** Now fill in the correct information
*/
set_date_in_widget(st, pu_date, ord_t, sep_t);
if (!showtime_set(appt) || magic_time(st))
text[0] = '\0';
else {
start_hr = hour(st);
if (sp) stop_hr = hour(sp);
if (dis_t == HOUR12) {
start_am = adjust_hour(&start_hr);
if (sp) {
/* NL_COMMENT
Message 1087 : This message is used to form
the alarm string that appears in the
reminder popup. In the C locale it would
look something like this:
``From 11:00am to 1:00pm''
In the printf conversion string the $n are:
$1 -> start hour
$2 -> start minute
$3 -> am or pm
$4 -> stop hour
$5 -> stop minute
$6 -> am or pm
*/
char *am = XtNewString(catgets(c->DT_catd,
1, 4, "am"));
char *pm = XtNewString(catgets(c->DT_catd,
1, 3, "pm"));
stop_am = adjust_hour(&stop_hr);
sprintf(text, catgets(c->DT_catd, 1, 1087,
"From %1$2d:%2$02d%3$s to %4$2d:%5$02d%6$s"),
start_hr, minute(st),
(start_am) ? am : pm,
stop_hr, minute(sp),
(stop_am) ? am : pm
);
XtFree(am);
XtFree(pm);
} else {
/* NL_COMMENT
Message 1088 : This message is used to form
the alarm string that appears in the
reminder popup. It is used when an appt
does not have and ``end'' time. In the
C locale it would look something like this:
``11:00am''
In the printf conversion string the $n are:
$1 -> start hour
$2 -> start minute
$3 -> am or pm
*/
char *meridian =
XtNewString ((start_am) ?
catgets(c->DT_catd, 1, 4, "am"):
catgets(c->DT_catd, 1, 3, "pm"));
sprintf(text, catgets(c->DT_catd, 1, 1088,
"%1$2d:%2$02d%3$s"),
start_hr, minute(st), meridian
);
XtFree(meridian);
}
} else {
if (sp) {
/* NL_COMMENT
Message 1089 : This message is used to form
the alarm string that appears in the
reminder popup. This string is used when
a user has asked that times be displayed
in 24 hour format. In the C locale it
would look something like this:
``From 0100 to 1600''
In the printf conversion string the $n are:
$1 -> start hour
$2 -> start minute
$3 -> stop hour
$4 -> stop minute
*/
sprintf(text, catgets(c->DT_catd, 1, 1089,
"From %1$02d%2$02d to %3$02d%4$02d"),
start_hr, minute(st), stop_hr,
minute(sp));
} else {
/* NL_COMMENT
Message 1090 : This message is used to form
the alarm string that appears in the
reminder popup. This string is used when
an appt does not have an end time and the
user has asked that times be displayed
in 24 hour format. In the C locale it
would look something like this:
``1600''
In the printf conversion string the $n are:
$1 -> start hour
$2 -> start minute
*/
sprintf(text, catgets(c->DT_catd, 1, 1090,
"%1$02d%2$02d"),
start_hr, minute(st));
}
}
}
free_appt_struct(&appt);
xmstr = XmStringCreateLocalized(text);
XtVaSetValues(pu_range, XmNlabelString, xmstr,
NULL);
XmStringFree(xmstr);
ManageChildren(pu_form);
ManageChildren(pu_base_form);
ManageChildren(pu_text_form);
XtManageChild(pu_base_form);
XtVaSetValues(button_form, XmNdefaultButton, pu_close, NULL);
XtVaSetValues(button_form, XmNcancelButton, pu_close, NULL);
XtPopup(pu_frame, XtGrabNone);
DtWsmOccupyAllWorkspaces(c->xcontext->display, XtWindow(pu_frame));
}
void
AttachArea::initialize()
{
// We're making the assumption here that this widget's parent`
// is also a form
XtWidgetGeometry size;
Dimension parWid, parHeight;
Dimension txt_w, txt_h;
XmFontList fl;
XmString xms;
int colorUse;
short act, inact, prim, second, text;
XmPixelSet pixels[XmCO_NUM_COLORS];
_w = XtVaCreateManagedWidget (
"AttachPane",
xmFormWidgetClass, _parent,
NULL);
// Get pixel data.
XmeGetColorObjData(XtScreen(_parent), &colorUse, pixels, XmCO_NUM_COLORS,
&act, &inact, &prim, &second, &text);
_foreground = pixels[text].fg;
_background = pixels[text].sc;
parWid = _myOwner->textEditor()->get_text_width();
fl = _myOwner->textEditor()->get_text_fontList();
xms = XmStringCreateLocalized("Xyb");
XmStringExtent(fl, xms, &txt_w, &txt_h);
parHeight = txt_h + Icon::maxIconHeight() + (2*VSPACE);
_appBackground = _background;
_appForeground = _foreground;
_sw = XtVaCreateManagedWidget (
"AttachPane_ScrolledWindow",
xmScrolledWindowWidgetClass, _w,
XmNscrollingPolicy, XmAPPLICATION_DEFINED,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNshadowThickness, (Dimension)1,
XmNspacing, 2,
XmNwidth, parWid,
XmNheight, parHeight,
NULL);
rowOfAttachmentsStatus = XtCreateManagedWidget("Attachments_Status",
xmFormWidgetClass,
_w, NULL, 0);
XtVaSetValues(rowOfAttachmentsStatus,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, _sw,
XmNtopOffset, 5,
XmNbottomOffset, 5,
NULL );
this->addToRowOfAttachmentsStatus();
size.request_mode = CWHeight;
XtQueryGeometry(rowOfAttachmentsStatus, NULL, &size);
XtVaSetValues(
rowOfAttachmentsStatus,
XmNpaneMaximum, size.height,
XmNpaneMinimum, size.height,
NULL
);
_vsb = XtVaCreateManagedWidget("vsb", xmScrollBarWidgetClass, _sw,
XmNorientation, XmVERTICAL,
XmNsliderSize, 1,
XmNmaximum, 1,
XmNpageIncrement, 1,
NULL);
XtAddCallback(
_vsb,
XmNvalueChangedCallback,&AttachArea::valueChangedCallback,
(XtPointer) this
);
XtAddCallback(
_vsb,
XmNdragCallback, &AttachArea::dragCallback,
(XtPointer) this
);
_clipWindow = XtVaCreateManagedWidget("AttachArea_clipWindow",
xmDrawingAreaWidgetClass, _sw,
XmNresizePolicy, XmRESIZE_NONE,
XmNbackground, _background,
XmNwidth, parWid,
XmNheight, parHeight,
NULL);
XmScrolledWindowSetAreas(_sw, NULL, _vsb, _clipWindow);
XtManageChild(_clipWindow);
XtManageChild(_vsb);
XtManageChild(_sw);
// Set RowCol to NULL here.
// It gets set in the expose_all_attachments.
_rc = NULL;
CalcSizeOfAttachPane();
installDestroyHandler();
}
int WNavMotif::continue_dialog( char *title, char *text)
{
Widget dialog;
XmString text_str;
XmString title_str;
XmString continue_str;
XmString quit_str;
Arg args[10];
int i;
XEvent Event;
text_str = XmStringCreateLocalized( wnav_dialog_convert_text(text));
title_str = XmStringCreateLocalized( title);
continue_str = XmStringCreateLocalized( (char*) "Continue");
quit_str = XmStringCreateLocalized( (char*) "Quit");
i = 0;
XtSetArg( args[i], XmNmessageString, text_str);
i++;
XtSetArg( args[i], XmNdialogTitle, title_str);
i++;
XtSetArg( args[i], XmNcancelLabelString, quit_str);
i++;
XtSetArg( args[i], XmNokLabelString, continue_str);
i++;
XtSetArg( args[i], XmNdialogType, XmDIALOG_WARNING);
i++;
if ( dialog_width && dialog_height)
{
XtSetArg( args[i], XmNwidth, dialog_width);
i++;
XtSetArg( args[i], XmNheight, dialog_height);
i++;
XtSetArg( args[i], XmNx, dialog_x);
i++;
XtSetArg( args[i], XmNy, dialog_y);
i++;
}
dialog = XmCreateInformationDialog( parent_wid, (char*) "Info", args, i);
XmStringFree( text_str);
XmStringFree( title_str);
XmStringFree( quit_str);
XmStringFree( continue_str);
XtUnmanageChild( XmMessageBoxGetChild( dialog, XmDIALOG_HELP_BUTTON));
XtAddCallback( dialog, XmNokCallback, wnav_message_dialog_ok, this);
XtAddCallback( dialog, XmNcancelCallback, wnav_message_dialog_cancel, this);
flow_AddCloseVMProtocolCb( XtParent(dialog),
(XtCallbackProc)wnav_message_dialog_cancel, this);
XtManageChild( dialog);
XtPopup( XtParent(dialog), XtGrabNone);
dialog_ok = 0;
dialog_cancel = 0;
dialog_help = 0;
for (;;)
{
XtAppNextEvent( XtWidgetToApplicationContext( dialog), &Event);
XtDispatchEvent( &Event);
if ( dialog_ok)
return 1;
if ( dialog_cancel)
return 0;
}
}
/*-------------------------
*
* display_cancel_warning
*
*------------------------*/
void
display_cancel_warning(Widget parent)
{
XmString msg, dialogTitle, cancelMsg, resumeMsg;
int n;
Arg args[20];
Widget dialog;
String copyWarnMessage = "This will stop the copy process. Any files that have\n\
already been copied will remain in the destination folder.";
String moveWarnMessage = "This will stop the move process. Any files that have\n\
already been moved will remain in the destination folder.";
if (G_move)
{
dialogTitle = XmStringCreateLocalized (GETMESSAGE(3, 12, "Folder Move - Warning"));
msg = XmStringCreateLocalized (GETMESSAGE(3, 10, moveWarnMessage));
cancelMsg = XmStringCreateLocalized (GETMESSAGE(3, 15, "Cancel Move"));
resumeMsg = XmStringCreateLocalized (GETMESSAGE(3, 16, "Continue Move"));
}
else
{
dialogTitle = XmStringCreateLocalized (GETMESSAGE(3, 11, "Folder Copy - Warning"));
msg = XmStringCreateLocalized (GETMESSAGE(3, 7, copyWarnMessage));
cancelMsg = XmStringCreateLocalized (GETMESSAGE(3, 13, "Cancel Copy"));
resumeMsg = XmStringCreateLocalized (GETMESSAGE(3, 14, "Continue Copy"));
}
n = 0;
XtSetArg(args[n], XmNmessageString, msg); n++;
XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
XtSetArg(args[n], XmNdialogTitle, dialogTitle); n++;
dialog = (Widget) XmCreateWarningDialog(parent, "warnDialog", args, n);
XmStringFree(msg);
XmStringFree(dialogTitle);
n = 0;
XtSetArg(args[n], XmNlabelString, cancelMsg); n++;
XtSetValues((Widget) XmMessageBoxGetChild(dialog, XmDIALOG_OK_BUTTON), args, n);
XmStringFree(cancelMsg);
n = 0;
XtSetArg(args[n], XmNlabelString, resumeMsg); n++;
XtSetValues((Widget) XmMessageBoxGetChild(dialog, XmDIALOG_CANCEL_BUTTON), args, n);
XmStringFree(resumeMsg);
XtAddCallback((Widget) XmMessageBoxGetChild(dialog, XmDIALOG_OK_BUTTON),
XmNactivateCallback,
warning_yes_callback,
dialog);
XtAddCallback((Widget) XmMessageBoxGetChild(dialog, XmDIALOG_CANCEL_BUTTON),
XmNactivateCallback,
warning_no_callback,
dialog);
XtAddCallback((Widget) XmMessageBoxGetChild(dialog, XmDIALOG_HELP_BUTTON),
XmNactivateCallback,
help_callback,
(XtPointer) STOPW_HELP_DIALOG);
XtManageChild(dialog);
} /* end display_cancel_warning */
/***************************************************************************
*
* SetDtLabelAndIcon
*
* label to display in the dt_label widget and
* the logo to display in logo_pixmap
**************************************************************************/
void
SetDtLabelAndIcon()
{
static XmString blanks = NULL;
int i;
char *logoFile;
char *logoName;
char *temp_p;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: entered SetDtLabelAndIcon ...");
#endif /* VG_TRACE */
if (NULL == blanks)
blanks = XmStringCreateLocalized(" ");
/*
* if user is logging in, set dt_label desired. No more than
* one desktop can be selected at a time ...
*/
i = 0;
XtSetArg(argt[0], XmNset, FALSE); i++;
XtSetValues(options_failsafe, argt, i);
XtSetValues(options_dtlite, argt, i);
XtSetValues(options_dt, argt, i);
if (options_last_dt != NULL)
XtSetValues(options_last_dt, argt, i);
for(i = 0; i<appInfo.altDts ; ++i)
if(alt_dts[i] != NULL)
XtSetValues(alt_dts[i], argt, i);
if (NULL != default_dt) {
i = 0;
XtSetArg(argt[i], XmNset, True); i++;
XtSetValues(default_dt, argt, i);
if(default_dt == options_last_dt)
xmstr = blanks;
else
{
i = 0;
XtSetArg(argt[i], XmNlabelString, &xmstr); i++;
XtGetValues(default_dt, argt, i);
}
i = 0;
XtSetArg(argt[i], XmNuserData, &logoFile); i++;
XtGetValues(default_dt, argt, i);
}
else {
xmstr = blanks;
logoFile = logoInfo.bitmapFile;
}
#ifdef FIX_FOR_DEFECT_CDExc19307
/*
* This code causes the Session toggle buttons to be reset
* to the default setting when the user commits a typing error.
* NOT very user friendly.
*
* As for setting the defaults after the user is done entering
* the we could do the same thing by passing in an argument. For
* now, I'm not convinced that it is required.
*/
/*
* to set the defaults after the user is done
* entering the login ..
*/
if (strcmp(userName,"\0") != 0)
strcpy(userName,"\0");
#endif
i = 0;
XtSetArg(argt[i], XmNlabelString, xmstr); i++;
XtSetValues(dt_label, argt, i);
/*
* remove trailing spaces
*/
if(strchr(logoFile,' '))
temp_p = strtok(logoFile," ");
else
temp_p = logoFile;
logoName = _DtGetIconFileName(
DefaultScreenOfDisplay(dpyinfo.dpy),
temp_p, NULL, NULL, 0);
if (logoName == NULL) {
LogError(
ReadCatalog(MC_LOG_SET,MC_LOG_NO_LOGOBIT,MC_DEF_LOG_NO_LOGOBIT),
logoFile);
logoFile = NULL;
}
i = 0;
XtSetArg(argt[i], XmNimageName, logoName); i++;
XtSetValues(logo_pixmap, argt, i);
}
Widget
prefs_appearance(struct topic_info *info)
{
Widget form;
Widget gui_frame, gui_label, gui_rowcol,
gui_statusline, gui_toolbar, gui_pagelist, gui_scrollbars;
Widget tips_frame, tips_label, tips_form, tips_statusline;
Widget tips_popups, tips_delay_text, tips_delay_label1, tips_delay_label2;
Widget match_frame, match_label, match_rowcol, match_inverted, match_boxed;
#if 0
Widget tb_buttons_frame, tb_buttons_label, tb_buttons_rowcol,
tb_buttons_flat, tb_buttons_raised;
#endif
XmString str;
char buf[LENGTH_OF_INT];
Arg args[10];
int n;
form = XmCreateForm(info->right_form, "appearance_form", NULL, 0);
h_attach_below(form, NULL);
n = 0;
XtSetArg(args[n], XmNmarginWidth, 8); n++;
XtSetArg(args[n], XmNmarginHeight, 4); n++;
gui_frame = XmCreateFrame(form, "gui_frame", args, n);
h_attach_below(gui_frame, NULL);
gui_label = XmCreateLabelGadget(gui_frame, "Window Configuration", &frame_title, 1);
XtManageChild(gui_label);
gui_rowcol = XmCreateRowColumn(gui_frame, "gui_rowcol", two_cols_fixed, XtNumber(two_cols_fixed));
XtManageChild(gui_rowcol);
gui_statusline = XmCreateToggleButtonGadget(gui_rowcol, Xdvi_GUI_STATUSLINE_STR, &n_of_many, 1);
XmToggleButtonGadgetSetState(gui_statusline, resource.expert_mode & XPRT_SHOW_STATUSLINE ? True : False, False);
XtManageChild(gui_statusline);
gui_toolbar = XmCreateToggleButtonGadget(gui_rowcol, Xdvi_GUI_TOOLBAR_STR, &n_of_many, 1);
XmToggleButtonGadgetSetState(gui_toolbar, resource.expert_mode & XPRT_SHOW_TOOLBAR ? True : False, False);
XtManageChild(gui_toolbar);
gui_pagelist = XmCreateToggleButtonGadget(gui_rowcol, Xdvi_GUI_PAGELIST_STR, &n_of_many, 1);
XmToggleButtonGadgetSetState(gui_pagelist, resource.expert_mode & XPRT_SHOW_PAGELIST ? True : False, False);
XtManageChild(gui_pagelist);
gui_scrollbars = XmCreateToggleButtonGadget(gui_rowcol, Xdvi_GUI_SCROLLBARS_STR, &n_of_many, 1);
XmToggleButtonGadgetSetState(gui_scrollbars, resource.expert_mode & XPRT_SHOW_SCROLLBARS ? True : False, False);
XtManageChild(gui_scrollbars);
XtAddCallback(gui_statusline, XmNvalueChangedCallback, gui_buttons_cb, (XtPointer)info);
XtAddCallback(gui_toolbar, XmNvalueChangedCallback, gui_buttons_cb, (XtPointer)info);
XtAddCallback(gui_pagelist, XmNvalueChangedCallback, gui_buttons_cb, (XtPointer)info);
XtAddCallback(gui_scrollbars, XmNvalueChangedCallback, gui_buttons_cb, (XtPointer)info);
n = 0;
XtSetArg(args[n], XmNmarginWidth, 8); n++;
XtSetArg(args[n], XmNmarginHeight, 4); n++;
XtSetArg(args[n], XmNtopOffset, 10); n++;
tips_frame = XmCreateFrame(form, "tips_frame", args, n);
h_attach_below(tips_frame, gui_frame);
tips_label = XmCreateLabelGadget(tips_frame, "Show Tooltips", &frame_title, 1);
XtManageChild(tips_label);
tips_form = XmCreateForm(tips_frame, "tips_form", NULL, 0);
str = XmStringCreateLocalized("As Text in Statusline");
tips_statusline = XtVaCreateManagedWidget(Xdvi_TIPS_STATUSLINE,
xmToggleButtonGadgetClass, tips_form,
XmNlabelString, str,
XmNindicatorType, XmN_OF_MANY,
XmNset, True,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
NULL);
XmStringFree(str);
str = XmStringCreateLocalized("As Popups");
tips_popups = XtVaCreateManagedWidget(Xdvi_TIPS_POPUPS,
xmToggleButtonGadgetClass, tips_form,
XmNlabelString, str,
XmNindicatorType, XmN_OF_MANY,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_statusline,
XmNleftAttachment, XmATTACH_FORM,
NULL);
XmStringFree(str);
str = XmStringCreateLocalized("with");
tips_delay_label1 = XtVaCreateManagedWidget(Xdvi_TIPS_DELAY_LABEL1,
xmLabelGadgetClass, tips_form,
XmNlabelString, tips_form,
XmNlabelString, str,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_statusline,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, tips_popups,
XmNleftOffset, 0, /* no spacing to prev text */
NULL);
XmStringFree(str);
SNPRINTF(buf, LENGTH_OF_INT, "%d", ABS(resource.tooltips_wait_period));
tips_delay_text = XtVaCreateManagedWidget(Xdvi_TIPS_DELAY_TEXT,
xmTextFieldWidgetClass, tips_form,
XmNcolumns, 4,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_statusline,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, tips_delay_label1,
XmNvalue, buf,
NULL);
str = XmStringCreateLocalized("milliseconds delay");
tips_delay_label2 = XtVaCreateManagedWidget(Xdvi_TIPS_DELAY_LABEL2,
xmLabelGadgetClass, tips_form,
XmNlabelString, str,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_statusline,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, tips_delay_text,
NULL);
adjust_heights(tips_popups, tips_delay_label1, tips_delay_text, tips_delay_label2, NULL);
XmToggleButtonGadgetSetState(tips_statusline, resource.tooltips_in_statusline, False);
XmToggleButtonGadgetSetState(tips_popups, resource.show_tooltips, False);
if (resource.toolbar_unusable) {
XtSetSensitive(tips_frame, False);
}
else {
XtSetSensitive(tips_delay_label1, resource.show_tooltips);
XtSetSensitive(tips_delay_text, resource.show_tooltips);
XtSetSensitive(tips_delay_label2, resource.show_tooltips);
XtAddCallback(tips_statusline, XmNvalueChangedCallback, tooltips_cb, (XtPointer)info);
XtAddCallback(tips_popups, XmNvalueChangedCallback, tooltips_cb, (XtPointer)info);
XtAddCallback(tips_delay_text, XmNvalueChangedCallback, tooltips_cb, (XtPointer)info);
}
#if 0
tb_buttons_frame = XmCreateFrame(form, "tb_buttons_frame", &v_off, 1);
h_attach_below(tb_buttons_frame, tips_frame);
tb_buttons_label = XmCreateLabelGadget(tb_buttons_frame, "Toolbar Buttons:", &frame_title, 1);
XtManageChild(tb_buttons_label);
tb_buttons_rowcol = XmCreateRowColumn(tb_buttons_frame, "tb_buttons_rowcol", two_cols, XtNumber(two_cols));
XtManageChild(tb_buttons_rowcol);
tb_buttons_raised = XmCreateToggleButtonGadget(tb_buttons_rowcol, "Raised", &one_of_many, 1);
XtManageChild(tb_buttons_raised);
tb_buttons_flat = XmCreateToggleButtonGadget(tb_buttons_rowcol, "Flat", &one_of_many, 1);
XtManageChild(tb_buttons_flat);
toolbar_buttons_init((XtPointer)info, tb_buttons_raised, tb_buttons_flat);
#endif /* 0 */
n = 0;
XtSetArg(args[n], XmNmarginWidth, 8); n++;
XtSetArg(args[n], XmNmarginHeight, 4); n++;
XtSetArg(args[n], XmNtopOffset, 10); n++;
match_frame = XmCreateFrame(form, "match_frame", args, n);
XtVaSetValues(match_frame,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, tips_frame,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
match_label = XmCreateLabelGadget(match_frame, "String Matches are shown:", &frame_title, 1);
XtManageChild(match_label);
match_rowcol = XmCreateRowColumn(match_frame, "tb_buttons_rowcol", two_cols, XtNumber(two_cols));
XtManageChild(match_rowcol);
match_inverted = XmCreateToggleButtonGadget(match_rowcol, Xdvi_MATCH_INVERTED_STR, &one_of_many, 1);
XtManageChild(match_inverted);
match_boxed = XmCreateToggleButtonGadget(match_rowcol, Xdvi_MATCH_BOXED_STR, &one_of_many, 1);
XtManageChild(match_boxed);
XmToggleButtonGadgetSetState(match_inverted, resource.match_highlight_inverted, False);
XmToggleButtonGadgetSetState(match_boxed, !resource.match_highlight_inverted, False);
XtAddCallback(match_inverted, XmNvalueChangedCallback, match_cb, (XtPointer)info);
XtAddCallback(match_boxed, XmNvalueChangedCallback, match_cb, (XtPointer)info);
/* manage children (order shouldn't matter, since children are already managed, but ...) */
XtManageChild(gui_frame);
XtManageChild(tips_form);
XtManageChild(tips_frame);
#if 0
XtManageChild(tb_buttons_frame);
#endif
XtManageChild(match_frame);
XtManageChild(form);
return form;
}
void pggrpch_popup ( void )
/************************************************************************
* pggrpch_popup *
* *
* This function pops up VG Group Change window. *
* *
* void pggrpch_popup() *
* *
* Input parameters: *
* Output parameters: *
* Return parameters: *
* NONE *
* *
** *
* Log: *
* H. Zeng/EAI 05/01 initial coding *
* H. Zeng/EAI 03/02 renamed for new nmap_pggrpch file *
* H. Zeng/EAI 04/02 modified to initialize _grpStr *
* H. Zeng/EAI 05/02 modified to use master group type list *
***********************************************************************/
{
int ii, el_num, el_loc, grpnum, ngrp, selection, iret, ier2;
char grptyp, cc[20], grpnam[20];
char *names = NULL;
char *ptr;
XmString xmstr;
static Boolean first = TRUE;
/*---------------------------------------------------------------------*/
/*
* Set "CURRENT GROUP" and "CHANGE TO" option menus at
* the first time.
*/
if( first ) {
/*
* Initialize _curGrpStr and _chngToStr.
*/
ces_gtgmgrps(FALSE, &ngrp, &names, &iret);
_numCurGrp = ngrp;
_curGrpStr = (char**) malloc( _numCurGrp * sizeof(char*) );
ii = 0;
ptr = strtok(names, ";");
while ( ptr != (char *)NULL ) {
_curGrpStr[ii] = (char*) malloc( strlen(ptr)+5 );
strcpy(_curGrpStr[ii], ptr);
ptr = strtok(NULL, ";" );
ii++;
}
if ( names != NULL ) free (names);
ces_gtggrps(&ngrp, &names, &iret);
_numChngTo = ngrp;
_chngToStr = (char**) malloc( _numChngTo * sizeof(char*) );
ii = 0;
ptr = strtok(names, ";");
while ( ptr != (char *)NULL ) {
_chngToStr[ii] = (char*) malloc( strlen(ptr)+5 );
strcpy(_chngToStr[ii], ptr);
ptr = strtok(NULL, ";" );
ii++;
}
if ( names != NULL ) free (names);
_curGrpNum = _numCurGrp + 1;
_chngToNum = _numChngTo + 1;
/*
* Set "CURRENT GROUP" option menu:
*/
sprintf (cc, "%s", "ALL GROUPS");
xmstr = XmStringCreateLocalized (cc);
XtVaSetValues(_curGrpStrc.pb[0],
XmNlabelString, xmstr,
NULL);
XtManageChild(_curGrpStrc.pb[0]);
XmStringFree (xmstr);
for (ii = 1; ii < _curGrpNum; ii++) {
sprintf (cc, "%s", _curGrpStr[ii-1] );
xmstr = XmStringCreateLocalized (cc);
XtVaSetValues(_curGrpStrc.pb[ii],
XmNlabelString, xmstr,
NULL);
XtManageChild(_curGrpStrc.pb[ii]);
XmStringFree (xmstr);
}
for (ii = _curGrpNum; ii < MAXNOPT; ii++) {
XtUnmanageChild( _curGrpStrc.pb[ii] );
}
/*
* Set "CHANGE TO" option menu.
*/
sprintf (cc, "%s", "NO CHANGE");
xmstr = XmStringCreateLocalized (cc);
XtVaSetValues(_chngToStrc.pb[0],
XmNlabelString, xmstr,
NULL);
XtManageChild(_curGrpStrc.pb[0]);
XmStringFree (xmstr);
for (ii = 1; ii < _chngToNum; ii++) {
sprintf (cc, "%s", _chngToStr[ii-1] );
xmstr = XmStringCreateLocalized (cc);
XtVaSetValues(_chngToStrc.pb[ii],
XmNlabelString, xmstr,
NULL);
XtManageChild(_chngToStrc.pb[ii]);
XmStringFree (xmstr);
}
for (ii = _chngToNum; ii < MAXNOPT; ii++) {
XtUnmanageChild( _chngToStrc.pb[ii] );
}
first = FALSE;
}
/*
* Set default info. when popping up the VG Group Change window.
*/
_curGrpCurr = 0;
for (ii = 0; ii < _curGrpNum; ii++) {
_chngToStrc.current[ii] = 0;
_chngToStrc.chng_flag[ii] = FALSE;
_chngToStrc.exist[ii] = FALSE;
_chngToStrc.disabled[ii] = FALSE;
XtSetSensitive( _curGrpStrc.pb[ii], FALSE );
}
XtSetSensitive( _curGrpStrc.form, FALSE );
/*
* Search available group types based on the VG file on main window.
*/
for (el_num = 0; el_num < MAX_EDITABLE_ELEMS; el_num++) {
crg_goffset (el_num, &el_loc, &ier2);
/*
* Skip cleared range record
*/
if (el_loc == -1) {
continue;
}
crg_ggrp (el_num, &grptyp, &grpnum, &ier2);
if (grpnum && grptyp != GRPTYP_OTHERS
&& grptyp != GRPTYP_COMSYM
&& grptyp != GRPTYP_WATCH
&& grptyp != GRPTYP_CCF ) {
ces_gtgnam((int)grptyp, grpnam, &ier2);
for( ii = 0; ii < _numCurGrp; ii++ ) {
if(strcmp(_curGrpStr[ii], grpnam) == 0) {
selection = ii + 1;
break;
}
}
if( ii < _numCurGrp ) {
_chngToStrc.exist[selection] = TRUE;
XtSetSensitive( _curGrpStrc.pb[selection], TRUE );
/*
* When there is at least one group, "ALL GROUPS" choice
* makes sense.
*/
_chngToStrc.exist[0] = TRUE;
} /* the end of if( ii < _numCurGrp ) */
} /* the end of if (grpnum &&... */
} /* the end of for (el_num... */
/*
* Make "ALL GROUPS" choice sensitive or insensitive according to
* its "exist" flag.
*/
if( _chngToStrc.exist[0] == TRUE ) {
XtSetSensitive( _curGrpStrc.pb[0], TRUE );
XtSetSensitive( _curGrpStrc.form, TRUE );
}
/*
* Update the VG Group Change Window
*/
pggrpch_update();
if( !pggrpch_isUp() ) {
XtManageChild (_grpChngWin);
}
}
/*
* MessageBox_popup
*/
void MessageBox_popup (Widget parent,
Widget *message_box,
int type,
char *title,
char *btn_txt,
char *format,
...)
{
va_list args;
XmString xstr_title;
XmString xstr_msg;
XmString xstr_btn;
char buf[2048];
/* make string */
va_start (args, format);
vsprintf (buf, format, args);
va_end (args);
/* initialize widget if necessary */
if (*message_box != (Widget)0)
if (parent != XtParent (*message_box))
{
XtDestroyWidget (*message_box);
*message_box = (Widget)0;
}
if (*message_box == (Widget)0)
*message_box = XmCreateMessageDialog (parent, "Oops", NULL, 0);
#if 0
xstr_msg = XmStringCreateLocalized (buf);
#else
/* Use XmStringGetLtoR because it handles multiple lines */
xstr_msg = XmStringCreateLtoR(buf, XmFONTLIST_DEFAULT_TAG);
#endif
xstr_btn = XmStringCreateLocalized (btn_txt);
xstr_title = XmStringCreateLocalized (title);
XtVaSetValues
(*message_box,
XmNdialogType, type,
XmNdefaultButtonType, XmDIALOG_OK_BUTTON,
XmNnoResize, True,
XmNdefaultPosition, False,
XmNdialogTitle, xstr_title,
XmNmessageString, xstr_msg,
XmNokLabelString, xstr_btn,
NULL);
XtUnmanageChild
(XmMessageBoxGetChild (*message_box, XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild
(XmMessageBoxGetChild (*message_box, XmDIALOG_HELP_BUTTON));
XtAddCallback
(*message_box, XmNokCallback, MessageBox_cb, (XtPointer)MSGBOX_OK);
XtAddCallback
(*message_box, XmNmapCallback, MessageBox_cb, (XtPointer)MSGBOX_MAP);
XmStringFree (xstr_msg);
XmStringFree (xstr_btn);
XmStringFree (xstr_title);
XtManageChild (*message_box);
XtPopup (XtParent (*message_box), XtGrabNone);
}
extern void
build_dssw(
DSSW *dssw,
Calendar *c,
Widget parent,
Boolean show_notime,
Boolean show_allday)
{
Props *p;
DisplayType dt;
Arg args[20];
int n;
Dimension max_left_label_width;
Widget child[2];
XmString label_str;
Dimension highest, widest;
Widget prev, curr;
Dimension _toLabel, _toText, _toMenu, _toRC;
dssw->cal = c;
dssw->parent = parent;
p = (Props *)c->properties;
dt = get_int_prop(p, CP_DEFAULTDISP);
dssw->show_notime_selection = show_notime;
dssw->show_allday_selection = show_allday;
/*
** One form manager for the widget
*/
dssw->dssw_form_mgr = XtVaCreateWidget("dssw_form_mgr",
xmFormWidgetClass, parent,
XmNautoUnmanage, False,
NULL);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 828, "Date:"));
dssw->date_label = XtVaCreateWidget("date_label",
xmLabelGadgetClass, dssw->dssw_form_mgr,
XmNlabelString, label_str,
NULL);
XmStringFree(label_str);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 829, "Start:"));
dssw->start_label = XtVaCreateWidget("start_label",
xmLabelGadgetClass, dssw->dssw_form_mgr,
XmNlabelString, label_str,
NULL);
XmStringFree(label_str);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 832, "End:"));
dssw->stop_label = XtVaCreateWidget("stop_label",
xmLabelGadgetClass, dssw->dssw_form_mgr,
XmNlabelString, label_str,
NULL);
XmStringFree(label_str);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 835, "What:"));
dssw->what_label = XtVaCreateWidget("what_label",
xmLabelGadgetClass, dssw->dssw_form_mgr,
XmNlabelString, label_str,
NULL);
XmStringFree(label_str);
dssw->date_text = XtVaCreateWidget("date_text",
xmTextWidgetClass, dssw->dssw_form_mgr,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNmaxLength, DATE_LEN - 1,
NULL);
/*
** Radio button behavior for AM/PM selection for start time
*/
dssw->start_text = XtVaCreateWidget("start_text",
xmTextWidgetClass, dssw->dssw_form_mgr,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNmaxLength, START_STOP_LEN - 1,
NULL);
dssw->start_menu = create_start_stop_time_menu(dssw->dssw_form_mgr,
NULL, dssw_set_start_hour, (XtPointer)dssw, p, show_notime,
show_allday, &dssw->start_menu_widget_list,
&dssw->start_menu_widget_count);
XtVaSetValues(dssw->start_menu,
XmNnavigationType, XmTAB_GROUP,
NULL);
dssw->start_ampm_rc_mgr = XtVaCreateWidget("start_ampm_rc_mgr",
xmRowColumnWidgetClass, dssw->dssw_form_mgr,
XmNpacking, XmPACK_COLUMN,
XmNorientation, XmHORIZONTAL,
XmNradioBehavior, True,
XmNisHomogeneous, True,
XmNentryClass, xmToggleButtonGadgetClass,
NULL);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 830, "AM"));
child[0] = dssw->start_am = XtVaCreateWidget("start_am",
xmToggleButtonGadgetClass, dssw->start_ampm_rc_mgr,
XmNlabelString, label_str,
XmNsensitive, (dt == HOUR12) ? True : False,
NULL);
XmStringFree(label_str);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 831, "PM"));
child[1] = dssw->start_pm = XtVaCreateWidget("start_pm",
xmToggleButtonGadgetClass, dssw->start_ampm_rc_mgr,
XmNlabelString, label_str,
XmNsensitive, (dt == HOUR12) ? True : False,
NULL);
XmStringFree(label_str);
XtManageChildren(child, 2);
/*
** Last and near the end, the stop stuff
** Radio button behavior for AM/PM selection for stop time
*/
dssw->stop_text = XtVaCreateWidget("stop_text",
xmTextWidgetClass, dssw->dssw_form_mgr,
XmNeditMode, XmSINGLE_LINE_EDIT,
XmNmaxLength, START_STOP_LEN - 1,
NULL);
dssw->stop_menu = create_start_stop_time_menu(dssw->dssw_form_mgr,
NULL, dssw_set_stop_hour, (XtPointer)dssw, p, show_notime,
False, &dssw->stop_menu_widget_list,
&dssw->stop_menu_widget_count);
XtVaSetValues(dssw->stop_menu,
XmNnavigationType, XmTAB_GROUP,
NULL);
dssw->stop_ampm_rc_mgr = XtVaCreateWidget("stop_ampm_rc_mgr",
xmRowColumnWidgetClass, dssw->dssw_form_mgr,
XmNpacking, XmPACK_COLUMN,
XmNorientation, XmHORIZONTAL,
XmNradioBehavior, True,
XmNisHomogeneous, True,
XmNentryClass, xmToggleButtonGadgetClass,
NULL);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 833, "AM"));
child[0] = dssw->stop_am = XtVaCreateWidget("stop_am",
xmToggleButtonGadgetClass, dssw->stop_ampm_rc_mgr,
XmNlabelString, label_str,
XmNsensitive, (dt == HOUR12) ? True : False,
NULL);
XmStringFree(label_str);
label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 834, "PM"));
child[1] = dssw->stop_pm = XtVaCreateWidget("stop_pm",
xmToggleButtonGadgetClass, dssw->stop_ampm_rc_mgr,
XmNlabelString, label_str,
XmNsensitive, (dt == HOUR12) ? True : False,
NULL);
XmStringFree(label_str);
XtManageChildren(child, 2);
/*
** Finally the what text field
*/
n = 0;
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT), n++;
/* XtSetArg(args[n], XmNscrollVertical, True), n++; */
XtSetArg(args[n], XmNscrollHorizontal, False), n++;
XtSetArg(args[n], XmNscrollingPolicy, XmAUTOMATIC), n++;
XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED), n++;
XtSetArg(args[n], XmNrows, 3), n++;
XtSetArg(args[n], XmNmaxLength, WHAT_LEN - 1), n++;
dssw->what_text = XmCreateScrolledText(dssw->dssw_form_mgr,
"what_text", args, n);
dssw->what_scrollwindow = XtParent(dssw->what_text);
XtManageChild(dssw->what_text);
/*
* Do a layout
*/
_i18n_WidestWidget( 4, &prev, &max_left_label_width,
dssw->date_label, dssw->start_label, dssw->stop_label,
dssw->what_label );
_toText = max_left_label_width + 2 * GAP;
/*
* dssw->date_label, dssw->date_text
*/
_i18n_WidestWidget( 1, &curr, &widest, dssw->date_label );
_toLabel = _toText - GAP - widest;
_i18n_HighestWidgetAdjust( 2, &curr, &highest, dssw->date_label,
dssw->date_text );
XtVaSetValues( curr,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, GAP,
NULL );
XtVaSetValues( dssw->date_label,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toLabel,
NULL );
XtVaSetValues( dssw->date_text,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toText,
XmNrightAttachment, XmATTACH_FORM,
NULL );
prev = curr;
/*
* dssw->start_label, dssw->start_text, dssw->start_menu,
* dssw->start_ampm_rc_mgr
*/
_i18n_WidestWidget( 1, &curr, &widest, dssw->start_label );
_toLabel = _toText - GAP - widest;
_i18n_WidestWidget( 1, &curr, &widest, dssw->start_text );
_toMenu = _toText + widest + GAP;
_i18n_WidestWidget( 1, &curr, &widest, dssw->start_menu );
_toRC = _toMenu + widest + GAP;
_i18n_HighestWidgetAdjust( 4, &curr, &highest, dssw->start_label,
dssw->start_text, dssw->start_menu, dssw->start_ampm_rc_mgr );
XtVaSetValues( curr,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, prev,
XmNtopOffset, GAP,
NULL );
XtVaSetValues( dssw->start_label,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toLabel,
NULL );
XtVaSetValues( dssw->start_text,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toText,
NULL );
XtVaSetValues( dssw->start_menu,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toMenu,
NULL );
XtVaSetValues( dssw->start_ampm_rc_mgr,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toRC,
NULL );
prev = curr;
/*
* dssw->stop_label, dssw->stop_text, dssw->stop_menu,
* dssw->stop_ampm_rc_mgr
*/
_i18n_WidestWidget( 1, &curr, &widest, dssw->stop_label );
_toLabel = _toText - GAP - widest;
_i18n_WidestWidget( 1, &curr, &widest, dssw->stop_text );
_toMenu = _toText + widest + GAP;
_i18n_WidestWidget( 1, &curr, &widest, dssw->stop_menu );
_toRC = _toMenu + widest + GAP;
_i18n_HighestWidgetAdjust( 4, &curr, &highest, dssw->stop_label,
dssw->stop_text, dssw->stop_menu, dssw->stop_ampm_rc_mgr );
XtVaSetValues( curr,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, prev,
XmNtopOffset, GAP,
NULL );
XtVaSetValues( dssw->stop_label,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toLabel,
NULL );
XtVaSetValues( dssw->stop_text,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toText,
NULL );
XtVaSetValues( dssw->stop_menu,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toMenu,
NULL );
XtVaSetValues( dssw->stop_ampm_rc_mgr,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toRC,
NULL );
prev = curr;
/*
* dssw->what_label, dssw->what_scrollwindow
*/
_i18n_WidestWidget( 1, &curr, &widest, dssw->what_label );
_toLabel = _toText - GAP - widest;
XtVaSetValues( dssw->what_label,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, prev,
XmNtopOffset, GAP,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toLabel,
NULL );
XtVaSetValues( dssw->what_scrollwindow,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, prev,
XmNtopOffset, GAP,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, _toText,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL );
}
void AliasListUiItem::handleAddButtonPress()
{
char *key_str = NULL;
char *value_str = NULL;
PropStringPair *new_pair = NULL;
XtVaGetValues(key_widget,
XmNvalue, &key_str,
NULL);
XtVaGetValues(value_widget,
XmNvalue, &value_str,
NULL);
if(key_str != NULL)
if(strlen(key_str) > 0)
{
new_pair = new PropStringPair;
int *pos_list, num_pos;
new_pair->label = strdup(key_str);
if(value_str != NULL)
new_pair->value = strdup(value_str);
else
new_pair->value = NULL;
if(XmListGetSelectedPos(this->getWidget(),
&pos_list,
&num_pos))
{
if(list_items == NULL)
list_items = new DtVirtArray<PropStringPair *>(10);
list_items->insert(new_pair,pos_list[0] - 1);
XmListAddItem(this->getWidget(),
XmStringCreateLocalized(
formatPropPair(
new_pair->label,
new_pair->value)),
pos_list[0]);
XmListSelectPos(this->getWidget(),
pos_list[0],
TRUE);
XmListSetPos(this->getWidget(),
pos_list[0]);
}
else
{
if(list_items == NULL)
list_items = new DtVirtArray<PropStringPair *>(10);
list_items->insert(new_pair,0);
XmListAddItem(this->getWidget(),
XmStringCreateLocalized(
formatPropPair(
new_pair->label,
new_pair->value)),
1);
XmListSelectPos(this->getWidget(),
1,
TRUE);
XmListSetPos(this->getWidget(),
1);
}
props_changed = TRUE;
}
}
void HCI_PM( const char* operation )
{
char op_label_buf[PM_MAX_LABEL_SIZE] = "";
XmString label;
if( PM_skip_flag == HCI_YES_FLAG )
{
/* Return, if previously decided progress meters aren't needed. */
return;
}
else if( PM_active_flag == HCI_YES_FLAG )
{
/* Return, if progress meter previously initialized and active. */
return;
}
/* Set active flag to prevent re-entry. */
PM_active_flag = HCI_YES_FLAG;
/* Ensure operation label is valid. */
if( operation != NULL )
{
if( strlen( operation ) < PM_MAX_LABEL_SIZE )
{
strcpy( op_label_buf, operation );
}
else
{
strncpy( op_label_buf, operation, PM_MAX_LABEL_SIZE );
op_label_buf[PM_MAX_LABEL_SIZE-1] = '\0';
}
}
else
{
strcpy( op_label_buf, PM_DEFAULT_OPERATION );
}
/* If operation label has changed, recreate widgets for correct sizing. */
if( strcmp( op_label_buf, Operation_label_buf ) != 0 )
{
strcpy( Operation_label_buf, op_label_buf );
}
/* If first time, initialize progress meter. */
if( PM_initialized_flag == HCI_NO_FLAG )
{
Satellite_connection_flag = HCI_is_satellite_connection();
Simulation_speed = HCI_simulation_speed();
if( Simulation_speed < 1 ){ Simulation_flag = HCI_NO_FLAG; }
if( Satellite_connection_flag == HCI_NO_FLAG && Simulation_flag == HCI_NO_FLAG )
{
/* Skip popups, if not low bandwidth or not simulating low bandwidth. */
PM_skip_flag = HCI_YES_FLAG;
PM_active_flag = HCI_NO_FLAG;
return;
}
PM_initialized_flag = HCI_YES_FLAG;
PM_initialize();
PM_display = HCI_get_display();
}
else
{
XtUnmanageChild( Operation_label );
label = XmStringCreateLocalized( Operation_label_buf );
XtVaSetValues( Operation_label, XmNlabelString, label, NULL );
XmStringFree( label );
XtManageChild( Operation_label );
PM_adjust_size();
}
/* Add RMT listener callbacks which update the progress meter. */
PM_add_listener_callback();
/* Reset flags. */
Running_sum_of_bytes = 0;
Previous_update_time = 0.0;
}
void AliasListUiItem::handleChangeButtonPress()
{
char *key_str = NULL;
char *value_str = NULL;
PropStringPair *new_pair = NULL;
XmString replace_string;
int *pos_list, num_pos;
// if nothing selected nothing to change...
if(XmListGetSelectedPos(this->getWidget(),
&pos_list,
&num_pos))
{
XtVaGetValues(key_widget,
XmNvalue, &key_str,
NULL);
XtVaGetValues(value_widget,
XmNvalue, &value_str,
NULL);
if(key_str != NULL)
if(strlen(key_str) > 0)
{
new_pair = (*list_items)[pos_list[0] - 1];
if(deleted_items == NULL)
{
deleted_items = new DtVirtArray<char *>(10);
}
deleted_items->append(strdup((*list_items)[pos_list[0] -1]->label));
free(new_pair->label);
new_pair->label = strdup(key_str);
if(new_pair->value != NULL)
{
free(new_pair->value);
if(value_str != NULL)
new_pair->value = strdup(value_str);
else
new_pair->value = NULL;
}
replace_string = XmStringCreateLocalized(
formatPropPair(new_pair->label,
new_pair->value));
XmListReplaceItemsPos(this->getWidget(),
&replace_string,
1,
pos_list[0]);
XmListSelectPos(this->getWidget(),
pos_list[0],
TRUE);
}
props_changed = TRUE;
}
}
Widget *XbrMenu(Widget parent, char *title, int menu_type,
XbrMenuData menu_data[], int n)
{
XtAppContext app_context = XtWidgetToApplicationContext(parent);
Widget *widgets;
Boolean radio_behaviour = False;
int i, extras;
Arg args[10];
Cardinal num;
XmString string;
char name[256];
/* Number of extra widgets to create - for a popup this is just the popup
menu but for pulldowns there is the menu and the cascade button.
*/
if(menu_type == XbrMENU_POPUP)
extras = 1;
else
extras = 2;
/* Allocate memory for widgets */
if((widgets = (Widget *) malloc(sizeof(Widget) * (n+extras))) == NULL) {
XtAppError(app_context, "Error - out of memory!\n");
return(NULL);
}
/* Create menu */
switch(menu_type) {
case XbrMENU_POPUP:
sprintf(name, "%sPopup", title);
widgets[MENU] = XmCreatePopupMenu(parent, name, NULL, 0);
break;
case XbrMENU_OPTION:
sprintf(name, "%sPane", title);
widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
num = 0;
string = XmStringCreateLocalized(title);
XtSetArg(args[num], XmNsubMenuId, widgets[MENU]); num++;
XtSetArg(args[num], XmNlabelString, string); num++;
sprintf(name, "%sOption", title);
widgets[CASCADE] = XmCreateOptionMenu(parent, name, args, num);
XmStringFree(string);
XtManageChild(widgets[CASCADE]);
break;
case XbrMENU_PULLDOWN_RADIO:
radio_behaviour = True;
case XbrMENU_PULLDOWN:
sprintf(name, "%sPulldown", title);
widgets[MENU] = XmCreatePulldownMenu(parent, name, NULL,0);
XtVaSetValues(widgets[MENU], XmNradioBehavior, radio_behaviour,
NULL);
/* Create menu title */
sprintf(name, "%sCascade", title);
widgets[CASCADE] = XtVaCreateManagedWidget(name,
xmCascadeButtonWidgetClass, parent,
XmNsubMenuId, widgets[MENU],
XtVaTypedArg, XmNlabelString, XmRString,
title, sizeof(char *),
NULL);
break;
default:
XtAppError(app_context, "Unknown menu type!\n");
}
/* Add desired widgets */
for(i = 0; i < n; i++) {
sprintf(name, "%s%d", title, i);
switch(menu_data[i].type) {
/* Label widget - easy */
case XbrLABEL:
string = XmStringCreateLocalized(menu_data[i].label);
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmLabelWidgetClass, widgets[MENU],
XmNlabelString, string,
NULL);
XmStringFree(string);
break;
/* Push button gadget - include activate callback & data */
case XbrPB:
string = XmStringCreateLocalized(menu_data[i].label);
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmPushButtonWidgetClass, widgets[MENU],
XmNlabelString, string,
NULL);
XmStringFree(string);
if(menu_data[i].callback)
XtAddCallback(widgets[i+extras], XmNactivateCallback,
menu_data[i].callback, menu_data[i].data);
if(menu_data[i].set && menu_type == XbrMENU_OPTION)
XtVaSetValues(widgets[CASCADE], XmNmenuHistory,
widgets[i+extras], NULL);
break;
/* Toggle button - include value changed callback & data */
case XbrTOGGLE:
num = 0;
string = XmStringCreateLocalized(menu_data[i].label);
XtSetArg(args[num], XmNlabelString, string); num++;
XtSetArg(args[num], XmNindicatorType, XmONE_OF_MANY); num++;
if(menu_data[i].set != XbrNOSET) {
XtSetArg(args[num], XmNset, menu_data[i].set); num++;
}
widgets[i+extras] = XmCreateToggleButton(widgets[MENU], name,
args, num);
XtManageChild(widgets[i+extras]);
XmStringFree(string);
if(menu_data[i].callback)
XtAddCallback(widgets[i+extras], XmNvalueChangedCallback,
menu_data[i].callback, menu_data[i].data);
break;
/* Separator to make menu look pretty! */
case XbrSEPARATOR:
widgets[i+extras] = XtVaCreateManagedWidget(name,
xmSeparatorWidgetClass, widgets[MENU],
NULL);
break;
/* A sub menu */
case XbrSUBMENU:
widgets[i+extras] = (Widget)XbrMenu(widgets[MENU], menu_data[i].title, menu_data[i].stype,
menu_data[i].submenu, menu_data[i].n);
break;
default:
XtAppError(app_context, "Unknown menu item!\n");
break;
}
}
return(widgets);
}
/*######################## popup_error_history() ########################*/
void
popup_error_history(int x_root, int y_root, int host_no)
{
if (error_shell != NULL)
{
destroy_error_history();
}
if (fsa[host_no].error_history[0] != 0)
{
Widget error_label,
form;
XmString x_string;
int display_height,
display_width,
error_list_length,
i,
length,
lines,
max_lines,
max_length,
over_hang,
str_length;
char *error_list;
/* Lets determine how many lines we are able to display. */
display_height = DisplayHeight(display, DefaultScreen(display));
max_lines = display_height / glyph_height;
error_list_length = ERROR_HISTORY_LENGTH *
(5 + 1 + MAX_ERROR_STR_LENGTH + 1);
if ((error_list = malloc(error_list_length)) == NULL)
{
(void)fprintf(stderr, "malloc() error : %s (%s %d)\n",
strerror(errno), __FILE__, __LINE__);
exit(INCORRECT);
}
length = max_length = lines = 0;
str_length = sprintf(error_list + length, "[%d] %s\n",
(int)fsa[host_no].error_history[0],
get_error_str(fsa[host_no].error_history[0]));
if (str_length > max_length)
{
max_length = str_length;
}
length += str_length;
lines++;
for (i = 1; i < ERROR_HISTORY_LENGTH; i++)
{
if ((fsa[host_no].error_history[i] == 0) || (lines >= max_lines))
{
i = ERROR_HISTORY_LENGTH;
}
else
{
str_length = sprintf(error_list + length, "[%d] %s\n",
(int)fsa[host_no].error_history[i],
get_error_str(fsa[host_no].error_history[i]));
if (str_length > max_length)
{
max_length = str_length;
}
length += str_length;
lines++;
}
}
error_shell = XtVaCreatePopupShell("error_history_shell",
topLevelShellWidgetClass, appshell,
XtNoverrideRedirect, True,
XtNallowShellResize, True,
XtNmappedWhenManaged, False,
XtNsensitive, True,
XtNwidth, 1,
XtNheight, 1,
XtNborderWidth, 0,
NULL);
XtManageChild(error_shell);
XtAddEventHandler(error_shell, ButtonPressMask | Button1MotionMask,
False, (XtEventHandler)eh_input, NULL);
form = XtVaCreateWidget("error_box",
xmFormWidgetClass, error_shell, NULL);
XtManageChild(form);
display_width = DisplayWidth(display, DefaultScreen(display));
over_hang = display_width - (x_root + (max_length * glyph_width));
if (over_hang < 0)
{
x_root += over_hang;
}
over_hang = display_height - (y_root + (lines * glyph_height));
if (over_hang < 0)
{
y_root += over_hang;
}
XMoveResizeWindow(display, XtWindow(error_shell),
x_root, y_root, max_length * glyph_width, lines * glyph_height);
error_list[length - 1] = '\0';
x_string = XmStringCreateLocalized(error_list);
error_label = XtVaCreateWidget("error_label",
xmLabelWidgetClass, form,
XmNlabelString, x_string,
XtNbackground, color_pool[WHITE],
XtNforeground, color_pool[BLACK],
NULL);
XtManageChild(error_label);
XmStringFree(x_string);
XtAddEventHandler(error_label, ButtonPressMask|LeaveWindowMask, False,
(XtEventHandler)destroy_error_history, NULL);
XtPopup(error_shell, XtGrabNone);
XRaiseWindow(display, XtWindow(error_shell));
free(error_list);
}
else
{
destroy_error_history();
}
return;
}
