static GtkWidget *radio_menu_item_new(GSList **group, const gchar *name)
{
GtkWidget *menu_item = gtk_radio_menu_item_new_with_mnemonic(*group, name);
*group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(menu_item));
return menu_item;
}
/**
* gtk_radio_menu_item_new_with_mnemonic_from_widget:
* @group: An existing #GtkRadioMenuItem
* @label: the text of the button, with an underscore in front of the
* mnemonic character
*
* Creates a new GtkRadioMenuItem containing a label. The label will be
* created using gtk_label_new_with_mnemonic(), so underscores in label
* indicate the mnemonic for the menu item.
*
* The new #GtkRadioMenuItem is added to the same group as @group.
*
* Return value: The new #GtkRadioMenuItem
*
* Since: 2.4
**/
GtkWidget *
gtk_radio_menu_item_new_with_mnemonic_from_widget (GtkRadioMenuItem *group,
const gchar *label)
{
GSList *list = NULL;
g_return_val_if_fail (GTK_IS_RADIO_MENU_ITEM (group), NULL);
if (group)
list = gtk_radio_menu_item_get_group (group);
return gtk_radio_menu_item_new_with_mnemonic (list, label);
}
static GtkWidget*
make_radio_menu_item (WindowAction action,
GSList **group,
const gchar *mnemonic_text)
{
GtkWidget *mi;
mi = gtk_radio_menu_item_new_with_mnemonic (*group, mnemonic_text);
*group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (mi));
g_signal_connect (G_OBJECT (mi), "activate",
G_CALLBACK (item_activated_callback),
GINT_TO_POINTER (action));
gtk_widget_show (mi);
return mi;
}
static VALUE
rmitem_initialize(int argc, VALUE *argv, VALUE self)
{
VALUE arg1, arg2, arg3;
GtkWidget *widget;
GSList *list = NULL;
const gchar *label = NULL;
const gchar *mnemonic = NULL;
if (rb_scan_args(argc, argv, "03", &arg1, &arg2, &arg3) > 0 &&
TYPE(arg1) == T_STRING) {
if (NIL_P(arg2) || RVAL2CBOOL(arg2))
mnemonic = RVAL2CSTR(arg1);
else
label = RVAL2CSTR(arg1);
} else {
if (!NIL_P(arg2)) {
if (NIL_P(arg3) || RVAL2CBOOL(arg3))
mnemonic = RVAL2CSTR(arg2);
else
label = RVAL2CSTR(arg2);
}
if (rb_obj_is_kind_of(arg1, GTYPE2CLASS(GTK_TYPE_RADIO_MENU_ITEM)))
list = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(RVAL2GOBJ(arg1)));
else if (TYPE(arg1) == T_ARRAY)
/* TODO: This might leak. */
list = RVAL2GTKRADIOMENUITEMGSLIST(arg1);
else if (!NIL_P(arg1))
rb_raise(rb_eArgError, "invalid argument %s (expect Array or Gtk::RadioMenuItem)",
rb_class2name(CLASS_OF(arg1)));
}
if (label != NULL)
widget = gtk_radio_menu_item_new_with_label(list, label);
else if (mnemonic != NULL)
widget = gtk_radio_menu_item_new_with_mnemonic(list, mnemonic);
else
widget = gtk_radio_menu_item_new(list);
RBGTK_INITIALIZE(self, widget);
return Qnil;
}
/**
* @brief Instance initializer function for the \e GtkExperimentTranscript widget
*
* @param klass Newly constructed \e GtkExperimentTranscript instance
*/
static void
gtk_experiment_transcript_init(GtkExperimentTranscript *klass)
{
GtkWidget *item, *submenu, *image;
klass->priv = GTK_EXPERIMENT_TRANSCRIPT_GET_PRIVATE(klass);
klass->speaker = NULL;
klass->interactive_format.default_font = NULL;
klass->interactive_format.default_text_color = NULL;
klass->interactive_format.default_bg_color = NULL;
klass->priv->flag_mask = 0;
klass->priv->time_adjustment = gtk_adjustment_new(0., 0., 0.,
0., 0., 0.);
g_object_ref_sink(klass->priv->time_adjustment);
klass->priv->time_adj_on_value_changed_id =
g_signal_connect(G_OBJECT(klass->priv->time_adjustment),
"value-changed",
G_CALLBACK(time_adj_on_value_changed), klass);
klass->priv->layer_text = NULL;
klass->priv->layer_text_layout =
gtk_widget_create_pango_layout(GTK_WIDGET(klass), NULL);
pango_layout_set_wrap(klass->priv->layer_text_layout, PANGO_WRAP_WORD_CHAR);
pango_layout_set_ellipsize(klass->priv->layer_text_layout, PANGO_ELLIPSIZE_END);
klass->priv->backdrop.start = 0;
klass->priv->backdrop.end = 0;
klass->priv->contribs = NULL;
klass->priv->formats = NULL;
klass->priv->interactive_format.regexp = NULL;
klass->priv->interactive_format.attribs = NULL;
/** @todo It should be possible to reset font and colors (to widget defaults) */
klass->priv->menu = gtk_menu_new();
gtk_menu_attach_to_widget(GTK_MENU(klass->priv->menu),
GTK_WIDGET(klass), NULL);
item = gtk_image_menu_item_new_with_mnemonic("Choose _Font...");
image = gtk_image_new_from_stock(GTK_STOCK_SELECT_FONT,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
g_signal_connect(item, "activate",
G_CALLBACK(choose_font_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
item = gtk_image_menu_item_new_with_mnemonic("Choose _Text Color...");
image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
g_signal_connect(item, "activate",
G_CALLBACK(choose_text_color_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
item = gtk_image_menu_item_new_with_mnemonic("Choose _Background Color...");
image = gtk_image_new_from_stock(GTK_STOCK_SELECT_COLOR,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
g_signal_connect(item, "activate",
G_CALLBACK(choose_bg_color_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
submenu = gtk_menu_new();
item = gtk_menu_item_new_with_label("Text Alignment");
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), submenu);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
/*
* position in alignment_group list corresponds with PangoAlignment
* (PANGO_ALIGN_RIGHT, PANGO_ALIGN_CENTER, PANGO_ALIGN_LEFT)
*/
item = gtk_radio_menu_item_new_with_mnemonic(NULL, "_Left");
klass->priv->alignment_group =
gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
g_signal_connect(item, "activate",
G_CALLBACK(text_alignment_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group,
"_Center");
klass->priv->alignment_group =
gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
g_signal_connect(item, "activate",
G_CALLBACK(text_alignment_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
item = gtk_radio_menu_item_new_with_mnemonic(klass->priv->alignment_group,
"_Right");
klass->priv->alignment_group =
gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
g_signal_connect(item, "activate",
G_CALLBACK(text_alignment_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(submenu), item);
gtk_widget_show_all(submenu);
gtk_experiment_transcript_set_alignment(klass, PANGO_ALIGN_LEFT);
item = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu), item);
gtk_widget_show(item);
klass->priv->menu_reverse_item =
gtk_check_menu_item_new_with_mnemonic("_Reverse");
g_signal_connect(klass->priv->menu_reverse_item, "activate",
G_CALLBACK(reverse_activated), klass);
gtk_menu_shell_append(GTK_MENU_SHELL(klass->priv->menu),
klass->priv->menu_reverse_item);
gtk_widget_show(klass->priv->menu_reverse_item);
gtk_widget_set_can_focus(GTK_WIDGET(klass), TRUE);
}
static gboolean
tm_do_popup_menu(GtkWidget * toolbar, GdkEventButton * event,
toolbar_info * info)
{
GtkWidget *menu;
#if !GTK_CHECK_VERSION(3, 22, 0)
int button, event_time;
#endif /*GTK_CHECK_VERSION(3, 22, 0) */
guint i;
GSList *group = NULL;
GtkToolbarStyle default_style = tm_default_style();
if (info->menu)
return FALSE;
info->menu = menu = gtk_menu_new();
g_signal_connect(menu, "deactivate",
G_CALLBACK(tm_popup_deactivated_cb), info);
/* ... add menu items ... */
for (i = 0; i < G_N_ELEMENTS(tm_toolbar_options); i++) {
GtkWidget *item;
if (!tm_toolbar_options[i].text)
continue;
item =
gtk_radio_menu_item_new_with_mnemonic(group,
_(tm_toolbar_options[i].
text));
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(item));
if (tm_toolbar_options[i].style == info->model->style)
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item),
TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_object_set_data(G_OBJECT(item), BALSA_TOOLBAR_STYLE,
GINT_TO_POINTER(tm_toolbar_options[i].style));
g_signal_connect(item, "toggled", G_CALLBACK(menu_item_toggled_cb),
info);
}
for (i = 0; i < G_N_ELEMENTS(tm_toolbar_options); i++) {
if (!tm_toolbar_options[i].text)
continue;
if (tm_toolbar_options[i].style == default_style) {
gchar *option_text, *text;
GtkWidget *item;
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
option_text =
tm_remove_underscore(_(tm_toolbar_options[i].text));
text =
g_strdup_printf(_("Use Desktop _Default (%s)"),
option_text);
g_free(option_text);
item = gtk_radio_menu_item_new_with_mnemonic(group, text);
g_free(text);
if (info->model->style == (GtkToolbarStyle) (-1))
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM
(item), TRUE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
g_object_set_data(G_OBJECT(item), BALSA_TOOLBAR_STYLE,
GINT_TO_POINTER(-1));
g_signal_connect(item, "toggled",
G_CALLBACK(menu_item_toggled_cb), info);
}
}
if (gtk_widget_is_sensitive(toolbar)) {
/* This is a real toolbar, not the template from the
* toolbar-prefs dialog. */
GtkWidget *item;
gtk_menu_shell_append(GTK_MENU_SHELL(menu),
gtk_separator_menu_item_new());
item =
gtk_menu_item_new_with_mnemonic(_("_Customize Toolbars…"));
g_signal_connect(item, "activate", G_CALLBACK(customize_dialog_cb),
gtk_widget_get_toplevel(toolbar));
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
/* Pass the model type to the customize widget, so that it can
* show the appropriate notebook page. */
g_object_set_data(G_OBJECT(item), BALSA_TOOLBAR_MODEL_TYPE,
GINT_TO_POINTER(info->model->type));
}
gtk_widget_show_all(menu);
#if GTK_CHECK_VERSION(3, 22, 0)
gtk_menu_attach_to_widget(GTK_MENU(menu), toolbar, NULL);
if (event)
gtk_menu_popup_at_pointer(GTK_MENU(menu),
(GdkEvent *) event);
else
gtk_menu_popup_at_widget(GTK_MENU(menu),
GTK_WIDGET(toolbar),
GDK_GRAVITY_CENTER, GDK_GRAVITY_CENTER,
NULL);
#else /*GTK_CHECK_VERSION(3, 22, 0) */
if (event) {
button = event->button;
event_time = event->time;
} else {
button = 0;
event_time = gtk_get_current_event_time();
}
gtk_menu_attach_to_widget(GTK_MENU(menu), toolbar, NULL);
if (button)
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, button,
event_time);
else
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, tm_popup_position_func,
toolbar, button, event_time);
#endif /*GTK_CHECK_VERSION(3, 22, 0) */
return TRUE;
}
RtTraceGtk::RtTraceGtk( void *tr_parent_ctx, GtkWidget *tr_parent_wid, pwr_tObjid tr_objid,
pwr_tStatus *status) :
RtTrace( tr_parent_ctx, tr_objid, status), parent_wid(tr_parent_wid), toplevel(0), nav_shell(0)
{
const int window_width = 900;
const int window_height = 800;
const int nav_width = 180;
pwr_tStatus sts;
pwr_tObjid window_objid;
pwr_tClassId cid;
char title[220];
pwr_tOName hostname;
pwr_tOName plcconnect;
pwr_tFileName fname;
sts = gdh_ObjidToName( tr_objid, name, sizeof(name), cdh_mNName);
if (EVEN(sts)) {
*status = sts;
return;
}
strcpy( title, "Trace ");
strcat( title, name);
/* Find plcwindow */
sts = gdh_GetObjectClass( tr_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
sts = gdh_GetChild( tr_objid, &window_objid);
if ( EVEN(sts)) {
*status = sts;
return;
}
}
else
window_objid = tr_objid;
sts = gdh_GetObjectClass( window_objid, &cid);
if ( EVEN(sts)) {
*status = sts;
return;
}
if ( !(cid == pwr_cClass_windowplc ||
cid == pwr_cClass_windowcond ||
cid == pwr_cClass_windoworderact ||
cid == pwr_cClass_windowsubstep )) {
*status = 0;
return;
}
sts = get_filename( window_objid, filename, &m_has_host, hostname,
plcconnect);
if ( EVEN(sts)) {
*status = sts;
return;
}
/* Create object context */
objid = window_objid;
if ( m_has_host) {
strcpy( m_hostname, hostname);
strcpy( m_plcconnect, plcconnect);
}
char *titleutf8 = g_convert( title, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
// Gtk
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", titleutf8,
NULL);
g_free( titleutf8);
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
// Submenu Print
GtkWidget *file_print = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Print"));
g_signal_connect( file_print, "activate",
G_CALLBACK(activate_print), this);
GtkWidget *file_print_select = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Print _Selected Documents"));
g_signal_connect( file_print_select, "activate",
G_CALLBACK(activate_printselect), this);
GtkWidget *file_savetrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Save _Trace"));
g_signal_connect( file_savetrace, "activate",
G_CALLBACK(activate_savetrace), this);
GtkWidget *file_restoretrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Restore Trace"));
g_signal_connect( file_restoretrace, "activate",
G_CALLBACK(activate_restoretrace), this);
GtkWidget *file_cleartrace = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("C_lear Trace"));
g_signal_connect( file_cleartrace, "activate",
G_CALLBACK(activate_cleartrace), this);
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_close), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print_select);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_savetrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_restoretrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_cleartrace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions Entry
GtkWidget *functions_open_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open Object"));
g_signal_connect( functions_open_object, "activate",
G_CALLBACK(activate_open_object), this);
gtk_widget_add_accelerator( functions_open_object, "activate", accel_g,
'a', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_open_subwindow = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("Open S_ubwindow"));
g_signal_connect( functions_open_subwindow, "activate",
G_CALLBACK(activate_open_subwindow), this);
gtk_widget_add_accelerator( functions_open_subwindow, "activate", accel_g,
'l', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_display_object = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Display object in Navigator"));
g_signal_connect( functions_display_object, "activate",
G_CALLBACK(activate_display_object), this);
gtk_widget_add_accelerator( functions_display_object, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_show_cross = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Show Crossreferences"));
g_signal_connect( functions_show_cross, "activate",
G_CALLBACK(activate_show_cross), this);
gtk_widget_add_accelerator( functions_show_cross, "activate", accel_g,
'r', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_open_classgraph = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Open ObjectGraph"));
g_signal_connect( functions_open_classgraph, "activate",
G_CALLBACK(activate_open_classgraph), this);
gtk_widget_add_accelerator( functions_open_classgraph, "activate", accel_g,
'g', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_collect_insert = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Collect Insert"));
g_signal_connect( functions_collect_insert, "activate",
G_CALLBACK(activate_collect_insert), this);
gtk_widget_add_accelerator( functions_collect_insert, "activate", accel_g,
'v', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_object);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_subwindow);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_display_object);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_show_cross);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_open_classgraph);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_collect_insert);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));
// View Entry
GtkWidget *view_zoom_in = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_IN, NULL);
g_signal_connect( view_zoom_in, "activate",
G_CALLBACK(activate_zoomin), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect( view_zoom_out, "activate",
G_CALLBACK(activate_zoomout), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect( view_zoom_reset, "activate",
G_CALLBACK(activate_zoomreset), this);
gtk_widget_add_accelerator( view_zoom_reset, "activate", accel_g,
'b', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
// Submenu ScanTime
GSList *view_sc_group = NULL;
GtkWidget *view_scantime1 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.50 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime1, "activate",
G_CALLBACK(activate_scantime1), this);
GtkWidget *view_scantime2 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.20 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime2, "activate",
G_CALLBACK(activate_scantime2), this);
GtkWidget *view_scantime3 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.10 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime3, "activate",
G_CALLBACK(activate_scantime3), this);
GtkWidget *view_scantime4 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.05 s");
view_sc_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_scantime1));
g_signal_connect( view_scantime4, "activate",
G_CALLBACK(activate_scantime4), this);
GtkWidget *view_scantime5 = gtk_radio_menu_item_new_with_mnemonic( view_sc_group,
"0.02 s");
g_signal_connect( view_scantime5, "activate",
G_CALLBACK(activate_scantime5), this);
GtkWidget *view_sc = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_ScanTime"));
GtkMenu *view_sc_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime1);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime2);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime3);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime4);
gtk_menu_shell_append(GTK_MENU_SHELL(view_sc_menu), view_scantime5);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_sc),
GTK_WIDGET(view_sc_menu));
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_sc);
GtkWidget *view = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Mode entry
GSList *mode_group = NULL;
GtkWidget *mode_view = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("V_iew"));
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_view));
g_signal_connect( mode_view, "activate",
G_CALLBACK(activate_view), this);
GtkWidget *mode_trace = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Trace"));
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(mode_trace));
g_signal_connect( mode_trace, "activate",
G_CALLBACK(activate_trace), this);
GtkWidget *mode_simulate = gtk_radio_menu_item_new_with_mnemonic( mode_group, CoWowGtk::translate_utf8("_Simulate"));
gtk_widget_add_accelerator( mode_simulate, "activate", accel_g,
's', GdkModifierType(GDK_CONTROL_MASK | GDK_SHIFT_MASK),
GTK_ACCEL_VISIBLE);
g_signal_connect( mode_simulate, "activate",
G_CALLBACK(activate_simulate), this);
GtkMenu *mode_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_view);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_trace);
gtk_menu_shell_append(GTK_MENU_SHELL(mode_menu), mode_simulate);
GtkWidget *mode = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Mode"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), mode);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(mode), GTK_WIDGET(mode_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _Trace"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *help_plcpgm = gtk_check_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("On _PlcPgm"));
g_signal_connect( help_plcpgm, "activate",
G_CALLBACK(activate_helpplc), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_plcpgm);
GtkWidget *help = gtk_menu_item_new_with_mnemonic( CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_display_object = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_navigator.png");
gtk_container_add( GTK_CONTAINER(tools_display_object),
gtk_image_new_from_file( fname));
g_signal_connect(tools_display_object, "clicked", G_CALLBACK(activate_display_object), this);
gtk_toolbar_append_widget( tools, tools_display_object, "Display object in Navigator", "");
GtkWidget *tools_show_cross = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_crossref.png");
gtk_container_add( GTK_CONTAINER(tools_show_cross),
gtk_image_new_from_file( fname));
g_signal_connect(tools_show_cross, "clicked", G_CALLBACK(activate_show_cross), this);
gtk_toolbar_append_widget( tools, tools_show_cross, "Show Crossreferences", "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(activate_zoomin), this);
gtk_toolbar_append_widget( tools, tools_zoom_in, "Zoom in", "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(activate_zoomout), this);
gtk_toolbar_append_widget( tools, tools_zoom_out, "Zoom out", "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset),
gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(activate_zoomreset), this);
gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");
// Flow widget
GtkWidget *flow_scrolled = scrolledflowwidgetgtk_new( init_flow,
this, &flow_widget);
gtk_widget_show_all(flow_widget);
nav_widget = flownavwidgetgtk_new( flow_widget);
GtkWidget *paned = gtk_hpaned_new();
gtk_paned_pack1( GTK_PANED(paned), flow_scrolled, TRUE, TRUE);
gtk_paned_pack2( GTK_PANED(paned), nav_widget, FALSE, TRUE);
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), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(paned), TRUE, TRUE, 0);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
gtk_paned_set_position( GTK_PANED(paned), window_width - nav_width);
#if 0
// Navigator window
nav_shell = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 200,
"default-width", 200,
"title", "Navigator",
NULL);
g_signal_connect( nav_shell, "delete_event", G_CALLBACK(nav_delete_event), this);
nav_widget = flownavwidgetgtk_new( flow_widget);
gtk_container_add( GTK_CONTAINER(nav_shell), nav_widget);
gtk_widget_show_all( nav_shell);
#endif
wow = new CoWowGtk( toplevel);
trace_timerid = wow->timer_new();
viewsetup();
flow_Open( flow_ctx, filename);
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( mode_trace), TRUE);
gtk_check_menu_item_set_active( GTK_CHECK_MENU_ITEM( view_scantime1), TRUE);
//trasetup();
//trace_start();
#if defined OS_LINUX
{
struct stat info;
if ( stat( filename, &info) != -1)
version = info.st_ctime;
}
#endif
// Check version
unsigned int flow_version;
pwr_tUInt32 window_version;
pwr_tAName aname;
flow_GetCtxUserVersion( flow_ctx, &flow_version);
strcpy( aname, name);
strcat( aname, ".Version");
sts = gdh_GetObjectInfo( aname, &window_version, sizeof(window_version));
if ( EVEN(sts)) return;
if ( flow_version > window_version)
wow->DisplayError( "Version mismatch", "Trace file is newer than database version");
else if ( flow_version < window_version)
wow->DisplayError( "Version mismatch", "Trace file is older than database version");
}
GtkWidget *
menu_create_main (void *accel_group, int bar, int away, int toplevel,
GtkWidget **menu_widgets)
{
int i = 0;
GtkWidget *item;
GtkWidget *menu = 0;
GtkWidget *menu_item = 0;
GtkWidget *menu_bar;
GtkWidget *usermenu = 0;
GtkWidget *submenu = 0;
int close_mask = GDK_CONTROL_MASK;
int away_mask = GDK_MOD1_MASK;
char *key_theme = NULL;
GtkSettings *settings;
GSList *group = NULL;
if (bar)
menu_bar = gtk_menu_bar_new ();
else
menu_bar = gtk_menu_new ();
/* /MENU needs to know this later */
g_object_set_data (G_OBJECT (menu_bar), "accel", accel_group);
#if GTK_CHECK_VERSION(2,4,0)
g_signal_connect (G_OBJECT (menu_bar), "can-activate-accel",
G_CALLBACK (menu_canacaccel), 0);
#endif
/* set the initial state of toggles */
mymenu[MENUBAR_OFFSET].state = !prefs.hidemenu;
mymenu[MENUBAR_OFFSET+1].state = prefs.topicbar;
mymenu[MENUBAR_OFFSET+2].state = !prefs.hideuserlist;
mymenu[MENUBAR_OFFSET+3].state = prefs.userlistbuttons;
mymenu[MENUBAR_OFFSET+4].state = prefs.chanmodebuttons;
mymenu[METRE_OFFSET].state = 0;
mymenu[METRE_OFFSET+1].state = 0;
mymenu[METRE_OFFSET+2].state = 0;
mymenu[METRE_OFFSET+3].state = 0;
switch (prefs.lagometer)
{
case 0:
mymenu[METRE_OFFSET].state = 1;
break;
case 1:
mymenu[METRE_OFFSET+1].state = 1;
break;
case 2:
mymenu[METRE_OFFSET+2].state = 1;
break;
default:
mymenu[METRE_OFFSET+3].state = 1;
}
/* change Close binding to ctrl-shift-w when using emacs keys */
settings = gtk_widget_get_settings (menu_bar);
if (settings)
{
g_object_get (settings, "gtk-key-theme-name", &key_theme, NULL);
if (key_theme)
{
if (!strcasecmp (key_theme, "Emacs"))
{
close_mask = GDK_SHIFT_MASK | GDK_CONTROL_MASK;
mymenu[SEARCH_OFFSET].key = 0;
}
g_free (key_theme);
}
}
/* Away binding to ctrl-alt-a if the _Help menu conflicts (FR/PT/IT) */
{
char *help = _("_Help");
char *under = strchr (help, '_');
if (under && (under[1] == 'a' || under[1] == 'A'))
away_mask = GDK_MOD1_MASK | GDK_CONTROL_MASK;
}
if (!toplevel)
{
mymenu[DETACH_OFFSET].text = N_("_Detach Tab");
mymenu[CLOSE_OFFSET].text = N_("_Close Tab");
}
else
{
mymenu[DETACH_OFFSET].text = N_("_Attach Window");
mymenu[CLOSE_OFFSET].text = N_("_Close Window");
}
while (1)
{
item = NULL;
if (mymenu[i].id == MENU_ID_USERMENU && !prefs.gui_usermenu)
{
i++;
continue;
}
switch (mymenu[i].type)
{
case M_NEWMENU:
if (menu)
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
item = menu = gtk_menu_new ();
if (mymenu[i].id == MENU_ID_USERMENU)
usermenu = menu;
menu_item = gtk_menu_item_new_with_mnemonic (_(mymenu[i].text));
/* record the English name for /menu */
g_object_set_data (G_OBJECT (menu_item), "name", mymenu[i].text);
gtk_menu_shell_append (GTK_MENU_SHELL (menu_bar), menu_item);
gtk_widget_show (menu_item);
break;
case M_MENUPIX:
item = create_icon_menu (_(mymenu[i].text), mymenu[i].image, FALSE);
goto normalitem;
case M_MENUSTOCK:
item = create_icon_menu (_(mymenu[i].text), mymenu[i].image, TRUE);
goto normalitem;
case M_MENUITEM:
item = gtk_menu_item_new_with_mnemonic (_(mymenu[i].text));
normalitem:
if (mymenu[i].key != 0)
gtk_widget_add_accelerator (item, "activate", accel_group,
mymenu[i].key,
mymenu[i].key == GDK_F1 ? 0 :
mymenu[i].key == GDK_w ? close_mask :
GDK_CONTROL_MASK,
GTK_ACCEL_VISIBLE);
if (mymenu[i].callback)
g_signal_connect (G_OBJECT (item), "activate",
G_CALLBACK (mymenu[i].callback), 0);
if (submenu)
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
else
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
break;
case M_MENUTOG:
item = gtk_check_menu_item_new_with_mnemonic (_(mymenu[i].text));
togitem:
/* must avoid callback for Radio buttons */
GTK_CHECK_MENU_ITEM (item)->active = mymenu[i].state;
/*gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
mymenu[i].state);*/
if (mymenu[i].key != 0)
gtk_widget_add_accelerator (item, "activate", accel_group,
mymenu[i].key, mymenu[i].id == MENU_ID_AWAY ?
away_mask : GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
if (mymenu[i].callback)
g_signal_connect (G_OBJECT (item), "toggled",
G_CALLBACK (mymenu[i].callback), 0);
if (submenu)
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), item);
else
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
gtk_widget_set_sensitive (item, mymenu[i].sensitive);
break;
case M_MENURADIO:
item = gtk_radio_menu_item_new_with_mnemonic (group, _(mymenu[i].text));
group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
goto togitem;
case M_SEP:
item = gtk_menu_item_new ();
gtk_widget_set_sensitive (item, FALSE);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
break;
case M_MENUSUB:
group = NULL;
submenu = gtk_menu_new ();
item = create_icon_menu (_(mymenu[i].text), mymenu[i].image, TRUE);
/* record the English name for /menu */
g_object_set_data (G_OBJECT (item), "name", mymenu[i].text);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
break;
/*case M_END:*/ default:
if (!submenu)
{
if (menu)
{
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), menu);
menu_add_plugin_mainmenu_items (menu_bar);
}
if (usermenu)
usermenu_create (usermenu);
return (menu_bar);
}
submenu = NULL;
}
/* record this GtkWidget * so it's state might be changed later */
if (mymenu[i].id != 0 && menu_widgets)
/* this ends up in sess->gui->menu_item[MENU_ID_XXX] */
menu_widgets[mymenu[i].id] = item;
i++;
}
}
void ptk_menu_add_items_from_data( GtkWidget* menu,
PtkMenuItemEntry* entries,
gpointer cb_data,
GtkAccelGroup* accel_group )
{
PtkMenuItemEntry* ent;
GtkWidget* menu_item = NULL;
GtkWidget* sub_menu;
GtkWidget* image;
GSList* radio_group = NULL;
const char* signal;
for( ent = entries; ; ++ent )
{
if( G_LIKELY( ent->label ) )
{
/* Stock item */
signal = "activate";
if( G_UNLIKELY( PTK_IS_STOCK_ITEM(ent) ) ) {
menu_item = gtk_image_menu_item_new_from_stock( ent->label, accel_group );
}
else if( G_LIKELY(ent->stock_icon) ) {
if( G_LIKELY( ent->stock_icon > (char *)2 ) ) {
menu_item = gtk_image_menu_item_new_with_mnemonic(_(ent->label));
image = gtk_image_new_from_stock( ent->stock_icon, GTK_ICON_SIZE_MENU );
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(menu_item), image );
}
else if( G_UNLIKELY( PTK_IS_CHECK_MENU_ITEM(ent) ) ) {
menu_item = gtk_check_menu_item_new_with_mnemonic(_(ent->label));
signal = "toggled";
}
else if( G_UNLIKELY( PTK_IS_RADIO_MENU_ITEM(ent) ) ) {
menu_item = gtk_radio_menu_item_new_with_mnemonic( radio_group, _(ent->label) );
if( G_LIKELY( PTK_IS_RADIO_MENU_ITEM( (ent + 1) ) ) )
radio_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(menu_item) );
else
radio_group = NULL;
signal = "toggled";
}
}
else {
menu_item = gtk_menu_item_new_with_mnemonic(_(ent->label));
}
if( G_LIKELY(accel_group) && ent->key ) {
gtk_widget_add_accelerator (menu_item, "activate", accel_group,
ent->key, ent->mod, GTK_ACCEL_VISIBLE);
}
if( G_LIKELY(ent->callback) ) { /* Callback */
g_signal_connect( menu_item, signal, ent->callback, cb_data);
}
if( G_UNLIKELY( ent->sub_menu ) ) { /* Sub menu */
sub_menu = ptk_menu_new_from_data( ent->sub_menu, cb_data, accel_group );
gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu_item), sub_menu );
ent->menu = sub_menu; //MOD
}
}
else
{
if( ! ent->stock_icon ) /* End of menu */
break;
menu_item = gtk_separator_menu_item_new();
}
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), menu_item );
if( G_UNLIKELY(ent->ret) ) {// Return
*ent->ret = menu_item;
ent->ret = NULL;
}
}
}
NodelistGtk::NodelistGtk( void *nodelist_parent_ctx,
GtkWidget *nodelist_parent_wid,
const char *nodelist_name, int nodelist_mode,
int nodelist_view_node_descr, int msgw_pop,
pwr_tStatus *status) :
Nodelist( nodelist_parent_ctx, nodelist_name, nodelist_mode,
nodelist_view_node_descr, status),
parent_wid(nodelist_parent_wid), clock_cursor(0), add_india_widget(0)
{
pwr_tStatus sts;
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 300,
"default-width", 850,
"title", nodelist_name,
NULL);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon( toplevel);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
// Menu
// Accelerators
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_with_mnemonic( CoWowGtk::translate_utf8("_Close"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_close),
gtk_image_new_from_stock( "gtk-close", GTK_ICON_SIZE_MENU));
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
gtk_widget_add_accelerator( file_close, "activate", accel_g,
'w', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *file_add_node = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Add Node"));
g_signal_connect(file_add_node, "activate", G_CALLBACK(activate_add_node), this);
GtkWidget *file_modify_node = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Modify Node"));
g_signal_connect(file_modify_node, "activate", G_CALLBACK(activate_modify_node), this);
GtkWidget *file_remove_node = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Remove Node"));
g_signal_connect(file_remove_node, "activate", G_CALLBACK(activate_remove_node), this);
pwr_tFileName fname;
GtkWidget *file_open_xtt = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Open Runtime _Navigator"));
dcli_translate_filename( fname, "$pwr_exe/xtt_navigator.png");
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_open_xtt), gtk_image_new_from_file( fname));
g_signal_connect(file_open_xtt, "activate", G_CALLBACK(activate_open_xtt), this);
GtkWidget *file_open_opplace = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Open Operatorplace"));
dcli_translate_filename( fname, "$pwr_exe/xtt_op.png");
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_open_opplace),
gtk_image_new_from_file( fname));
g_signal_connect(file_open_opplace, "activate", G_CALLBACK(activate_open_opplace), this);
GtkWidget *file_open_rtmon = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Open Runtime _Monitor"));
dcli_translate_filename( fname, "$pwr_exe/xtt_rtmon.png");
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_open_rtmon), gtk_image_new_from_file( fname));
g_signal_connect(file_open_rtmon, "activate", G_CALLBACK(activate_open_rtmon), this);
GtkWidget *file_save = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Save Configuration"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(file_save),
gtk_image_new_from_stock( "gtk-save", GTK_ICON_SIZE_MENU));
g_signal_connect(file_save, "activate", G_CALLBACK(activate_save), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_save);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_add_node);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_modify_node);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_remove_node);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_open_xtt);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_open_opplace);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_open_rtmon);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_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 menu
GtkWidget *view_show_events = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Show _Events"));
g_signal_connect(view_show_events, "activate", G_CALLBACK(activate_show_events), this);
GtkWidget *view_pop_events = gtk_check_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Pop Events"));
g_signal_connect(view_pop_events, "activate", G_CALLBACK(activate_pop_events), this);
// Submenu Remote GUI
GSList *rg_group = NULL;
GtkWidget *view_gui_gtk = gtk_radio_menu_item_new_with_mnemonic( rg_group, "_GTK");
rg_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_gui_gtk));
g_signal_connect( view_gui_gtk, "activate",
G_CALLBACK(activate_gui_gtk), this);
GtkWidget *view_gui_motif = gtk_radio_menu_item_new_with_mnemonic( rg_group, "_Motif");
rg_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_gui_motif));
g_signal_connect( view_gui_motif, "activate",
G_CALLBACK(activate_gui_motif), this);
GtkWidget *view_gui = gtk_menu_item_new_with_mnemonic( "_Remote GUI");
GtkMenu *view_gui_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_gui_menu), view_gui_gtk);
gtk_menu_shell_append(GTK_MENU_SHELL(view_gui_menu), view_gui_motif);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_gui),
GTK_WIDGET(view_gui_menu));
// Submenu Mode
GSList *mode_group = NULL;
GtkWidget *view_mode_systemstatus = gtk_radio_menu_item_new_with_mnemonic( mode_group, "_SystemStatus");
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_mode_systemstatus));
g_signal_connect( view_mode_systemstatus, "activate",
G_CALLBACK(activate_mode_systemstatus), this);
GtkWidget *view_mode_userstatus1 = gtk_radio_menu_item_new_with_mnemonic( mode_group, "UserStatus_1");
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_mode_userstatus1));
g_signal_connect( view_mode_userstatus1, "activate",
G_CALLBACK(activate_mode_userstatus1), this);
GtkWidget *view_mode_userstatus2 = gtk_radio_menu_item_new_with_mnemonic( mode_group, "UserStatus_2");
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_mode_userstatus2));
g_signal_connect( view_mode_userstatus2, "activate",
G_CALLBACK(activate_mode_userstatus2), this);
GtkWidget *view_mode_userstatus3 = gtk_radio_menu_item_new_with_mnemonic( mode_group, "UserStatus_3");
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_mode_userstatus3));
g_signal_connect( view_mode_userstatus3, "activate",
G_CALLBACK(activate_mode_userstatus3), this);
GtkWidget *view_mode_userstatus4 = gtk_radio_menu_item_new_with_mnemonic( mode_group, "UserStatus_4");
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_mode_userstatus4));
g_signal_connect( view_mode_userstatus4, "activate",
G_CALLBACK(activate_mode_userstatus4), this);
GtkWidget *view_mode_userstatus5 = gtk_radio_menu_item_new_with_mnemonic( mode_group, "UserStatus_5");
mode_group = gtk_radio_menu_item_get_group( GTK_RADIO_MENU_ITEM(view_mode_userstatus5));
g_signal_connect( view_mode_userstatus5, "activate",
G_CALLBACK(activate_mode_userstatus5), this);
GtkWidget *view_mode = gtk_menu_item_new_with_mnemonic( "_Mode");
GtkMenu *view_mode_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_mode_menu), view_mode_systemstatus);
gtk_menu_shell_append(GTK_MENU_SHELL(view_mode_menu), view_mode_userstatus1);
gtk_menu_shell_append(GTK_MENU_SHELL(view_mode_menu), view_mode_userstatus2);
gtk_menu_shell_append(GTK_MENU_SHELL(view_mode_menu), view_mode_userstatus3);
gtk_menu_shell_append(GTK_MENU_SHELL(view_mode_menu), view_mode_userstatus4);
gtk_menu_shell_append(GTK_MENU_SHELL(view_mode_menu), view_mode_userstatus5);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_mode),
GTK_WIDGET(view_mode_menu));
GtkWidget *view_zoom_in = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _In"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_in),
gtk_image_new_from_stock( "gtk-zoom-in", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_in, "activate", G_CALLBACK(activate_zoom_in), this);
gtk_widget_add_accelerator( view_zoom_in, "activate", accel_g,
'i', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_out = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Out"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_out),
gtk_image_new_from_stock( "gtk-zoom-out", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_out, "activate", G_CALLBACK(activate_zoom_out), this);
gtk_widget_add_accelerator( view_zoom_out, "activate", accel_g,
'o', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *view_zoom_reset = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Zoom _Reset"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(view_zoom_reset),
gtk_image_new_from_stock( "gtk-zoom-100", GTK_ICON_SIZE_MENU));
g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(activate_zoom_reset), this);
GtkMenu *view_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_show_events);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_pop_events);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_gui);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_mode);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_in);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_out);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_zoom_reset);
GtkWidget *view = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_View"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(view), GTK_WIDGET(view_menu));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock( "gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator( help_help, "activate", accel_g,
'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget *help = gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
msg_window = new MsgWindowGtk( this, toplevel, "Status Events", &sts);
msg_window->find_wnav_cb = find_node_cb;
msg_window->msg( 'I', "Status Montitor started");
nodelistnav = new NodelistNavGtk( this, vbox, msg_window, 0, mode, view_node_descr,
msgw_pop, &nodelistnav_widget);
// Toolbar
GtkToolbar *tools = (GtkToolbar *) g_object_new(GTK_TYPE_TOOLBAR, NULL);
GtkWidget *tools_save = gtk_button_new();
gtk_container_add( GTK_CONTAINER(tools_save),
gtk_image_new_from_stock( "gtk-save", GTK_ICON_SIZE_SMALL_TOOLBAR));
g_signal_connect(tools_save, "clicked", G_CALLBACK(activate_save), this);
g_object_set( tools_save, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_save, CoWowGtk::translate_utf8("Save configuration"), "");
GtkWidget *tools_add_node = gtk_button_new();
gtk_container_add( GTK_CONTAINER(tools_add_node),
gtk_image_new_from_stock( "gtk-add", GTK_ICON_SIZE_SMALL_TOOLBAR));
g_signal_connect(tools_add_node, "clicked", G_CALLBACK(activate_add_node), this);
g_object_set( tools_add_node, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_add_node,CoWowGtk::translate_utf8("Add node"), "");
GtkWidget *tools_remove_node = gtk_button_new();
gtk_container_add( GTK_CONTAINER(tools_remove_node),
gtk_image_new_from_stock( "gtk-remove", GTK_ICON_SIZE_SMALL_TOOLBAR));
g_signal_connect(tools_remove_node, "clicked", G_CALLBACK(activate_remove_node), this);
g_object_set( tools_remove_node, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_remove_node,CoWowGtk::translate_utf8("Remove node"), "");
GtkWidget *tools_xtt = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_navigator.png");
gtk_container_add( GTK_CONTAINER(tools_xtt),
gtk_image_new_from_file( fname));
g_signal_connect(tools_xtt, "clicked", G_CALLBACK(activate_open_xtt), this);
g_object_set( tools_xtt, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_xtt,CoWowGtk::translate_utf8("Start Runtime Navigator on selected node"), "");
GtkWidget *tools_op = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_op.png");
gtk_container_add( GTK_CONTAINER(tools_op),
gtk_image_new_from_file( fname));
g_signal_connect(tools_op, "clicked", G_CALLBACK(activate_open_opplace), this);
g_object_set( tools_op, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_op,CoWowGtk::translate_utf8("Start Operatorplace on selected node"), "");
GtkWidget *tools_rtmon = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_rtmon.png");
gtk_container_add( GTK_CONTAINER(tools_rtmon),
gtk_image_new_from_file( fname));
g_signal_connect(tools_rtmon, "clicked", G_CALLBACK(activate_open_rtmon), this);
g_object_set( tools_rtmon, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_rtmon,CoWowGtk::translate_utf8("Start Runtime Monitor on selected node"), "");
GtkWidget *tools_zoom_in = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_in.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_in), gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_in, "clicked", G_CALLBACK(activate_zoom_in), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_in,CoWowGtk::translate_utf8("Zoom in"), "");
GtkWidget *tools_zoom_out = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_out.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_out), gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_out, "clicked", G_CALLBACK(activate_zoom_out), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_out,CoWowGtk::translate_utf8("Zoom out"), "");
GtkWidget *tools_zoom_reset = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/xtt_zoom_reset.png");
gtk_container_add( GTK_CONTAINER(tools_zoom_reset), gtk_image_new_from_file( fname));
g_signal_connect(tools_zoom_reset, "clicked", G_CALLBACK(activate_zoom_reset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset,CoWowGtk::translate_utf8("Zoom reset"), "");
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(tools), FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(vbox), GTK_WIDGET(nodelistnav_widget), TRUE, TRUE, 0);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
wow = new CoWowGtk( toplevel);
*status = 1;
}
