//
// Create a new foe window
// SG 09.02.91 : Create a new toplevel widget and give it an pixmap icon
// SG : 13.02.91 Fetch a caution box and save the id of the widget in the
// foe context for futher use
// SG : 24.02.91 Fetch a widget ( again !) . This time a message box
// SG : 24.03.91 Send the routine the desired position (x_top , y_top)
// and the desired size ( width_adb , height_adb ) for the window to be created.
// The two first parameters are set to the top level widget
// and the two last paramters are set to the adb widget (see in uil file
// the widget hierarchy )
// SG 14.04.91 A new widget to fetch , the help widget !
// SG 2.05.91 New parameter : function ( edit , trace , view , simulate ..)
// to indicate which neted events and which menu entries should be alllowed.
//
pwr_tStatus WFoeMotif::create_window( int x_top,
int y_top,
int width_adb,
int height_adb,
ldh_tSesContext ldhsession,
foe_eFuncAccess function_access)
{
Arg args[20];
int sts;
Widget *children;
int i, num_children;
XmString TitleStr;
Dimension icon_w, icon_h;
/* DRM database hierarchy related variables */
MrmHierarchy s_MrmH;
MrmType dclass;
char uid_filename[200] = {"pwr_exe:wb_foe.uid"};
char *uid_filename_p = uid_filename;
static Atom MwmDeleteWind = 0;
static char translations[] = "\
<FocusIn>: foe_inputfocus()\n";
static XtTranslations compiled_translations = NULL;
static XtActionsRec actions[] =
{
{(char*) "foe_inputfocus", (XtActionProc) action_inputfocus}
};
sts = dcli_translate_filename( uid_filename, uid_filename);
if ( EVEN(sts)) {
printf( "** pwr_exe is not defined\n");
exit(0);
}
/*
* Now start the module creation
*/
/* Save the context structure in the widget */
XtSetArg (args[0], XmNuserData, (XtPointer) this);
/*
* Create a new main widget
*/
/*
* Open the UID files (the output of the UIL compiler) in the hierarchy
* Register the items DRM needs to bind for us.
* Create a new neted-widget
* Close the hierarchy
* Compile the additional button translations and augment and add actions
*/
sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_MrmH);
if (sts != MrmSUCCESS) {
printf("can't open hierarchy\n");
return 0;
}
register_callbacks();
/* SG 09.02.91 : create the new hierarchy. By the way use a pixmap define
with help of wb_foe_ptrn.h */
/* create a pixmap for the icon */
if ( icon_pixmap == 0 )
sts = MrmFetchBitmapLiteral(s_MrmH,(char*) "icon",
XtScreen(parent_wid), XtDisplay(parent_wid),
&icon_pixmap, &icon_w, &icon_h);
i=0;
XtSetArg(args[i],XmNiconName,name); i++;
XtSetArg(args[i],XtNiconPixmap,icon_pixmap); i++;
/* SG 11.02.91 Save the id of the top in the context */
parent_wid = XtCreatePopupShell("plcEditor",
topLevelShellWidgetClass, parent_wid, args, i);
if (compiled_translations == NULL)
XtAppAddActions( XtWidgetToApplicationContext( parent_wid),
actions, XtNumber(actions));
/* the positioning of a top level can only be define after the creation
of the widget . So i do it know:
SG 24.02.91 use the parameters received x and y
*/
i=0;
XtSetArg(args[i],XmNx,x_top);i++;
XtSetArg(args[i],XmNy,y_top);i++;
XtSetArg(args[i],XtNallowShellResize,TRUE), i++;
if ( ! map_window) {
XtSetArg(args[i],XmNmappedWhenManaged,FALSE); i++;
}
XtSetValues( parent_wid, args, i);
XtSetArg (args[0], XmNuserData, (XtPointer) this);
/* now that we have a top level we can get the main window */
sts = MrmFetchWidgetOverride(s_MrmH, (char*) "foe_window", parent_wid ,
name, args, 1,
&widgets.foe_window, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch foedit widget\n");
/* SG 24.02.91 Set the width and hight desired for the main window to his
child the adb widget */
i=0;
XtSetArg(args[i],XmNwidth,width_adb);i++;
XtSetArg(args[i],XmNheight,height_adb);i++;
XtSetValues( widgets.adb ,args,i);
/* SG 24.02.91
Get a litle message box widget that you will make appears when you want by
calling foe_msgbox
*/
if (MrmFetchWidget (s_MrmH,
(char*) "foe_msgbox",
widgets.foe_window,
&widgets.msgbox,
&dclass) != MrmSUCCESS)
printf("can't fetch msgbox \n");
TitleStr = XmStringCreateLtoR((char*) "PlcEdit Message" , (char*) "ISO8859-1");
XtSetArg(args[0],XmNdialogTitle,TitleStr);
XtSetValues( widgets.msgbox, args, 1);
XmStringFree(TitleStr);
/* SG 13.02.91
Get a litle caution widget that you will make appears when you want by
calling foe_popupmsg
*/
if (MrmFetchWidget (s_MrmH,
(char*) "foe_popupmsg",
widgets.foe_window,
&widgets.caution,
&dclass) != MrmSUCCESS)
printf("can't fetch popupmsg\n");
TitleStr = XmStringCreateLtoR((char*) "PlcEdit Confirm" , (char*) "ISO8859-1");
XtSetArg(args[0],XmNdialogTitle,TitleStr);
XtSetValues( widgets.caution, args, 1);
XmStringFree(TitleStr);
/* create the pane widgets */
/* create the palette module */
/* SG 07.03.91 put two palletes in the sub pane widget */
node_palctx = new PalMotif( this, widgets.subpane, "Objects",
ldhsession, "PlcEditorPalette",
&widgets.node_palette, &sts);
node_palette_managed = 1;
navctx = new NavMotif( this, widgets.subpane, "Plant",
ldhsession, "NavigatorW1",
&widgets.nav_palette, &sts);
XtUnmanageChild( widgets.nav_palette);
con_palctx = new PalMotif( this, widgets.subpane, "Connections",
ldhsession, "PlcEditorConPalette",
&widgets.con_palette, &sts);
XtUnmanageChild( widgets.con_palette);
/* Turn off traversal for sash widgets */
XtVaGetValues(widgets.subpane,
XmNchildren, &children,
XmNnumChildren, &num_children,
NULL);
for (i = 0; i < num_children; i++) {
if (XmIsSash(children[i]))
XtVaSetValues(children[i], XmNtraversalOn, False, NULL);
}
/* create the gredit module */
XtManageChild(widgets.foe_window);
gre = new WGreMotif( this, widgets.pane, "Name");
((WGreMotif *)gre)->new_navigator( widgets.subpane);
if ( map_window)
XtPopup(parent_wid, XtGrabNone);
else
XtRealizeWidget( parent_wid);
gre->init();
/* create the setup ie:
enable netedevents,
enable menu entries
setup backcalls from the gredit module */
function_setup();
MrmCloseHierarchy(s_MrmH);
if (compiled_translations == NULL)
compiled_translations = XtParseTranslationTable(translations);
XtOverrideTranslations( widgets.foe_window, compiled_translations);
XtUnmanageChild(widgets.textinput);
if ( !(CoLogin::privilege() & pwr_mPrv_DevPlc ) ||
(function_access == foe_eFuncAccess_View)) {
/* Mode Edit and Simulate is not allowed */
i=0;
XtSetArg(args[i],XmNsensitive,0); i++;
XtSetValues( widgets.edit_togg,args,i);
XtSetValues( widgets.simulate_togg,args,i);
}
if (MwmDeleteWind == 0)
MwmDeleteWind = XInternAtom(XtDisplay(parent_wid), "WM_DELETE_WINDOW", FALSE);
if (MwmDeleteWind != 0) {
XtVaSetValues(parent_wid, XmNdeleteResponse, XmDO_NOTHING, NULL);
XmAddWMProtocolCallback(parent_wid, MwmDeleteWind,
(XtCallbackProc)activate_quit, this);
}
CoWowMotif::GetAtoms( parent_wid, 0, &objid_atom, 0);
/* SG 09.02.91 a top level should always be realized !
* ML 16.03.94 changed Realize to Popup
*/
return FOE__SUCCESS;
}
//
// Create a new ute window
//
WUtedGtk::WUtedGtk( void *wu_parent_ctx,
GtkWidget *wu_parent_wid,
const char *wu_name,
const char *wu_iconname,
ldh_tWBContext wu_ldhwb,
ldh_tSesContext wu_ldhses,
int wu_editmode,
void (*wu_quit_cb)(void *),
pwr_tStatus *status) :
WUted(wu_parent_ctx,wu_name,wu_iconname,wu_ldhwb,wu_ldhses,wu_editmode,wu_quit_cb,
status), parent_wid(wu_parent_wid), cursor(0)
{
const int window_width = 800;
const int window_height = 400;
memset( &widgets, 0, sizeof(widgets));
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
NULL);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
CoWowGtk::SetWindowIcon( toplevel);
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File Entry
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_quit), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// View Entry
GtkWidget *view_show_cmd = gtk_menu_item_new_with_mnemonic( "_Show Current Command");
g_signal_connect( view_show_cmd, "activate",
G_CALLBACK(activate_show_cmd), this);
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_show_cmd);
GtkWidget *view = gtk_menu_item_new_with_mnemonic("_View");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Commands entry
GtkMenu *commands_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
GtkMenu *current_menu = commands_menu;
int j = 0;
int in_submenu = 0;
uted_sCommand *next_cmd;
for ( uted_sCommand *command_ptr = commands; command_ptr->command[0]; command_ptr++) {
// Build submenu if first command verb is equal to next
char cmd_verb[5][80];
int num;
char next_cmd_verb[5][80];
int next_num;
num = dcli_parse( command_ptr->command, " ", "", (char *)cmd_verb,
sizeof( cmd_verb) / sizeof( cmd_verb[0]), sizeof( cmd_verb[0]), 0);
next_cmd = command_ptr + 1;
int close_submenu = 0;
if ( next_cmd->command[0]) {
next_num = dcli_parse( next_cmd->command, " ", "", (char *)next_cmd_verb,
sizeof( next_cmd_verb) / sizeof( next_cmd_verb[0]),
sizeof( next_cmd_verb[0]), 0);
if ( in_submenu) {
// Check if time to close menu
if ( strcmp( cmd_verb[0], next_cmd_verb[0]) != 0) {
// Close submenu
close_submenu = 1;
}
}
else if ( strcmp( cmd_verb[0], next_cmd_verb[0]) == 0) {
// Open submenu
GtkWidget *submenu_item = gtk_menu_item_new_with_label( cmd_verb[0]);
GtkMenu *submenu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(submenu_item),
GTK_WIDGET(submenu));
gtk_menu_shell_append(GTK_MENU_SHELL(commands_menu), submenu_item);
current_menu = submenu;
in_submenu = 1;
}
}
else if ( in_submenu) {
// Last command
close_submenu = 1;
}
widgets.optmenubuttons[j] = gtk_menu_item_new();
widgets.optmenubuttonslabel[j] = gtk_label_new( command_ptr->command);
gtk_misc_set_alignment( GTK_MISC(widgets.optmenubuttonslabel[j]), 0.0, 0.5);
gtk_container_add( GTK_CONTAINER(widgets.optmenubuttons[j]),
widgets.optmenubuttonslabel[j]);
g_signal_connect( widgets.optmenubuttons[j], "activate",
G_CALLBACK(activate_command), this);
gtk_menu_shell_append(GTK_MENU_SHELL(current_menu), widgets.optmenubuttons[j]);
if ( close_submenu) {
current_menu = commands_menu;
in_submenu = 0;
}
j++;
}
GtkWidget *commands = gtk_menu_item_new_with_mnemonic("_Commands");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), commands);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(commands), GTK_WIDGET(commands_menu));
// Menu Help
GtkWidget *help_utils = gtk_image_menu_item_new_with_mnemonic("_On Window");
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_utils),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_utils, "activate", G_CALLBACK(activate_helputils), this);
gtk_widget_add_accelerator( help_utils, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *help_cmd = gtk_menu_item_new_with_mnemonic( "On _Commands");
g_signal_connect( help_cmd, "activate",
G_CALLBACK(activate_helppwr_plc), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_utils);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_cmd);
GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Qualifier labels, entries and checkboxes
GtkWidget *qual_box_qual = gtk_vbox_new( FALSE, 0);
GtkWidget *qual_box_value = gtk_vbox_new( FALSE, 0);
for ( j = 0; j < 10; j++) {
widgets.qualifier[j] = gtk_label_new( "Qual");
gtk_widget_set_size_request( widgets.qualifier[j], 120, 20);
gtk_misc_set_alignment( GTK_MISC(widgets.qualifier[j]), 0.0, 0.5);
gtk_box_pack_start( GTK_BOX(qual_box_qual), widgets.qualifier[j], FALSE, FALSE, 5);
GtkWidget *box = gtk_hbox_new( FALSE, 0);
widgets.value[j] = gtk_entry_new();
gtk_widget_set_size_request( widgets.value[j], -1, 20);
gtk_box_pack_start( GTK_BOX(box), widgets.value[j], TRUE, TRUE, 0);
widgets.present[j] = gtk_check_button_new();
gtk_widget_set_size_request( widgets.present[j], -1, 20);
gtk_box_pack_start( GTK_BOX(box), widgets.present[j], FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(qual_box_value), box, FALSE, FALSE, 5);
}
g_signal_connect( widgets.present[0], "toggled", G_CALLBACK(activate_present1), this);
g_signal_connect( widgets.present[1], "toggled", G_CALLBACK(activate_present2), this);
g_signal_connect( widgets.present[2], "toggled", G_CALLBACK(activate_present3), this);
g_signal_connect( widgets.present[3], "toggled", G_CALLBACK(activate_present4), this);
g_signal_connect( widgets.present[4], "toggled", G_CALLBACK(activate_present5), this);
g_signal_connect( widgets.present[5], "toggled", G_CALLBACK(activate_present6), this);
g_signal_connect( widgets.present[6], "toggled", G_CALLBACK(activate_present7), this);
g_signal_connect( widgets.present[7], "toggled", G_CALLBACK(activate_present8), this);
g_signal_connect( widgets.present[8], "toggled", G_CALLBACK(activate_present9), this);
g_signal_connect( widgets.present[9], "toggled", G_CALLBACK(activate_present10), this);
// Command label
GtkWidget *cmdlabel = gtk_label_new( "Command");
widgets.commandlabel = gtk_label_new( "No command selected");
gtk_misc_set_alignment( GTK_MISC(widgets.commandlabel), 0.0, 0.5);
gtk_widget_set_size_request( widgets.commandlabel, 140, -1);
GtkWidget *vbox_command = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox_command), cmdlabel, FALSE, FALSE, 10);
gtk_box_pack_start( GTK_BOX(vbox_command), widgets.commandlabel, FALSE, FALSE, 10);
// Apply button
GtkWidget *applybutton = gtk_button_new_with_label( "Apply");
gtk_widget_set_size_request( applybutton, 70, 25);
g_signal_connect( applybutton, "clicked",
G_CALLBACK(activate_ok), this);
GtkWidget *left_box = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(left_box), vbox_command, FALSE, FALSE, 10);
GtkWidget *button_box = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(button_box), applybutton, FALSE, FALSE, 50);
GtkWidget *qual_box = gtk_hbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(qual_box), left_box, FALSE, FALSE, 10);
gtk_box_pack_start( GTK_BOX(qual_box), gtk_vseparator_new(), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(qual_box), qual_box_qual, FALSE, FALSE, 10);
gtk_box_pack_start( GTK_BOX(qual_box), qual_box_value, TRUE, TRUE, 10);
// Statusbar
GtkWidget *statusbar = gtk_hbox_new( FALSE, 0);
widgets.label = gtk_label_new( "");
gtk_box_pack_start( GTK_BOX(statusbar), widgets.label, FALSE, FALSE, 20);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), qual_box, TRUE, TRUE, 0);
gtk_box_pack_start( GTK_BOX(vbox), gtk_hseparator_new(), FALSE, FALSE, 3);
gtk_box_pack_start( GTK_BOX(vbox), button_box, FALSE, FALSE, 3);
gtk_box_pack_start( GTK_BOX(vbox), statusbar, FALSE, FALSE, 3);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
batch_sts = UTED_BATCH_CURRSESS;
reset_qual();
enable_entries( wu_editmode);
#if 0
Arg args[20];
pwr_tStatus sts;
int i;
MrmHierarchy s_MrmH;
MrmType dclass;
/* DRM database hierarchy related variables */
static Pixmap icon = 0;
Dimension icon_w;
Dimension icon_h;
static Atom MwmDeleteWind = 0;
char uid_filename[200] = {"pwr_exe:wb_uted.uid"};
char *uid_filename_p = uid_filename;
static MrmRegisterArg reglist[] = {
/* First the context variable */
{ "uted_ctx", 0 },
/* Callbacks for the controlled foe widget */
{"uted_create_adb",(caddr_t)create_adb},
{"uted_create_quit",(caddr_t)create_quit},
{"uted_activate_quit",(caddr_t)activate_quit},
{"uted_create_commandlabel",(caddr_t)create_commandlabel},
{"uted_create_batchoptmenu",(caddr_t)create_batchoptmenu},
{"uted_create_batch",(caddr_t)create_batch},
{"uted_create_currsess",(caddr_t)create_currsess},
{"uted_create_file_entry",(caddr_t)create_file_entry},
{"uted_create_label",(caddr_t)create_label},
{"uted_create_adb",(caddr_t)create_adb},
{"uted_activate_command",(caddr_t)activate_command},
{"uted_create_command",(caddr_t)create_command},
{"uted_activate_batch",(caddr_t)activate_batch},
{"uted_activate_currsess",(caddr_t)activate_currsess},
{"uted_activate_ok",(caddr_t)activate_ok},
{"uted_activate_cancel",(caddr_t)activate_cancel},
{"uted_activate_show_cmd",(caddr_t)activate_show_cmd},
{"uted_create_commandwind_button",(caddr_t)create_commandwind_button},
{"uted_activate_cmd_wind",(caddr_t)activate_cmd_wind},
{"uted_create_cmd_wind",(caddr_t)create_cmd_wind},
{"uted_create_timelabel",(caddr_t)create_timelabel},
{"uted_create_timevalue",(caddr_t)create_timevalue},
{"uted_create_qualifier1",(caddr_t)create_qualifier1},
{"uted_create_value1",(caddr_t)create_value1},
{"uted_activate_present1",(caddr_t)activate_present1},
{"uted_create_present1",(caddr_t)create_present1},
{"uted_create_qualifier2",(caddr_t)create_qualifier2},
{"uted_create_value2",(caddr_t)create_value2},
{"uted_activate_present2",(caddr_t)activate_present2},
{"uted_create_present2",(caddr_t)create_present2},
{"uted_create_qualifier3",(caddr_t)create_qualifier3},
{"uted_create_value3",(caddr_t)create_value3},
{"uted_activate_present3",(caddr_t)activate_present3},
{"uted_create_present3",(caddr_t)create_present3},
{"uted_create_qualifier4",(caddr_t)create_qualifier4},
{"uted_create_value4",(caddr_t)create_value4},
{"uted_activate_present4",(caddr_t)activate_present4},
{"uted_create_present4",(caddr_t)create_present4},
{"uted_create_qualifier5",(caddr_t)create_qualifier5},
{"uted_create_value5",(caddr_t)create_value5},
{"uted_activate_present5",(caddr_t)activate_present5},
{"uted_create_present5",(caddr_t)create_present5},
{"uted_create_qualifier6",(caddr_t)create_qualifier6},
{"uted_create_value6",(caddr_t)create_value6},
{"uted_activate_present6",(caddr_t)activate_present6},
{"uted_create_present6",(caddr_t)create_present6},
{"uted_create_qualifier7",(caddr_t)create_qualifier7},
{"uted_create_value7",(caddr_t)create_value7},
{"uted_activate_present7",(caddr_t)activate_present7},
{"uted_create_present7",(caddr_t)create_present7},
{"uted_create_qualifier8",(caddr_t)create_qualifier8},
{"uted_create_value8",(caddr_t)create_value8},
{"uted_activate_present8",(caddr_t)activate_present8},
{"uted_create_present8",(caddr_t)create_present8},
{"uted_create_qualifier9",(caddr_t)create_qualifier9},
{"uted_create_value9",(caddr_t)create_value9},
{"uted_activate_present9",(caddr_t)activate_present9},
{"uted_create_present9",(caddr_t)create_present9},
{"uted_create_qualifier10",(caddr_t)create_qualifier10},
{"uted_create_value10",(caddr_t)create_value10},
{"uted_activate_present10",(caddr_t)activate_present10},
{"uted_create_present10",(caddr_t)create_present10},
{"uted_activate_helputils",(caddr_t)activate_helputils},
{"uted_activate_helppwr_plc",(caddr_t)activate_helppwr_plc},
{"uted_commandchanged",(caddr_t)commandchanged},
{"uted_qbox_cr",(caddr_t)qbox_cr},
{"uted_qbox_yes_cb",(caddr_t)qbox_yes_cb},
{"uted_qbox_no_cb",(caddr_t)qbox_no_cb},
{"uted_qbox_cancel_cb",(caddr_t)qbox_cancel_cb}
};
static int reglist_num = (sizeof reglist / sizeof reglist[0]);
/*
* Now start the module creation
*/
sts = dcli_translate_filename( uid_filename, uid_filename);
if ( EVEN(sts)) {
printf( "** pwr_exe is not defined\n");
exit(0);
}
/* set initialization values in context */
/* Save the context structure in the widget */
XtSetArg (args[0], XmNuserData, (unsigned int) this);
/*
* Create a new widget
* Open the UID files (the output of the UIL compiler) in the hierarchy
* Register the items DRM needs to bind for us.
* Create a new widget
* Close the hierarchy
* Compile the additional button translations and augment and add actions
*/
sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_MrmH);
if (sts != MrmSUCCESS) printf("can't open hierarchy\n");
reglist[0].value = (caddr_t) this;
MrmRegisterNames(reglist, reglist_num);
if (icon == 0)
sts = MrmFetchBitmapLiteral(s_MrmH,"icon",
XtScreen(parent_wid), XtDisplay(parent_wid),
&icon, &icon_w, &icon_h);
i=0;
XtSetArg(args[i],XmNiconName, wu_iconname); i++;
XtSetArg(args[i],XmNiconPixmap, icon); i++;
XtSetArg(args[i],XmNtitle, name); i++;
/* SG 11.02.91 Save the id of the top in the context */
parent_wid = XtCreatePopupShell("utilities",
topLevelShellGtkWidgetClass, parent_wid, args, i);
/* the positioning of a top level can only be define after the creation
of the widget . So i do it know:
SG 24.02.91 use the parameters received x and y
*/
i=0;
XtSetArg(args[i],XmNx,100);i++;
XtSetArg(args[i],XmNy,100);i++;
XtSetArg(args[i],XtNallowShellResize,TRUE), i++;
XtSetValues( parent_wid, args, i);
/* now that we have a top level we can get the main window */
sts = MrmFetchGtkWidgetOverride(s_MrmH, "uted_window", parent_wid ,
name, args, 1,
&widgets.uted_window, &dclass);
if (sts != MrmSUCCESS) printf("can't fetch utedit widget\n");
XtManageChild( widgets.uted_window);
/* SG 09.02.91 a top level should always be realized ! */
XtPopup( parent_wid, XtGrabNone );
/* Ask MRM to fetch the question box */
i=0;
if (MrmFetchGtkWidgetOverride(s_MrmH,
"uted_qbox",
widgets.uted_window,
0,
args , i,
&widgets.questionbox, &dclass) != MrmSUCCESS) {
printf("can't fetch uted_qbox widget\n");
}
MrmCloseHierarchy(s_MrmH);
reset_qual();
batch_sts = UTED_BATCH_CURRSESS;
XtSetArg(args[0],XmNsensitive, 0);
XtSetValues( widgets.timelabel,args,1);
XtUnmanageChild( widgets.timevalue);
XtUnmanageChild( widgets.command_window);
enable_entries( wu_editmode);
if (MwmDeleteWind == 0)
MwmDeleteWind = XInternAtom(XtDisplay(parent_wid), "WM_DELETE_WINDOW", FALSE);
if (MwmDeleteWind != 0)
{
XtVaSetValues( parent_wid, XmNdeleteResponse, XmDO_NOTHING, NULL);
XmAddWMProtocolCallback( parent_wid, MwmDeleteWind,
(XtCallbackProc) activate_quit, this);
}
#endif
*status = FOE__SUCCESS;
}
