static Widget
CreateMainWindowWithMenuBar(Widget toplevel)
{
Widget main_window, menu_bar, menu_pane, cascade, button ;
Arg args[20];
Cardinal n;
/* Create MainWindow.
*/
n = 0;
main_window = XmCreateMainWindow (toplevel, "main_window", args, n);
XtManageChild (main_window);
/* Create MenuBar in MainWindow.
*/
n = 0;
menu_bar = XmCreateMenuBar (main_window, "menu_bar", args, n);
XtManageChild (menu_bar);
/* Create "File" PulldownMenu.
*/
n = 0;
menu_pane = XmCreatePulldownMenu (menu_bar, "menu_pane", args, n);
n = 0;
button = XmCreatePushButton (menu_pane, "Exit", args, n);
XtManageChild (button);
XtAddCallback (button, XmNactivateCallback, QuitCB, NULL);
n = 0;
XtSetArg (args[n], XmNsubMenuId, menu_pane); n++;
cascade = XmCreateCascadeButton (menu_bar, "File", args, n);
XtManageChild (cascade);
/* Create "Help" PulldownMenu.
*/
n = 0;
menu_pane = XmCreatePulldownMenu (menu_bar, "menu_pane3", args, n);
n = 0;
button = XmCreatePushButton (menu_pane, "Overview", args, n);
XtManageChild (button);
XtAddCallback (button, XmNactivateCallback, HelpCB, NULL);
n = 0;
XtSetArg (args[n], XmNsubMenuId, menu_pane); n++;
cascade = XmCreateCascadeButton (menu_bar, "Help", args, n);
XtManageChild (cascade);
n = 0;
XtSetArg (args[n], XmNmenuHelpWidget, cascade); n++;
XtSetValues (menu_bar, args, n);
return main_window ;
}
void CreateMainW(Widget w, String name)
{
Widget Form, MenuBar, Label, FileCascade, FileMenu;
Widget Cascade, CascadeMenu, wch;
Form = XmCreateForm(w, name, NULL, 0);
MenuBar = XmCreateMenuBar(Form, "menubar", NULL, 0);
XtVaSetValues(MenuBar,
XmNtopAttachment, XmATTACH_FORM,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
NULL);
Label = XmCreateLabel(Form, "ExtTest Test Application", NULL, 0);
XtVaSetValues(Label,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, MenuBar,
XmNleftAttachment, XmATTACH_FORM,
XmNrightAttachment, XmATTACH_FORM,
XmNbottomAttachment, XmATTACH_FORM,
NULL);
FileCascade = XmCreateCascadeButton(MenuBar, "File", NULL, 0);
FileMenu = XmCreatePulldownMenu(MenuBar, "filemenu", NULL, 0);
XtVaSetValues(FileCascade, XmNsubMenuId, FileMenu, NULL);
Cascade = XmCreateCascadeButton(FileMenu, "Cascade", NULL, 0);
XtManageChild(Cascade);
XtManageChild(wch = XmCreatePushButton(FileMenu, "Modeless Dialog", NULL, 0));
XtAddCallback(wch, XmNactivateCallback, DoDialogCB, (XtPointer) XmDIALOG_MODELESS);
XtManageChild(wch = XmCreatePushButton(FileMenu, "Two Modeless Dialogs", NULL, 0));
XtAddCallback(wch, XmNactivateCallback, DoDialogCB, (XtPointer) 42);
XtManageChild(wch = XmCreatePushButton(FileMenu, "Two Modeless Dialogs Cascaded", NULL, 0));
XtAddCallback(wch, XmNactivateCallback, DoDialogCB, (XtPointer) 43);
XtManageChild(wch = XmCreatePushButton(FileMenu, "Application Modal Dialog", NULL, 0));
XtAddCallback(wch, XmNactivateCallback, DoDialogCB, (XtPointer) XmDIALOG_APPLICATION_MODAL);
XtManageChild(wch = XmCreatePushButton(FileMenu, "Two Application Modal Dialogs", NULL, 0));
XtAddCallback(wch, XmNactivateCallback, DoDialogCB, (XtPointer) 44);
XtManageChild(wch = XmCreatePushButton(FileMenu, "Full Application Modal Dialog", NULL, 0));
XtAddCallback(wch, XmNactivateCallback, DoDialogCB, (XtPointer) XmDIALOG_FULL_APPLICATION_MODAL);
XtManageChild(XmCreatePushButton(FileMenu, "Quit", NULL, 0));
CascadeMenu = XmCreatePulldownMenu(FileMenu, "cascademenu", NULL, 0);
XtVaSetValues(Cascade, XmNsubMenuId, CascadeMenu, NULL);
XtManageChild(XmCreatePushButton(CascadeMenu, "Test1", NULL, 0));
XtManageChild(wch = XmCreatePushButton(CascadeMenu, "Test2", NULL, 0));
XtAddCallback(wch, XmNarmCallback, DumpCB, (XtPointer) NULL);
XtManageChild(FileCascade);
XtManageChild(MenuBar);
XtManageChild(Label);
XtManageChild(Form);
} /* CreateMainW */
void create_feature_menu(Widget parent)
{
Widget feature_menu_pane, feature_button, area_button, feature_sep_1, perimeter_button,
feature_sep_2, ctomass_button, feature_sep_3, moments_button, feature_sep_4,
circular_button;
/* Create the menu pane for the menu */
feature_menu_pane = XmCreatePulldownMenu(parent, "feature menu pane", NULL, 0);
/* Populate the menu pane */
area_button = XmCreatePushButton(feature_menu_pane, "Area", NULL, 0);
XtManageChild(area_button);
XtAddCallback(area_button, XmNactivateCallback,
(XtCallbackProc) activate_area_callback, (XtPointer) NULL);
/* Separator 1 */
feature_sep_1 = XmCreateSeparator(feature_menu_pane, "feature sep 1", NULL, 0);
XtManageChild(feature_sep_1);
perimeter_button = XmCreatePushButton(feature_menu_pane, "Perimeter", NULL, 0);
XtManageChild(perimeter_button);
XtAddCallback(perimeter_button, XmNactivateCallback,
(XtCallbackProc) activate_perimeter_callback, (XtPointer) NULL);
/* Separator 2*/
feature_sep_2 = XmCreateSeparator(feature_menu_pane, "feature sep 2", NULL, 0);
XtManageChild(feature_sep_2);
ctomass_button = XmCreatePushButton(feature_menu_pane, "Ctomass", NULL, 0);
XtManageChild(ctomass_button);
XtAddCallback(ctomass_button, XmNactivateCallback,
(XtCallbackProc) activate_ctomass_callback, (XtPointer) NULL);
/* Separator3*/
feature_sep_3 = XmCreateSeparator(feature_menu_pane, "feature sep 3", NULL, 0);
XtManageChild(feature_sep_3);
moments_button = XmCreatePushButton(feature_menu_pane, "Moments", NULL, 0);
XtManageChild(moments_button);
XtAddCallback(moments_button, XmNactivateCallback,
NULL /*(XtCallbackProc) activate_moments_callback */, (XtPointer) NULL);
/* Separator4*/
feature_sep_4 = XmCreateSeparator(feature_menu_pane, "feature sep 4", NULL, 0);
XtManageChild(feature_sep_4);
circular_button = XmCreatePushButton(feature_menu_pane, "Circular", NULL, 0);
XtManageChild(circular_button);
XtAddCallback(circular_button, XmNactivateCallback,
(XtCallbackProc) activate_circular_callback, (XtPointer) NULL);
/* Create the featurea cascade button on the menu bar and */
/* attach the about menu pane to it. */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, feature_menu_pane); argcount++;
feature_button = XmCreateCascadeButton(parent, "Feature ", args, argcount);
/* XtManageChild(feature_button); */
}
void create_about_menu(Widget parent)
{
Widget about_menu_pane, about_menu_button, version_button,help_button;
/* Create the menu pane for the menu */
about_menu_pane = XmCreatePulldownMenu(parent, "Help ", NULL, 0);
help_button = XmCreatePushButton(about_menu_pane, "Help", NULL, 0);
XtManageChild(help_button);
/* Populate the menu pane */
/* Version button */
version_button = XmCreatePushButton(about_menu_pane, "Version", NULL, 0);
XtManageChild(version_button);
/* Create the version dialog and add the activation function as */
/* the version button's activate callback. */
create_version_dialog(parent);
XtAddCallback(version_button, XmNactivateCallback,
(XtCallbackProc) activate_version_dialog, (XtPointer) NULL);
XtAddCallback(help_button, XmNactivateCallback,
(XtCallbackProc) help_moi, (XtPointer) NULL);
/* Create the about cascade button on the menu bar and */
/* attach the about menu pane to it. */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, about_menu_pane); argcount++;
about_menu_button = XmCreateCascadeButton(parent, "Help ", args, argcount);
XtManageChild(about_menu_button);
}
void create_multi_menu(Widget parent)
{
Widget multi_menu_pane, inverse_button, multi_menu_button, twofile_button, merg_button;
/* Create the menu pane for the menu */
multi_menu_pane = XmCreatePulldownMenu(parent, "MultiImage ", NULL, 0);
/* Populate the menu pane */
/* Version button */
twofile_button = XmCreatePushButton(multi_menu_pane, "Compare f1&f2=>f3", NULL, 0);
XtManageChild(twofile_button);
merg_button = XmCreatePushButton(multi_menu_pane, "Merge f1&f2=>f3", NULL, 0);
XtManageChild(merg_button);
/* Create the version dialog and add the activation function as */
/* the version button's activate callback. */
XtAddCallback(twofile_button, XmNactivateCallback,
(XtCallbackProc) multi_window_callback, (XtPointer) NULL);
XtAddCallback(merg_button, XmNactivateCallback,
(XtCallbackProc) multi_merge_callback, (XtPointer) NULL);
inverse_button = XmCreatePushButton(multi_menu_pane, "Inverse f1=>-f1", NULL, 0);
XtManageChild(inverse_button);
/* Create the version dialog and add the activation function as */
/* the version button's activate callback. */
XtAddCallback(inverse_button, XmNactivateCallback,
(XtCallbackProc) inverse_callback, (XtPointer) NULL);
/* Create the about cascade button on the menu bar and */
/* attach the about menu pane to it. */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, multi_menu_pane); argcount++;
multi_menu_button = XmCreateCascadeButton(parent, "MultiImage ", args, argcount);
XtManageChild(multi_menu_button);
}
void guitst_createUserItems ( Widget parent )
/************************************************************************
* guitst_createUserItems *
* *
* This function first calls user function named user_func() which *
* calls guitst_AddUserItem() to save user items in buffer and then *
* adds them to the program *
* *
* void guitst_createUserItems(parent) *
* *
* Input parameters: *
* *
* parent Widget parent widget id *
* *
* Output parameters: *
* NONE *
* *
* Return parameters: *
* *
** Log: *
* S. Wang/GSC 10/97 *
***********************************************************************/
{
int i, num;
Pixel bg;
Widget button;
user_item_t *item_pt;
/*---------------------------------------------------------------------*/
/*
* user_func() is a user function that is manditory
* by guitst.c
*/
/* user_func(); */
XtVaGetValues(parent, XmNbackground, &bg, NULL);
num = _userInfo.num;
for ( i=0;i< num ;i++ ) {
item_pt = &(_userInfo.useritem[i]);
if ( item_pt->create_func != NULL )
item_pt->create_func(parent);
button = XmCreateCascadeButton( _menuBar,
item_pt->btn_name, NULL, 0 );
XtVaSetValues( button, XmNbackground, bg, NULL );
XtManageChild( button );
if ( item_pt->callback_func != NULL )
XtAddCallback( button, XmNactivateCallback,
item_pt->callback_func, NULL );
}
return;
}
PulldownMenu::PulldownMenu(std::string name, MenuBar* menuBar)
{
Arg args[1];
widget = XmCreatePulldownMenu(menuBar->getWidget(), (char*)name.c_str(), NULL, 0);
XtSetArg(args[0], XmNsubMenuId, widget);
cascadeButton = XmCreateCascadeButton(menuBar->getWidget(), (char*)name.c_str(), args, 1);
XtManageChild(cascadeButton);
}
void guitst_createMain ( Widget parent )
/************************************************************************
* guitst_createMain *
* *
* This function creates the main window *
* *
* void guitst_createMain( parent ) *
* *
* Input parameters: *
* *
* parent Widget parent widget id *
* *
* Output parameters: *
* NONE *
* *
* Return parameters: *
* *
** Log: *
* S. Wang/GSC 10/97 *
***********************************************************************/
{
Widget main_w, button;
Pixel bg;
long ii;
/*---------------------------------------------------------------------*/
main_w = XtVaCreateWidget("mainw_pane",
xmPanedWindowWidgetClass, parent,
XmNsashWidth, 1,
XmNsashHeight, 1,
NULL, 0);
_menuBar = XmCreateMenuBar(main_w, "menubar", NULL, 0);
XtVaGetValues(parent, XmNbackground, &bg, NULL);
XtVaSetValues(_menuBar, XmNbackground, bg, NULL);
/*
* create Exit button
*/
button = XmCreateCascadeButton( _menuBar,
"Exit", NULL, 0 );
XtVaSetValues( button, XmNbackground, bg, NULL );
XtManageChild( button );
XtAddCallback( button, XmNactivateCallback,
guitst_exitCb, (XtPointer)ii );
XtManageChild( _menuBar );
guitst_createCanvas( main_w );
XtManageChild( main_w );
}
void create_window_menu(Widget parent)
{
Widget dump_button, window_menu_pane, window_menu_button, operate_pane, operate_menu_button, cascade_button, tile_button, operate_button, delete_button, reduce_button;
/* Create the menu pane for the menu */
window_menu_pane = XmCreatePulldownMenu(parent, "Window ", NULL, 0);
operate_pane = XmCreatePulldownMenu(parent, "Operate ", NULL, 0);
/* Populate the menu pane */
/* Version button */
cascade_button = XmCreatePushButton(window_menu_pane, "Cascade", NULL, 0);
XtManageChild(cascade_button);
XtAddCallback(cascade_button, XmNactivateCallback,
(XtCallbackProc) cascade_callback, (XtPointer) NULL);
tile_button = XmCreatePushButton(window_menu_pane, "Tile", NULL, 0);
XtManageChild(tile_button);
XtAddCallback(tile_button, XmNactivateCallback,
(XtCallbackProc) tile_callback, (XtPointer) NULL);
operate_button = XmCreatePushButton(operate_pane, "Operate on", NULL, 0);
XtManageChild(operate_button);
XtAddCallback(operate_button, XmNactivateCallback,
(XtCallbackProc) operate_callback, (XtPointer) NULL);
delete_button = XmCreatePushButton(window_menu_pane, "Deallocate one file", NULL, 0);
XtManageChild(delete_button);
XtAddCallback(delete_button, XmNactivateCallback,
(XtCallbackProc) delete_callback, (XtPointer) NULL);
dump_button = XmCreatePushButton(window_menu_pane, "Deallocate all files", NULL, 0);
XtManageChild(dump_button);
XtAddCallback(dump_button, XmNactivateCallback,
(XtCallbackProc) dump_callback, (XtPointer) NULL);
reduce_button = XmCreatePushButton(window_menu_pane, "Reduce/Enlarge all files", NULL, 0);
XtManageChild(reduce_button);
XtAddCallback(reduce_button, XmNactivateCallback,
(XtCallbackProc) red_callback, (XtPointer) NULL);
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, operate_pane); argcount++;
operate_menu_button = XmCreateCascadeButton(parent, "Selector ", args, argcount);
XtManageChild(operate_menu_button);
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, window_menu_pane); argcount++;
window_menu_button = XmCreateCascadeButton(parent, "Window ", args, argcount);
XtManageChild(window_menu_button);
}
void create_tools_menu(Widget parent)
{
Widget tools_menu_pane, tools_menu_button,
editing_tools_button, region_cut_button, zoom_button,
tools_sep_1, tools_sep_2;
/* Create the menu pane for the menu */
tools_menu_pane = XmCreatePulldownMenu(parent, "tools menu pane", NULL, 0);
/* Create the representation cascade button on the menu bar and */
/* Editing tools button */
editing_tools_button = XmCreatePushButton(tools_menu_pane,
"Editing Tools ", NULL, 0);
XtManageChild(editing_tools_button);
/* Create the editing tools window and add the activation function as */
/* the editing tools button's activate callback. */
create_editing_tools_window(parent);
XtAddCallback(editing_tools_button, XmNactivateCallback,
(XtCallbackProc) activate_editing_tools_window, (XtPointer) NULL);
/* Separator 1 */
tools_sep_1 = XmCreateSeparator(tools_menu_pane, "tools sep 1", NULL, 0);
XtManageChild(tools_sep_1);
/* Region cut button*/
region_cut_button = XmCreatePushButton(tools_menu_pane,
"Region Cut", NULL, 0);
/* XtManageChild(region_cut_button); */
XtAddCallback(region_cut_button, XmNactivateCallback,
(XtCallbackProc) region_cut_callback, (XtPointer) NULL);
/* Separator 2 */
tools_sep_2 = XmCreateSeparator(tools_menu_pane, "tools sep 2", NULL, 0);
XtManageChild(tools_sep_2);
/* Zoom button */
zoom_button = XmCreatePushButton(tools_menu_pane, "Zoom ... ", NULL, 0);
XtManageChild(zoom_button);
create_zoom_dialog(parent);
XtAddCallback(zoom_button, XmNactivateCallback,
(XtCallbackProc) activate_zoom_dialog, (XtPointer) NULL);
/* attach the tools menu pane to it. */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, tools_menu_pane); argcount++;
tools_menu_button = XmCreateCascadeButton(parent, "Tools ", args, argcount);
XtManageChild(tools_menu_button);
}
Widget CreateMenu(Widget parent, char* name)
{
Widget cascade, menuwidget;
Arg args[20];
int n = 0;
menuwidget = XmCreatePulldownMenu(parent, name, args, n);
n=0;
XtSetArg(args[n], XmNsubMenuId, menuwidget); n++;
cascade = XmCreateCascadeButton(parent, name, args, n);
XtManageChild(cascade);
return menuwidget;
}
static Widget createMBitem(Widget parent, char *name)
{
Widget menu, btn;
Arg arg;
menu = XmCreatePulldownMenu(parent, "", NULL, 0);
XtSetArg(arg, XmNsubMenuId, menu);
btn = XmCreateCascadeButton(parent, name, &arg, 1);
XtManageChild(btn);
if (!strcmp(name, "Help")) {
XtSetArg(arg, XmNmenuHelpWidget, btn);
XtSetValues(parent, &arg, 1);
}
return menu;
}
void structGuiOptionMenu :: f_init (GuiForm parent, int left, int right, int top, int bottom, unsigned long flags)
{
d_shell = parent -> d_shell;
d_parent = parent;
d_options = Ordered_create ();
#if gtk
d_widget = gtk_combo_box_new_text ();
gtk_widget_set_size_request (GTK_WIDGET (d_widget), right - left, bottom - top + 8);
gtk_fixed_put (GTK_FIXED (parent -> d_widget), GTK_WIDGET (d_widget), left, top - 6);
gtk_combo_box_set_focus_on_click (GTK_COMBO_BOX (d_widget), false);
GTK_WIDGET_UNSET_FLAGS (d_widget, GTK_CAN_DEFAULT);
#elif cocoa
d_widget = (GuiObject) [GuiCocoaOptionMenu alloc];
v_positionInForm (d_widget, left, right, top, bottom, parent);
[(GuiCocoaOptionMenu *) d_widget setUserData: this];
[(NSTextField *) d_widget setBezelStyle: NSRoundedBezelStyle];
[(NSTextField *) d_widget setBordered: NO];
[(NSTextField *) d_widget setSelectable: NO];
#elif motif
d_xmMenuBar = XmCreateMenuBar (parent -> d_widget, "UiOptionMenu", NULL, 0);
XtVaSetValues (d_xmMenuBar, XmNx, left - 4, XmNy, top - 4
#if mac
- 1
#endif
, XmNwidth, right - left + 8, XmNheight, bottom - top + 8, NULL);
d_xmCascadeButton = XmCreateCascadeButton (d_xmMenuBar, "choice", NULL, 0);
d_widget = XmCreatePulldownMenu (d_xmMenuBar, "choice", NULL, 0);
if (flags & GuiMenu_INSENSITIVE)
XtSetSensitive (d_widget, False);
XtVaSetValues (d_xmCascadeButton, XmNsubMenuId, d_widget, NULL);
XtManageChild (d_xmCascadeButton);
XtVaSetValues (d_xmMenuBar, XmNwidth, right - left + 8, NULL); // BUG: twice?
XtVaSetValues (d_xmCascadeButton, XmNx, 4, XmNy, 4, XmNwidth, right - left, XmNheight, bottom - top, NULL);
#endif
#if gtk
g_signal_connect (G_OBJECT (d_widget), "destroy", G_CALLBACK (_guiGtkOptionMenu_destroyCallback), this);
#elif cocoa
#elif motif
XtAddCallback (d_widget, XmNdestroyCallback, _guiMotifOptionMenu_destroyCallback, this);
#endif
}
/*F-------------------------------------------------------------------------
* Function: xGRwidget_menubar_mini ()
* -always present menu buttons in graphik part
* -
* In: -parent widget
* out: -
* Return: -
*---------------------------------------------------------------------------
*/
Widget xGRwidget_menubar_mini( Widget parent )
{
extern char *xgrLabelTable[][XGRLABMAXTEXTS];
extern GRAWIDGETS grawidgets;
Widget minimenu, pulldown[8], pullbutton[8], cascadebutton[8];
Arg args[6];
int i, n, ac;
XmString xmstr;
static ACTCALLBACK actminicallback[] = {
{BUTTONFILE, BUTTONFILE_CANCEL },
{BUTTONZOOM, BUTTONZOOM_START },
{BUTTONZOOM, BUTTONZOOM_ZOOM },
{BUTTONZOOM, BUTTONZOOM_LAST },
{BUTTONZOOM, BUTTONZOOM_NEXT },
{BUTTONHILFE, BUTTONHILFE_GRAPHIK }
};
/*---- menubar --------*/
minimenu = XmCreateMenuBar(parent, GRAPHIKMENUBAR, 0, 0);
/*---- build an ONE line menu -----------------------------------------*/
for (i=0; i<XtNumber(actminicallback); i++) {
/*--- pulldown ----*/
xmstr = XmStringCreateSimple( xgrLabelTable[_GR_MINI_MENU][i]);
/*-- menubar cascade button -----*/
ac = 0;
XtSetArg(args[ac], XmNlabelString, xmstr); ac++;
XtSetArg(args[ac], XmNmnemonic, ' '); ac++;
cascadebutton[i] = XmCreateCascadeButton( minimenu, GRAPHIKPUSHBUTTON, args, ac);
XtManageChild(cascadebutton[i]);
XtAddCallback(cascadebutton[i], XmNactivateCallback,
(XtCallbackProc)xGRaction, (XtPointer)&actminicallback[i]);
XmStringFree( xmstr);
}
/*---- Help right justified ---------*/
ac = 0;
XtSetArg(args[ac], XmNmenuHelpWidget, cascadebutton[XtNumber(actminicallback)-1]); ac++;
XtSetValues( minimenu, args, ac);
return( minimenu);
}
static Widget Make_menu(char *menu_name, Widget menu_bar)
{
int ac;
Arg al[10];
Widget menu, cascade;
ac = 0;
menu = XmCreatePulldownMenu(menu_bar, menu_name, al, ac);
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, menu);
ac++;
XtSetArg(al[ac], XmNlabelString,
XmStringCreateLtoR(menu_name, char_set));
ac++;
cascade = XmCreateCascadeButton(menu_bar, menu_name, al, ac);
XtManageChild(cascade);
return (menu);
}
APP_WIDGET appMakeMenuInParent( APP_WIDGET * pButton,
AppToplevel * at,
APP_WIDGET menuBar,
const char * itemText,
int isHelp )
{
APP_WIDGET menu;
APP_WIDGET button;
XmString labelString;
Arg al[20];
int ac= 0;
labelString= XmStringCreateLocalized( (char *)itemText );
ac= 0;
menu= XmCreatePulldownMenu( menuBar, WIDGET_NAME, al, ac );
if ( ! menu )
{ XDEB(menu); return menu; }
ac= 0;
XtSetArg( al[ac], XmNlabelString, labelString ); ac++;
XtSetArg( al[ac], XmNsubMenuId, menu ); ac++;
button= XmCreateCascadeButton( menuBar, WIDGET_NAME, al, ac );
XtManageChild( button );
if ( isHelp )
{
XtVaSetValues( menuBar,
XmNmenuHelpWidget, button,
NULL );
}
XmStringFree( labelString );
*pButton= button;
return menu;
}
static Widget CreateCascade(char *label, char mnemonic, Widget submenu,
Widget parent)
{
Widget widget;
register int n;
Arg args[MAX_ARGS];
XmString tcs;
n = 0;
tcs = XmStringLtoRCreate(label, XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, tcs);
n++;
XtSetArg(args[n], XmNmnemonic, mnemonic);
n++;
XtSetArg(args[n], XmNsubMenuId, submenu);
n++;
widget = XmCreateCascadeButton(parent, label, args, n);
XtManageChild(widget);
XmStringFree(tcs);
return(widget);
}
void create_flasher(Widget parent)
{
Widget flasher_pane;
Display *display;
/* Create the menu pane for the menu */
flasher_pane = XmCreatePulldownMenu(parent, "Flasher", NULL, 0);
display=XtDisplay(parent);
cov = XCreatePixmapFromBitmapData(display,
DefaultRootWindow(display),
log_bits, log_width, log_height,
BlackPixel(display,DefaultScreen(display)),
WhitePixel(display,DefaultScreen(display)),
DefaultDepth(display,DefaultScreen(display)));
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, flasher_pane); argcount++;
XtSetArg(args[argcount], XmNmarginHeight, 0); argcount++;
XtSetArg(args[argcount], XmNlabelType,XmPIXMAP); argcount++;
XtSetArg(args[argcount], XmNlabelPixmap, cov); argcount++;
flasher_button = XmCreateCascadeButton(parent,NULL, args, argcount);
XtManageChild(flasher_button);
}
/**************************************************************
* DaCreateGui:
**************************************************************/
Widget DaCreateGui(char * name,
char * aclass,
int argc,
char ** argv,
Display * display)
{
Arg args[15];
Widget widget_array[10];
int n;
/***************** object of type : ApplicationShell *****************/
n = 0;
/* Setup argc & argv attribute */
XtSetArg(args[n], XtNargc, argc); n++;
XtSetArg(args[n], XtNargv, argv); n++;
widget_array[WI_DAINPUT] =
XtAppCreateShell(name, aclass, applicationShellWidgetClass,
display, args, n);
/***************** mainWindow : XmMainWindow *****************/
widget_array[WI_MAINWINDOW] =
XmCreateMainWindow(widget_array[WI_DAINPUT], "mainWindow", NULL, 0);
/***************** menuBar : XmMenuBar *****************/
widget_array[WI_MENUBAR] =
XmCreateMenuBar(widget_array[WI_MAINWINDOW], "menuBar", NULL, 0);
/***************** File : XmCascadeButton *****************/
widget_array[WI_FILE] =
XmCreateCascadeButton(widget_array[WI_MENUBAR], "File", NULL, 0);
/***************** fileMenu : XmPulldownMenu *****************/
widget_array[WI_FILEMENU] =
XmCreatePulldownMenu(widget_array[WI_MENUBAR], "fileMenu", NULL, 0);
{
Arg args[1];
XtSetArg(args[0], XmNsubMenuId, widget_array[WI_FILEMENU]);
XtSetValues(widget_array[WI_FILE], args, 1);
}
/***************** Exit : XmPushButton *****************/
widget_array[WI_EXIT] =
XmCreatePushButton(widget_array[WI_FILEMENU], "Exit", NULL, 0);
XtAddCallback(widget_array[WI_EXIT],
XmNactivateCallback, DaExit, NULL);
/***************** Help : XmCascadeButton *****************/
widget_array[WI_HELP] =
XmCreateCascadeButton(widget_array[WI_MENUBAR], "Help", NULL, 0);
/***************** helpMenu : XmPulldownMenu *****************/
widget_array[WI_HELPMENU] =
XmCreatePulldownMenu(widget_array[WI_MENUBAR], "helpMenu", NULL, 0);
{
Arg args[1];
XtSetArg(args[0], XmNsubMenuId, widget_array[WI_HELPMENU]);
XtSetValues(widget_array[WI_HELP], args, 1);
}
/***************** Overview : XmPushButton *****************/
widget_array[WI_OVERVIEW] =
XmCreatePushButton(widget_array[WI_HELPMENU], "Overview", NULL, 0);
XtAddCallback(widget_array[WI_OVERVIEW],
XmNactivateCallback, DaOverView, NULL);
/***************** workArea : XmDrawingArea *****************/
n = 0;
XtSetArg(args[n], XmNwidth, 300); n++;
XtSetArg(args[n], XmNheight, 35); n++;
widget_array[WI_WORKAREA] =
XmCreateDrawingArea(widget_array[WI_MAINWINDOW], "workArea", args, n);
/*
* Register drawing area for input method support and set input
* context values.
*/
XmImRegister(widget_array[WI_WORKAREA], 0);
{
Pixel bg, fg;
Pixmap bg_pixmap;
n = 0;
XtSetArg(args[n], XmNbackground, &bg); n++;
XtSetArg(args[n], XmNforeground, &fg); n++;
XtSetArg(args[n], XmNbackgroundPixmap, &bg_pixmap);n++;
XtGetValues(widget_array[WI_WORKAREA], args, n);
n = 0;
XtSetArg(args[n], XmNbackground, bg); n++;
XtSetArg(args[n], XmNforeground, fg); n++;
XtSetArg(args[n], XmNbackgroundPixmap, bg_pixmap);n++;
XmImSetValues(widget_array[WI_WORKAREA], args, n);
}
/*
* Add event handler for focus events. This is needed for the
* input method to correctly display the input area.
*/
XtAddEventHandler(widget_array[WI_WORKAREA],
EnterWindowMask|LeaveWindowMask|FocusChangeMask,
False, DaFocusHandler, NULL);
XtAddCallback(widget_array[WI_WORKAREA],
XmNexposeCallback, DaRedrawText, NULL);
XtAddCallback(widget_array[WI_WORKAREA],
XmNinputCallback, DaInputText, NULL);
XtAddCallback(widget_array[WI_WORKAREA],
XmNresizeCallback, DaResizedText, NULL);
/***************** menuBar : XmMenuBar *****************/
n = 0;
XtSetArg(args[n], XmNmenuHelpWidget, widget_array[WI_HELP]); n++;
XtSetValues(widget_array[WI_MENUBAR], args, n);
XtManageChild(widget_array[WI_EXIT]);
XtManageChild(widget_array[WI_FILE]);
XtManageChild(widget_array[WI_OVERVIEW]);
XtManageChild(widget_array[WI_HELP]);
XtManageChild(widget_array[WI_MENUBAR]);
XtManageChild(widget_array[WI_WORKAREA]);
XtManageChild(widget_array[WI_MAINWINDOW]);
/*
* Return the first created widget.
*/
return widget_array[WI_DAINPUT];
}
void
create_appShell (Display *display, char *app_name, int app_argc, char **app_argv)
{
Widget children[12]; /* Children to manage */
Arg al[64]; /* Arg List */
register int ac = 0; /* Arg Count */
char from_s [256]; /* For font list conversion */
XrmValue from_value, to_value; /* ditto */
int fg, bg; /* colour values for pixmaps */
XmString *list_items; /* For list items */
int list_item; /* Index for list_items */
XmString xmstrings[15]; /* temporary storage for XmStrings */
Widget widget1 = (Widget)NULL;
Widget widget2 = (Widget)NULL;
Widget widget3 = (Widget)NULL;
Widget widget7 = (Widget)NULL;
Widget widget8 = (Widget)NULL;
Widget widget9 = (Widget)NULL;
Widget widget10 = (Widget)NULL;
Widget widget11 = (Widget)NULL;
Widget widget12 = (Widget)NULL;
Widget generateButton = (Widget)NULL;
Widget deleteButton = (Widget)NULL;
Widget browseButton = (Widget)NULL;
Widget widget13 = (Widget)NULL;
Widget widget14 = (Widget)NULL;
Widget widget15 = (Widget)NULL;
Widget widget16 = (Widget)NULL;
Widget widget17 = (Widget)NULL;
Widget nameLabel = (Widget)NULL;
Widget textLabel = (Widget)NULL;
Widget severityLabel = (Widget)NULL;
Widget widget25 = (Widget)NULL;
Widget widget27 = (Widget)NULL;
Widget widget28 = (Widget)NULL;
Widget widget29 = (Widget)NULL;
Widget widget30 = (Widget)NULL;
Widget widget31 = (Widget)NULL;
Widget widget32 = (Widget)NULL;
Widget widget33 = (Widget)NULL;
Widget moduleLabel = (Widget)NULL;
Widget widget37 = (Widget)NULL;
Widget *modbutton; /* replaces 38-49 */
Widget categoryLabel = (Widget)NULL;
Widget descriptionLabel = (Widget)NULL;
Widget toolMenu = (Widget)NULL;
Widget toolCascade = (Widget)NULL;
Widget lockMenu = (Widget)NULL;
Widget lockCascade = (Widget)NULL;
Widget unlockButton = (Widget)NULL;
Widget lockButton = (Widget)NULL;
int imod;
XtSetArg(al[ac], XmNallowShellResize, TRUE); ac++;
XtSetArg(al[ac], XmNargc, app_argc); ac++;
XtSetArg(al[ac], XmNargv, app_argv); ac++;
appShell = XtAppCreateShell ( app_name, "EditMessage", applicationShellWidgetClass, display, al, ac );
ac = 0;
XtSetArg(al[ac], XmNscrollingPolicy, XmAUTOMATIC); ac++;
widget1 = XmCreateMainWindow ( appShell, "mainWindow", al, ac );
ac = 0;
XtSetArg(al[ac], XmNhorizontalScrollBar, &widget2 ); ac++;
XtSetArg(al[ac], XmNverticalScrollBar, &widget3 ); ac++;
XtGetValues(widget1, al, ac );
ac = 0;
widget7 = XmCreateMenuBar ( widget1, "widget7", al, ac );
widget9 = XmCreatePulldownMenu ( widget7, "fileMenu", al, ac );
/*
XtAddCallback(widget9, XmNunmapCallback, grab_input, NULL);
*/
widget10 = XmCreatePushButton ( widget9, "openButton", al, ac );
widget11 = XmCreatePushButton ( widget9, "newButton", al, ac );
ac = 0; XtSetArg(al[ac], XmNsensitive, False); ac++;
widget12 = XmCreatePushButton ( widget9, "saveButton", al, ac );
ac = 0; XtSetArg(al[ac], XmNsensitive, False); ac++;
deleteButton = XmCreatePushButton ( widget9, "deleteButton", al, ac );
ac = 0;
widget13 = XmCreateSeparator ( widget9, "widget13", al, ac );
widget14 = XmCreatePushButton ( widget9, "exitButton", al, ac );
XtSetArg(al[ac], XmNsubMenuId, widget9); ac++;
widget8 = XmCreateCascadeButton ( widget7, "fileCascade", al, ac );
ac = 0;
toolMenu = XmCreatePulldownMenu ( widget7, "toolMenu", al, ac );
/*
XtAddCallback(toolMenu, XmNunmapCallback, grab_input, NULL);
*/
generateButton = XmCreatePushButton ( toolMenu, "generateButton", al, ac );
browseButton = XmCreatePushButton ( toolMenu, "browseButton", al, ac );
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, toolMenu); ac++;
toolCascade = XmCreateCascadeButton ( widget7, "toolCascade", al, ac );
lockMenu = XmCreatePulldownMenu ( widget7, "lockMenu", al, ac );
/*
XtAddCallback(widget9, XmNunmapCallback, grab_input, NULL);
*/
lockButton = XmCreatePushButton ( lockMenu, "lockButton", al, ac );
ac = 0; XtSetArg(al[ac], XmNsensitive, False); ac++;
unlockButton = XmCreatePushButton ( lockMenu, "unlockButton", al, ac );
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, lockMenu); ac++;
lockCascade = XmCreateCascadeButton ( widget7, "lockCascade", al, ac );
ac = 0;
widget16 = XmCreatePulldownMenu ( widget7, "widget16", al, ac );
/*
XtAddCallback(widget16, XmNunmapCallback, grab_input, NULL);
*/
XtSetArg(al[ac], XmNsubMenuId, widget16); ac++;
widget15 = XmCreateCascadeButton ( widget7, "helpCascade", al, ac );
/* Hand-added */
XtVaSetValues(widget7, XmNmenuHelpWidget, widget15, NULL);
ac = 0;
widget17 = XmCreateForm ( widget1, "editMsgForm", al, ac );
XtSetArg(al[ac], XmNwidth, 100); ac++;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
nameLabel = XmCreateLabel ( widget17, "nameLabel", al, ac );
ac = 0;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
textLabel = XmCreateLabel ( widget17, "textLabel", al, ac );
ac = 0;
XtSetArg(al[ac], XmNmaxLength, 20); ac++;
nameTextField = XmCreateTextField( widget17, "nameTextField", al, ac );
XtAddCallback(nameTextField, XmNvalueChangedCallback, message_modified,
NULL);
ac = 0;
XtSetArg(al[ac], XmNmaxLength, 50); ac++;
msgTextField = XmCreateTextField ( widget17, "msgTextField", al, ac );
XtAddCallback(msgTextField, XmNvalueChangedCallback, message_modified,
NULL);
ac = 0;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
severityLabel = XmCreateLabel ( widget17, "severityLabel", al, ac );
ac = 0;
severityMenu = XmCreatePulldownMenu ( widget17, "severityPulldown", al, ac );
/*
XtAddCallback(severityMenu, XmNunmapCallback, grab_input, NULL);
*/
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_DEBUG);
widget27 = XmCreatePushButton ( severityMenu, "debugButton", al, 1);
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_INFORM);
widget28 = XmCreatePushButton ( severityMenu, "informButton", al, 1 );
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_WARN);
widget29 = XmCreatePushButton ( severityMenu, "warnButton", al, 1 );
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_ERROR);
widget30 = XmCreatePushButton ( severityMenu, "errorButton", al, 1 );
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_ALARM);
widget31 = XmCreatePushButton ( severityMenu, "alarmButton", al, 1 );
XtSetArg(al[0], XmNuserData, (caddr_t)SEV_FATAL);
widget32 = XmCreatePushButton ( severityMenu, "fatalButton", al, 1 );
ac = 0;
XtSetArg(al[ac], XmNuserData, (caddr_t)SEV_UNKNOWN); ac++;
/* "Unknown" is only allowed if it is found in the DB */
XtSetArg(al[ac], XmNsensitive, FALSE); ac++;
widget33 = XmCreatePushButton (severityMenu, "unknownButton", al, ac );
ac = 0;
XtSetArg(al[ac], XmNsubMenuId, severityMenu); ac++;
severityOptionMenu = XmCreateOptionMenu ( widget17, "severityOptionMenu", al, ac );
ac = 0;
widget25 = XmOptionButtonGadget ( severityOptionMenu );
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
moduleLabel = XmCreateLabel ( widget17, "moduleLabel", al, ac );
ac = 0;
moduleMenu = XmCreatePulldownMenu ( widget17, "moduleMenu", al, ac );
/*
XtAddCallback(moduleMenu, XmNunmapCallback, grab_input, NULL);
*/
/* Create the button for the chosen module as the default.
*/
if (strcmp(module_names[0], g_module)) {
for (imod=0; imod<nmodule_names; imod++)
if (!strcmp(module_names[imod], g_module)) break;
strcpy(module_names[imod], module_names[0]);
strcpy(module_names[0], g_module);
}
modbutton = (Widget *)XtMalloc(nmodule_names * sizeof(Widget));
for (imod = 0; imod < nmodule_names; imod++) {
XtSetArg(al[0], XmNuserData, module_names[imod]);
modbutton[imod] = XmCreatePushButton(moduleMenu, module_names[imod],
al, 1 );
}
XtSetArg(al[ac], XmNsubMenuId, moduleMenu); ac++;
moduleOptionMenu = XmCreateOptionMenu ( widget17, "moduleOptionMenu", al, ac );
ac = 0;
widget37 = XmOptionButtonGadget ( moduleOptionMenu );
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
categoryLabel = XmCreateLabel ( widget17, "categoryLabel", al, ac );
ac = 0;
categoryTextField = XmCreateTextField ( widget17, "categoryTextField", al, ac );
XtAddCallback(categoryTextField, XmNvalueChangedCallback,
message_modified, NULL);
XtSetArg(al[ac], XmNwidth, 101); ac++;
XtSetArg(al[ac], XmNalignment, XmALIGNMENT_END); ac++;
descriptionLabel = XmCreateLabel ( widget17, "descriptionLabel", al, ac );
ac = 0;
XtSetArg(al[ac], XmNmaxLength, 255); ac++;
descriptionText = XmCreateText ( widget17, "descriptionText", al, ac );
XtAddCallback(descriptionText, XmNvalueChangedCallback,
message_modified, NULL);
ac = 0;
children[ac++] = widget10;
children[ac++] = widget11;
children[ac++] = widget12;
children[ac++] = deleteButton;
children[ac++] = widget13;
children[ac++] = widget14;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = generateButton;
children[ac++] = browseButton;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = unlockButton;
children[ac++] = lockButton;
XtManageChildren(children, ac);
ac = 0;
children[ac++] = widget8;
children[ac++] = widget15;
children[ac++] = toolCascade;
children[ac++] = lockCascade;
XtManageChildren(children, ac);
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, nameTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, nameTextField); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, nameTextField); ac++;
XtSetValues ( nameLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, msgTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, msgTextField); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, msgTextField); ac++;
XtSetValues ( textLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_POSITION); ac++;
XtSetValues ( nameTextField,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, nameTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, nameTextField); ac++;
XtSetValues ( msgTextField,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, severityOptionMenu); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, severityOptionMenu); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, severityOptionMenu); ac++;
XtSetValues ( severityLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, msgTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, msgTextField); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetValues ( severityOptionMenu,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, moduleOptionMenu); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, moduleOptionMenu); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNleftOffset, 0); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, moduleOptionMenu); ac++;
XtSetValues ( moduleLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, severityOptionMenu); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, severityOptionMenu); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_FORM); ac++;
XtSetValues ( moduleOptionMenu,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, categoryTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, categoryTextField); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, categoryTextField); ac++;
XtSetValues ( categoryLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, moduleOptionMenu); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, moduleOptionMenu); ac++;
XtSetValues ( categoryTextField,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, descriptionText); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNbottomWidget, descriptionText); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_FORM); ac++;
XtSetArg(al[ac], XmNrightAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNrightWidget, descriptionText); ac++;
XtSetValues ( descriptionLabel,al, ac );
ac = 0;
XtSetArg(al[ac], XmNtopAttachment, XmATTACH_WIDGET); ac++;
XtSetArg(al[ac], XmNtopWidget, categoryTextField); ac++;
XtSetArg(al[ac], XmNbottomAttachment, XmATTACH_NONE); ac++;
XtSetArg(al[ac], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); ac++;
XtSetArg(al[ac], XmNleftWidget, categoryTextField); ac++;
XtSetValues ( descriptionText,al, ac );
XtAddCallback(widget10, XmNactivateCallback, open_message, NULL);
XtAddCallback(browseButton, XmNactivateCallback, browse_messages,
g_module);
XtAddCallback(widget11, XmNactivateCallback, new_message, NULL);
XtAddCallback(widget12, XmNactivateCallback, save_message, NULL);
XtAddCallback(deleteButton, XmNactivateCallback, delete_message, NULL);
XtAddCallback(generateButton, XmNactivateCallback, generate_header, NULL);
XtAddCallback(lockButton, XmNactivateCallback, set_lock, widget9);
XtAddCallback(unlockButton, XmNactivateCallback, unset_lock, widget9);
XtAddCallback(widget14, XmNactivateCallback, exit_app, NULL);
XtAddCallback(widget27, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget28, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget29, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget30, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget31, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget32, XmNactivateCallback, set_severity, NULL);
XtAddCallback(widget33, XmNactivateCallback, set_severity, NULL);
for (imod = 0; imod < nmodule_names; imod++)
XtAddCallback(modbutton[imod], XmNactivateCallback, set_module,
NULL);
ac = 0;
children[ac++] = widget27;
children[ac++] = widget28;
children[ac++] = widget29;
children[ac++] = widget30;
children[ac++] = widget31;
children[ac++] = widget32;
children[ac++] = widget33;
XtManageChildren(children, ac);
XtManageChildren(modbutton, nmodule_names);
ac = 0;
children[ac++] = nameLabel;
children[ac++] = textLabel;
children[ac++] = nameTextField;
children[ac++] = msgTextField;
children[ac++] = severityLabel;
children[ac++] = severityOptionMenu;
children[ac++] = moduleLabel;
children[ac++] = moduleOptionMenu;
children[ac++] = categoryLabel;
children[ac++] = categoryTextField;
children[ac++] = descriptionLabel;
children[ac++] = descriptionText;
XtManageChildren(children, ac);
ac = 0;
XtManageChild ( widget7 );
XtManageChild ( widget17 );
XmMainWindowSetAreas(widget1, widget7, (Widget) NULL, widget2, widget3, widget17 );
XtManageChild ( widget1);
}
Widget XmCreateCascadeButton_TNK(Widget parent, String name, ArgList arglist,Cardinal argcount) { return XmCreateCascadeButton(parent, name, arglist, argcount);}
int main(int argc, char **argv)
{
XtAppContext AppCtx;
Widget TopLevel, Main, Menu, Form, Text, PullDownMenu;
Widget Cascade, Butt1, Butt3, Butt4, Butt5;
Widget Frame, Label, RowCol, w;
Arg args[10];
TopLevel = XtVaAppInitialize(&AppCtx, "Demo", NULL, 0,
&argc, argv, Fallbacks, NULL);
Main = XmCreateMainWindow(TopLevel, "main", NULL, 0);
XtManageChild(Main);
Menu = XmCreateMenuBar(Main, "menu", NULL, 0);
XtManageChild(Menu);
XtSetArg(args[0], XmNmnemonic, XK_F);
Cascade = XmCreateCascadeButton(Menu, "File", args, 1);
XtManageChild(Cascade);
PullDownMenu = XmCreatePulldownMenu(Cascade, "filemenu", NULL, 0);
w = XmCreateToggleButtonPlus(PullDownMenu, "Enjoy it!", NULL, 0);
XtVaSetValues(w, XmNmnemonic, XK_j, NULL);
XtManageChild(w);
XtVaCreateManagedWidget(
"sepp1", xmSeparatorWidgetClass, PullDownMenu,
NULL);
w = XmCreateToggleButtonPlus(PullDownMenu, "One", NULL, 0);
XtVaSetValues(w, XmNmnemonic, XK_O, XmNindicatorType, XmONE_OF_MANY, NULL);
XtManageChild(w);
w = XmCreateToggleButtonPlus(PullDownMenu, "Two", NULL, 0);
XtVaSetValues(w, XmNmnemonic, XK_T, XmNindicatorType, XmONE_OF_MANY, NULL);
XtManageChild(w);
w = XmCreateToggleButtonPlus(PullDownMenu, "Fourtytwo", NULL, 0);
XtVaSetValues(w, XmNmnemonic, XK_F, XmNindicatorType, XmONE_OF_MANY, NULL);
XtManageChild(w);
XtVaCreateManagedWidget(
"sepp2", xmSeparatorWidgetClass, PullDownMenu,
NULL);
Butt1 = XtVaCreateManagedWidget(
"Exit", xmPushButtonWidgetClass, PullDownMenu,
XmNmnemonic, XK_E,
NULL);
XtAddCallback(Butt1, XmNactivateCallback,
(XtCallbackProc) DummyCallback, NULL);
XtVaSetValues(Cascade, XmNsubMenuId, PullDownMenu, NULL);
Form = XtVaCreateManagedWidget("form", xmFormWidgetClass, Main, NULL);
Label = XtVaCreateManagedWidget(
"XmN_OF_MANY", xmLabelWidgetClass, Form,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 24,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 8,
NULL);
Frame = XtVaCreateManagedWidget(
"frame1", xmFrameWidgetClass, Form,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 20,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, Label,
XmNrightAttachment, XmATTACH_POSITION,
XmNrightPosition, 50,
XmNrightOffset, 4,
NULL);
RowCol = XtVaCreateManagedWidget(
"RowCol", xmRowColumnWidgetClass, Frame,
NULL);
Butt3 = XmCreateToggleButtonPlus(RowCol, "I like the OSF", NULL, 0);
XtVaSetValues(Butt3, XmNsensitive, False, NULL);
XtManageChild(Butt3);
Butt4 = XmCreateToggleButtonPlus(RowCol, "Support Freeware!", NULL, 0);
XtVaSetValues(Butt4, XmNset, True, NULL);
XtManageChild(Butt4);
Butt5 = XmCreateToggleButtonPlus(RowCol, "New Widgets", NULL, 0);
XtManageChild(Butt5);
Label = XtVaCreateManagedWidget(
"XmONE_OF_MANY", xmLabelWidgetClass, Form,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 50,
XmNleftOffset, 4,
XmNtopAttachment, XmATTACH_FORM,
XmNtopOffset, 8,
NULL);
Frame = XtVaCreateManagedWidget(
"frame2", xmFrameWidgetClass, Form,
XmNleftAttachment, XmATTACH_POSITION,
XmNleftPosition, 50,
XmNleftOffset, 4,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, Label,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 20,
NULL);
RowCol = XtVaCreateManagedWidget(
"RowCol", xmRowColumnWidgetClass, Frame,
XmNradioBehavior, True,
XmNradioAlwaysOne, True,
NULL);
Butt3 = XmCreateToggleButtonPlus(RowCol, "Athena", NULL, 0);
XtVaSetValues(Butt3, XmNindicatorType, XmONE_OF_MANY, NULL);
XtManageChild(Butt3);
Butt4 = XmCreateToggleButtonPlus(RowCol, "OSF/Motif(=Hades)", NULL, 0);
XtVaSetValues(Butt4, XmNindicatorType, XmONE_OF_MANY, NULL);
XtManageChild(Butt4);
Butt5 = XmCreateToggleButtonPlus(RowCol, "Harry's Motif Widgets", NULL, 0);
XtVaSetValues(Butt5, XmNindicatorType, XmONE_OF_MANY,
XmNset, True, NULL);
XtManageChild(Butt5);
/* Label = XtVaCreateManagedWidget(
"XmNtriState = True",
xmLabelWidgetClass, Form,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 20,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, Frame,
XmNtopOffset, 8,
NULL);
Frame = XtVaCreateManagedWidget(
"frame3", xmFrameWidgetClass, Form,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 20,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, Label,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 20,
NULL);
RowCol = XtVaCreateManagedWidget(
"RowCol", xmRowColumnWidgetClass, Frame,
NULL);
Butt3 = XtVaCreateManagedWidget(
"Click on me several times.", xmToggleButtonWidgetClass, RowCol,
XmNtriState, True,
XmNset, XmTOGGLE_DONTKNOW,
NULL);
*/
Text = XtVaCreateManagedWidget(
"The new xmToggleButtonWidgetClass",
xmLabelWidgetClass, Form,
XmNleftAttachment, XmATTACH_FORM,
XmNleftOffset, 20,
XmNrightAttachment, XmATTACH_FORM,
XmNrightOffset, 20,
XmNtopAttachment, XmATTACH_WIDGET,
XmNtopWidget, Frame,
XmNtopOffset, 20,
XmNbottomAttachment, XmATTACH_FORM,
XmNbottomOffset, 20,
NULL);
XmMainWindowSetAreas(Main, Menu, NULL, NULL, NULL, Form);
XtRealizeWidget(TopLevel);
{
static XtWidgetGeometry Expected[] = {
CWWidth | CWHeight , 0, 0, 370, 204, 0,0,0, /* main */
CWWidth | CWHeight | CWX | CWY, 0, 0, 370, 31, 0,0,0, /* menu */
CWWidth | CWHeight | CWX | CWY, 5, 5, 40, 21, 0,0,0, /* File */
CWWidth | CWHeight | CWX | CWY, 0, 31, 370, 173, 0,0,0, /* form */
CWWidth | CWHeight | CWX | CWY, 24, 8, 70, 17, 0,0,0, /* XmN_OF_MANY */
CWWidth | CWHeight | CWX | CWY, 20, 25, 161, 91, 0,0,0, /* frame1 */
CWWidth | CWHeight | CWX | CWY, 2, 2, 157, 87, 0,0,0, /* RowCol */
CWWidth | CWHeight | CWX | CWY, 3, 3, 151, 25, 0,0,0, /* I like the OSF */
CWWidth | CWHeight | CWX | CWY, 3, 31, 151, 25, 0,0,0, /* Support Freeware! */
CWWidth | CWHeight | CWX | CWY, 3, 59, 151, 25, 0,0,0, /* New Widgets */
CWWidth | CWHeight | CWX | CWY, 189, 8, 82, 17, 0,0,0, /* XmONE_OF_MANY */
CWWidth | CWHeight | CWX | CWY, 189, 25, 161, 91, 0,0,0, /* frame2 */
CWWidth | CWHeight | CWX | CWY, 2, 2, 157, 87, 0,0,0, /* RowCol */
CWWidth | CWHeight | CWX | CWY, 3, 3, 151, 25, 0,0,0, /* Athena */
CWWidth | CWHeight | CWX | CWY, 3, 31, 151, 25, 0,0,0, /* OSF/Motif(=Hades) */
CWWidth | CWHeight | CWX | CWY, 3, 59, 151, 25, 0,0,0, /* Harry's Motif Widgets */
CWWidth | CWHeight | CWX | CWY, 20, 136, 330, 17, 0,0,0, /* The new xmToggleButtonWidgetClass */
};
PrintDetails( TopLevel ,Expected);
};
LessTifTestMainLoop( TopLevel );
return 0;
} /* main */
void create_preprocessing_menu(Widget parent)
{
Widget preprocessing_menu_pane, preprocessing_menu_button, histogram_button, preprocessing_sep_1,
histo_eq_button, preprocessing_sep_2, threshold_button, preprocessing_sep_3,
filter_button, filter_pane, mean_filter_button,
median_filter_button, smooth_t_button, smooth_mask1_button,
smooth_mask2_button, median_vf_button;
/* Create the menu pane for the menu */
preprocessing_menu_pane = XmCreatePulldownMenu(parent, "preprocessing menu pane", NULL, 0);
/* Populate the menu pane */
/* Histogram button */
histogram_button = XmCreatePushButton(preprocessing_menu_pane, "Histogram", NULL, 0);
XtManageChild(histogram_button);
XtAddCallback(histogram_button, XmNactivateCallback,
(XtCallbackProc) histogram_callback, (XtPointer) NULL);
/* Separator 1 */
preprocessing_sep_1 = XmCreateSeparator(preprocessing_menu_pane,
"preprocessing sep 1", NULL, 0);
XtManageChild(preprocessing_sep_1);
/* Histogram equalization button */
histo_eq_button = XmCreatePushButton(preprocessing_menu_pane,
"Histogram Equalization", NULL, 0);
XtManageChild(histo_eq_button);
XtAddCallback(histo_eq_button, XmNactivateCallback,
(XtCallbackProc) histo_eq_callback, (XtPointer) NULL);
/* Separator 2 */
preprocessing_sep_2 = XmCreateSeparator(preprocessing_menu_pane,
"preprocessing sep 2", NULL, 0);
XtManageChild(preprocessing_sep_2);
/* Threshold button */
threshold_button = XmCreatePushButton(preprocessing_menu_pane,
"Threshold", NULL, 0);
XtManageChild(threshold_button);
/* Create the threshold dialog and add the activation function as the
threshold button's activate callback */
create_threshold_dialog(parent);
XtAddCallback(threshold_button, XmNactivateCallback,
(XtCallbackProc) activate_threshold_dialog, (XtPointer) NULL);
/* Separator 3 */
preprocessing_sep_3 = XmCreateSeparator(preprocessing_menu_pane,
"preprocessing sep 3", NULL, 0);
XtManageChild(preprocessing_sep_3);
/* Filter button */
filter_pane = XmCreatePulldownMenu(preprocessing_menu_pane,
"filter pane", NULL, 0);
mean_filter_button = XmCreatePushButton(filter_pane, "Mean Filter", NULL, 0);
XtManageChild(mean_filter_button);
XtAddCallback(mean_filter_button, XmNactivateCallback,
(XtCallbackProc) mean_filter_callback, (XtPointer) NULL);
median_filter_button = XmCreatePushButton(filter_pane,
"Median Filter", NULL, 0);
XtManageChild(median_filter_button);
XtAddCallback(median_filter_button, XmNactivateCallback,
(XtCallbackProc) median_filter_callback, (XtPointer) NULL);
smooth_t_button = XmCreatePushButton(filter_pane, "Smooth T", NULL, 0);
XtManageChild(smooth_t_button);
create_smooth_t_dialog(parent); /* Dialogo */
XtAddCallback(smooth_t_button, XmNactivateCallback,
(XtCallbackProc) activate_smooth_t_dialog, (XtPointer) NULL);
smooth_mask1_button = XmCreatePushButton(filter_pane,
"Smooth .. Mask1", NULL, 0);
XtManageChild(smooth_mask1_button);
XtAddCallback(smooth_mask1_button, XmNactivateCallback,
(XtCallbackProc) smooth_mask1_callback, (XtPointer) NULL);
smooth_mask2_button = XmCreatePushButton(filter_pane,
"Smooth .. Mask2", NULL, 0);
XtManageChild(smooth_mask2_button);
XtAddCallback(smooth_mask2_button, XmNactivateCallback,
(XtCallbackProc) smooth_mask2_callback, (XtPointer) NULL);
median_vf_button = XmCreatePushButton(filter_pane,
"Median VF", NULL, 0);
XtManageChild(median_vf_button);
XtAddCallback(median_vf_button, XmNactivateCallback,
(XtCallbackProc) median_vf_callback, (XtPointer) NULL);
/* Submenus del Filter */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, filter_pane); argcount++;
filter_button = XmCreateCascadeButton(preprocessing_menu_pane,
"Filter ", args, argcount );
XtManageChild(filter_button);
/* Create the preprocessing cascade button on the menu bar and attach the *
* preprocessing menu pane to it. */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, preprocessing_menu_pane); argcount++;
preprocessing_menu_button = XmCreateCascadeButton(parent,
"Pre-processing ", args, argcount);
/* XtManageChild(preprocessing_menu_button); */
}
static void CreateAnotherContainer()
{
Widget PopupShell;
Widget MainW2, menubar2, pulldown2, menu_btn2;
Widget CutPB2, CopyPB2, CopyLinkPB2, PastePB2, PasteLinkPB2;
Widget OtherContainer4;
Widget IconGad6, IconGad7, IconGad8, IconGad9, IconGad10;
Cardinal n;
XmString Label;
Arg args[MAX_ARGS];
/*
* Create a Dialog Shell
*/
n = 0;
XtSetArg(args[n], XtNgeometry, "=375x375+400+300"); n++;
XtSetArg(args[n], XtNallowShellResize, True); n++;
PopupShell = XtCreatePopupShell("OtherContainer",
topLevelShellWidgetClass, Shell1,
args, n);
/*
* Create a main window
*/
n = 0;
XtSetArg(args[n], XmNborderWidth, 2); n++;
MainW2 = XmCreateMainWindow(PopupShell, "MainW2", args, n);
XtManageChild(MainW2);
/*
* Create a menu bar with a pulldown menu for interacting with the
* clipboard
*/
n = 0;
menubar2 = XmCreateMenuBar(MainW2, "menubar2", args, n);
XtManageChild(menubar2);
n = 0;
pulldown2 = XmCreatePulldownMenu(menubar2, "pulldown2", args, n);
Label = XmStringCreate("Edit", XmSTRING_DEFAULT_CHARSET);
n = 0;
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNsubMenuId, pulldown2); n++;
menu_btn2 = XmCreateCascadeButton(menubar2, "menu_btn2", args, n);
XtManageChild(menu_btn2);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Cut", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
CutPB2 = XmCreatePushButtonGadget(pulldown2, "CutPB2", args, n);
XtManageChild(CutPB2);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Copy", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
CopyPB2 = XmCreatePushButtonGadget(pulldown2, "CopyPB2", args, n);
XtManageChild(CopyPB2);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Copy Link", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
CopyLinkPB2 = XmCreatePushButtonGadget(pulldown2, "CopyLinkPB2", args, n);
XtManageChild(CopyLinkPB2);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Paste", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
PastePB2 = XmCreatePushButtonGadget(pulldown2, "PastePB2", args, n);
XtManageChild(PastePB2);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Paste Link", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
PasteLinkPB2= XmCreatePushButtonGadget(pulldown2, "PasteLinkPB2", args, n);
XtManageChild(PasteLinkPB2);
XmStringFree(Label);
/*
* Create the container
*/
n = 0;
XtSetArg(args[n], XmNwidth, 450); n++;
XtSetArg(args[n], XmNheight, 450); n++;
XtSetArg(args[n], XmNentryViewType, XmANY_ICON); n++;
XtSetArg(args[n], XmNlayoutType, XmSPATIAL); n++;
XtSetArg(args[n], XmNspatialStyle, XmNONE); n++;
XtSetArg(args[n], XmNautomaticSelection, XmNO_AUTO_SELECT); n++;
OtherContainer4 = XmCreateContainer(MainW2, "OtherContainer", args, n);
XtManageChild(OtherContainer4);
XtAddCallback(OtherContainer4, XmNconvertCallback, ConvertCB, NULL);
XtAddCallback(OtherContainer4, XmNdestinationCallback, DestinationCB,
NULL);
XtAddCallback(CutPB2, XmNactivateCallback, CutCB,
(XtPointer) OtherContainer4);
XtAddCallback(CopyPB2, XmNactivateCallback, CopyCB,
(XtPointer) OtherContainer4);
XtAddCallback(CopyLinkPB2, XmNactivateCallback, CopyLinkCB,
(XtPointer) OtherContainer4);
XtAddCallback(PastePB2, XmNactivateCallback, PasteCB,
(XtPointer) OtherContainer4);
XtAddCallback(PasteLinkPB2, XmNactivateCallback, PasteLinkCB,
(XtPointer) OtherContainer4);
n = 0;
XtSetArg(args[n], XmNx, 50); n++;
XtSetArg(args[n], XmNy, 50); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
IconGad6 = XmCreateIconGadget(OtherContainer4, "IconGad6", args, n);
XtManageChild(IconGad6);
n = 0;
XtSetArg(args[n], XmNx, 150); n++;
XtSetArg(args[n], XmNy, 150); n++;
XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
IconGad7 = XmCreateIconGadget(OtherContainer4, "IconGad7", args, n);
XtManageChild(IconGad7);
n = 0;
XtSetArg(args[n], XmNx, 50); n++;
XtSetArg(args[n], XmNy, 300); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
IconGad8 = XmCreateIconGadget(OtherContainer4, "IconGad8", args, n);
XtManageChild(IconGad8);
n = 0;
XtSetArg(args[n], XmNx, 300); n++;
XtSetArg(args[n], XmNy, 300); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
IconGad9 = XmCreateIconGadget(OtherContainer4, "IconGad9", args, n);
XtManageChild(IconGad9);
n = 0;
XtSetArg(args[n], XmNx, 200); n++;
XtSetArg(args[n], XmNy, 50); n++;
XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
IconGad10 = XmCreateIconGadget(OtherContainer4, "IconGad10", args, n);
XtManageChild(IconGad10);
XmMainWindowSetAreas(MainW2, menubar2, NULL, NULL, NULL, OtherContainer4);
XtPopup(PopupShell, XtGrabNone);
}
void
main(int argc, char **argv)
{
int i,j;
Cardinal n;
XmString Label;
Arg args[MAX_ARGS];
int test_num;
char test_char;
char ContainerName[NAME_LEN + 1];
ContainerName[0] = '\0';
test_num = 0;
test_char = '\0';
CommonTestInit(argc, argv);
if (UserData != NULL) {
if (strcmp(UserData, "a") == 0)
test_num = 1;
else if (strcmp(UserData, "b") == 0)
test_num = 2;
else if (strcmp(UserData, "c") == 0)
test_num = 3;
else if (strcmp(UserData, "d") == 0)
test_num = 4;
test_char = *UserData;
free(UserData);
}
sprintf(ContainerName, "Container4%c", test_char);
/*
* Create a main window
*/
n = 0;
XtSetArg(args[n], XmNborderWidth, 2); n++;
MainW1 = XmCreateMainWindow(Shell1, "MainW1", args, n);
XtManageChild(MainW1);
/*
* Create a menu bar with a pulldown menu for interacting with the
* clipboard
*/
n = 0;
menubar1 = XmCreateMenuBar(MainW1, "menubar1", args, n);
XtManageChild(menubar1);
n = 0;
pulldown1 = XmCreatePulldownMenu(menubar1, "pulldown1", args, n);
Label = XmStringCreate("Edit", XmSTRING_DEFAULT_CHARSET);
n = 0;
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNsubMenuId, pulldown1); n++;
menu_btn1 = XmCreateCascadeButton(menubar1, "menu_btn1", args, n);
XtManageChild(menu_btn1);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Cut", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
CutPB1 = XmCreatePushButtonGadget(pulldown1, "CutPB1", args, n);
XtManageChild(CutPB1);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Copy", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
CopyPB1 = XmCreatePushButtonGadget(pulldown1, "CopyPB1", args, n);
XtManageChild(CopyPB1);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Copy Link", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
CopyLinkPB1 = XmCreatePushButtonGadget(pulldown1, "CopyLinkPB1", args, n);
XtManageChild(CopyLinkPB1);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Paste", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
PastePB1 = XmCreatePushButtonGadget(pulldown1, "PastePB1", args, n);
XtManageChild(PastePB1);
XmStringFree(Label);
n = 0;
Label = XmStringCreate("Paste Link", XmSTRING_DEFAULT_CHARSET);
XtSetArg(args[n], XmNlabelString, Label); n++;
XtSetArg(args[n], XmNalignment, XmALIGNMENT_BEGINNING); n++;
PasteLinkPB1= XmCreatePushButtonGadget(pulldown1, "PasteLinkPB1", args, n);
XtManageChild(PasteLinkPB1);
XmStringFree(Label);
/*
* Create the container
*/
ColumnHeadings = (XmStringTable) XtMalloc(NUM_COL * sizeof(XmString));
for (i = 0; i < NUM_COL; i++)
ColumnHeadings[i] = XmStringGenerate(ColumnHeadingText[i],
NULL,
XmCHARSET_TEXT,
NULL);
n = 0;
XtSetArg(args[n], XmNdetailColumnHeading, ColumnHeadings); n++;
XtSetArg(args[n], XmNdetailColumnHeadingCount, NUM_COL); n++;
XtSetArg(args[n], XmNdetailOrderCount, NUM_COL-1); n++;
Container4 = XmCreateContainer(MainW1, ContainerName, args, n);
XtManageChild(Container4);
XtAddCallback(Container4, XmNdefaultActionCallback, PrintChildrenCB, NULL);
XtAddCallback(Container4, XmNconvertCallback, ConvertCB, NULL);
XtAddCallback(Container4, XmNdestinationCallback, DestinationCB, NULL);
XtAddCallback(CutPB1, XmNactivateCallback, CutCB, (XtPointer) Container4);
XtAddCallback(CopyPB1, XmNactivateCallback, CopyCB, (XtPointer)Container4);
XtAddCallback(CopyLinkPB1, XmNactivateCallback, CopyLinkCB,
(XtPointer) Container4);
XtAddCallback(PastePB1, XmNactivateCallback, PasteCB,
(XtPointer) Container4);
XtAddCallback(PasteLinkPB1, XmNactivateCallback, PasteLinkCB,
(XtPointer) Container4);
for (i=0; i<NUM_COL; i++)
XmStringFree(ColumnHeadings[i]);
XtFree((XtPointer) ColumnHeadings);
EntryDetails = (XmStringTable *) XtMalloc(NUM_OBJ * sizeof(XmStringTable));
for (i = 0; i < NUM_OBJ; i++) {
ColumnHeadings = (XmStringTable)XtMalloc((NUM_COL-1) * sizeof(XmString));
ColumnHeadings[0] = XmStringGenerate(FullTitleText[i],
NULL,
XmCHARSET_TEXT,
NULL);
ColumnHeadings[1] = XmStringGenerate(FlavorText[i],
NULL,
XmCHARSET_TEXT,
NULL);
ColumnHeadings[2] = XmStringGenerate(AgeText[i],
NULL,
XmCHARSET_TEXT,
NULL);
EntryDetails[i] = ColumnHeadings;
}
n = 0;
XtSetArg(args[n], XmNx, 100); n++;
XtSetArg(args[n], XmNy, 100); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[0]); n++;
IconGad1 = XmCreateIconGadget(Container4, "IconGad1", args, n);
XtManageChild(IconGad1);
n = 0;
XtSetArg(args[n], XmNx, 200); n++;
XtSetArg(args[n], XmNy, 200); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[1]); n++;
IconGad2 = XmCreateIconGadget(Container4, "IconGad2", args, n);
XtManageChild(IconGad2);
n = 0;
XtSetArg(args[n], XmNx, 300); n++;
XtSetArg(args[n], XmNy, 100); n++;
XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[2]); n++;
IconGad3 = XmCreateIconGadget(Container4, "IconGad3", args, n);
XtManageChild(IconGad3);
n = 0;
XtSetArg(args[n], XmNx, 50); n++;
XtSetArg(args[n], XmNy, 400); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[3]); n++;
IconGad4 = XmCreateIconGadget(Container4, "IconGad4", args, n);
XtManageChild(IconGad4);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad3); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[4]); n++;
IconGad31 = XmCreateIconGadget(Container4, "IconGad31", args, n);
XtManageChild(IconGad31);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad3); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[5]); n++;
IconGad32 = XmCreateIconGadget(Container4, "IconGad32", args, n);
XtManageChild(IconGad32);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad32); n++;
XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[6]); n++;
IconGad321 = XmCreateIconGadget(Container4, "IconGad321", args, n);
XtManageChild(IconGad321);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad321); n++;
XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[7]); n++;
IconGad3211 = XmCreateIconGadget(Container4, "IconGad3211", args, n);
XtManageChild(IconGad3211);
n = 0;
XtSetArg(args[n], XmNentryParent, IconGad3); n++;
XtSetArg(args[n], XmNviewType, XmSMALL_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[8]); n++;
IconGad33 = XmCreateIconGadget(Container4, "IconGad33", args, n);
XtManageChild(IconGad33);
n = 0;
XtSetArg(args[n], XmNx, 70); n++;
XtSetArg(args[n], XmNy, 420); n++;
XtSetArg(args[n], XmNviewType, XmLARGE_ICON); n++;
XtSetArg(args[n], XmNdetailCount, NUM_COL-1); n++;
XtSetArg(args[n], XmNdetail, EntryDetails[9]); n++;
IconGad5 = XmCreateIconGadget(Container4, "IconGad5", args, n);
XtManageChild(IconGad5);
XmMainWindowSetAreas(MainW1, menubar1, NULL, NULL, NULL, Container4);
for (i = 0; i < NUM_OBJ; i++) {
ColumnHeadings = EntryDetails[i];
for (j = 0; j < NUM_COL-1; j++)
XmStringFree(ColumnHeadings[j]);
XtFree((XtPointer)ColumnHeadings);
}
XtFree((XtPointer)EntryDetails);
XtRealizeWidget(Shell1);
CommonPause();
CommonPause();
XmContainerRelayout(Container4);
CommonPause();
if ((test_num == 1) || (test_num == 2)) {
TestContainerReorder();
CommonPause();
}
/*
* Create another Container for UTM testing
*/
CreateAnotherContainer();
CommonPause();
CommonPause();
CommonPause();
CommonPause();
CommonPause();
CommonPause();
CommonPause();
CommonPause();
XtAppMainLoop(app_context);
}
/*+++++++++++++++++++++++++++++++++++++++++++++*/
static void
build_mainWindow(
Widget shell )
{
int count, n, n2;
Arg args[MAX_ARGS];
Widget WidgList[10];
Widget frame;
Widget mainMenu;
Widget mainRC;
Widget filePulldown;
Widget helpPulldown;
Widget exitBtn;
char *mnemonic;
char *tmpStr;
Pixmap pixmap;
XmString labelString;
Pixmap ditherPix;
XmPixelSet pixelSet[XmCO_NUM_COLORS];
Pixel bg;
short a,i,p,s;
/* saveRestore
* Note that save.poscnt has been initialized elsewhere.
* save.posArgs may contain information from restoreAudio().*/
XtSetArg(save.posArgs[save.poscnt], XmNnoResize, True); save.poscnt++;
XtSetArg(save.posArgs[save.poscnt], XmNresizePolicy, XmRESIZE_NONE); save.poscnt++;
style.mainWindow= XmCreateMainWindow(shell,"mainWindow", save.posArgs, save.poscnt);
XtAddCallback(style.mainWindow, XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_MAIN_WINDOW);
n = 0;
tmpStr = (char *)XtMalloc(strlen(GETMESSAGE(4, 1, "Style Manager"))+1);
sprintf(tmpStr, GETMESSAGE(4, 1, "Style Manager"));
XtSetArg(args[n], XmNtitle, tmpStr); n++;
XtSetArg(args[n], XmNiconName,
(char *)GETMESSAGE(4, 37, "Style")); n++;
XtSetValues(XtParent(style.mainWindow), args, n);
XtFree(tmpStr);
n = 0;
mainMenu= XmCreateMenuBar(style.mainWindow,"mainMenu", args, n);
XtAddCallback(mainMenu, XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_MENUBAR);
XtManageChild(mainMenu);
/* create the pulldown widgets */
n = 0;
filePulldown= XmCreatePulldownMenu(mainMenu,"fileMenu", args, n );
XtAddCallback(filePulldown, XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_FILE_MENU);
n = 0;
helpPulldown= XmCreatePulldownMenu(mainMenu, "helpMenu" , args, n );
XtAddCallback(helpPulldown, XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_HELP_MENU);
/* create the cascade butons */
count = 0;
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 2, "F"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 3, "File"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
XtSetArg(args[n], XmNsubMenuId, filePulldown); n++;
XtSetArg (args[n], XmNmarginWidth, LB_MARGIN_WIDTH); n++;
WidgList[count++]=
XmCreateCascadeButton(mainMenu, "fileCascadeButton", args, n );
XtAddCallback(WidgList[count-1], XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_FILE_MENU);
XmStringFree(labelString);
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 4, "H"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 5, "Help"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
XtSetArg(args[n], XmNsubMenuId, helpPulldown); n++;
XtSetArg (args[n], XmNmarginWidth, 6); n++;
WidgList[count++]=
XmCreateCascadeButton(mainMenu, "helpCascadeButton", args, n );
XtAddCallback(WidgList[count-1], XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_HELP_MENU);
XmStringFree(labelString);
n = 0;
XtSetArg(args[n], XmNmenuHelpWidget, WidgList[count-1]); n++;
XtSetValues (mainMenu, args, n);
XtManageChildren (WidgList, count);
/* create the File menu pane's buttons */
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 53, "x"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 7, "Exit"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
exitBtn= XmCreatePushButton(filePulldown, "exit", args, n );
XtAddCallback(exitBtn, XmNactivateCallback, activateCB_exitBtn, NULL);
XtAddCallback(exitBtn, XmNhelpCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_EXIT);
XtManageChild(exitBtn);
XmStringFree(labelString);
/* create the Help menu pane's buttons */
count =0;
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 54, "v"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 55, "Overview"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
WidgList[count++]=
XmCreatePushButton(helpPulldown, "overview", args, n );
XtAddCallback(WidgList[count-1], XmNactivateCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_INTRODUCTION);
XmStringFree(labelString);
n = 0;
WidgList[count++]=
XmCreateSeparatorGadget(helpPulldown,"separator",args,n);
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 43, "T"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 56, "Tasks"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
WidgList[count++]= XmCreatePushButton(helpPulldown, "tasks", args, n );
XtAddCallback(WidgList[count-1], XmNactivateCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_TASKS);
XmStringFree(labelString);
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 45, "R"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 57, "Reference"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
WidgList[count++]= XmCreatePushButton(helpPulldown, "reference", args, n );
XtAddCallback(WidgList[count-1], XmNactivateCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_REFERENCE);
XmStringFree(labelString);
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 47, "O"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 48, "On Item"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
WidgList[count++]= XmCreatePushButton(helpPulldown, "onItem", args, n );
XtAddCallback(WidgList[count-1], XmNactivateCallback,
(XtCallbackProc)HelpModeCB, (XtPointer)NULL);
XmStringFree(labelString);
n = 0;
WidgList[count++] =
XmCreateSeparatorGadget(helpPulldown,"separator",args,n);
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 49, "U"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 58, "Using Help"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
WidgList[count++]=
XmCreatePushButton(helpPulldown, "usingHelp", args, n );
XtAddCallback(WidgList[count-1], XmNactivateCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_USING);
XmStringFree(labelString);
n = 0;
WidgList[count++] =
XmCreateSeparatorGadget(helpPulldown,"separator",args,n);
n = 0;
mnemonic = ((char *)GETMESSAGE(4, 59, "A"));
XtSetArg(args[n], XmNmnemonic, mnemonic[0]); n++;
labelString = CMPSTR((char *)GETMESSAGE(4, 60, "About Style Manager"));
XtSetArg(args[n], XmNlabelString, labelString); n++;
WidgList[count++]= XmCreatePushButton(helpPulldown, "stylemanager", args, n );
XtAddCallback(WidgList[count-1], XmNactivateCallback,
(XtCallbackProc)HelpRequestCB, (XtPointer)HELP_VERSION);
XmStringFree(labelString);
XtManageChildren(WidgList, count);
/* create frame and row column for icon gadgets */
n = 0;
XtSetArg(args[n], XmNresizePolicy, XmRESIZE_NONE); n++;
XtSetArg(args[n], XmNshadowType, XmSHADOW_OUT); n++;
XtSetArg(args[n], XmNshadowThickness, 1); n++;
frame = XmCreateFrame(style.mainWindow, "frame", args, n);
XtManageChild(frame);
/* Save pixels for later use */
/* primary top/bottom shadow -> fg/bg for pixmaps in primary areas */
/* secondary top/bottom shadow -> fg/bg for pixmaps in secondary areas */
/* secondary select color -> backgrounds of editable text areas */
/* secondary foreground -> fill color on toggle indicators */
/* Get the primary colors to be used later */
n = 0;
XtSetArg(args[n], XmNbackground, &bg); n++;
XtGetValues(style.mainWindow, args, n);
XmGetColors (style.screen, style.colormap, bg,
NULL,
&style.primTSCol,
&style.primBSCol,
NULL);
/* Get the secondary colors to be used later */
n = 0;
XtSetArg(args[n], XmNbackground, &style.secBgCol); n++;
XtGetValues(exitBtn, args, n);
XmGetColors (style.screen, style.colormap, style.secBgCol,
&style.tgSelectColor,
&style.secTSCol,
&style.secBSCol,
&style.secSelectColor);
if ((style.secTSCol == style.secBSCol) || /* B_W or shadowPixmaps==True */
(!style.useMultiColorIcons)) /* multiColorIcons turned off */
{
/* force TS = White, BS = Black */
style.secTSCol = style.primTSCol = WhitePixelOfScreen(style.screen);
style.secBSCol = style.primBSCol = BlackPixelOfScreen(style.screen);
}
XmeGetPixelData(style.screenNum, &colorUse, pixelSet, &a, &i, &p, &s);
n = 0;
if (colorUse == XmCO_BLACK_WHITE)
{
ditherPix = XmGetPixmap (style.screen, "50_foreground",
style.primBSCol,style.primTSCol);
XtSetArg(args[n], XmNbackgroundPixmap, ditherPix); n++;
}
XtSetArg(args[n], XmNallowOverlap, False); n++;
XtSetArg(args[n], XmNadjustLast, False); n++;
XtSetArg(args[n], XmNpacking, XmPACK_TIGHT); n++;
XtSetArg(args[n], XmNspacing, style.horizontalSpacing); n++;
mainRC = XmCreateRowColumn(frame, "mainRC", args, n);
XtManageChild(mainRC);
n = 0;
XtSetArg(args[n], XmNmenuBar, mainMenu); n++;
XtSetArg(args[n], XmNcommandWindow, NULL); n++;
XtSetArg(args[n], XmNworkWindow, frame); n++;
XtSetValues (style.mainWindow, args, n);
ProcessComponentList (shell, mainRC);
}
void
main(int argc, char *argv[])
{
int i;
#ifdef IRIX_5_1_MOTIF_BUG_WORKAROUND
/*
* XXX Unfortunately a bug in the IRIX 5.1 Motif shared library
* causes a BadMatch X protocol error if the SGI look&feel
* is enabled for this program. If we detect we are on an
* IRIX 5.1 system, skip the first two fallback resources which
* specify using the SGI look&feel.
*/
struct utsname versionInfo;
if(uname(&versionInfo) >= 0) {
if(!strcmp(versionInfo.sysname, "IRIX") &&
!strncmp(versionInfo.release, "5.1", 3)) {
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
&fallbackResources[2], NULL, 0);
}
}
if(toplevel == NULL) {
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
}
#else
toplevel = XtAppInitialize(&app, "Textfun", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
#endif
dpy = XtDisplay(toplevel);
/* find an OpenGL-capable RGB visual with depth buffer */
vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
if (vi == NULL) {
vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
if (vi == NULL)
XtAppError(app, "no RGB visual with depth buffer");
doubleBuffer = GL_FALSE;
}
for (i = 0; i < NUM_FONT_ENTRIES; i++) {
fontEntry[i].xfont = XLoadQueryFont(dpy, fontEntry[i].xlfd);
if (i == 0 && !fontEntry[i].xfont)
XtAppError(app, "could not get basic font");
}
fontEntry[0].fontinfo = SuckGlyphsFromServer(dpy, fontEntry[0].xfont->fid);
if (!fontEntry[0].fontinfo)
XtAppError(app, "could not get font glyphs");
/* create an OpenGL rendering context */
cx = glXCreateContext(dpy, vi, /* no display list sharing */ None,
/* favor direct */ GL_TRUE);
if (cx == NULL)
XtAppError(app, "could not create rendering context");
/* create an X colormap since probably not using default visual */
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
vi->visual, AllocNone);
XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth,
XtNcolormap, cmap, NULL);
XtAddEventHandler(toplevel, StructureNotifyMask, False,
map_state_changed, NULL);
mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0);
XtManageChild(mainw);
/* create menu bar */
menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0);
XtManageChild(menubar);
/* hack around Xt's ignorance of visuals */
XtSetArg(menuPaneArgs[0], XmNdepth, DefaultDepthOfScreen(XtScreen(mainw)));
XtSetArg(menuPaneArgs[1],
XmNcolormap, DefaultColormapOfScreen(XtScreen(mainw)));
/* create File pulldown menu: Quit */
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 2);
btn = XmCreatePushButton(menupane, "Quit", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, quit, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "File", args, 1);
XtManageChild(cascade);
/* create Options pulldown menu: Motion, Dolly, Rotate, Wobble */
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 2);
btn = XmCreateToggleButton(menupane, "Motion", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) toggle, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Dolly", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) dolly, NULL);
XtVaSetValues(btn, XmNset, True, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Rotate", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) rotate, NULL);
XtManageChild(btn);
btn = XmCreateToggleButton(menupane, "Wobble", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) wobble, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Options", args, 1);
XtManageChild(cascade);
XtSetArg(menuPaneArgs[2], XmNradioBehavior, True);
XtSetArg(menuPaneArgs[3], XmNradioAlwaysOne, True);
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 4);
XtAddCallback(menupane, XmNentryCallback, (XtCallbackProc) fontSelect, NULL);
for (i = 0; i < NUM_FONT_ENTRIES; i++) {
btn = XmCreateToggleButton(menupane, fontEntry[i].name, NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc) neverCalled, &fontEntry[i]);
if (i == 0)
XtVaSetValues(btn, XmNset, True, NULL);
if (!fontEntry[i].xfont)
XtSetSensitive(btn, False);
XtManageChild(btn);
}
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Font", args, 1);
XtManageChild(cascade);
/* create framed drawing area for OpenGL rendering */
frame = XmCreateFrame(mainw, "frame", NULL, 0);
XtManageChild(frame);
glxarea = XtCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass,
frame, NULL, 0);
XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc) draw, NULL);
XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
XtAddCallback(glxarea, XmNinputCallback, input, NULL);
/* set up application's window layout */
XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame);
XtRealizeWidget(toplevel);
/*
* Once widget is realized (ie, associated with a created X window), we
* can bind the OpenGL rendering context to the window.
*/
glXMakeCurrent(dpy, XtWindow(glxarea), cx);
made_current = GL_TRUE;
/* setup OpenGL state */
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearDepth(1.0);
glMatrixMode(GL_PROJECTION);
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 80);
glMatrixMode(GL_MODELVIEW);
MakeCube();
if (argv[1] != NULL) {
numMessages = argc - 1;
messages = &argv[1];
} else {
numMessages = NUM_DEFAULT_MESSAGES;
messages = defaultMessage;
}
base = glGenLists(numMessages + 1);
SetupMessageDisplayList(&fontEntry[0], numMessages, messages);
tick();
/* start event processing */
XtAppMainLoop(app);
}
main(int argc, char *argv[])
{
int i;
exename= argv[0];
if (argc>1) { /* Check for command line arguments */
i= 1;
while ((--argc > 0) && (argv[i][0]=='-')) {
int c= argv[i][1];
switch (c) {
case 'a':
automanage= 1;
fprintf(stderr,"%s: Windows will be automanaged.\n",argv[0]);
break;
default:
fprintf(stderr,"%s: illegal option %c\n",argv[0],c);
fprintf(stderr,"usage: %s [-a]\n",argv[0]);
argc= 0;
break;
}
i++;
}
}
if (!automanage) {
Arg args[16];
Widget toplevel, main_window, menu_bar, menu_pane, button;
Widget draw_form;
XmString title_string;
int width=300, height=300;
i = 0;
toplevel = XtInitialize("p3d", "xpainter", NULL, 0, &i, NULL);
i= 0;
main_window= XmCreateMainWindow(toplevel, "main_window", args, i);
i= 0;
menu_bar= XmCreateMenuBar(main_window, "menu_bar", args, i);
XtManageChild(menu_bar);
i= 0;
menu_pane= XmCreatePulldownMenu(menu_bar, "menu_pane", args, i);
title_string= XmStringCreateSimple("File");
i= 0;
XtSetArg(args[i], XmNsubMenuId, menu_pane); i++;
XtSetArg(args[i], XmNlabelString, title_string); i++;
button= XmCreateCascadeButton(menu_bar,"file",args,i);
if (title_string) XmStringFree(title_string);
XtManageChild(button);
title_string= XmStringCreateSimple("Show");
i= 0;
XtSetArg(args[i], XmNlabelString, title_string); i++;
button= XmCreatePushButtonGadget(menu_pane,"show",args,i);
XtAddCallback(button,XmNactivateCallback,show_cb,NULL);
if (title_string) XmStringFree(title_string);
XtManageChild(button);
title_string= XmStringCreateSimple("Exit");
i= 0;
XtSetArg(args[i], XmNlabelString, title_string); i++;
button= XmCreatePushButtonGadget(menu_pane,"exit",args,i);
XtAddCallback(button,XmNactivateCallback,exit_cb,NULL);
if (title_string) XmStringFree(title_string);
XtManageChild(button);
i= 0;
draw_form= XmCreateForm(main_window,"draw_form", args, i);
XtManageChild(draw_form);
i = 0;
XtSetArg(args[i], XtNwidth, width); i++;
XtSetArg(args[i], XtNheight, height); i++;
XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM); i++;
XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM); i++;
XtSetArg(args[i], XmNleftAttachment, XmATTACH_FORM); i++;
#ifdef USE_OPENGL
XtSetArg(args[i], GLwNrgba, TRUE); i++;
XtSetArg(args[i], GLwNdoublebuffer, TRUE); i++;
XtSetArg(args[i], GLwNdepthSize, 16); i++;
XtSetArg(args[i], GLwNallocateBackground, TRUE); i++;
XtSetArg(args[i], GLwNinstallBackground, TRUE); i++;
drawa= GLwCreateMDrawingArea(draw_form, "spina", args, i);
#else
XtSetArg(args[i], GlxNglxConfig, glxconfig); i++;
drawa= GlxCreateMDraw(draw_form, "spina", args, i);
#endif
XtManageChild(drawa);
i = 0;
XtSetArg(args[i], XtNwidth, width); i++;
XtSetArg(args[i], XtNheight, height); i++;
XtSetArg(args[i], XmNtopAttachment, XmATTACH_FORM); i++;
XtSetArg(args[i], XmNbottomAttachment, XmATTACH_FORM); i++;
XtSetArg(args[i], XmNleftAttachment, XmATTACH_WIDGET); i++;
XtSetArg(args[i], XmNleftWidget, drawa); i++;
XtSetArg(args[i], XmNrightAttachment, XmATTACH_FORM); i++;
#ifdef USE_OPENGL
XtSetArg(args[i], GLwNrgba, TRUE); i++;
XtSetArg(args[i], GLwNdoublebuffer, TRUE); i++;
XtSetArg(args[i], GLwNdepthSize, 16); i++;
XtSetArg(args[i], GLwNallocateBackground, TRUE); i++;
XtSetArg(args[i], GLwNinstallBackground, TRUE); i++;
drawb= GLwCreateMDrawingArea(draw_form, "spinb", args, i);
#else
XtSetArg(args[i], GlxNglxConfig, glxconfig); i++;
drawb= GlxCreateMDraw(draw_form, "spinb", args, i);
#endif
XtManageChild(drawb);
XtManageChild(main_window);
XtRealizeWidget(toplevel);
}
else { /* automanage renderers */
dp_init_ren("myrena", "gl","",
"title=\"Ren A\",size=\"256x256+200+200\"");
dp_init_ren("myrenb", "gl","",
"title=\"Ren B\",size=\"300x400+500+500\"");
fprintf(stderr, "%s: renderer initialized\n",exename);
dp_print_ren("myrena");
dp_print_ren("myrenb");
rens_initialized= 1;
build_geom();
}
if (!automanage) {
XtMainLoop();
}
else {
fprintf(stderr, "%s: about to render\n",exename);
for (i=0; i<180; i++) make_new_snaps();
finish_and_shutdown();
}
}
void create_segmentation_menu(Widget parent)
{
Widget segmentation_menu_pane, segmentation_menu_button,
region_detection_button, region_detection_pane, region_growing_button,
grow_image_button, watershed_button, split_merge_button,
segmentation_sep_1, edge_detection_button, edge_detection_pane,
edge_sobel_button, hough_button, edge_prewitt_button, edge_frei_button,
edge_marr_button, edge_roberts_button, edge_vert_button,
edge_horiz_button, edge_hv_button, edge_unsharp_button,
segmentation_sep_2, mixed_methods_button, mixed_methods_pane, mixed_button,
region_growing_pane, grow_region_button;
/* Create the menu pane for the menu */
segmentation_menu_pane = XmCreatePulldownMenu(parent, "segmentation menu pane ", NULL, 0);
/* Populate the menu pane */
/* Region detection button */
region_detection_pane = XmCreatePulldownMenu(segmentation_menu_pane, "region detection pane",
NULL, 0);
/* Region growing button */
region_growing_pane = XmCreatePulldownMenu(region_detection_pane,
"region growing pane",NULL, 0);
grow_region_button = XmCreatePushButton(region_growing_pane,
"Grow Regions in 3D ... ", NULL, 0);
create_region_dialog(parent);
XtManageChild(grow_region_button);
XtAddCallback(grow_region_button, XmNactivateCallback,
(XtCallbackProc) activate_region_dialog, (XtPointer) NULL);
grow_image_button = XmCreatePushButton(region_growing_pane,
"Grow Images in 3D ... ", NULL, 0);
XtManageChild(grow_image_button);
XtAddCallback(grow_image_button, XmNactivateCallback,
(XtCallbackProc) activate_image_dialog, (XtPointer) NULL);
/* Submenus of Region Growing*/
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, region_growing_pane); argcount++;
region_growing_button = XmCreateCascadeButton(region_detection_pane,
"Region Growing", args, argcount );
XtManageChild(region_growing_button);
watershed_button = XmCreatePushButton(region_detection_pane, "Watershed ", NULL, 0);
XtManageChild(watershed_button);
create_sigma_dialog(parent);
XtAddCallback(watershed_button, XmNactivateCallback,
(XtCallbackProc) activate_total_gradient_dialog, (XtPointer) NULL);
split_merge_button = XmCreatePushButton(region_detection_pane, "Split-Merge", NULL, 0);
create_split_dialog(parent);
/* XtManageChild(split_merge_button); */
XtAddCallback(split_merge_button, XmNactivateCallback,
(XtCallbackProc) activate_split_dialog, (XtPointer) NULL);
/* Submenus of Region */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, region_detection_pane); argcount++;
region_detection_button = XmCreateCascadeButton(segmentation_menu_pane, "Region Detection",
args, argcount );
XtManageChild(region_detection_button);
/* Separator 1 */
segmentation_sep_1 = XmCreateSeparator(segmentation_menu_pane, "segmentation sep 1", NULL, 0);
XtManageChild(segmentation_sep_1);
/* Edge detection button */
edge_detection_pane = XmCreatePulldownMenu(segmentation_menu_pane, "edge detection pane", NULL, 0);
edge_sobel_button = XmCreatePushButton(edge_detection_pane, "Edge Sobel", NULL, 0);
/* XtManageChild(edge_sobel_button); */
XtAddCallback(edge_sobel_button, XmNactivateCallback,
(XtCallbackProc) edge_sobel_callback, (XtPointer) NULL);
hough_button = XmCreatePushButton(edge_detection_pane, "Hough", NULL, 0);
/* XtManageChild(hough_button); */
create_hough_dialog(parent); /* Dialogo*/
XtAddCallback(hough_button, XmNactivateCallback,
(XtCallbackProc) activate_hough_dialog, (XtPointer) NULL);
edge_prewitt_button = XmCreatePushButton(edge_detection_pane, "Edge Prewitt", NULL, 0);
/* XtManageChild(edge_prewitt_button); */
XtAddCallback(edge_prewitt_button, XmNactivateCallback,
(XtCallbackProc) edge_prewitt_callback, (XtPointer) NULL);
edge_frei_button = XmCreatePushButton(edge_detection_pane, "Edge Frei", NULL, 0);
/* XtManageChild(edge_frei_button); */
XtAddCallback(edge_frei_button, XmNactivateCallback,
(XtCallbackProc) edge_frei_callback, (XtPointer) NULL);
edge_marr_button = XmCreatePushButton(edge_detection_pane, "Edge Marr", NULL, 0);
/* XtManageChild(edge_marr_button); */
XtAddCallback(edge_marr_button, XmNactivateCallback,
(XtCallbackProc) edge_marr_callback, (XtPointer) NULL);
edge_roberts_button = XmCreatePushButton(edge_detection_pane, "Edge Roberts", NULL, 0);
/* XtManageChild(edge_roberts_button); */
XtAddCallback(edge_roberts_button, XmNactivateCallback,
(XtCallbackProc) edge_roberts_callback, (XtPointer) NULL);
edge_vert_button = XmCreatePushButton(edge_detection_pane, "Edge Vert.", NULL, 0);
/* XtManageChild(edge_vert_button); */
XtAddCallback(edge_vert_button, XmNactivateCallback,
(XtCallbackProc) edge_vert_callback, (XtPointer) NULL);
edge_horiz_button = XmCreatePushButton(edge_detection_pane, "Erode", NULL, 0);
XtManageChild(edge_horiz_button);
create_edge_dilate_dialog(parent);
XtAddCallback(edge_horiz_button, XmNactivateCallback,
(XtCallbackProc) activate_edge_dilate_dialog, (XtPointer) NULL);
edge_hv_button = XmCreatePushButton(edge_detection_pane, "Dilate", NULL, 0);
XtManageChild(edge_hv_button);
create_edge_hv_dialog(parent);
XtAddCallback(edge_hv_button, XmNactivateCallback,
(XtCallbackProc) activate_edge_hv_dialog, (XtPointer) NULL);
edge_unsharp_button = XmCreatePushButton(edge_detection_pane, "Edge Unsharp", NULL, 0);
/* XtManageChild(edge_unsharp_button); */
XtAddCallback(edge_unsharp_button, XmNactivateCallback,
(XtCallbackProc) edge_unsharp_callback, (XtPointer) NULL);
/* Submenus del Edge */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, edge_detection_pane); argcount++;
edge_detection_button = XmCreateCascadeButton(segmentation_menu_pane, "Edge Detection",
args, argcount );
XtManageChild(edge_detection_button);
/* Separator 2 */
segmentation_sep_2 = XmCreateSeparator(segmentation_menu_pane, "segmentation sep 2", NULL, 0);
XtManageChild(segmentation_sep_2);
/* Mixed button */
mixed_methods_pane = XmCreatePulldownMenu(segmentation_menu_pane, "mixed methods pane", NULL, 0);
mixed_button = XmCreatePushButton(mixed_methods_pane, "Mixed Methods", NULL, 0);
/* XtManageChild(mixed_button); */
/* XtAddCallback(mixed_button, XmNactivateCallback,
(XtCallbackProc) mixed_callback, (XtPointer) NULL);
*/
/* Submenus del Mixed */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, mixed_methods_pane); argcount++;
mixed_methods_button = XmCreateCascadeButton(segmentation_menu_pane, "Mixed Methods",
args, argcount );
/* XtManageChild(mixed_methods_button); */
/* Create the segmentation cascade button on the menu bar and */
/* attach the about menu pane to it. */
argcount = 0;
XtSetArg(args[argcount], XmNsubMenuId, segmentation_menu_pane); argcount++;
segmentation_menu_button = XmCreateCascadeButton(parent, "Segmentation ",
args, argcount);
XtManageChild(segmentation_menu_button);
}
main(int argc, char *argv[])
{
toplevel = XtAppInitialize(&app, "Paperplane", NULL, 0, &argc, argv,
fallbackResources, NULL, 0);
dpy = XtDisplay(toplevel);
/* find an OpenGL-capable RGB visual with depth buffer */
vi = glXChooseVisual(dpy, DefaultScreen(dpy), dblBuf);
if (vi == NULL) {
vi = glXChooseVisual(dpy, DefaultScreen(dpy), snglBuf);
if (vi == NULL)
XtAppError(app, "no RGB visual with depth buffer");
doubleBuffer = GL_FALSE;
}
/* create an OpenGL rendering context */
cx = glXCreateContext(dpy, vi, /* no display list sharing */ None,
/* favor direct */ GL_TRUE);
if (cx == NULL)
XtAppError(app, "could not create rendering context");
/* create an X colormap since probably not using default visual */
#ifdef noGLwidget
cmap = XCreateColormap(dpy, RootWindow(dpy, vi->screen),
vi->visual, AllocNone);
/*
* Establish the visual, depth, and colormap of the toplevel
* widget _before_ the widget is realized.
*/
XtVaSetValues(toplevel, XtNvisual, vi->visual, XtNdepth, vi->depth,
XtNcolormap, cmap, NULL);
#endif
XtAddEventHandler(toplevel, StructureNotifyMask, False,
map_state_changed, NULL);
mainw = XmCreateMainWindow(toplevel, "mainw", NULL, 0);
XtManageChild(mainw);
/* create menu bar */
menubar = XmCreateMenuBar(mainw, "menubar", NULL, 0);
XtManageChild(menubar);
#ifdef noGLwidget
/* Hack around Xt's unfortunate default visual inheritance. */
XtSetArg(menuPaneArgs[0], XmNvisual, vi->visual);
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
btn = XmCreatePushButton(menupane, "Quit", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, quit, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "File", args, 1);
XtManageChild(cascade);
#ifdef noGLwidget
menupane = XmCreatePulldownMenu(menubar, "menupane", menuPaneArgs, 1);
#else
menupane = XmCreatePulldownMenu(menubar, "menupane", NULL, 0);
#endif
btn = XmCreateToggleButton(menupane, "Motion", NULL, 0);
XtAddCallback(btn, XmNvalueChangedCallback, (XtCallbackProc)toggle, NULL);
XtManageChild(btn);
btn = XmCreatePushButton(menupane, "Add plane", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)add_plane, NULL);
XtManageChild(btn);
btn = XmCreatePushButton(menupane, "Remove plane", NULL, 0);
XtAddCallback(btn, XmNactivateCallback, (XtCallbackProc)remove_plane, NULL);
XtManageChild(btn);
XtSetArg(args[0], XmNsubMenuId, menupane);
cascade = XmCreateCascadeButton(menubar, "Planes", args, 1);
XtManageChild(cascade);
/* create framed drawing area for OpenGL rendering */
frame = XmCreateFrame(mainw, "frame", NULL, 0);
XtManageChild(frame);
#ifdef noGLwidget
glxarea = XtVaCreateManagedWidget("glxarea", xmDrawingAreaWidgetClass,
frame, NULL);
#else
#ifdef noMotifGLwidget
/* notice glwDrawingAreaWidgetClass lacks an 'M' */
glxarea = XtVaCreateManagedWidget("glxarea", glwDrawingAreaWidgetClass,
#else
glxarea = XtVaCreateManagedWidget("glxarea", glwMDrawingAreaWidgetClass,
#endif
frame, GLwNvisualInfo, vi, NULL);
#endif
XtAddCallback(glxarea, XmNexposeCallback, (XtCallbackProc)draw, NULL);
XtAddCallback(glxarea, XmNresizeCallback, resize, NULL);
XtAddCallback(glxarea, XmNinputCallback, input, NULL);
/* set up application's window layout */
XmMainWindowSetAreas(mainw, menubar, NULL, NULL, NULL, frame);
XtRealizeWidget(toplevel);
/*
* Once widget is realized (ie, associated with a created X window), we
* can bind the OpenGL rendering context to the window.
*/
glXMakeCurrent(dpy, XtWindow(glxarea), cx);
made_current = GL_TRUE;
/* setup OpenGL state */
glClearDepth(1.0);
glClearColor(0.0, 0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glFrustum(-1.0, 1.0, -1.0, 1.0, 1.0, 20);
glMatrixMode(GL_MODELVIEW);
/* add three initial random planes */
srandom(getpid());
add_plane(); add_plane(); add_plane(); add_plane(); add_plane();
/* start event processing */
toggle();
XtAppMainLoop(app);
}
