Widget CreateScrolledText ( Widget parent, char name[] )
/************************************************************************
* CreateScrolledText *
* *
* Widget CreateScrolledText( parent, name ) *
* *
* Input parameters: *
* parent Widget *
* name[] char *
* *
* Output parameters: *
* CreateScrolledText Widget *
** *
************************************************************************/
{
Widget text_widget;
Arg args[10];
int n;
/*---------------------------------------------------------------------*/
n = 0;
XtSetArg( args[n], XmNrows , 24 ); n++;
XtSetArg( args[n], XmNcolumns, 80 ); n++;
XtSetArg( args[n], XmNscrollHorizontal , True ); n++;
XtSetArg( args[n], XmNscrollVertical , True ); n++;
XtSetArg( args[n], XmNeditable , False ); n++;
XtSetArg( args[n], XmNeditMode , XmMULTI_LINE_EDIT ); n++;
text_widget = XmCreateScrolledText( parent, name, args, n);
XtManageChild( text_widget );
return( text_widget );
}
Widget make_text_widget(char *name, Widget parent, Arg *args, int n)
{
/* white background when active, emacs translations */
/* used only for comment widget in file data box (snd-xfile.c), but needs to be in this file to pick up actions etc */
Widget df;
if (!actions_loaded)
{
XtAppAddActions(MAIN_APP(ss), acts, NUM_ACTS);
actions_loaded = true;
}
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
/* XmNblinkRate 0 turns off the cursor blink */
XtSetArg(args[n], XmNcursorPositionVisible, false); n++;
XtSetArg(args[n], XmNhighlightThickness, 1); n++;
df = XmCreateScrolledText(parent, name, args, n);
XtManageChild(df);
XtAddCallback(df, XmNfocusCallback, textfield_focus_callback, NULL);
XtAddCallback(df, XmNlosingFocusCallback, textfield_unfocus_callback, NULL);
XtAddEventHandler(df, EnterWindowMask, false, mouse_enter_text_callback, NULL);
XtAddEventHandler(df, LeaveWindowMask, false, mouse_leave_text_callback, NULL);
if (!transTable3)
transTable3 = XtParseTranslationTable(TextTrans3);
XtOverrideTranslations(df, transTable3);
return(df);
}
static void make_command_widget(int height)
{
if (!listener_text)
{
Arg args[32];
Widget wv, wh;
int n;
if (!actions_loaded) {XtAppAddActions(MAIN_APP(ss), acts, NUM_ACTS); actions_loaded = true;}
n = attach_all_sides(args, 0);
XtSetArg(args[n], XmNheight, height); n++;
if ((sound_style(ss) == SOUNDS_IN_NOTEBOOK) || (sound_style(ss) == SOUNDS_HORIZONTAL))
listener_pane = XtCreateManagedWidget("frm", xmFormWidgetClass, SOUND_PANE_BOX(ss), args, n);
else listener_pane = XtCreateManagedWidget("frm", xmFormWidgetClass, SOUND_PANE(ss), args, n);
/* this widget is not redundant at least in Metroworks Motif */
n = 0;
XtSetArg(args[n], XmNbackground, ss->sgx->listener_color); n++;
XtSetArg(args[n], XmNforeground, ss->sgx->listener_text_color); n++;
if (ss->sgx->listener_fontlist) {XtSetArg(args[n], XM_FONT_RESOURCE, ss->sgx->listener_fontlist); n++;}
n = attach_all_sides(args, n);
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
XtSetArg(args[n], XmNskipAdjust, true); n++;
XtSetArg(args[n], XmNvalue, listener_prompt(ss)); n++;
XtSetArg(args[n], XmNpendingDelete, false); n++; /* don't cut selection upon paste */
XtSetArg(args[n], XmNpositionIndex, XmLAST_POSITION); n++;
XtSetArg(args[n], XmNhighlightThickness, 1); n++;
listener_text = XmCreateScrolledText(listener_pane, "lisp-listener", args, n);
ss->sgx->listener_pane = listener_text;
XtVaSetValues(MAIN_SHELL(ss), XmNallowShellResize, false, NULL);
XtManageChild(listener_text);
XmTextSetCursorPosition(listener_text, 1);
if (!transTable4)
transTable4 = XtParseTranslationTable(TextTrans4);
XtOverrideTranslations(listener_text, transTable4);
printout_end = 0;
XtAddCallback(listener_text, XmNactivateCallback, command_return_callback, NULL);
XtAddCallback(listener_text, XmNmodifyVerifyCallback, command_modify_callback, NULL);
XtAddCallback(listener_text, XmNmotionVerifyCallback, command_motion_callback, NULL);
lisp_window = XtParent(listener_text);
XtAddEventHandler(lisp_window, EnterWindowMask, false, listener_focus_callback, NULL);
XtAddEventHandler(lisp_window, LeaveWindowMask, false, listener_unfocus_callback, NULL);
XmChangeColor(lisp_window, ss->sgx->basic_color);
XtVaGetValues(lisp_window, XmNverticalScrollBar, &wv, XmNhorizontalScrollBar, &wh, NULL);
XmChangeColor(wv, ss->sgx->basic_color);
XmChangeColor(wh, ss->sgx->basic_color);
map_over_children(SOUND_PANE(ss), color_sashes);
if (auto_resize(ss))
XtVaSetValues(MAIN_SHELL(ss), XmNallowShellResize, true, NULL);
}
}
int main(int argc, char *argv[])
{
int i, n;
Arg args[10];
XtAppContext app;
Widget toplevel, rowcol, sep, button;
XmString str_months[12];
setlocale(LC_ALL, "");
//建立顶级窗口
toplevel = XtVaAppInitialize(&app, "Text", NULL, 0,
&argc, argv, NULL, NULL);
//建立rowcolumn 布局
n = 0;
XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
rowcol = XmCreateRowColumn(toplevel, "rowcol", args, n);
XtManageChild(rowcol);
//建立输入条
n = 0;
XtSetArg(args[n], XmNvalue, "输入条"); n++;
textf = XmCreateTextField(rowcol, "textf", args, n);
XtManageChild(textf);
//建立回调
XtAddCallback(textf, XmNactivateCallback,
(XtCallbackProc)checkit, NULL);
//建立输入区
n = 0;
XtSetArg(args[n], XmNrows, 10); n++;
XtSetArg(args[n], XmNcolumns, 40); n++;
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
XtSetArg(args[n], XmNvalue, "输入区域\n请测试"); n++;
text = XmCreateScrolledText(rowcol, "text", args, n);
//text = XmCreateText(rowcol, "text", args, n);
XtManageChild(text);
//建立分隔符
sep = XmCreateSeparator(rowcol, "separator", NULL, 0);
XtManageChild(sep);
//建立一个普通按钮
button = XmCreatePushButton(rowcol,
"打印输入条和文本区内容", NULL, 0);
XtManageChild(button);
XtAddCallback(button, XmNactivateCallback,
(XtCallbackProc)checkit, NULL);
//显示窗口
XtRealizeWidget(toplevel);
//进入事件循环
XtAppMainLoop(app);
}
MainWindow::MainWindow()
: QtMotifWidget("mainwindow", xmMainWindowWidgetClass, 0)
{
Widget menubar = XmCreateMenuBar( motifWidget(), const_cast<char*>("menubar"), NULL, 0 );
Widget filemenu = XmCreatePulldownMenu( menubar, const_cast<char*>("filemenu"), NULL, 0 );
Widget item;
item = XtVaCreateManagedWidget( "Motif Dialog...",
xmPushButtonGadgetClass, filemenu,
XmNmnemonic, 'C',
NULL );
XtAddCallback( item, XmNactivateCallback, motifDialogCallback, this );
item = XtVaCreateManagedWidget( "Qt Dialog...",
xmPushButtonGadgetClass, filemenu,
XmNmnemonic, 'Q',
NULL );
XtAddCallback( item, XmNactivateCallback, qtDialogCallback, this );
item = XtVaCreateManagedWidget( "sep",
xmSeparatorGadgetClass, filemenu,
NULL );
item = XtVaCreateManagedWidget( "Exit",
xmPushButtonGadgetClass, filemenu,
XmNmnemonic, 'x',
NULL );
XtAddCallback( item, XmNactivateCallback, quitCallback, this );
XmString str = XmStringCreateLocalized( const_cast<char*>("File") );
item = XtVaCreateManagedWidget( "File",
xmCascadeButtonWidgetClass, menubar,
XmNlabelString, str,
XmNmnemonic, 'F',
XmNsubMenuId, filemenu,
NULL );
XmStringFree( str );
Arg args[2];
XtSetArg( args[0], XmNeditMode, XmMULTI_LINE_EDIT );
Widget texteditor =
XmCreateScrolledText( motifWidget(), const_cast<char*>("texteditor"),
args, 1 );
XtManageChild( menubar );
XtManageChild( texteditor );
// pick a nice default size
XtVaSetValues( motifWidget(),
XmNwidth, 400,
XmNheight, 300,
NULL );
setWindowTitle(tr("QtMotif Dialog Example"));
}
int main(int argc, char *argv[])
{
int i, n;
Arg args[10];
XtAppContext app;
Widget toplevel, rowcol, textf, text;
XmString str_months[12];
setlocale(LC_ALL, "");
//建立顶级窗口
toplevel = XtVaAppInitialize(&app, "Edit", NULL, 0,
&argc, argv, NULL, NULL);
//建立rowcolumn 布局
n = 0;
XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
rowcol = XmCreateRowColumn(toplevel, "rowcol", args, n);
XtManageChild(rowcol);
//建立输入条
n = 0;
XtSetArg(args[n], XmNvalue, "输入条"); n++;
textf = XmCreateTextField(rowcol, "textf", args, n);
XtManageChild(textf);
//建立文本区
n = 0;
XtSetArg(args[n], XmNrows, 10); n++;
XtSetArg(args[n], XmNcolumns, 40); n++;
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
XtSetArg(args[n], XmNwordWrap, True); n++;
XtSetArg(args[n], XmNvalue, "输入区域\n请测试"); n++;
text = XmCreateScrolledText(rowcol, "text", args, n);
XtManageChild(text);
//显示窗口
XtRealizeWidget(toplevel);
//edit
XmTextSetInsertionPosition(text, 3);
XmTextInsert(text, 5, "测试插入");
XmTextSetSelection(text, 5, 8, CurrentTime);
XmTextCopy(text, CurrentTime);
XmTextSetInsertionPosition(text, 1);
XmTextPaste(text);
//进入事件循环
XtAppMainLoop(app);
}
int main(int argc, char *argv[])
{
int i, n;
Arg args[10];
char buf[80];
XtAppContext app;
Widget toplevel, notebook, page[6], label[6], frame[6], text[6];
setlocale(LC_ALL, "");
//建立顶级窗口
toplevel = XtVaAppInitialize(&app, "Notebook", NULL, 0,
&argc, argv, NULL, NULL);
//建立Notebook
n = 0;
XtSetArg(args[n], XmNwidth, 600 ); n++;
XtSetArg(args[n], XmNheight, 400 ); n++;
XtSetArg(args[n], XmNfirstPageNumber, 1); n++;
XtSetArg(args[n], XmNlastPageNumber, 6); n++;
notebook = XmCreateNotebook(toplevel, "notebook", args, n);
XtManageChild(notebook);
//建立页面
for(i=0; i<6; i++){
n = 0;
sprintf(buf, "页面 %d", i + 1);
label[i] = XmCreateLabel(notebook, buf, args, n);
page[i] = XmCreatePushButton(notebook, buf, args, n);
}
XtManageChildren(label, 6);
XtManageChildren(page, 6);
for(i=0; i<6; i++){
XtSetArg(args[n], XmNpageNumber, i + 1); n++;
text[i] = XmCreateScrolledText(notebook, buf, args, n);
XtManageChild(text[i]);
}
//显示窗口
XtRealizeWidget(toplevel);
//进入事件循环
XtAppMainLoop(app);
}
void InitClientsTab()
{
Widget clients_form, out_scroll;
clients_frame = XtVaCreateWidget( "clients_frame", xmFrameWidgetClass,
tab_form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, main_tab,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNchildType, XmFRAME_WORKAREA_CHILD,
XmNshadowType, XmSHADOW_ETCHED_OUT,
XmNmarginHeight, 3,
XmNmarginWidth, 3,
NULL );
clients_form = XtVaCreateManagedWidget( "clients_form", xmFormWidgetClass,
clients_frame,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL );
clients_out = XmCreateScrolledText( clients_form, "clients_out", NULL, 0 );
XtManageChild( clients_out );
out_scroll = XtParent( clients_out );
XtVaSetValues( out_scroll,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL );
XtVaSetValues( clients_out,
XmNshadowThickness, 0,
XmNwordWrap, TRUE,
XmNeditMode, XmMULTI_LINE_EDIT,
XmNeditable, FALSE, /* can't edit */
XmNcursorPositionVisible, FALSE, /* no cursor */
XmNautoShowCursorPosition, FALSE,
XmNscrollingPolicy, XmAUTOMATIC,
NULL );
}
static Widget createPanelHelp(Widget parent, const char *helpText, const char *title)
{
Arg al[20];
int ac;
Widget form, text, button;
XmString st1;
ac = 0;
form = CreateFormDialog(parent, "helpForm", al, ac);
ac = 0;
XtSetArg (al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg (al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNlabelString, st1=XmStringCreateLtoR ("OK",
XmSTRING_DEFAULT_CHARSET)); ac++;
XtSetArg (al[ac], XmNmarginWidth, BUTTON_WIDTH_MARGIN); ac++;
button = XmCreatePushButtonGadget(form, "ok", al, ac);
XtAddCallback(button, XmNactivateCallback, (XtCallbackProc)helpDismissCB,
(char *)form);
XmStringFree(st1);
XtManageChild(button);
SET_ONE_RSRC(form, XmNdefaultButton, button);
ac = 0;
XtSetArg(al[ac], XmNrows, 15); ac++;
XtSetArg(al[ac], XmNcolumns, 60); ac++;
XtSetArg(al[ac], XmNresizeHeight, False); ac++;
XtSetArg(al[ac], XmNtraversalOn, False); ac++;
XtSetArg(al[ac], XmNwordWrap, True); ac++;
XtSetArg(al[ac], XmNscrollHorizontal, False); ac++;
XtSetArg(al[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
XtSetArg(al[ac], XmNeditable, False); ac++;
XtSetArg(al[ac], XmNvalue, helpText); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomWidget, button); ac++;
text = XmCreateScrolledText(form, "helpText", al, ac);
AddMouseWheelSupport(text);
XtManageChild(text);
SET_ONE_RSRC(XtParent(form), XmNtitle, title);
return form;
}
static void createBrowserHeadDump()
{
Arg args[50];
int ac;
XmString s1;
Widget dismissBtn;
ac = 0;
XtSetArg(args[ac], XmNautoUnmanage, False); ac++;
XtSetArg(args[ac], XmNresizePolicy, XmRESIZE_NONE); ac++;
DumpHeadFormW = XmCreateFormDialog(McfioMainPanelW, "form", args, ac);
DumpHeadShellW = XtParent(DumpHeadFormW);
XtVaSetValues(DumpHeadShellW, XmNtitle,
"File Header Information", 0);
AddMotifCloseCallback(XtParent(DumpHeadFormW),
(XtCallbackProc)dismissHeadDumpCB, NULL);
dismissBtn = XtVaCreateManagedWidget("dismissBtn",
xmPushButtonGadgetClass, DumpHeadFormW,
XmNlabelString, s1=XmStringCreateSimple("Dismiss"),
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 4,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 25,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 75, 0);
XmStringFree(s1);
XtAddCallback(dismissBtn, XmNactivateCallback,
(XtCallbackProc)dismissHeadDumpCB, NULL);
ac = 0;
XtSetArg(args[ac], XmNrows, 8); ac++;
XtSetArg(args[ac], XmNcolumns, 80); ac++;
XtSetArg(args[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
XtSetArg(args[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetArg(args[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(args[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(args[ac], XmNbottomWidget, dismissBtn); ac++;
XtSetArg(args[ac], XmNdeleteResponse, XmDO_NOTHING); ac++;
DumpHeadTextW = XmCreateScrolledText(DumpHeadFormW,
"HeaderText", args, ac);
XtManageChild(DumpHeadTextW);
XtManageChild(DumpHeadFormW);
}
/* -------------------------------------------------------------------- */
static void CreateStatsWindow()
{
Arg args[8];
Cardinal n;
Widget drFrame, drRC, b[3];
n = 0;
StatsShell = XtCreatePopupShell("statsShell",
topLevelShellWidgetClass, AppShell, args, n);
n = 0;
StatsWindow = XmCreateForm(StatsShell, (char *)"statsForm", args, n);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
drFrame = XmCreateFrame(StatsWindow, (char *)"buttonFrame", args, n);
XtManageChild(drFrame);
n = 0;
drRC = XmCreateRowColumn(drFrame, (char *)"buttonRC", args, n);
XtManageChild(drRC);
n = 0;
b[0] = XmCreatePushButton(drRC, (char *)"dismissButton", args, n);
b[1] = XmCreatePushButton(drRC, (char *)"printButton", args, n);
b[2] = XmCreatePushButton(drRC, (char *)"parmsButton", args, n);
XtManageChildren(b, 3);
XtAddCallback(b[0], XmNactivateCallback, DismissStats, StatsWindow);
XtAddCallback(b[1], XmNactivateCallback, PrintStats, NULL);
XtAddCallback(b[2], XmNactivateCallback, EditStatsParms, NULL);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, drFrame); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
statsText = XmCreateScrolledText(StatsWindow, (char *)"statsText", args, n);
XtManageChild(statsText);
} /* END CREATESTATSWINDOW */
void make_edit_box(QSP_ARG_DECL Screen_Obj *sop)
{
#ifdef HAVE_MOTIF
Arg al[8];
int ac = 0;
sop->so_frame = generic_frame(curr_panel->po_panel_obj,
sop, XmSHADOW_IN);
XtSetArg(al[ac], XmNeditable, TRUE); ac++;
XtSetArg(al[ac], XmNrecomputeSize, FALSE); ac++;
XtSetArg(al[ac], XmNwidth, PO_WIDTH(curr_panel)-30 ); ac++;
/* BUG do something sensible about the height... */
//XtSetArg(al[ac], XmNheight, PO_HEIGHT(curr_panel)-30 ); ac++;
#define EDIT_BOX_HEIGHT 100 // height of editable area?
#define EDIT_BOX_EXTRA 30 // add for total height - this value is guessed!?
XtSetArg(al[ac], XmNheight, EDIT_BOX_HEIGHT); ac++;
XtSetArg(al[ac], XmNscrollHorizontal, FALSE); ac++;
XtSetArg(al[ac], XmNwordWrap, TRUE); ac++;
//sop->so_obj = XmCreateTextField(sop->so_frame, (char *)sop->so_name, al, ac);
sop->so_obj = XmCreateScrolledText(sop->so_frame, (char *)sop->so_name, al, ac);
XtAddCallback(sop->so_obj, XmNvalueChangedCallback, text_func, NULL);
XtAddCallback(sop->so_obj, XmNlosingFocusCallback, text_func2, NULL);
XtManageChild(sop->so_obj);
/* this works for a TextField, but not ScrolledText!? */
//XmTextFieldSetString(sop->so_obj, (char *)sop->so_content_text );
/* this works! */
XmTextSetString(sop->so_obj, (char *)sop->so_content_text );
SET_SOB_HEIGHT(sop,EDIT_BOX_HEIGHT+EDIT_BOX_EXTRA);
#endif /* HAVE_MOTIF */
}
int
main( int argc, char *argv[] )
{
int n;
Arg Args[MAX_ARGS];
int i;
Widget Text;
Widget Window;
Pixmap WindPixmap;
Pixmap TextPixmap;
CommonTestInit(argc, argv);
/* Get the pixmaps for the backgrounds */
WindPixmap = XmGetPixmap(screen, WINDOW_PIXMAP, BlackPixelOfScreen(screen),
WhitePixelOfScreen(screen));
TextPixmap = XmGetPixmap(screen, TEXT_PIXMAP, BlackPixelOfScreen(screen),
WhitePixelOfScreen(screen));
if (!WindPixmap)
{
(void)printf("Can't make pixmap for file %s!\n", WINDOW_PIXMAP );
exit(1);
}
if (!TextPixmap)
{
(void)printf("Can't make pixmap for file %s!\n", TEXT_PIXMAP );
exit(1);
}
/* Make the ScrolledWindow and Text */
n = 0;
XtSetArg( Args[n], XmNvalue, Strings ); n++;
XtSetArg( Args[n], XmNeditable, False ); n++;
XtSetArg( Args[n], XmNeditMode, XmMULTI_LINE_EDIT ); n++;
Text = XmCreateScrolledText(Shell1, "Text", Args, n );
/* Get the Widget for the parent Scrolled Window */
Window = XtParent(Text);
/* Set the Text Pixmap and color */
n = 0;
XtSetArg(Args[n], XmNbackgroundPixmap, TextPixmap ); n++;
XtSetValues( Text, Args, n );
SetWidgetColor( Text, "white" );
/* Set the Window Pixmap and color */
n = 0;
XtSetArg(Args[n], XmNbackgroundPixmap, WindPixmap ); n++;
XtSetValues( Window, Args, n );
SetWidgetColor( Window, "pink" );
XtManageChild(Text);
XtManageChild(Window);
/*************
* Assertion 1. Now that the text and window have differing pixmaps,
* lets dump the values for the child scrollbar values.
*/
PrintValues( Window, "Assertion 1" );
CommonPause();
/*************
* Assertion 2. Now that the text and window have differing pixmaps,
* lets dump the values for the child scrollbar values.
*/
SetWidgetColor( Text, "green" );
PrintValues( Window, "Assertion 2" );
CommonPause();
/* Cleanup Time */
XmDestroyPixmap( screen, WindPixmap );
XmDestroyPixmap( screen, TextPixmap );
XtDestroyWidget( XtParent(Text) );
CommonPause();
XtAppMainLoop(app_context);
return 0;
}
/*$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ main() $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$*/
int
main(int argc, char *argv[])
{
int i;
char window_title[100],
work_dir[MAX_PATH_LENGTH],
str_line[MAX_INFO_STRING_LENGTH],
tmp_str_line[MAX_INFO_STRING_LENGTH];
static String fallback_res[] =
{
"*mwmDecorations : 42",
"*mwmFunctions : 12",
".mon_info.form*background : NavajoWhite2",
".mon_info.form.msa_box.?.?.?.text_wl.background : NavajoWhite1",
".mon_info.form.msa_box.?.?.?.text_wr.background : NavajoWhite1",
".mon_info.form.host_infoSW.host_info.background : NavajoWhite1",
".mon_info.form.buttonbox*background : PaleVioletRed2",
".mon_info.form.buttonbox*foreground : Black",
".mon_info.form.buttonbox*highlightColor : Black",
NULL
};
Widget form_w,
msa_box_w,
msa_box1_w,
msa_box2_w,
msa_text_w,
button_w,
buttonbox_w,
rowcol1_w,
rowcol2_w,
h_separator1_w,
h_separator2_w,
v_separator_w;
XmFontListEntry entry;
XmFontList fontlist;
Arg args[MAXARGS];
Cardinal argcount;
uid_t euid, /* Effective user ID. */
ruid; /* Real user ID. */
CHECK_FOR_VERSION(argc, argv);
/* Initialise global values. */
p_work_dir = work_dir;
init_mon_info(&argc, argv);
/*
* SSH uses wants to look at .Xauthority and with setuid flag
* set we cannot do that. So when we initialize X lets temporaly
* disable it. After XtAppInitialize() we set it back.
*/
euid = geteuid();
ruid = getuid();
if (euid != ruid)
{
if (seteuid(ruid) == -1)
{
(void)fprintf(stderr, "Failed to seteuid() to %d : %s\n",
ruid, strerror(errno));
}
}
(void)strcpy(window_title, afd_name);
(void)strcat(window_title, " Info");
argcount = 0;
XtSetArg(args[argcount], XmNtitle, window_title); argcount++;
appshell = XtAppInitialize(&app, "AFD", NULL, 0,
&argc, argv, fallback_res, args, argcount);
disable_drag_drop(appshell);
if (euid != ruid)
{
if (seteuid(euid) == -1)
{
(void)fprintf(stderr, "Failed to seteuid() to %d : %s\n",
euid, strerror(errno));
}
}
display = XtDisplay(appshell);
#ifdef HAVE_XPM
/* Setup AFD logo as icon. */
setup_icon(display, appshell);
#endif
/* Create managing widget. */
form_w = XmCreateForm(appshell, "form", NULL, 0);
entry = XmFontListEntryLoad(XtDisplay(form_w), font_name,
XmFONT_IS_FONT, "TAG1");
fontlist = XmFontListAppendEntry(NULL, entry);
XmFontListEntryFree(&entry);
argcount = 0;
XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNrightAttachment, XmATTACH_FORM);
argcount++;
msa_box_w = XmCreateForm(form_w, "msa_box", args, argcount);
XtManageChild(msa_box_w);
argcount = 0;
XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM);
argcount++;
msa_box1_w = XmCreateForm(msa_box_w, "msa_box1", args, argcount);
XtManageChild(msa_box1_w);
rowcol1_w = XtVaCreateWidget("rowcol1", xmRowColumnWidgetClass,
msa_box1_w, NULL);
for (i = 0; i < NO_OF_MSA_ROWS; i++)
{
msa_text_w = XtVaCreateWidget("msa_text", xmFormWidgetClass,
rowcol1_w,
XmNfractionBase, 41,
NULL);
label_l_widget[i] = XtVaCreateManagedWidget(label_l[i],
xmLabelGadgetClass, msa_text_w,
XmNfontList, fontlist,
XmNtopAttachment, XmATTACH_POSITION,
XmNtopPosition, 1,
XmNbottomAttachment, XmATTACH_POSITION,
XmNbottomPosition, 40,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 1,
XmNalignment, XmALIGNMENT_END,
NULL);
text_wl[i] = XtVaCreateManagedWidget("text_wl",
xmTextWidgetClass, msa_text_w,
XmNfontList, fontlist,
XmNcolumns, MON_INFO_LENGTH,
XmNtraversalOn, False,
XmNeditable, False,
XmNcursorPositionVisible, False,
XmNmarginHeight, 1,
XmNmarginWidth, 1,
XmNshadowThickness, 1,
XmNhighlightThickness, 0,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 22,
NULL);
XtManageChild(msa_text_w);
}
XtManageChild(rowcol1_w);
/* Fill up the text widget with some values. */
(void)sprintf(str_line, "%*s", MON_INFO_LENGTH,
prev.real_hostname[(int)prev.afd_toggle]);
XmTextSetString(text_wl[0], str_line);
(void)sprintf(str_line, "%*d",
MON_INFO_LENGTH, prev.port[(int)prev.afd_toggle]);
XmTextSetString(text_wl[1], str_line);
(void)strftime(tmp_str_line, MAX_INFO_STRING_LENGTH, "%d.%m.%Y %H:%M:%S",
localtime(&prev.last_data_time));
(void)sprintf(str_line, "%*s", MON_INFO_LENGTH, tmp_str_line);
XmTextSetString(text_wl[2], str_line);
(void)sprintf(str_line, "%*d", MON_INFO_LENGTH, prev.max_connections);
XmTextSetString(text_wl[3], str_line);
(void)sprintf(str_line, "%*s", MON_INFO_LENGTH, prev.afd_version);
XmTextSetString(text_wl[4], str_line);
if (prev.top_tr > 1048576)
{
(void)sprintf(str_line, "%*u MB/s",
MON_INFO_LENGTH - 5, prev.top_tr / 1048576);
}
else if (prev.top_tr > 1024)
{
(void)sprintf(str_line, "%*u KB/s",
MON_INFO_LENGTH - 5, prev.top_tr / 1024);
}
else
{
(void)sprintf(str_line, "%*u Bytes/s",
MON_INFO_LENGTH - 8, prev.top_tr);
}
XmTextSetString(text_wl[5], str_line);
/* Create the first horizontal separator. */
argcount = 0;
XtSetArg(args[argcount], XmNorientation, XmHORIZONTAL);
argcount++;
XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_WIDGET);
argcount++;
XtSetArg(args[argcount], XmNtopWidget, msa_box_w);
argcount++;
XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNrightAttachment, XmATTACH_FORM);
argcount++;
h_separator1_w = XmCreateSeparator(form_w, "h_separator1_w", args, argcount);
XtManageChild(h_separator1_w);
/* Create the vertical separator. */
argcount = 0;
XtSetArg(args[argcount], XmNorientation, XmVERTICAL);
argcount++;
XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_WIDGET);
argcount++;
XtSetArg(args[argcount], XmNleftWidget, msa_box1_w);
argcount++;
XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNbottomAttachment, XmATTACH_FORM);
argcount++;
v_separator_w = XmCreateSeparator(msa_box_w, "v_separator", args, argcount);
XtManageChild(v_separator_w);
argcount = 0;
XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_WIDGET);
argcount++;
XtSetArg(args[argcount], XmNleftWidget, v_separator_w);
argcount++;
msa_box2_w = XmCreateForm(msa_box_w, "msa_box2", args, argcount);
XtManageChild(msa_box2_w);
rowcol2_w = XtVaCreateWidget("rowcol2", xmRowColumnWidgetClass,
msa_box2_w, NULL);
for (i = 0; i < NO_OF_MSA_ROWS; i++)
{
msa_text_w = XtVaCreateWidget("msa_text", xmFormWidgetClass,
rowcol2_w,
XmNfractionBase, 41,
NULL);
label_r_widget[i] = XtVaCreateManagedWidget(label_r[i],
xmLabelGadgetClass, msa_text_w,
XmNfontList, fontlist,
XmNtopAttachment, XmATTACH_POSITION,
XmNtopPosition, 1,
XmNbottomAttachment, XmATTACH_POSITION,
XmNbottomPosition, 40,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 1,
XmNalignment, XmALIGNMENT_END,
NULL);
text_wr[i] = XtVaCreateManagedWidget("text_wr",
xmTextWidgetClass, msa_text_w,
XmNfontList, fontlist,
XmNcolumns, MON_INFO_LENGTH,
XmNtraversalOn, False,
XmNeditable, False,
XmNcursorPositionVisible, False,
XmNmarginHeight, 1,
XmNmarginWidth, 1,
XmNshadowThickness, 1,
XmNhighlightThickness, 0,
XmNrightAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 20,
NULL);
XtManageChild(msa_text_w);
}
XtManageChild(rowcol2_w);
/* Fill up the text widget with some values. */
get_ip_no(msa[afd_position].hostname[(int)prev.afd_toggle], tmp_str_line);
(void)sprintf(str_line, "%*s", MON_INFO_LENGTH, tmp_str_line);
XmTextSetString(text_wr[0], str_line);
(void)sprintf(str_line, "%*s", MON_INFO_LENGTH, prev.r_work_dir);
XmTextSetString(text_wr[1], str_line);
(void)sprintf(str_line, "%*d", MON_INFO_LENGTH, prev.poll_interval);
XmTextSetString(text_wr[2], str_line);
(void)sprintf(str_line, "%*d", MON_INFO_LENGTH, prev.top_not);
XmTextSetString(text_wr[3], str_line);
(void)sprintf(str_line, "%*d", MON_INFO_LENGTH, prev.no_of_hosts);
XmTextSetString(text_wr[4], str_line);
(void)sprintf(str_line, "%*u files/s", MON_INFO_LENGTH - 8, prev.top_fr);
XmTextSetString(text_wr[5], str_line);
argcount = 0;
XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNrightAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNbottomAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNfractionBase, 21);
argcount++;
buttonbox_w = XmCreateForm(form_w, "buttonbox", args, argcount);
/* Create the second horizontal separator. */
argcount = 0;
XtSetArg(args[argcount], XmNorientation, XmHORIZONTAL);
argcount++;
XtSetArg(args[argcount], XmNbottomAttachment, XmATTACH_WIDGET);
argcount++;
XtSetArg(args[argcount], XmNbottomWidget, buttonbox_w);
argcount++;
XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNrightAttachment, XmATTACH_FORM);
argcount++;
h_separator2_w = XmCreateSeparator(form_w, "h_separator2", args, argcount);
XtManageChild(h_separator2_w);
if (editable == YES)
{
button_w = XtVaCreateManagedWidget("Save",
xmPushButtonWidgetClass, buttonbox_w,
XmNfontList, fontlist,
XmNtopAttachment, XmATTACH_POSITION,
XmNtopPosition, 2,
XmNbottomAttachment, XmATTACH_POSITION,
XmNbottomPosition, 19,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 1,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 9,
NULL);
XtAddCallback(button_w, XmNactivateCallback,
(XtCallbackProc)save_button, (XtPointer)0);
button_w = XtVaCreateManagedWidget("Close",
xmPushButtonWidgetClass, buttonbox_w,
XmNfontList, fontlist,
XmNtopAttachment, XmATTACH_POSITION,
XmNtopPosition, 2,
XmNbottomAttachment, XmATTACH_POSITION,
XmNbottomPosition, 19,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 10,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 20,
NULL);
XtAddCallback(button_w, XmNactivateCallback,
(XtCallbackProc)close_button, (XtPointer)0);
}
else
{
button_w = XtVaCreateManagedWidget("Close",
xmPushButtonWidgetClass, buttonbox_w,
XmNfontList, fontlist,
XmNtopAttachment, XmATTACH_POSITION,
XmNtopPosition, 2,
XmNbottomAttachment, XmATTACH_POSITION,
XmNbottomPosition, 19,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 1,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 20,
NULL);
XtAddCallback(button_w, XmNactivateCallback,
(XtCallbackProc)close_button, (XtPointer)0);
}
XtManageChild(buttonbox_w);
/* Create log_text as a ScrolledText window. */
argcount = 0;
XtSetArg(args[argcount], XmNfontList, fontlist);
argcount++;
XtSetArg(args[argcount], XmNrows, 10);
argcount++;
XtSetArg(args[argcount], XmNcolumns, 80);
argcount++;
if (editable == YES)
{
XtSetArg(args[argcount], XmNeditable, True);
argcount++;
XtSetArg(args[argcount], XmNcursorPositionVisible, True);
argcount++;
XtSetArg(args[argcount], XmNautoShowCursorPosition, True);
}
else
{
XtSetArg(args[argcount], XmNeditable, False);
argcount++;
XtSetArg(args[argcount], XmNcursorPositionVisible, False);
argcount++;
XtSetArg(args[argcount], XmNautoShowCursorPosition, False);
}
argcount++;
XtSetArg(args[argcount], XmNeditMode, XmMULTI_LINE_EDIT);
argcount++;
XtSetArg(args[argcount], XmNwordWrap, False);
argcount++;
XtSetArg(args[argcount], XmNscrollHorizontal, False);
argcount++;
XtSetArg(args[argcount], XmNcursorPositionVisible, False);
argcount++;
XtSetArg(args[argcount], XmNautoShowCursorPosition, False);
argcount++;
XtSetArg(args[argcount], XmNtopAttachment, XmATTACH_WIDGET);
argcount++;
XtSetArg(args[argcount], XmNtopWidget, h_separator1_w);
argcount++;
XtSetArg(args[argcount], XmNtopOffset, 3);
argcount++;
XtSetArg(args[argcount], XmNleftAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNleftOffset, 3);
argcount++;
XtSetArg(args[argcount], XmNrightAttachment, XmATTACH_FORM);
argcount++;
XtSetArg(args[argcount], XmNrightOffset, 3);
argcount++;
XtSetArg(args[argcount], XmNbottomAttachment, XmATTACH_WIDGET);
argcount++;
XtSetArg(args[argcount], XmNbottomWidget, h_separator2_w);
argcount++;
XtSetArg(args[argcount], XmNbottomOffset, 3);
argcount++;
info_w = XmCreateScrolledText(form_w, "host_info", args, argcount);
XtManageChild(info_w);
XtManageChild(form_w);
/* Free font list. */
XmFontListFree(fontlist);
#ifdef WITH_EDITRES
XtAddEventHandler(appshell, (EventMask)0, True,
_XEditResCheckMessages, NULL);
#endif
/* Realize all widgets. */
XtRealizeWidget(appshell);
wait_visible(appshell);
/* Read and display the information file. */
(void)check_info_file(afd_name, AFD_INFO_FILE, YES);
XmTextSetString(info_w, NULL); /* Clears old entry. */
XmTextSetString(info_w, info_data);
/* Call update_info() after UPDATE_INTERVAL ms. */
interval_id_host = XtAppAddTimeOut(app, UPDATE_INTERVAL,
(XtTimerCallbackProc)update_info,
form_w);
/* We want the keyboard focus on the Done button. */
XmProcessTraversal(button_w, XmTRAVERSE_CURRENT);
/* Write window ID, so mon_ctrl can set focus if it is called again. */
write_window_id(XtWindow(appshell), getpid(), MON_INFO);
/* Start the main event-handling loop. */
XtAppMainLoop(app);
exit(SUCCESS);
}
Widget XmCreateScrolledText_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateScrolledText(parent, name, arglist, argcount);}
void CoWowMotif::DisplayLicense()
{
char text[20000];
Arg arg[11];
Widget question_widget;
XmString CStr2, TitleStr, cancelstr;
XmFontList fontlist;
XFontStruct *font;
XmFontListEntry fontentry;
char title[80];
Widget w;
FILE *fp;
char fname[200];
int i;
Widget wcancel;
strcpy( title, lng_translate("License"));
sprintf( fname, "$pwr_exe/%s/license.txt", lng_get_language_str());
dcli_translate_filename( fname, fname);
fp = fopen( fname, "r");
if ( !fp) {
strcpy( fname, "$pwr_exe/en_us/lincense.txt");
dcli_translate_filename( fname, fname);
fp = fopen( fname, "r");
if ( !fp)
return;
}
for ( i = 0; i < (int)sizeof(text) - 1; i++) {
text[i] = fgetc( fp);
if ( text[i] == EOF)
break;
}
fclose( fp);
text[i] = 0;
// Set default fontlist
font = XLoadQueryFont( XtDisplay(m_parent),
"-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
fontlist = XmFontListAppendEntry( NULL, fontentry);
XtFree( (char *)fontentry);
CStr2 = XmStringCreateLtoR( (char*) "", XmSTRING_DEFAULT_CHARSET);
TitleStr = XmStringCreateLtoR( title, XmSTRING_DEFAULT_CHARSET);
cancelstr = XmStringCreateLtoR( (char*) " Close ", XmSTRING_DEFAULT_CHARSET );
XtSetArg(arg[0],XmNheight,400);
XtSetArg(arg[1],XmNwidth,600);
XtSetArg(arg[2],XmNmessageString, CStr2);
XtSetArg(arg[3],XmNx,400);
XtSetArg(arg[4],XmNy,300);
XtSetArg(arg[5],XmNdialogTitle,TitleStr);
XtSetArg(arg[6], XmNcancelLabelString, cancelstr);
XtSetArg(arg[7], XmNbuttonFontList, fontlist);
XtSetArg(arg[8], XmNlabelFontList, fontlist);
question_widget = XmCreateMessageDialog( m_parent,(char*) "questionDialog",arg,9);
XmStringFree( CStr2);
XmStringFree( TitleStr);
XmStringFree( cancelstr);
XmFontListFree( fontlist);
wcancel = XmMessageBoxGetChild(question_widget, XmDIALOG_CANCEL_BUTTON);
XtSetArg(arg[0], XmNscrollHorizontal, True);
XtSetArg(arg[1], XmNscrollVertical, True);
XtSetArg(arg[2], XmNeditMode, XmMULTI_LINE_EDIT);
XtSetArg(arg[3], XmNeditable, False);
XtSetArg(arg[4], XmNcursorPositionVisible, False);
XtSetArg(arg[5], XmNrows, 30);
XtSetArg(arg[6], XmNvalue, text);
XtSetArg(arg[7], XmNfontList, fontlist);
w = XmCreateScrolledText( question_widget, (char*) "text", arg, 7);
XtVaSetValues( XtParent(w),
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, wcancel,
NULL);
XtManageChild(w);
w = XmMessageBoxGetChild(question_widget, XmDIALOG_OK_BUTTON);
XtUnmanageChild( w);
w = XmMessageBoxGetChild(question_widget, XmDIALOG_HELP_BUTTON);
XtUnmanageChild( w);
XtManageChild( question_widget);
}
void
MakeDialog( DialogType dtype )
{
register int i, j;
int width;
FILE *fp, *fopen();
char buffer[128];
char *str;
Widget w, text;
Dimension txt_width, txt_height;
XmString ok, cancel, nw, sv;
Widget tlev;
/*
* do things common to all dialogs...
*/
ok = ReadCatalogXms(MC_LABEL_SET, MC_OK_LABEL, MC_DEF_OK_LABEL);
cancel = ReadCatalogXms(MC_LABEL_SET, MC_CANCEL_LABEL, MC_DEF_CANCEL_LABEL);
i = InitArg(MessageBox);
XtSetArg(argt[i], XmNmarginHeight, MBOX_MARGIN_HEIGHT ); i++;
XtSetArg(argt[i], XmNmarginWidth, MBOX_MARGIN_WIDTH ); i++;
XtSetArg(argt[i], XmNshadowThickness, SHADOW_THICKNESS ); i++;
XtSetArg(argt[i], XmNokLabelString, ok ); i++;
XtSetArg(argt[i], XmNcancelLabelString, cancel ); i++;
XtSetArg(argt[i], XmNnoResize, False ); i++;
XtSetArg(argt[i], XmNresizePolicy, XmRESIZE_ANY ); i++;
/*
* create the various dialogs...
*/
/* JET - check the matte widget, and if non-null, well use that as
* the parent for dialogs. Otherwise use table (the original
* toplevel widget for this func). This is useful for Xinerama so
* that child dialogs are centered on the matte, and not the whole
* SLS screen.
*/
if (matte != (Widget)NULL)
tlev = matte;
else
tlev = table;
switch (dtype) {
case error:
xmstr = ReadCatalogXms(MC_ERROR_SET, MC_LOGIN, "");
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
w = XmCreateErrorDialog(tlev, "error_message", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
error_message = w;
break;
case help:
xmstr = ReadCatalogXms(MC_HELP_SET, MC_HELP, MC_DEF_HELP);
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
w = XmCreateInformationDialog(tlev, "help_message", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
txt_width = DisplayWidth (XtDisplay(w), DefaultScreen(XtDisplay(w)));
txt_height = DisplayHeight (XtDisplay(w), DefaultScreen(XtDisplay(w)));
txt_width = (txt_width > 850) ? 800 : txt_width - 50;
txt_height = (txt_height > 900) ? 750 : txt_height - 150;
i = InitArg(Text);
XtSetArg(argt[i], XmNheight, txt_height); i++;
XtSetArg(argt[i], XmNwidth, txt_width); i++;
XtSetArg(argt[i], XmNeditMode, XmMULTI_LINE_EDIT); i++;
XtSetArg(argt[i], XmNscrollBarDisplayPolicy, XmAS_NEEDED); i++;
XtSetArg(argt[i], XmNscrollingPolicy, XmAUTOMATIC); i++;
XtSetArg(argt[i], XmNeditable, False); i++;
str = (char*) ReadCatalog(MC_HELP_SET, MC_HELP, MC_DEF_HELP);
XtSetArg(argt[i], XmNvalue, strdup(str)); i++;
text = XmCreateScrolledText(w, "help_message_text", argt, i);
XtManageChild(text);
XtManageChild(w);
help_message = w;
break;
case copyright:
if ((fp = fopen(COPYRIGHT,"r")) == NULL)
#if defined( __hp_osf )
xmstr = XmStringCreate("Cannot open copyright file '/usr/X11/copyright'.",
XmFONTLIST_DEFAULT_TAG);
#else
xmstr = XmStringCreate("Cannot open copyright file '/etc/copyright'.",
XmFONTLIST_DEFAULT_TAG);
#endif
else {
xmstr = (XmString) NULL;
while (fgets(buffer, 128, fp) != NULL) {
j = strlen(buffer);
if ( buffer[j-1] == '\n' ) buffer[j-1] = '\0';
if ( xmstr != NULL )
xmstr = XmStringConcat(xmstr, XmStringSeparatorCreate());
xmstr = XmStringConcat(xmstr,
XmStringCreate(buffer,
XmFONTLIST_DEFAULT_TAG));
}
}
fclose(fp);
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
w = XmCreateInformationDialog(tlev, "copyright_msg", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
XtAddCallback(w, XmNokCallback, CopyrightCB, (XtPointer) 0);
copyright_msg = w;
break;
case hostname:
nw = ReadCatalogXms(MC_LABEL_SET, MC_NW_LABEL, MC_DEF_NW_LABEL);
sv = ReadCatalogXms(MC_LABEL_SET, MC_START_LABEL, MC_DEF_START_LABEL);
xmstr = ReadCatalogXms(MC_HELP_SET, MC_SYSTEM, MC_DEF_SYSTEM);
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
XtSetArg(argt[i], XmNokLabelString, nw ); i++;
XtSetArg(argt[i], XmNcancelLabelString, sv ); i++;
w = XmCreateWarningDialog(tlev, "hostname_msg", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
XmStringFree(nw);
XmStringFree(sv);
hostname_message = w;
break;
case expassword:
xmstr = ReadCatalogXms(MC_ERROR_SET, MC_PASSWD_EXPIRED,
MC_DEF_PASSWD_EXPIRED);
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
w = XmCreateQuestionDialog(tlev, "password_msg", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
passwd_message = w;
break;
case help_chooser:
xmstr = ReadCatalogXms(MC_HELP_SET, MC_HELP_CHOOSER, MC_DEF_HELP_CHOOSER);
w = XmCreateInformationDialog(tlev, "help_message", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
txt_width = DisplayWidth (XtDisplay(w), DefaultScreen(XtDisplay(w)));
txt_height = DisplayHeight (XtDisplay(w), DefaultScreen(XtDisplay(w)));
txt_width = (txt_width > 850) ? 800 : txt_width - 50;
txt_height = (txt_height > 900) ? 750 : txt_height - 150;
i = InitArg(Text);
XtSetArg(argt[i], XmNheight, txt_height); i++;
XtSetArg(argt[i], XmNwidth, txt_width); i++;
XtSetArg(argt[i], XmNeditMode, XmMULTI_LINE_EDIT); i++;
XtSetArg(argt[i], XmNscrollBarDisplayPolicy, XmAS_NEEDED); i++;
XtSetArg(argt[i], XmNscrollingPolicy, XmAUTOMATIC); i++;
XtSetArg(argt[i], XmNeditable, False); i++;
str = (char*)
ReadCatalog(MC_HELP_SET, MC_HELP_CHOOSER, MC_DEF_HELP_CHOOSER);
XtSetArg(argt[i], XmNvalue, strdup(str)); i++;
text = XmCreateScrolledText(w, "help_message_text", argt, i);
XtManageChild(text);
XtManageChild(w);
help_message = w;
break;
}
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 );
}
bool wxTextCtrl::Create(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name)
{
if( !CreateControl( parent, id, pos, size, style, validator, name ) )
return false;
PreCreation();
m_tempCallbackStruct = NULL;
m_modified = false;
m_processedDefault = false;
Widget parentWidget = (Widget) parent->GetClientWidget();
Bool wantHorizScroll = (m_windowStyle & wxHSCROLL) != 0 ? True : False;
// If we don't have horizontal scrollbars, we want word wrap.
// OpenMotif 2.1 crashes if wantWordWrap is True in Japanese
// locale (and probably other multibyte locales). The check might be
// more precise
#if wxCHECK_LESSTIF() || wxCHECK_MOTIF_VERSION( 2, 2 )
Bool wantWordWrap = wantHorizScroll == True ? False : True;
#else
Bool wantWordWrap = False;
#endif
if (m_windowStyle & wxTE_MULTILINE)
{
Arg args[8];
int count = 0;
XtSetArg (args[count], XmNscrollHorizontal, wantHorizScroll); ++count;
if( m_font.IsOk() )
XtSetArg (args[count], (String) wxFont::GetFontTag(),
m_font.GetFontType( XtDisplay(parentWidget) ) ); ++count;
XtSetArg (args[count], XmNwordWrap, wantWordWrap); ++count;
XtSetArg (args[count], XmNvalue, (const char*)value.mb_str()); ++count;
XtSetArg (args[count], XmNeditable,
style & wxTE_READONLY ? False : True); ++count;
XtSetArg (args[count], XmNeditMode, XmMULTI_LINE_EDIT ); ++count;
m_mainWidget =
(WXWidget) XmCreateScrolledText(parentWidget,
name.char_str(),
args, count);
XtManageChild ((Widget) m_mainWidget);
}
else
{
m_mainWidget = (WXWidget)XtVaCreateManagedWidget
(
name.mb_str(),
xmTextWidgetClass,
parentWidget,
wxFont::GetFontTag(), m_font.GetFontType( XtDisplay(parentWidget) ),
XmNvalue, (const char*)value.mb_str(),
XmNeditable, (style & wxTE_READONLY) ?
False : True,
NULL
);
#if 0
// TODO: Is this relevant? What does it do?
int noCols = 2;
if (!value.IsNull() && (value.length() > (unsigned int) noCols))
noCols = value.length();
XtVaSetValues((Widget) m_mainWidget,
XmNcolumns, noCols,
NULL);
#endif
}
// remove border if asked for
if ( style & wxNO_BORDER )
{
XtVaSetValues((Widget)m_mainWidget,
XmNshadowThickness, 0,
NULL);
}
// install callbacks
XtAddCallback((Widget) m_mainWidget, XmNvalueChangedCallback, (XtCallbackProc)wxTextWindowChangedProc, (XtPointer)this);
XtAddCallback((Widget) m_mainWidget, XmNmodifyVerifyCallback, (XtCallbackProc)wxTextWindowModifyProc, (XtPointer)this);
XtAddCallback((Widget) m_mainWidget, XmNactivateCallback, (XtCallbackProc)wxTextWindowActivateProc, (XtPointer)this);
XtAddCallback((Widget) m_mainWidget, XmNfocusCallback, (XtCallbackProc)wxTextWindowGainFocusProc, (XtPointer)this);
XtAddCallback((Widget) m_mainWidget, XmNlosingFocusCallback, (XtCallbackProc)wxTextWindowLoseFocusProc, (XtPointer)this);
PostCreation();
AttachWidget (parent, m_mainWidget, (WXWidget) NULL,
pos.x, pos.y, size.x, size.y);
return true;
}
void scrnInitX(void)
{
Widget toplevel, control;
Widget mb, fileMenu, viewMenu, confMenu, helpMenu;
Widget procFrame = NULL, bboxFrame = NULL;
#ifdef ICON_DEFINED
Pixmap icon;
#endif
XmString s;
Arg args[10];
unsigned i, n;
int argc = 0;
addRegwRsrcOpts();
addDatwRsrcOpts();
toplevel = XtAppInitialize(&app_context, "XSki",
options, topopts, &argc, NULL,
NULL, NULL, 0);
top_level = toplevel; /* XXX - temporary for Platform only */
XtGetApplicationResources(toplevel, &app_data,
resources, toprsrc, NULL, 0);
XtAppAddActions(app_context, actions, XtNumber(actions));
dpy = XtDisplay(toplevel);
#ifdef ICON_DEFINED
/* set default icon */
icon = XCreateBitmapFromData(dpy, RootWindowOfScreen(XtScreen(toplevel)),
icon_bits, icon_width, icon_height);
XtSetArg(args[0], XmNiconPixmap, icon);
XtSetValues(toplevel, args, 1);
#endif
#if 0
XSynchronize(dpy, True);
#endif
/* create control window manager */
control = XmCreateForm(toplevel, "control", NULL, 0);
XtManageChild(control);
/* Control window menubar */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
mb = XmCreateMenuBar(control, "mb", args, n);
XtManageChild(mb);
fileMenu = createMBitem(mb, "File");
viewMenu = createMBitem(mb, "View");
confMenu = createMBitem(mb, "Configure");
helpMenu = createMBitem(mb, "Help");
#if 0
createSubmenuItem(fileMenu, "load", loadCallback);
#else
createSubmenuItem(fileMenu, "load", 0);
#endif
createSubmenuItem(fileMenu, "save", 0);
createSubmenuItem(fileMenu, "trace", 0);
createSubmenuItem(fileMenu, "traceOn", 0);
createSubmenuItem(fileMenu, "traceOff", 0);
createSubmenuItem(fileMenu, "read", 0);
XtManageChild(XmCreateSeparatorGadget(fileMenu, "", NULL, 0));
createSubmenuItem(fileMenu, "quit", simCmdCallback);
createSubmenuItem(viewMenu, "program", programCallback);
createSubmenuItem(viewMenu, "data", dataCallback);
createSubmenuItem(viewMenu, "registers", regCallback);
createSubmenuItem(viewMenu, "cache", 0);
createSubmenuItem(viewMenu, "tlb", sdtCallback);
XtManageChild(XmCreateSeparatorGadget(viewMenu, "", NULL, 0));
createSubmenuItem(viewMenu, "callstack", cstCallback);
createSubmenuItem(viewMenu, "statistics", 0);
createSubmenuItem(viewMenu, "breakpoints", blistCallback);
createSubmenuItem(viewMenu, "branches", 0);
createSubmenuItem(viewMenu, "symbols", symlistCallback);
createSubmenuItem(viewMenu, "macros", 0);
#if 0
/* No support for window format yet */
createSubmenuItem(confMenu, "program", prgFmtCallback);
#else
createSubmenuItem(confMenu, "program", 0);
#endif
createSubmenuItem(confMenu, "data", 0);
#if 0
/* No support for window format yet */
createSubmenuItem(confMenu, "registers", regFmtCallback);
#else
createSubmenuItem(confMenu, "registers", 0);
#endif
createSubmenuItem(helpMenu, "context", 0);
createSubmenuItem(helpMenu, "overview", 0);
createSubmenuItem(helpMenu, "commands", cmdHelpCallback);
createSubmenuItem(helpMenu, "product", prodInfoCallback);
/* Control window processor option menu */
if (nproc > 1) {
Widget procMenu, proc[NPROC];
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
procFrame = XmCreateFrame(control, "", args, n);
XtManageChild(procFrame);
procMenu = XmCreatePulldownMenu(procFrame, "", NULL, 0);
for (i = 0; i < nproc; i++) {
char name[4];
(void)sprintf(name, "p%d", i);
proc[i] = XmCreatePushButton(procMenu, name, NULL, 0);
XtAddCallback(proc[i], XmNactivateCallback,
changeCprocCallback, (XtPointer)i);
}
XtManageChildren(proc, nproc);
n = 0;
XtSetArg(args[n], XmNsubMenuId, procMenu); n++;
XtManageChild(XmCreateOptionMenu(procFrame, "procOption", args, n));
}
/* Control window button box */
if (app_data.numButtons) {
Widget bbox, btns[20];
/* create button box manager */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, procFrame ? procFrame : mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
bboxFrame = XmCreateFrame(control, "", args, n);
XtManageChild(bboxFrame);
/* create button box window */
bbox = XmCreateRowColumn(bboxFrame, "bbox", NULL, 0);
XtManageChild(bbox);
/* create each button */
for (i = 0; i < app_data.numButtons; i++) {
char name[8];
(void)sprintf(name, "bb%d", i);
btns[i] = XmCreatePushButton(bbox, name, NULL, 0);
}
XtManageChildren(btns, app_data.numButtons);
}
/* Control window command area */
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget,
bboxFrame ? bboxFrame : procFrame ? procFrame : mb); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
cmd = XmCreateCommand(control, "cmd", args, n);
XtManageChild(cmd);
XtAddCallback(cmd, XmNcommandEnteredCallback, simCmdCallback, 0);
/* command history box */
n = 0;
XtSetArg(args[0], XmNinitialFocus, cmd); n++;
XtSetValues(control, args, n);
cmdHist = XmCommandGetChild(cmd, XmDIALOG_HISTORY_LIST);
/* message window */
msgs = XmCreateScrolledText(control, "msgs", NULL, 0);
XtManageChild(msgs);
n = 0;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, cmd); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetValues(XtParent(msgs), args, n);
/* create stop simulation dialog */
/* Consider changing this to a button. This would allow other
functionality to still be active when simulation is going on.
For example, Help, Quit, opening and closing windows, etc. */
stopsim = XmCreateWorkingDialog(control, "stopsim", NULL, 0);
n = 0;
XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
s = XmStringCreateLocalized("Running...");
XtSetArg(args[n], XmNdialogTitle, s); n++;
s = XmStringCreateLocalized(" icnt: 0 ");
XtSetArg(args[n], XmNmessageString, s); n++;
s = XmStringCreateLocalized("Stop");
XtSetArg(args[n], XmNcancelLabelString, s); n++;
XtSetValues(stopsim, args, n);
XtAddCallback(stopsim, XmNcancelCallback, stop_execLoopXCB, NULL);
XtUnmanageChild(XmMessageBoxGetChild(stopsim, XmDIALOG_OK_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(stopsim, XmDIALOG_HELP_BUTTON));
XmStringFree(s);
/* XXX - This should probably be inside regwInit */
for (i = 0; i < topregw; i++)
regwtbl[i].show = app_data.showRs[i];
/* XXX - This should probably be inside datwInit */
for (i = 0; i < topdatw; i++)
datwtbl[i].show = app_data.viewDw[i];
prgwInit();
datwInit();
regwInit();
if (app_data.viewProg)
prgwDrawX();
datwDrawX();
if (app_data.viewRegs)
regwDrawX();
noscreen = NO;
XtRealizeWidget(toplevel);
}
int main (int argc, char *argv[])
{
Widget topWidget;
Widget mainForm;
Widget userForm;
/* Menu Stuff */
Widget menuBar, helpMenu;
static String fallback_resources[] = {
"*sgiMode: True",
"*useSchemes: all",
NULL };
topWidget = XtVaAppInitialize(&nebulaIrcAppContext, "Nebula IRC",
NULL, 0, /* no command line options */
&argc, argv,
fallback_resources, /* fallback resource list */
NULL);
mainWindow = XtVaCreateManagedWidget("main_window",
xmMainWindowWidgetClass, topWidget,
XmNcommandWindowLocation, XmCOMMAND_BELOW_WORKSPACE,
XmNwidth, 600,
XmNheight, 500,
NULL);
/* create menu bar */
{
XmString fileMenuStr, userMenuStr, helpMenuStr;
fileMenuStr = XM_STRING_CREATE("File");
userMenuStr = XM_STRING_CREATE("User");
helpMenuStr = XM_STRING_CREATE("Help");
menuBar = XmVaCreateSimpleMenuBar(mainWindow, "menubar",
XmVaCASCADEBUTTON, fileMenuStr, 'F',
XmVaCASCADEBUTTON, userMenuStr, 'U',
NULL);
XmStringFree(fileMenuStr);
XmStringFree(userMenuStr);
XmStringFree(helpMenuStr);
}
/* File Menu */
{
XmString prefStr;
XmString saveConvStr;
XmString quitStr;
prefStr = XM_STRING_CREATE("Preferences...");
saveConvStr = XM_STRING_CREATE("Save Conversation...");
quitStr = XM_STRING_CREATE("Quit");
XmVaCreateSimplePulldownMenu(menuBar, "file_menu", 0,
fileMenuCall,
XmVaPUSHBUTTON, prefStr, 'P', NULL, NULL,
XmVaPUSHBUTTON, saveConvStr, 'S', NULL, NULL,
XmVaPUSHBUTTON, quitStr, 'Q', NULL, NULL,
NULL);
XmStringFree(prefStr);
XmStringFree(saveConvStr);
XmStringFree(quitStr);
}
/* User Menu */
{
XmString whoisStr;
XmString versionStr;
XmString opStr;
XmString deopStr;
whoisStr = XM_STRING_CREATE("Whois");
versionStr = XM_STRING_CREATE("Client version");
opStr = XM_STRING_CREATE("Op");
deopStr = XM_STRING_CREATE("Deop");
XmVaCreateSimplePulldownMenu(menuBar, "user_menu", 1,
userMenuCall,
XmVaPUSHBUTTON, whoisStr, 'W', NULL, NULL,
XmVaPUSHBUTTON, versionStr, '\0', NULL, NULL,
XmVaPUSHBUTTON, opStr, 'O', NULL, NULL,
XmVaPUSHBUTTON, deopStr, 'D', NULL, NULL,
NULL);
XmStringFree(whoisStr);
XmStringFree(versionStr);
XmStringFree(opStr);
XmStringFree(deopStr);
}
/* Help Menu */
{
XmString helpCommandStr;
XmString aboutStr;
helpCommandStr = XM_STRING_CREATE("Commands...");
aboutStr = XM_STRING_CREATE("About...");
helpMenu = XtVaCreateManagedWidget("Help",
xmCascadeButtonWidgetClass, menuBar,
XmNmnemonic, 'H',
NULL);
XmVaCreateSimplePulldownMenu(menuBar, "Help", 2,
helpMenuCall,
XmVaPUSHBUTTON, aboutStr, 'A', NULL, NULL,
XmVaPUSHBUTTON, helpCommandStr, 'C', NULL, NULL,
NULL);
XmStringFree(helpCommandStr);
XmStringFree(aboutStr);
/* now set the help button */
XtVaSetValues(menuBar, XmNmenuHelpWidget, helpMenu, NULL);
}
/* now manage the menu bar */
XtManageChild(menuBar);
/* create a form */
mainForm = XtVaCreateWidget("form", xmFormWidgetClass, mainWindow, XmNfractionBase, 3, NULL);
/* vertical split user form */
userForm = XtVaCreateWidget("userform", xmFormWidgetClass, mainForm,
XmNfractionBase, 5,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
/* output area */
{
Arg args[12];
XtSetArg(args[0], XmNeditable, False);
XtSetArg(args[1], XmNeditMode, XmMULTI_LINE_EDIT);
XtSetArg(args[2], XmNscrollHorizontal, False);
XtSetArg(args[3], XmNwordWrap, True);
XtSetArg(args[4], XmNtopAttachment, XmATTACH_POSITION);
XtSetArg(args[5], XmNtopPosition, 0);
XtSetArg(args[6], XmNbottomAttachment, XmATTACH_POSITION);
XtSetArg(args[7], XmNbottomPosition, 5);
XtSetArg(args[8], XmNleftAttachment, XmATTACH_POSITION);
XtSetArg(args[9], XmNleftPosition, 0);
XtSetArg(args[10], XmNrightAttachment, XmATTACH_POSITION);
XtSetArg(args[11], XmNrightPosition, 4);
outputArea = XmCreateScrolledText(userForm, "output", args, 12);
if (outputArea == NULL)
perror("outputArea: ");
XtManageChild(outputArea);
}
/* user list at left */
{
Arg args[9];
XtSetArg(args[0], XmNtopAttachment, XmATTACH_POSITION);
XtSetArg(args[1], XmNtopPosition, 0);
XtSetArg(args[2], XmNbottomAttachment, XmATTACH_POSITION);
XtSetArg(args[3], XmNbottomPosition, 5);
XtSetArg(args[4], XmNleftAttachment, XmATTACH_POSITION);
XtSetArg(args[5], XmNleftPosition, 4);
XtSetArg(args[6], XmNrightAttachment, XmATTACH_POSITION);
XtSetArg(args[7], XmNrightPosition, 5);
XtSetArg(args[8], XmNselectionPolicy, XmSINGLE_SELECT);
userList = XmCreateScrolledList(userForm, "list", args, 9);
XtAddCallback(userList, XmNsingleSelectionCallback, userListSelectCbk, NULL);
XtManageChild(userList);
}
XtManageChild(userForm);
XtManageChild(mainForm);
/* Command line area */
commandInput = XtVaCreateWidget("command",
xmTextFieldWidgetClass, mainWindow,
XmNmaxLength, MAX_INPUT_LEN,
NULL);
XtAddCallback(commandInput, XmNactivateCallback, commandInputCall, NULL);
XtManageChild(commandInput);
XtVaSetValues(mainWindow,
XmNmenuBar, menuBar,
XmNworkWindow, mainForm,
XmNcommandWindow, commandInput,
NULL);
XtManageChild(mainWindow);
XtRealizeWidget(topWidget);
/* initialize System Status */
sysState.isConnected = NO;
/* get some preferences */
getStartupPrefs(mainWindow);
/* set focus to input area */
/* For Motif 1.0 we should use _XmGrabTheFocus(target) according to FAQ */
XmProcessTraversal(commandInput, XmTRAVERSE_CURRENT);
/* initialize hostname and system info */
/* should switch back to ARCHOS if uname not available */
{
struct utsname sysInfo;
char tempName[2*SYSINFO_LEN];
gethostname(sysState.myHostName, MAXHOSTNAMELEN);
uname(&sysInfo);
sprintf(tempName, "%s %s running on %s", sysInfo.sysname, sysInfo.release, sysInfo.machine);
tempName[SYSINFO_LEN] = '\0';
strcpy(sysState.systemInfo, tempName);
}
/* get the user login name from unix */
{
char *tempName;
tempName = getenv("USER");
if (tempName == NULL)
tempName = getenv("LOGNAME");
if (strlen(tempName) > MAX_NAME_LEN || tempName == NULL)
{
strcpy(sysState.myUnixname, "joesmith");
printf("Failed to get a proper Unix login name. Using: %s\n", sysState.myUnixname);
}
strcpy(sysState.myUnixname, tempName);
}
/* create unmanaged dialogs */
createAboutBox(mainWindow);
createCommandsHelpBox(mainWindow);
while(1)
{
XEvent theEvent;
XtAppNextEvent(nebulaIrcAppContext, &theEvent);
XtDispatchEvent(&theEvent);
}
}
/* 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();
}
Widget Browser::createWorkArea(Widget parent)
{
Widget form1;
Widget hsb;
Widget label;
Pixel bg;
Arg wargs[50];
int n;
form1 = XtVaCreateManagedWidget("browForm", xmFormWidgetClass, parent,NULL);
n = 0;
XtSetArg(wargs[n], XmNwordWrap, False); n++;
XtSetArg(wargs[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
XtSetArg(wargs[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(wargs[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(wargs[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg(wargs[n], XmNeditable, False); n++;
XtSetArg(wargs[n], XmNcolumns, 80); n++;
XtSetArg(wargs[n], XmNrows, 16); n++;
this->text = XmCreateScrolledText(form1, "Btext", wargs, n);
XtManageChild(this->text);
XtAddCallback(this->text,
XmNmotionVerifyCallback,
Browser::motionCB,
(XtPointer)this);
XtVaGetValues(XtParent(this->text),
XmNverticalScrollBar, &this->vsb,
XmNhorizontalScrollBar, &hsb,
NULL);
XtVaGetValues(this->text,
XmNbackground, &bg,
NULL);
XtVaSetValues(this->vsb, XmNforeground, bg, NULL);
XtVaSetValues(hsb, XmNforeground, bg, NULL);
XtAddCallback(this->vsb,
XmNincrementCallback,
Browser::pageIncCB,
(XtPointer)this);
XtAddCallback(this->vsb,
XmNdecrementCallback,
Browser::pageDecCB,
(XtPointer)this);
XtAddCallback(this->vsb,
XmNpageIncrementCallback,
Browser::pageIncCB,
(XtPointer)this);
XtAddCallback(this->vsb,
XmNpageDecrementCallback,
Browser::pageDecCB,
(XtPointer)this);
XtAddCallback(this->vsb,
XmNtoTopCallback,
Browser::pageDecCB,
(XtPointer)this);
XtAddCallback(this->vsb,
XmNtoBottomCallback,
Browser::pageIncCB,
(XtPointer)this);
XtAddCallback(this->vsb,
XmNvalueChangedCallback,
Browser::pageControlCB,
(XtPointer)this);
label = XtVaCreateManagedWidget(
"browFromMark", xmLabelWidgetClass, form1,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 20,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 20,
NULL);
this->byte_mark_offset = XtVaCreateManagedWidget(
"byte_mark_offset", xmTextWidgetClass, form1,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopOffset, -2,
XmNtopWidget, label,
XmNcolumns, 8,
NULL);
XtAddCallback(this->byte_mark_offset,
XmNactivateCallback,
Browser::gotoByteMarkOffsetCB,
(XtPointer)this);
XtAddCallback(this->byte_mark_offset,
XmNmodifyVerifyCallback,
Browser::integerMVCB,
(XtPointer)this);
label = XtVaCreateManagedWidget(
"browFromMark", xmLabelWidgetClass, form1,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 20,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 70,
NULL);
this->line_mark_offset = XtVaCreateManagedWidget(
"line_mark_offset", xmTextWidgetClass, form1,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopOffset, -2,
XmNtopWidget, label,
XmNcolumns, 8,
NULL);
XtAddCallback(this->line_mark_offset,
XmNactivateCallback,
Browser::gotoLineMarkOffsetCB,
(XtPointer)this);
XtAddCallback(this->line_mark_offset,
XmNmodifyVerifyCallback,
Browser::integerMVCB,
(XtPointer)this);
label = XtVaCreateManagedWidget(
"browFromStartOfLine", xmLabelWidgetClass, form1,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, label,
XmNbottomOffset, 10,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 20,
NULL);
this->byte_start_offset = XtVaCreateManagedWidget(
"byte_start_offset", xmTextWidgetClass, form1,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, label,
XmNtopOffset, -2,
XmNcolumns, 8,
NULL);
XtAddCallback(this->byte_start_offset,
XmNactivateCallback,
Browser::gotoByteStartOffsetCB,
(XtPointer)this);
XtAddCallback(this->byte_start_offset,
XmNmodifyVerifyCallback,
Browser::integerMVCB,
(XtPointer)this);
label = XtVaCreateManagedWidget(
"browFromTopOfFile", xmLabelWidgetClass, form1,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, label,
XmNbottomOffset, 10,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 20,
NULL);
this->byte_top_offset = XtVaCreateManagedWidget(
"byte_top_offset", xmTextWidgetClass, form1,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, label,
XmNtopOffset, -2,
XmNcolumns, 8,
NULL);
XtAddCallback(this->byte_top_offset,
XmNactivateCallback,
Browser::gotoByteTopOffsetCB,
(XtPointer)this);
XtAddCallback(this->byte_top_offset,
XmNmodifyVerifyCallback,
Browser::integerMVCB,
(XtPointer)this);
label = XtVaCreateManagedWidget(
"browFromTopOfFile", xmLabelWidgetClass, form1,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, label,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 70,
NULL);
this->line_top_offset = XtVaCreateManagedWidget(
"line_top_offset", xmTextWidgetClass, form1,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, label,
XmNleftOffset, 10,
XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNtopWidget, label,
XmNtopOffset, -2,
XmNcolumns, 8,
NULL);
XtAddCallback(this->line_top_offset,
XmNactivateCallback,
Browser::gotoLineTopOffsetCB,
(XtPointer)this);
XtAddCallback(this->line_top_offset,
XmNmodifyVerifyCallback,
Browser::integerMVCB,
(XtPointer)this);
label = XtVaCreateManagedWidget(
"browByteOffsets", xmLabelWidgetClass, form1,
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, label,
XmNbottomOffset, 10,
XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNrightWidget, this->byte_top_offset,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, this->byte_top_offset,
XmNleftOffset, -10,
XmNrightOffset, -10,
NULL);
label = XtVaCreateManagedWidget(
"browLineOffsets", xmLabelWidgetClass, form1,
XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNbottomWidget, label,
XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNrightWidget, this->line_top_offset,
XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
XmNleftWidget, this->line_top_offset,
XmNleftOffset, -10,
XmNrightOffset, -10,
NULL);
XtVaSetValues(XtParent(this->text),
XmNbottomAttachment, XmATTACH_WIDGET,
XmNbottomWidget, label,
XmNbottomOffset, 10,
NULL);
Browser::AddHelpCallbacks(form1);
return form1;
}
/***************************************************************************
Creates the process message dialog and callbacks. Although many
static items like signal names are set up, values for various fields
like the priority and and process information are reassigned only
after a particular process is selected.
***************************************************************************/
Widget
create_process_menu(Widget parent, char *name)
{
Widget form;
#include "help/process_window.h"
#ifdef HAVE_KILL
int i;
XmStringTable xmstr;
xmstr = ( XmString * ) XtMalloc (sizeof ( XmString ) * sigmap_elts ) ;
for ( i = 0; i < sigmap_elts; i++ ) {
xmstr[i] = XmStringCreateLtoR ( signal_map[i].signal_name,
XmFONTLIST_DEFAULT_TAG );
}
#endif
/* Create the dialog widget. */
process_dialog = XmCreateMessageDialog ( parent, name, NULL, 0 );
XtAddCallback(process_dialog, XmNokCallback, do_process_action_callback,
&dialog_signal_pos);
XtAddCallback(process_dialog, XmNcancelCallback, do_process_cancel_callback,
NULL);
XtAddCallback(process_dialog, XmNhelpCallback, help_callback,
process_window_help);
/*
Remove unneeded buttons and children.
*/
/* This is something along the top line */
XtUnmanageChild( XmMessageBoxGetChild ( process_dialog,
XmDIALOG_SYMBOL_LABEL ) );
XtUnmanageChild( XmMessageBoxGetChild ( process_dialog,
XmDIALOG_MESSAGE_LABEL ) );
/* Create a manager widget as a child of the dialog, to be used
as the work area of the dialog, replacing the label and icon.
*/
process_form = XtVaCreateManagedWidget( "form", xmFormWidgetClass,
process_dialog, NULL ) ;
form =
XtVaCreateManagedWidget("processForm", xmFormWidgetClass,
process_form,
XmNorientation, XmVERTICAL,
XmNtopAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
/* Widget for ps info. XmCreateText doesn't do variable args.
So set up a local temp argument array. Uck! Motif sucks. */
{
Arg args[20];
int n = 0;
XtSetArg(args[n], XmNeditable, False); n++;
XtSetArg(args[n], XmNcursorPositionVisible, False); n++;
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); n++;
XtSetArg(args[n], XmNscrollHorizontal, True); n++;
XtSetArg(args[n], XmNscrollVertical, True); n++;
XtSetArg(args[n], XmNtraversalOn, True); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNbottomWidget, form); n++;
/* done as X resource, but must be done.
XtSetArg(args[n], XmNwidth, 8000); n++;
XtSetArg(args[n], XmNheight, 1000); n++;
XtSetArg(args[n], XmNunitType, Xm100TH_FONT_UNITS); n++;
*/
XtSetArg(args[n], XmNvisualPolicy, XmVARIABLE); n++;
XtSetArg(args[n], XmNscrollingPolicy, XmAUTOMATIC); n++;
XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmAS_NEEDED); n++;
ps_info = XmCreateScrolledText(process_form, "PsInfo", args, n);
XmTextSetString(ps_info, "");
}
#ifdef HAVE_KILL
signal_list = XmCreateScrolledList( form, "signal_list", NULL, 0 );
XtManageChild(signal_list);
XtVaSetValues(signal_list,
XmNitems, xmstr,
XmNitemCount, sigmap_elts,
XmNvisibleItemCount, 6,
XmNselectionPolicy, XmSINGLE_SELECT,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, ps_info,
XmNtopAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_FORM,
NULL );
for ( i = 0; i < sigmap_elts; i++ ) {
XmStringFree ( xmstr[i] );
}
XtFree((char *) xmstr);
XtAddCallback( signal_list, XmNdefaultActionCallback,
SignalListCallback, &dialog_signal_pos);
XtAddCallback( signal_list, XmNsingleSelectionCallback,
SignalListCallback, &dialog_signal_pos);
#endif
/* Priority slider */
priority_slider =
XtVaCreateManagedWidget ("priority", xmScaleWidgetClass, form,
XtVaTypedArg, XmNtitleString,
XmRString, "priority",
10,
XmNmaximum, PRIO_MAX,
XmNminimum, PRIO_MIN,
XmNvalue, 10, /* Will be reset later */
XmNshowValue, True,
XmNorientation, XmVERTICAL,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_WIDGET,
/* We use XtParent() below because of some (all?) Lesstif
complaints. XmCreateScrolledList seems to creates
a scrolled widgets parent and a list widget child and returns
the list widget. */
#ifdef HAVE_KILL
XmNleftWidget, XtParent(signal_list),
#endif
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtAddCallback(priority_slider, XmNdragCallback,
set_priority_callback, NULL);
XtAddCallback(priority_slider, XmNvalueChangedCallback,
set_priority_callback, NULL);
/* Process group identifier */
process_group_button =
XtVaCreateManagedWidget ("process group", xmToggleButtonWidgetClass,
form,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, priority_slider,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_NONE,
NULL);
XtAddCallback(process_group_button, XmNvalueChangedCallback,
toggle_button_callback, &do_process_group);
#ifdef HAVE_SETPRIORITY
priority_button =
XtVaCreateManagedWidget ("set priority", xmToggleButtonWidgetClass,
form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, process_group_button,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, priority_slider,
XmNrightAttachment, XmATTACH_NONE,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XtAddCallback(priority_button, XmNvalueChangedCallback,
toggle_button_callback, &do_priority);
#endif
return(process_dialog);
}
main (int argc, char *argv[])
{
Widget top, main_w, rc, text_w, label_w;
XtAppContext app;
XmString file, open, exit;
Arg args[10];
int n;
//XtSetLanguageProc (NULL, NULL, NULL);
/* initialize toolkit and create toplevel shell */
top = XtVaOpenApplication (&app, "Demos", NULL, 0, &argc, argv, NULL,
sessionShellWidgetClass, NULL);
/*
main_w = XmCreateMainWindow (top, "main_w", NULL, 0);
rc = XmCreateRowColumn (main_w, "work_area", NULL, 0);
*/
#if 0
n = 0;
XtSetArg (args[n], XmNorientation, XmVERTICAL/*XmHORIZONTAL*/);
n++;
XtSetArg (args[n], XmNresizeHeight, True);
n++;
rc = XmCreateRowColumn (top, "work_area", args, n);
#endif
n = 0;
rc = XmCreateFrame (top, "work_area", args, n);
/*
n = 0;
//XtSetArg (args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
XtSetArg (args[n], XmNtopAttachment, XmATTACH_FORM); n++;
label_w = XmCreateLabel (rc, "Filename:", args, n);
XtManageChild (label_w);
*/
n = 0;
XtSetArg (args[n], XmNframeChildType, XmFRAME_TITLE_CHILD);
n++;
XtSetArg (args[n], XmNchildVerticalAlignment, XmALIGNMENT_CENTER);
n++;
label_w = XmCreateLabelGadget (rc, "!!! TITLE !!!", args, n);
XtManageChild (label_w);
/* Create ScrolledText -- this is work area for the MainWindow */
#if 1
n = 0;
XtSetArg (args[n], XmNrows, 12);
n++;
XtSetArg (args[n], XmNcolumns, 70);
n++;
XtSetArg (args[n], XmNeditMode, XmMULTI_LINE_EDIT);
n++;
XtSetArg (args[n], XmNtopAttachment, label_w/*XmATTACH_FORM*/);
n++;
text_w = XmCreateScrolledText (rc, "text_w", args, n);
XtManageChild (text_w);
#endif
XtManageChild (rc);
XtRealizeWidget (top);
XtAppMainLoop (app);
}
int main(int argc, char *argv[])
{
Arg al[20];
int ac;
int canvaswidth, canvasheight;
/* read command line options */
if (Read_options (argc, argv) != 0)
exit (-1);
/* create the toplevel shell */
toplevel = XtAppInitialize(&context, "", NULL, 0,
&argc, argv, NULL, NULL, 0);
CS_error((void (*) ()) printf);
printf("We serve line %d\n", Cur_link_ind);
SIM_init (In_lb, Out_lb);
/* default window size. */
ac = 0;
canvaswidth = 400;
canvasheight = 700;
XtSetArg(al[ac], XmNheight, canvaswidth);
ac++;
XtSetArg(al[ac], XmNwidth, canvasheight);
ac++;
XtSetValues(toplevel, al, ac);
/* create a form widget. */
ac = 0;
form = XmCreateForm(toplevel, "form", al, ac);
XtManageChild(form);
/* create a menu bar and attach it to the form. */
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM);
ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM);
ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM);
ac++;
menu_bar = XmCreateMenuBar(form, "menu_bar", al, ac);
XtManageChild(menu_bar);
/* create a textshow widget and attach it to the form. */
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET);
ac++;
XtSetArg(al[ac], XmNtopWidget, menu_bar);
ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM);
ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION);
ac++;
XtSetArg(al[ac], XmNleftPosition, 0);
ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_POSITION);
ac++;
XtSetArg(al[ac], XmNbottomPosition, 93);
ac++;
XtSetArg(al[ac], XmNeditMode, XmMULTI_LINE_EDIT);
ac++;
textshow = XmCreateScrolledText(form, "text", al, ac);
XtManageChild(textshow);
XmTextSetEditable(textshow, False);
Create_menus(menu_bar);
XtAppAddTimeOut(context,
950,
(XtTimerCallbackProc) timer_callback,
(XtPointer) NULL);
XtRealizeWidget(toplevel);
XtAppMainLoop(context);
return (0);
}
/*
** Create a dialog for the output of a shell command. The dialog lives until
** the user presses the Dismiss button, and is then destroyed
*/
static void createOutputDialog(Widget parent, char *text)
{
Arg al[50];
int ac, rows, cols, hasScrollBar, wrapped;
Widget form, textW, button;
XmString st1;
/* measure the width and height of the text to determine size for dialog */
measureText(text, MAX_OUT_DIALOG_COLS, &rows, &cols, &wrapped);
if (rows > MAX_OUT_DIALOG_ROWS) {
rows = MAX_OUT_DIALOG_ROWS;
hasScrollBar = True;
} else
hasScrollBar = False;
if (cols > MAX_OUT_DIALOG_COLS)
cols = MAX_OUT_DIALOG_COLS;
if (cols == 0)
cols = 1;
/* Without completely emulating Motif's wrapping algorithm, we can't
be sure that we haven't underestimated the number of lines in case
a line has wrapped, so let's assume that some lines could be obscured
*/
if (wrapped)
hasScrollBar = True;
ac = 0;
form = CreateFormDialog(parent, "shellOutForm", al, ac);
ac = 0;
XtSetArg(al[ac], XmNlabelString, st1=MKSTRING("OK")); ac++;
XtSetArg(al[ac], XmNmarginWidth, BUTTON_WIDTH_MARGIN); ac++;
XtSetArg(al[ac], XmNhighlightThickness, 0); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_NONE); ac++;
button = XmCreatePushButtonGadget(form, "ok", al, ac);
XtManageChild(button);
XtVaSetValues(form, XmNdefaultButton, button, NULL);
XtVaSetValues(form, XmNcancelButton, button, NULL);
XmStringFree(st1);
XtAddCallback(button, XmNactivateCallback, destroyOutDialogCB,
XtParent(form));
ac = 0;
XtSetArg(al[ac], XmNrows, rows); ac++;
XtSetArg(al[ac], XmNcolumns, cols); ac++;
XtSetArg(al[ac], XmNresizeHeight, False); ac++;
XtSetArg(al[ac], XmNtraversalOn, False); ac++;
XtSetArg(al[ac], XmNwordWrap, True); ac++;
XtSetArg(al[ac], XmNscrollHorizontal, False); ac++;
XtSetArg(al[ac], XmNscrollVertical, hasScrollBar); ac++;
XtSetArg(al[ac], XmNhighlightThickness, 0); ac++;
XtSetArg(al[ac], XmNspacing, 0); ac++;
XtSetArg(al[ac], XmNeditMode, XmMULTI_LINE_EDIT); ac++;
XtSetArg(al[ac], XmNeditable, False); ac++;
XtSetArg(al[ac], XmNvalue, text); ac++;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomWidget, button); ac++;
textW = XmCreateScrolledText(form, "outText", al, ac);
AddMouseWheelSupport(textW);
XtManageChild(textW);
XtVaSetValues(XtParent(form), XmNtitle, "Output from Command", NULL);
ManageDialogCenteredOnPointer(form);
}
void view_all_messages( /*@unused@*/ Widget w, /*@unused@*/ XtPointer clientData, /*@unused@*/ XtPointer callData) {
Widget pane, my_form, button_close, dist, dist_units;
Widget option_box, tnc_data, net_data, tnc_net_data,
read_mine_only_button;
unsigned int n;
#define NCNT 50
#define IncN(n) if (n< NCNT) n++; else fprintf(stderr, "Oops, too many arguments for array!\a")
Arg args[NCNT];
Atom delw;
char temp[10];
if (!All_messages_dialog) {
begin_critical_section(&All_messages_dialog_lock, "view_message_gui.c:view_all_messages" );
All_messages_dialog = XtVaCreatePopupShell(langcode("AMTMW00001"),
xmDialogShellWidgetClass, appshell,
XmNdeleteResponse, XmDESTROY,
XmNdefaultPosition, FALSE,
XmNfontList, fontlist1,
NULL);
pane = XtVaCreateWidget("view_all_messages pane",
xmPanedWindowWidgetClass,
All_messages_dialog,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
NULL);
my_form = XtVaCreateWidget("view_all_messages my_form",
xmFormWidgetClass,
pane,
XmNfractionBase, 5,
XmNautoUnmanage, FALSE,
XmNshadowThickness, 1,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
NULL);
dist = XtVaCreateManagedWidget(langcode("AMTMW00002"),
xmLabelWidgetClass,
my_form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 10,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_NONE,
XmNtraversalOn, FALSE,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
XmNfontList, fontlist1,
NULL);
vm_dist_data = XtVaCreateManagedWidget("view_all_messages dist_data",
xmTextFieldWidgetClass,
my_form,
XmNeditable, TRUE,
XmNcursorPositionVisible, TRUE,
XmNsensitive, TRUE,
XmNshadowThickness, 1,
XmNcolumns, 8,
XmNwidth, ((8*7)+2),
XmNmaxLength, 8,
XmNbackground, colors[0x0f],
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 5,
XmNbottomAttachment,XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, dist,
XmNleftOffset, 10,
XmNrightAttachment,XmATTACH_NONE,
XmNfontList, fontlist1,
NULL);
dist_units = XtVaCreateManagedWidget((english_units?langcode("UNIOP00004"):langcode("UNIOP00005")),
xmLabelWidgetClass,
my_form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 10,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, vm_dist_data,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_NONE,
XmNtraversalOn, FALSE,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
XmNfontList, fontlist1,
NULL);
button_range = XtVaCreateManagedWidget(langcode("BULMW00003"),
xmPushButtonGadgetClass,
my_form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 5,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, dist_units,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_NONE,
XmNnavigationType, XmTAB_GROUP,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
XmNfontList, fontlist1,
NULL);
XtAddCallback(button_range, XmNactivateCallback, All_messages_change_range, All_messages_dialog);
button_close = XtVaCreateManagedWidget(langcode("UNIOP00003"),
xmPushButtonGadgetClass,
my_form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 5,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, button_range,
XmNleftOffset, 10,
XmNrightAttachment, XmATTACH_FORM,
XmNnavigationType, XmTAB_GROUP,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
XmNfontList, fontlist1,
NULL);
XtAddCallback(button_close, XmNactivateCallback, All_messages_destroy_shell, All_messages_dialog);
n=0;
XtSetArg(args[n],XmNforeground, MY_FG_COLOR); n++;
XtSetArg(args[n],XmNbackground, MY_BG_COLOR); n++;
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); n++;
XtSetArg(args[n], XmNtopWidget, dist); n++;
XtSetArg(args[n], XmNtopOffset, 5); n++;
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); n++;
XtSetArg(args[n], XmNleftOffset, 5); n++;
XtSetArg(args[n], XmNrightAttachment, XmATTACH_NONE); n++;
XtSetArg(args[n], XmNfontList, fontlist1); n++;
option_box = XmCreateRadioBox(my_form,
"Vew Messages option box",
args,
n);
XtVaSetValues(option_box,
XmNpacking, XmPACK_TIGHT,
XmNorientation, XmHORIZONTAL,
NULL);
tnc_data = XtVaCreateManagedWidget(langcode("WPUPDPD002"),
xmToggleButtonGadgetClass,
option_box,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
XmNfontList, fontlist1,
NULL);
XtAddCallback(tnc_data,XmNvalueChangedCallback,Read_messages_packet_toggle,"1");
net_data = XtVaCreateManagedWidget(langcode("WPUPDPD003"),
xmToggleButtonGadgetClass,
option_box,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
XmNfontList, fontlist1,
NULL);
XtAddCallback(net_data,XmNvalueChangedCallback,Read_messages_packet_toggle,"2");
tnc_net_data = XtVaCreateManagedWidget(langcode("WPUPDPD004"),
xmToggleButtonGadgetClass,
option_box,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
XmNfontList, fontlist1,
NULL);
XtAddCallback(tnc_net_data,XmNvalueChangedCallback,Read_messages_packet_toggle,"0");
read_mine_only_button = XtVaCreateManagedWidget(langcode("WPUPDPD008"),
xmToggleButtonGadgetClass,
my_form,
XmNvisibleWhenOff, TRUE,
XmNindicatorSize, 12,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, dist,
XmNtopOffset, 10,
XmNbottomAttachment, XmATTACH_NONE,
XmNleftAttachment, XmATTACH_WIDGET,
XmNleftWidget, option_box,
XmNleftOffset, 20,
XmNrightAttachment, XmATTACH_NONE,
MY_FOREGROUND_COLOR,
MY_BACKGROUND_COLOR,
XmNfontList, fontlist1,
NULL);
XtAddCallback(read_mine_only_button,XmNvalueChangedCallback,Read_messages_mine_only_toggle,"1");
n=0;
XtSetArg(args[n], XmNrows, 15); IncN(n);
XtSetArg(args[n], XmNcolumns, 85); IncN(n);
XtSetArg(args[n], XmNeditable, FALSE); IncN(n);
XtSetArg(args[n], XmNtraversalOn, TRUE); IncN(n);
XtSetArg(args[n], XmNlistSizePolicy, XmVARIABLE); IncN(n);
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT); IncN(n);
XtSetArg(args[n], XmNwordWrap, TRUE); IncN(n);
XtSetArg(args[n], XmNscrollHorizontal, TRUE); IncN(n);
XtSetArg(args[n], XmNscrollVertical, TRUE); IncN(n);
// XtSetArg(args[n], XmNscrollBarDisplayPolicy, XmSTATIC); IncN(n);
XtSetArg(args[n], XmNselectionPolicy, XmMULTIPLE_SELECT); IncN(n);
XtSetArg(args[n], XmNcursorPositionVisible, FALSE); IncN(n);
XtSetArg(args[n], XmNtopAttachment, XmATTACH_WIDGET); IncN(n);
XtSetArg(args[n], XmNtopWidget, option_box); IncN(n);
XtSetArg(args[n], XmNtopOffset, 5); IncN(n);
XtSetArg(args[n], XmNbottomAttachment, XmATTACH_FORM); IncN(n);
XtSetArg(args[n], XmNleftAttachment, XmATTACH_FORM); IncN(n);
XtSetArg(args[n], XmNleftOffset, 5); IncN(n);
XtSetArg(args[n], XmNrightAttachment, XmATTACH_FORM); IncN(n);
XtSetArg(args[n], XmNrightOffset, 5); IncN(n);
XtSetArg(args[n], XmNforeground, MY_FG_COLOR); IncN(n);
XtSetArg(args[n], XmNbackground, MY_BG_COLOR); IncN(n);
XtSetArg(args[n], XmNfontList, fontlist1); n++;
view_messages_text = XmCreateScrolledText(my_form,
"view_all_messages text",
args,
n);
// It's hard to get tab groups working with ScrolledText widgets. Tab'ing in is
// fine, but then I'm stuck in insert mode and it absorbs the tabs and beeps.
pos_dialog(All_messages_dialog);
delw = XmInternAtom(XtDisplay(All_messages_dialog),"WM_DELETE_WINDOW", FALSE);
XmAddWMProtocolCallback(All_messages_dialog, delw, All_messages_destroy_shell, (XtPointer)All_messages_dialog);
sprintf(temp,"%d",vm_range);
XmTextFieldSetString(vm_dist_data,temp);
switch (Read_messages_packet_data_type) {
case(0):
XmToggleButtonSetState(tnc_net_data,TRUE,FALSE);
break;
case(1):
XmToggleButtonSetState(tnc_data,TRUE,FALSE);
break;
case(2):
XmToggleButtonSetState(net_data,TRUE,FALSE);
break;
default:
XmToggleButtonSetState(tnc_net_data,TRUE,FALSE);
break;
}
if (Read_messages_mine_only) {
XmToggleButtonSetState(read_mine_only_button,TRUE,FALSE);
XtSetSensitive(vm_dist_data, FALSE);
}
else {
XmToggleButtonSetState(read_mine_only_button,FALSE,FALSE);
XtSetSensitive(vm_dist_data, TRUE);
}
XtManageChild(option_box);
XtManageChild(view_messages_text);
XtVaSetValues(view_messages_text, XmNbackground, colors[0x0f], NULL);
XtManageChild(my_form);
XtManageChild(pane);
redraw_on_new_packet_data=1;
// Dump all currently active messages to the new window
view_message_display_file('M');
end_critical_section(&All_messages_dialog_lock, "view_message_gui.c:view_all_messages" );
XtPopup(All_messages_dialog,XtGrabNone);
// fix_dialog_vsize(All_messages_dialog);
// Move focus to the Close button. This appears to highlight the
// button fine, but we're not able to hit the <Enter> key to
// have that default function happen. Note: We _can_ hit the
// <SPACE> key, and that activates the option.
// XmUpdateDisplay(All_messages_dialog);
XmProcessTraversal(button_close, XmTRAVERSE_CURRENT);
}
else {
(void)XRaiseWindow(XtDisplay(All_messages_dialog), XtWindow(All_messages_dialog));
}
}
void showtextwin(Widget parent)
{
Widget pane, text_w, form, button, toggle;
Arg args[10];
int n=0;
char *textptr=NULL;
if (!textdialog) {
/* Create dialog */
textdialog = XtVaCreatePopupShell("text_win",
topLevelShellWidgetClass, parent, NULL);
/* Create a pane to hold things (dialogs can only have 1 manager) */
pane = XtVaCreateWidget("text_pane", xmPanedWindowWidgetClass,
textdialog, XmNsashWidth, 1, XmNsashHeight, 1, NULL);
/* Create a form to hold the text area */
form = XtVaCreateWidget("text_form1", xmFormWidgetClass, pane, NULL);
/* Create text area */
XtSetArg(args[n], XmNrows, 20);
n++;
XtSetArg(args[n], XmNcolumns, 70);
n++;
XtSetArg(args[n], XmNeditable, False);
n++;
XtSetArg(args[n], XmNeditMode, XmMULTI_LINE_EDIT);
n++;
text_w = XmCreateScrolledText(form, "text_w", args, n);
/* Attach text area Note the parent here */
XtVaSetValues(XtParent(text_w),
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
XtManageChild(text_w);
XtManageChild(form);
/* A form to hold our toggle button */
form = XtVaCreateWidget("text_form2", xmFormWidgetClass, pane, NULL);
/* make a radio button for editing */
toggle = XtVaCreateManagedWidget("Editable",
xmToggleButtonWidgetClass, form, NULL);
/* Store the text area */
XtVaSetValues(toggle, XmNuserData, text_w, NULL);
XtVaSetValues(toggle,
XmNleftAttachment, XmATTACH_FORM,
XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
/*
* We'll add the callback below since we need the Apply button
* to be passed to the callback
*/
XtManageChild(form);
/* Create a form to hold the buttons */
form = XtVaCreateWidget("text_form3", xmFormWidgetClass, pane,
XmNfractionBase, 9, NULL);
/* Create Buttons at the bottom */
/* OK, Apply, Cancel, Reset, Save */
button = XtVaCreateManagedWidget("OK", xmPushButtonWidgetClass,
form, XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 1,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 2, NULL);
XtAddCallback(button, XmNactivateCallback, text_ok, NULL);
button = XtVaCreateManagedWidget("Apply", xmPushButtonWidgetClass,
form, XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 2,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 3, NULL);
XtAddCallback(button, XmNactivateCallback, text_apply, NULL);
XtSetSensitive(button, False);
XtAddCallback(toggle, XmNvalueChangedCallback, text_toggled, button);
button = XtVaCreateManagedWidget("Cancel", xmPushButtonWidgetClass,
form, XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 3,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 4, NULL);
XtAddCallback(button, XmNactivateCallback, text_cancel, NULL);
button = XtVaCreateManagedWidget("Reset", xmPushButtonWidgetClass,
form, XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 4,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 5, NULL);
XtAddCallback(button, XmNactivateCallback, text_reset, NULL);
button = XtVaCreateManagedWidget("Save", xmPushButtonWidgetClass,
form, XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 5,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 6, NULL);
XtAddCallback(button, XmNactivateCallback, text_save, NULL);
button = XtVaCreateManagedWidget("Print", xmPushButtonWidgetClass,
form, XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 6,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 7, NULL);
XtAddCallback(button, XmNactivateCallback, text_print, NULL);
button = XtVaCreateManagedWidget("CSV", xmPushButtonWidgetClass,
form, XmNtopAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 7,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 8, NULL);
XtAddCallback(button, XmNactivateCallback, text_cvf, NULL);
XtManageChild(form);
/* Manage the pane or else nothing will show up */
XtManageChild(pane);
}
/* Populate the text window in case it is visible */
textptr = createtextsounding();
set_textareatext(textptr);
free(textptr);
/* Make it visible */
XtPopup(textdialog, XtGrabNone);
}
int
main(int argc, char **argv)
{
Widget toplevel, form, mb, tf, sl, st, cb, menu, pb;
XtAppContext app;
Arg al[10];
int ac;
XtSetLanguageProc(NULL, NULL, NULL);
toplevel = XtVaAppInitialize(&app, "Phone", NULL, 0, &argc, argv, NULL, NULL);
form = XtVaCreateManagedWidget("form", xmFormWidgetClass, toplevel,
XmNwidth, 450,
XmNheight, 300,
XmNresizable, True,
XmNfractionBase, 3,
NULL);
mb = XtVaCreateManagedWidget("mb", xmRowColumnWidgetClass, form,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 0,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 0,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 0,
XmNrowColumnType, XmMENU_BAR,
NULL);
tf = XtVaCreateManagedWidget("tf", xmTextFieldWidgetClass, form,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopOffset, 0,
XmNtopWidget, mb,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 0,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 0,
NULL);
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, tf); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_POSITION); ac++;
XtSetArg(al[ac], XmNrightPosition, 1); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
sl = XmCreateScrolledList(form, "sl", al, ac);
XtManageChild(sl);
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, tf); ac++;
XtSetArg(al[ac], XmNtopOffset, 0); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, XtParent(sl)); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightOffset, 0); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomOffset, 0); ac++;
st = XmCreateScrolledText(form, "st", al, ac);
XtManageChild(st);
ac = 0;
menu = XmCreatePulldownMenu(mb, "menu", al, ac);
cb = XtVaCreateManagedWidget("cb", xmCascadeButtonGadgetClass, mb,
XmNsubMenuId, menu,
NULL);
pb = XtVaCreateManagedWidget("quit", xmPushButtonGadgetClass, menu,
NULL);
XtAddCallback(pb, XmNactivateCallback, Quit, NULL);
XtRealizeWidget(toplevel);
{
static XtWidgetGeometry Expected[] = {
{CWWidth | CWHeight, 0, 0, 450, 300, 0,0,0, /* Form */},
{CWWidth | CWHeight | CWX | CWY, 0, 0, 450, 31, 0,0,0, /* two */},
{CWWidth | CWHeight | CWX | CWY, 5, 5, 28, 21, 0,0,0, /* two */},
{CWWidth | CWHeight | CWX | CWY, 0, 31, 450, 31, 0,0,0, /* two */},
{CWWidth | CWHeight | CWX | CWY, 0, 62, 150, 238, 0,0,0, /* two */},
{CWWidth | CWHeight | CWX | CWY, 0, 0, 150, 238, 0,0,0, /* two */},
{CWWidth | CWHeight | CWX | CWY, 150, 62, 300, 238, 0,0,0, /* two */},
{CWWidth | CWHeight | CWX | CWY, 0, 223, 300, 15, 0,0,0, /* two */},
{CWWidth | CWHeight | CWX | CWY, 0, 0, 300, 219, 0,0,0, /* two */},
{CWWidth | CWHeight | CWX | CWY, 0, 0, 0, 0, 0,0,0, /* two */},
};
PrintDetails(toplevel, Expected);
}
XtAddCallback(st, XmNfocusCallback, Focus, "in");
XtAddCallback(st, XmNlosingFocusCallback, Focus, "out");
XtAddCallback(tf, XmNfocusCallback, Focus, "in");
XtAddCallback(tf, XmNlosingFocusCallback, Focus, "out");
LessTifTestMainLoop(toplevel);
exit(0);
}
