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; }