static GtkWidget *
make_menubar (void)
{
GtkWidget *w, *menu;
GtkWidget *menubar = gtk_menu_bar_new ();
/* FIXME: add translatable string here */
w = gtk_menu_item_new_with_label ("Menu");
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), w);
gtk_widget_show (GTK_WIDGET (w));
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (w), menu);
w = gtk_image_menu_item_new_with_mnemonic (_("Select _Language..."));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
gtk_image_new_from_icon_name ("preferences-desktop-locale", GTK_ICON_SIZE_MENU));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
gtk_widget_show (GTK_WIDGET (w));
g_signal_connect (G_OBJECT (w), "activate",
G_CALLBACK (activate_button),
"language_button");
w = gtk_image_menu_item_new_with_mnemonic (_("Select _Session..."));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
gtk_image_new_from_icon_name ("user-desktop", GTK_ICON_SIZE_MENU));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
gtk_widget_show (GTK_WIDGET (w));
g_signal_connect (G_OBJECT (w), "activate",
G_CALLBACK (activate_button),
"session_button");
greeter_system_append_system_menu (menu);
/* Add a quit/disconnect item when in xdmcp mode or flexi mode */
/* Do note that the order is important, we always want "Quit" for
* flexi, even if not local (non-local xnest). and Disconnect
* only for xdmcp */
if ( ! ve_string_empty (g_getenv ("MDM_FLEXI_SERVER"))) {
w = gtk_image_menu_item_new_with_mnemonic (_("_Quit"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
gtk_image_new_from_icon_name ("system-log-out", GTK_ICON_SIZE_MENU));
} else if (ve_string_empty (g_getenv ("MDM_IS_LOCAL"))) {
w = gtk_image_menu_item_new_with_mnemonic (_("D_isconnect"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (w),
gtk_image_new_from_icon_name ("system-log-out", GTK_ICON_SIZE_MENU));
} else {
w = NULL;
}
if (w != NULL) {
GtkWidget *sep;
/* add separator before the quit */
sep = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep);
gtk_widget_show (GTK_WIDGET (sep));
gtk_menu_shell_append (GTK_MENU_SHELL (menu), w);
gtk_widget_show (GTK_WIDGET (w));
g_signal_connect (G_OBJECT (w), "activate",
G_CALLBACK (gtk_main_quit), NULL);
}
g_signal_connect (G_OBJECT(gtk_menu_item_get_submenu(
gtk_container_get_children(GTK_CONTAINER(menubar))->data)), "selection-done", G_CALLBACK (menubar_done), NULL);
return menubar;
}
static GtkWidget *create_popup_menu(void)
{
GtkWidget *item, *menu, *image;
menu = gtk_menu_new();
image = gtk_image_new_from_stock(GTK_STOCK_NEW, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("New Project"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_new_project), NULL);
popup_items.new_project = item;
image = gtk_image_new_from_stock(GTK_STOCK_DELETE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Delete Project"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_delete_project), NULL);
popup_items.delete_project = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Add File"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_add_file), NULL);
popup_items.add_file = item;
image = gtk_image_new_from_stock(GTK_STOCK_REMOVE, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Remove File"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_remove_files), NULL);
popup_items.remove_files = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
image = gtk_image_new_from_stock(GTK_STOCK_PREFERENCES, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Preferences"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_preferences), NULL);
popup_items.preferences = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
image = gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
item = gtk_image_menu_item_new_with_mnemonic(_("Find in Project"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect((gpointer) item, "activate", G_CALLBACK(on_find_in_project), NULL);
popup_items.find_in_files = item;
item = gtk_separator_menu_item_new();
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
item = gtk_image_menu_item_new_with_mnemonic(_("H_ide Sidebar"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item),
gtk_image_new_from_stock("gtk-close", GTK_ICON_SIZE_MENU));
gtk_widget_show(item);
gtk_container_add(GTK_CONTAINER(menu), item);
g_signal_connect_swapped((gpointer) item, "activate",
G_CALLBACK(keybindings_send_command),
GINT_TO_POINTER(GEANY_KEYS_VIEW_SIDEBAR));
return menu;
}
/* [gtk thread] */
static GtkWidget *build_menu_item(ALLEGRO_MENU_ITEM *aitem)
{
GtkWidget *gitem;
if (!aitem->caption) {
gitem = gtk_separator_menu_item_new();
}
else {
ALLEGRO_USTR *caption = al_ustr_dup(aitem->caption);
/* convert & to _ using unprintable chars as placeholders */
al_ustr_find_replace_cstr(caption, 0, "_", "\x01\x02");
al_ustr_find_replace_cstr(caption, 0, "&", "_");
al_ustr_find_replace_cstr(caption, 0, "\x01\x02", "__");
if (aitem->flags & ALLEGRO_MENU_ITEM_CHECKBOX) {
gitem = gtk_check_menu_item_new_with_mnemonic(al_cstr(caption));
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gitem), aitem->flags & ALLEGRO_MENU_ITEM_CHECKED);
g_signal_connect_swapped (gitem, "toggled", G_CALLBACK(checkbox_on_toggle),
(gpointer) aitem);
}
else {
/* always create an image menu item, in case the user ever sets an icon */
gitem = gtk_image_menu_item_new_with_mnemonic(al_cstr(caption));
if (aitem->icon) {
const int w = al_get_bitmap_width(aitem->icon), h = al_get_bitmap_height(aitem->icon);
const int stride = w * 4;
int x, y, i;
GdkPixbuf *pixbuf;
uint8_t *data = al_malloc(stride * h);
if (data) {
for (y = 0, i = 0; y < h; ++y) {
for (x = 0; x < w; ++x, i += 4) {
al_unmap_rgba(al_get_pixel(aitem->icon, x, y),
&data[i],
&data[i + 1],
&data[i + 2],
&data[i + 3]
);
}
}
pixbuf = gdk_pixbuf_new_from_data (data, GDK_COLORSPACE_RGB, TRUE, 8,
w, h, stride, destroy_pixbuf, NULL);
aitem->extra2 = gtk_image_new_from_pixbuf(pixbuf);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(gitem), aitem->extra2);
/* Subtract the main reference. the image still holds a reference, so the
* pixbuf won't be destroyed until the image itself is. */
g_object_unref(pixbuf);
}
}
}
al_ustr_free(caption);
gtk_widget_set_sensitive(gitem, !(aitem->flags & ALLEGRO_MENU_ITEM_DISABLED));
aitem->extra1 = gitem;
if (aitem->popup) {
GtkWidget *gsubmenu = gtk_menu_new();
build_menu(gsubmenu, aitem->popup);
aitem->popup->extra1 = gsubmenu;
gtk_widget_show(gsubmenu);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(gitem), gsubmenu);
}
else if (aitem->id) {
g_signal_connect_swapped (gitem, "activate",
G_CALLBACK(menuitem_response), (gpointer) aitem);
}
}
gtk_widget_show(gitem);
return gitem;
}
GtkWidget *
create_window1 (void)
{
GtkWidget *vbox1;
/* menu */
GtkWidget *menubar1;
GtkWidget *menuitem1;
GtkWidget *menuitem1_menu;
GtkWidget *open;
GtkWidget *apply;
GtkWidget *save;
GtkWidget *separatormenuitem1;
GtkWidget *save_picture;
GtkWidget *save_picture_image;
GtkWidget *xsane;
GtkWidget *separatormenuitem2;
GtkWidget *quit;
GtkWidget *menuitem2;
GtkWidget *menuitem2_menu;
GtkWidget *font;
GtkWidget *separator2;
GtkWidget *spell_check;
GtkWidget *separator3;
GtkWidget *menuitem3;
GtkWidget *menuitem3_menu;
GtkWidget *zoom_in;
GtkWidget *zoom_out;
GtkWidget *normal_size;
GtkWidget *menuitem4;
GtkWidget *menuitem4_menu;
GtkWidget *about;
GtkAccelGroup *accel_group;
/* toolbar */
GtkWidget *toolbar;
GtkIconSize tmp_toolbar_icon_size;
GtkWidget *toolbutton_open;
GtkWidget *toolbutton_apply;
GtkWidget *toolbutton_save;
GtkWidget *toolitem1;
GtkWidget *vseparator1;
GtkWidget *toolbutton_spell;
GtkWidget *toolitem2;
GtkWidget *vseparator2;
GtkWidget *toolbutton_zoom_in;
GtkWidget *toolbutton_zoom_out;
GtkWidget *toolbutton_zoom_fit;
/* image */
GtkWidget *vpaned1;
GtkWidget *scrolledwindow_image;
/* text */
GtkTooltips *tooltips;
PangoFontDescription *font_desc;
tooltips = gtk_tooltips_new ();
accel_group = gtk_accel_group_new ();
window1 = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_widget_set_size_request (window1, 600, 300);
gtk_window_maximize (GTK_WINDOW (window1));
gtk_window_set_title (GTK_WINDOW (window1), _("hocr-gtk"));
vbox1 = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox1);
gtk_container_add (GTK_CONTAINER (window1), vbox1);
/* menu */
menubar1 = gtk_menu_bar_new ();
gtk_widget_show (menubar1);
gtk_box_pack_start (GTK_BOX (vbox1), menubar1, FALSE, FALSE, 0);
menuitem1 = gtk_menu_item_new_with_mnemonic (_("_File"));
gtk_widget_show (menuitem1);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem1);
menuitem1_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem1), menuitem1_menu);
open = gtk_image_menu_item_new_from_stock ("gtk-open", accel_group);
gtk_widget_show (open);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), open);
apply = gtk_image_menu_item_new_from_stock ("gtk-apply", accel_group);
gtk_widget_show (apply);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), apply);
save = gtk_image_menu_item_new_from_stock ("gtk-save", accel_group);
gtk_widget_show (save);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), save);
separatormenuitem1 = gtk_separator_menu_item_new ();
gtk_widget_show (separatormenuitem1);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), separatormenuitem1);
gtk_widget_set_sensitive (separatormenuitem1, FALSE);
save_picture = gtk_image_menu_item_new_with_label (_("Save Picture"));
save_picture_image =
gtk_image_new_from_stock ("gtk-save", GTK_ICON_SIZE_MENU);
gtk_widget_show (save_picture_image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (save_picture),
save_picture_image);
gtk_widget_show (save_picture);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), save_picture);
xsane = gtk_menu_item_new_with_label (_("Xsane"));
gtk_widget_show (xsane);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), xsane);
separatormenuitem2 = gtk_separator_menu_item_new ();
gtk_widget_show (separatormenuitem2);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), separatormenuitem2);
gtk_widget_set_sensitive (separatormenuitem2, FALSE);
quit = gtk_image_menu_item_new_from_stock ("gtk-quit", accel_group);
gtk_widget_show (quit);
gtk_container_add (GTK_CONTAINER (menuitem1_menu), quit);
menuitem2 = gtk_menu_item_new_with_mnemonic (_("_Edit"));
gtk_widget_show (menuitem2);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem2);
menuitem2_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem2), menuitem2_menu);
font = gtk_image_menu_item_new_from_stock ("gtk-select-font",
accel_group);
gtk_widget_show (font);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), font);
separator2 = gtk_separator_menu_item_new ();
gtk_widget_show (separator2);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), separator2);
gtk_widget_set_sensitive (separator2, FALSE);
#ifdef WITH_GTKSPELL
spell_check =
gtk_image_menu_item_new_from_stock ("gtk-spell-check",
accel_group);
gtk_widget_show (spell_check);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), spell_check);
separator3 = gtk_separator_menu_item_new ();
gtk_widget_show (separator3);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), separator3);
gtk_widget_set_sensitive (separator3, FALSE);
#endif
color_text_box =
gtk_check_menu_item_new_with_mnemonic (_("Color boxes"));
gtk_widget_show (color_text_box);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), color_text_box);
gtk_tooltips_set_tip (tooltips, color_text_box, _("Color text boxes"),
NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (color_text_box),
TRUE);
color_misread =
gtk_check_menu_item_new_with_mnemonic (_("Color misread"));
gtk_widget_show (color_misread);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), color_misread);
gtk_tooltips_set_tip (tooltips, color_misread, _("Color misread fonts"),
NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (color_misread),
TRUE);
clear_text = gtk_check_menu_item_new_with_mnemonic (_("Clear"));
gtk_widget_show (clear_text);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), clear_text);
gtk_tooltips_set_tip (tooltips, clear_text,
_("Clear text each time you ocr new scan"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (clear_text), TRUE);
ocr = gtk_check_menu_item_new_with_mnemonic (_("Ocr"));
gtk_widget_show (ocr);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), ocr);
gtk_tooltips_set_tip (tooltips, ocr,
_("Try to recognize fonts in scaned text"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (ocr), TRUE);
use_dict = gtk_check_menu_item_new_with_mnemonic (_("Use dictionary"));
gtk_widget_show (use_dict);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), use_dict);
gtk_tooltips_set_tip (tooltips, use_dict,
_
("Try to guess unrecognized fonts in scaned text using internal dictionary"),
NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (use_dict), FALSE);
use_nikud = gtk_check_menu_item_new_with_mnemonic (_("Use nikud"));
gtk_widget_show (use_nikud);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), use_nikud);
gtk_tooltips_set_tip (tooltips, use_nikud,
_("Try to guess nikud"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (use_nikud), TRUE);
use_spaces = gtk_check_menu_item_new_with_mnemonic (_("Use spaces"));
gtk_widget_show (use_spaces);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), use_spaces);
gtk_tooltips_set_tip (tooltips, use_spaces,
_("Use spaces for tabs"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (use_spaces),
FALSE);
use_indent =
gtk_check_menu_item_new_with_mnemonic (_("Use indentation"));
gtk_widget_show (use_indent);
gtk_container_add (GTK_CONTAINER (menuitem2_menu), use_indent);
gtk_tooltips_set_tip (tooltips, use_indent,
_("Try to guess line indentation"), NULL);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (use_indent),
FALSE);
menuitem3 = gtk_menu_item_new_with_mnemonic (_("_View"));
gtk_widget_show (menuitem3);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem3);
menuitem3_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem3), menuitem3_menu);
zoom_in =
gtk_image_menu_item_new_from_stock ("gtk-zoom-in", accel_group);
gtk_widget_show (zoom_in);
gtk_container_add (GTK_CONTAINER (menuitem3_menu), zoom_in);
zoom_out =
gtk_image_menu_item_new_from_stock ("gtk-zoom-out",
accel_group);
gtk_widget_show (zoom_out);
gtk_container_add (GTK_CONTAINER (menuitem3_menu), zoom_out);
normal_size =
gtk_image_menu_item_new_from_stock ("gtk-zoom-100",
accel_group);
gtk_widget_show (normal_size);
gtk_container_add (GTK_CONTAINER (menuitem3_menu), normal_size);
menuitem4 = gtk_menu_item_new_with_mnemonic (_("_Help"));
gtk_widget_show (menuitem4);
gtk_container_add (GTK_CONTAINER (menubar1), menuitem4);
menuitem4_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem4), menuitem4_menu);
about = gtk_menu_item_new_with_mnemonic (_("_About"));
gtk_widget_show (about);
gtk_container_add (GTK_CONTAINER (menuitem4_menu), about);
/* toolbar */
toolbar = gtk_toolbar_new ();
gtk_widget_show (toolbar);
gtk_box_pack_start (GTK_BOX (vbox1), toolbar, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH);
tmp_toolbar_icon_size =
gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
toolbutton_open =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-open");
gtk_widget_show (toolbutton_open);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_open);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton_open), tooltips,
_("Open a new picture for the OCR"), NULL);
toolbutton_apply =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-apply");
gtk_widget_show (toolbutton_apply);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_apply);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton_apply), tooltips,
_("Convert picture to text"), NULL);
toolbutton_save =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-save");
gtk_widget_show (toolbutton_save);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_save);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton_save), tooltips,
_("Save the text created by the OCR"), NULL);
toolitem1 = (GtkWidget *) gtk_tool_item_new ();
gtk_widget_show (toolitem1);
gtk_container_add (GTK_CONTAINER (toolbar), toolitem1);
vseparator1 = gtk_vseparator_new ();
gtk_widget_show (vseparator1);
gtk_container_add (GTK_CONTAINER (toolitem1), vseparator1);
#ifdef WITH_GTKSPELL
toolbutton_spell =
(GtkWidget *)
gtk_tool_button_new_from_stock ("gtk-spell-check");
gtk_widget_show (toolbutton_spell);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_spell);
gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbutton_spell), tooltips,
_("Spell check the text"), NULL);
toolitem2 = (GtkWidget *) gtk_tool_item_new ();
gtk_widget_show (toolitem2);
gtk_container_add (GTK_CONTAINER (toolbar), toolitem2);
vseparator2 = gtk_vseparator_new ();
gtk_widget_show (vseparator2);
gtk_container_add (GTK_CONTAINER (toolitem2), vseparator2);
#endif
toolbutton_zoom_in =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-zoom-in");
gtk_widget_show (toolbutton_zoom_in);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_zoom_in);
toolbutton_zoom_out =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-zoom-out");
gtk_widget_show (toolbutton_zoom_out);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_zoom_out);
toolbutton_zoom_fit =
(GtkWidget *) gtk_tool_button_new_from_stock ("gtk-zoom-fit");
gtk_widget_show (toolbutton_zoom_fit);
gtk_container_add (GTK_CONTAINER (toolbar), toolbutton_zoom_fit);
/* image */
vpaned1 = gtk_vpaned_new ();
gtk_widget_show (vpaned1);
gtk_container_add (GTK_CONTAINER (vbox1), vpaned1);
scrolledwindow_image = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *)
scrolledwindow_image,
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolledwindow_image);
gtk_container_add (GTK_CONTAINER (vpaned1), scrolledwindow_image);
viewport1 = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport1);
gtk_container_add (GTK_CONTAINER (scrolledwindow_image), viewport1);
image = gtk_image_new ();
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (viewport1), image);
/* text */
scrolledwindow_text = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy ((GtkScrolledWindow *)
scrolledwindow_text,
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show (scrolledwindow_text);
gtk_container_add (GTK_CONTAINER (vpaned1), scrolledwindow_text);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW
(scrolledwindow_text),
GTK_SHADOW_IN);
textview = gtk_text_view_new ();
gtk_widget_show (textview);
gtk_container_add (GTK_CONTAINER (scrolledwindow_text), textview);
font_desc = pango_font_description_from_string (font_name);
gtk_widget_modify_font (textview, font_desc);
font_name = g_strdup (TEXT_FONT_NAME);
/* progress bar */
hbox2 = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox2);
gtk_box_pack_start (GTK_BOX (vbox1), hbox2, FALSE, FALSE, 0);
pbar = gtk_progress_bar_new ();
gtk_widget_show (pbar);
gtk_box_pack_start (GTK_BOX (hbox2), pbar, FALSE, FALSE, 0);
gtk_widget_set_size_request (pbar, 100, -1);
statusbar1 = gtk_statusbar_new ();
gtk_widget_show (statusbar1);
gtk_box_pack_start (GTK_BOX (hbox2), statusbar1, TRUE, TRUE, 0);
/* main window */
g_signal_connect ((gpointer) window1, "delete_event",
G_CALLBACK (on_window1_delete_event), NULL);
/* toolbar */
g_signal_connect ((gpointer) toolbutton_open, "clicked",
G_CALLBACK (on_toolbutton_open_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_apply, "clicked",
G_CALLBACK (on_toolbutton_apply_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_save, "clicked",
G_CALLBACK (on_toolbutton_save_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_zoom_in, "clicked",
G_CALLBACK (on_toolbutton_zoom_in_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_zoom_out, "clicked",
G_CALLBACK (on_toolbutton_zoom_out_clicked), NULL);
g_signal_connect ((gpointer) toolbutton_zoom_fit, "clicked",
G_CALLBACK (on_toolbutton_zoom_fit_clicked), NULL);
#ifdef WITH_GTKSPELL
g_signal_connect ((gpointer) toolbutton_spell, "clicked",
G_CALLBACK (on_toolbutton_spell_clicked), NULL);
#endif
/* menu */
g_signal_connect ((gpointer) open, "activate",
G_CALLBACK (on_open_activate), NULL);
g_signal_connect ((gpointer) apply, "activate",
G_CALLBACK (on_apply_activate), NULL);
g_signal_connect ((gpointer) save, "activate",
G_CALLBACK (on_save_activate), NULL);
g_signal_connect ((gpointer) save_picture, "activate",
G_CALLBACK (on_save_picture_activate), NULL);
g_signal_connect ((gpointer) xsane, "activate",
G_CALLBACK (on_xsane_activate), NULL);
g_signal_connect ((gpointer) quit, "activate",
G_CALLBACK (on_quit_activate), NULL);
g_signal_connect ((gpointer) font, "activate",
G_CALLBACK (on_font_activate), NULL);
#ifdef WITH_GTKSPELL
g_signal_connect ((gpointer) spell_check, "activate",
G_CALLBACK (on_spell_check_activate), NULL);
#endif
g_signal_connect ((gpointer) zoom_in, "activate",
G_CALLBACK (on_zoom_in_activate), NULL);
g_signal_connect ((gpointer) zoom_out, "activate",
G_CALLBACK (on_zoom_out_activate), NULL);
g_signal_connect ((gpointer) normal_size, "activate",
G_CALLBACK (on_normal_size_activate), NULL);
g_signal_connect ((gpointer) about, "activate",
G_CALLBACK (on_about_activate), NULL);
gtk_window_add_accel_group (GTK_WINDOW (window1), accel_group);
return window1;
}
/** \brief Show popup menu for a pass.
*
*
*/
void
pass_popup_menu_exec (qth_t *qth, pass_t *pass, GdkEventButton *event, GtkWidget *toplevel)
{
GtkWidget *menu;
GtkWidget *menuitem;
GtkWidget *image;
gchar *buff;
menu = gtk_menu_new ();
/* pass details */
menuitem = gtk_image_menu_item_new_with_label (_("Show details"));
image = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
g_object_set_data (G_OBJECT (menuitem), "pass", pass);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate",
G_CALLBACK (show_pass_details),
toplevel);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* Polar plot pass */
menuitem = gtk_image_menu_item_new_with_label (_("Polar plot"));
buff = icon_file_name ("gpredict-polar-small.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
g_object_set_data (G_OBJECT (menuitem), "pass", pass);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate",
G_CALLBACK (polar_plot_pass_details),
toplevel);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
gtk_widget_set_sensitive (menuitem, FALSE);
/* Az/El plot pass */
menuitem = gtk_image_menu_item_new_with_label (_("Az/El plot"));
buff = icon_file_name ("gpredict-azel-small.png");
image = gtk_image_new_from_file (buff);
g_free (buff);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
g_object_set_data (G_OBJECT (menuitem), "pass", pass);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate",
G_CALLBACK (azel_plot_pass_details),
toplevel);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
gtk_widget_set_sensitive (menuitem, FALSE);
gtk_widget_show_all (menu);
/* Note: event can be NULL here when called from view_onPopupMenu;
* gdk_event_get_time() accepts a NULL argument */
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time ((GdkEvent*) event));
}
static gboolean
gtk_tool_button_create_menu_proxy (GtkToolItem *item)
{
GtkToolButton *button = GTK_TOOL_BUTTON (item);
GtkWidget *menu_item;
GtkWidget *menu_image = NULL;
GtkStockItem stock_item;
gboolean use_mnemonic = TRUE;
const char *label;
if (_gtk_tool_item_create_menu_proxy (item))
return TRUE;
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
if (GTK_IS_LABEL (button->priv->label_widget))
{
label = gtk_label_get_label (GTK_LABEL (button->priv->label_widget));
use_mnemonic = gtk_label_get_use_underline (GTK_LABEL (button->priv->label_widget));
}
else if (button->priv->label_text)
{
label = button->priv->label_text;
use_mnemonic = button->priv->use_underline;
}
else if (button->priv->stock_id && gtk_stock_lookup (button->priv->stock_id, &stock_item))
{
label = stock_item.label;
}
else
{
label = "";
}
if (use_mnemonic)
menu_item = gtk_image_menu_item_new_with_mnemonic (label);
else
menu_item = gtk_image_menu_item_new_with_label (label);
if (GTK_IS_IMAGE (button->priv->icon_widget))
{
menu_image = clone_image_menu_size (GTK_IMAGE (button->priv->icon_widget));
}
else if (button->priv->stock_id)
{
menu_image = gtk_image_new_from_stock (button->priv->stock_id, GTK_ICON_SIZE_MENU);
}
if (menu_image)
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), menu_image);
G_GNUC_END_IGNORE_DEPRECATIONS;
g_signal_connect_closure_by_id (menu_item,
g_signal_lookup ("activate", G_OBJECT_TYPE (menu_item)), 0,
g_cclosure_new_object_swap (G_CALLBACK (gtk_button_clicked),
G_OBJECT (GTK_TOOL_BUTTON (button)->priv->button)),
FALSE);
gtk_tool_item_set_proxy_menu_item (GTK_TOOL_ITEM (button), MENU_ID, menu_item);
return TRUE;
}
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;
}
}
}
XttTblGtk::XttTblGtk(GtkWidget* a_parent_wid, void* a_parent_ctx,
sevcli_tCtx a_sevcli, sevcli_sHistItem* itemlist, int item_cnt)
: XttTbl(a_parent_ctx, a_sevcli), parent_wid(a_parent_wid)
{
int sts;
pwr_tFileName fname;
toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height", 700,
"default-width", 500, "title", "SevXtt Navigator", 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(xtttbl_focus_in_event), 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_print = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Print"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(file_print),
gtk_image_new_from_stock("gtk-print", GTK_ICON_SIZE_MENU));
g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this);
GtkWidget* file_login
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Login"));
g_signal_connect(file_login, "activate", G_CALLBACK(activate_login), this);
GtkWidget* file_logout
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Log_Out"));
g_signal_connect(file_logout, "activate", G_CALLBACK(activate_logout), 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_login);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_logout);
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));
// Functions entry
GtkWidget* functions_opensevhist = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Open Process History"));
g_signal_connect(functions_opensevhist, "activate",
G_CALLBACK(activate_opensevhist), this);
gtk_widget_add_accelerator(functions_opensevhist, "activate", accel_g, 'g',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget* functions_command
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("Co_mmand"));
g_signal_connect(
functions_command, "activate", G_CALLBACK(activate_command), this);
gtk_widget_add_accelerator(functions_command, "activate", accel_g, 'b',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget* functions_delete_item = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Delete Item"));
g_signal_connect(functions_delete_item, "activate",
G_CALLBACK(activate_delete_item), this);
GtkMenu* functions_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_opensevhist);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_command);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_delete_item);
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 menu
GtkWidget* view_tree_layout = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Tree Layout"));
g_signal_connect(
view_tree_layout, "activate", G_CALLBACK(activate_tree_layout), this);
GtkWidget* view_list_layout = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_List Layout"));
g_signal_connect(
view_list_layout, "activate", G_CALLBACK(activate_list_layout), this);
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_tree_layout);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_list_layout);
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));
// Help entry
GtkWidget* help_overview = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Overview"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(help_overview),
gtk_image_new_from_stock("gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_overview, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator(help_overview, "activate", accel_g, 'h',
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget* help_project
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Project"));
g_signal_connect(
help_project, "activate", G_CALLBACK(activate_help_project), this);
GtkWidget* help_proview = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_About Proview"));
g_signal_connect(
help_proview, "activate", G_CALLBACK(activate_help_proview), this);
GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_overview);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_project);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_proview);
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_opensevhist = gtk_button_new();
dcli_translate_filename(fname, "$pwr_exe/xtt_meth_trend.png");
gtk_container_add(
GTK_CONTAINER(tools_opensevhist), gtk_image_new_from_file(fname));
g_signal_connect(
tools_opensevhist, "clicked", G_CALLBACK(activate_opensevhist), this);
g_object_set(tools_opensevhist, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget(tools, tools_opensevhist,
CoWowGtk::translate_utf8("Open history item"), "");
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"), "");
// Statusbar and cmd input
GtkWidget* statusbar = gtk_hbox_new(FALSE, 0);
msg_label = gtk_label_new("");
gtk_widget_set_size_request(msg_label, -1, 25);
cmd_prompt = gtk_label_new("xtt > ");
gtk_widget_set_size_request(cmd_prompt, -1, 25);
cmd_recall = new CoWowRecall();
cmd_entry = new CoWowEntryGtk(cmd_recall);
cmd_input = cmd_entry->widget();
gtk_widget_set_size_request(cmd_input, -1, 25);
g_signal_connect(
cmd_input, "activate", G_CALLBACK(valchanged_cmd_input), this);
gtk_box_pack_start(GTK_BOX(statusbar), msg_label, FALSE, FALSE, 20);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_prompt, FALSE, FALSE, 20);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_input, TRUE, TRUE, 20);
gtk_widget_show_all(statusbar);
tblnav
= new TblNavGtk(this, toplevel, itemlist, item_cnt, &brow_widget, &sts);
tblnav->message_cb = &XttTbl::message;
tblnav->is_authorized_cb = &XttTbl::is_authorized;
tblnav->command_cb = &XttTbl::command_cb;
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(brow_widget), TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(statusbar), FALSE, FALSE, 3);
gtk_container_add(GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all(toplevel);
g_object_set(cmd_prompt, "visible", FALSE, NULL);
g_object_set(cmd_input, "visible", FALSE, NULL);
// Create help window
CoXHelp* xhelp = new CoXHelpGtk(toplevel, this, xhelp_eUtility_Xtt, &sts);
CoXHelp::set_default(xhelp);
wow = new CoWowGtk(toplevel);
if (!is_authorized(pwr_mAccess_AllSev, 0))
open_login();
if (!quiet) {
if (cologin)
// Set login window as parent to warranty as focus is left to parent.
((CoWowGtk*)wow)->SetParent(((CoLoginGtk*)cologin)->widgets.toplevel);
wow->DisplayWarranty();
if (cologin)
((CoWowGtk*)wow)->SetParent(toplevel);
}
}
static void
deskmenu_construct_item (DeskmenuObject *dm_object)
{
DeskmenuItem *item = dm_object->current_item;
GtkWidget *menu_item, *submenu;
gchar *name, *icon, *command, *vpicon;
gboolean images;
gint w, h;
//constructs the items in menu
switch (item->type)
{
case DESKMENU_ITEM_LAUNCHER:
if (item->name_exec)
{
GtkWidget *label;
GHook *hook;
name = g_strstrip (item->name->str);
menu_item = gtk_image_menu_item_new ();
label = gtk_label_new_with_mnemonic (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_container_add (GTK_CONTAINER (menu_item), label);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
if (item->name)
name = g_strstrip (item->name->str);
else
name = "";
menu_item = gtk_image_menu_item_new_with_mnemonic (name);
}
if (item->icon)
{
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU));
}
}
if (item->command_pipe)
{
command = g_strstrip (item->command->str);
if (item->cache_output)
{
g_object_set_data(G_OBJECT(menu_item), "cached", g_strdup("yes"));
}
else
{
g_object_set_data(G_OBJECT(menu_item), "cached", g_strdup("no"));
}
g_object_set_data(G_OBJECT(menu_item), "menu", dm_object);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (pipe_menu_recreate), g_strdup(command));
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
}
else
{
if (item->command)
{
command = g_strstrip (item->command->str);
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (launcher_activated), g_strdup (command));
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
#if HAVE_WNCK
case DESKMENU_ITEM_WINDOWLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Windows");
images = FALSE;
gboolean this_vp = FALSE;
gboolean mini_only = FALSE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->thisvp
&& strcmp (g_strstrip (item->thisvp->str), "true") == 0)
this_vp = TRUE;
if (item->mini_only
&& strcmp (g_strstrip (item->mini_only->str), "true") == 0)
mini_only = TRUE;
g_object_set_data(G_OBJECT(menu_item), "windowlist", deskmenu_windowlist_initialize (images, this_vp, mini_only));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_windowlist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
case DESKMENU_ITEM_DESKTOPLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Desktops");
gboolean file;
images = FALSE;
file = FALSE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->vpicon)
{
vpicon = g_strstrip (parse_expand_tilde(item->vpicon->str));
if (item->vpicon_file)
{
file = TRUE;
}
}
else
{
vpicon = "";
}
g_object_set_data(G_OBJECT(menu_item), "dplist", deskmenu_dplist_initialize (images, file, vpicon));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_desktoplist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
case DESKMENU_ITEM_VIEWPORTLIST:
menu_item = gtk_image_menu_item_new_with_mnemonic ("_Viewports");
gboolean wrap;
wrap = FALSE;
images = FALSE;
file = FALSE;
if (item->wrap && strcmp (g_strstrip (item->wrap->str), "true") == 0)
wrap = TRUE;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->vpicon)
{
vpicon = g_strstrip (parse_expand_tilde(item->vpicon->str));
if (item->vpicon_file)
{
file = TRUE;
}
}
else
{
vpicon = "";
}
g_object_set_data(G_OBJECT(menu_item), "vplist", deskmenu_vplist_initialize (wrap, images, file, vpicon));
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (refresh_viewportlist_item), NULL);
submenu = gtk_menu_new();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item), submenu);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), menu_item);
break;
#endif
case DESKMENU_ITEM_RELOAD:
menu_item = gtk_image_menu_item_new_with_mnemonic ("Reload");
if (item->icon)
{
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
g_signal_connect (G_OBJECT (menu_item), "activate",
G_CALLBACK (quit), NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
case DESKMENU_ITEM_DOCUMENTS:
menu_item = gtk_image_menu_item_new_with_mnemonic ("Recent Doc_uments");
gint limit, age;
gchar *sort_type;
images = FALSE;
sort_type = "least used";
age = 25;
if (item->icon)
{
images = TRUE;
icon = g_strstrip (item->icon->str);
if (item->icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_pixbuf (
gdk_pixbuf_new_from_file_at_size (
parse_expand_tilde(icon), w, h, NULL
)
)
);
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item),
gtk_image_new_from_icon_name (icon,
GTK_ICON_SIZE_MENU)
);
}
}
if (item->age)
{
age = atoi(g_strstrip (item->age->str));
}
if (item->sort_type)
{
sort_type = g_strstrip (item->sort_type->str);
}
if (item->quantity)
{
limit = atoi(g_strstrip (item->quantity->str));
}
else
{
limit = -1;
}
if (item->command)
{
command = g_strstrip (item->command->str);
}
else
{
command = g_strdup ("xdg-open");
}
GtkWidget *docs = make_recent_documents_list(images, command, limit, age, sort_type);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menu_item),
docs);
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
menu_item);
break;
default:
break;
}
}
static void
gnumeric_create_popup_menu_list (GSList *elements,
GnumericPopupMenuHandler handler,
gpointer user_data,
int display_filter,
int sensitive_filter,
GdkEventButton *event)
{
GtkWidget *menu, *item;
char const *trans;
menu = gtk_menu_new ();
for (; elements != NULL ; elements = elements->next)
{
GnumericPopupMenuElement const *element = elements->data;
char const * const name = element->name;
char const * const pix_name = element->pixmap;
item = NULL;
if (element->display_filter != 0 &&
!(element->display_filter & display_filter))
continue;
if (name != NULL && *name != '\0')
{
trans = _(name);
item = gtk_image_menu_item_new_with_mnemonic (trans);
if (element->sensitive_filter != 0 &&
(element->sensitive_filter & sensitive_filter))
gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
if (pix_name != NULL)
{
GtkWidget *image = gtk_image_new_from_stock (pix_name,
GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_image_menu_item_set_image (
GTK_IMAGE_MENU_ITEM (item),
image);
}
}
else
{
/* separator */
item = gtk_menu_item_new ();
gtk_widget_set_sensitive (item, FALSE);
}
if (element->index != 0)
{
g_signal_connect (G_OBJECT (item),
"activate",
G_CALLBACK (&popup_item_activate), user_data);
g_object_set_data (
G_OBJECT (item), "descriptor", (gpointer)(element));
g_object_set_data (
G_OBJECT (item), "handler", (gpointer)handler);
}
gtk_widget_show (item);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
}
gnumeric_popup_menu (GTK_MENU (menu), event);
}
void nsgtk_theme_implement(struct gtk_scaffolding *g)
{
struct nsgtk_theme *theme[IMAGE_SET_COUNT];
int i;
struct nsgtk_button_connect *button;
struct gtk_search *search;
for (i = 0; i <= IMAGE_SET_POPUP_MENU; i++)
theme[i] = nsgtk_theme_load(GTK_ICON_SIZE_MENU);
theme[IMAGE_SET_BUTTONS] =
nsgtk_theme_load(GTK_ICON_SIZE_LARGE_TOOLBAR);
for (i = BACK_BUTTON; i < PLACEHOLDER_BUTTON; i++) {
if ((i == URL_BAR_ITEM) || (i == THROBBER_ITEM) ||
(i == WEBSEARCH_ITEM))
continue;
button = nsgtk_scaffolding_button(g, i);
if (button == NULL)
continue;
/* gtk_image_menu_item_set_image accepts NULL image */
if ((button->main != NULL) &&
(theme[IMAGE_SET_MAIN_MENU] != NULL)) {
gtk_image_menu_item_set_image(button->main,
GTK_WIDGET(
theme[IMAGE_SET_MAIN_MENU]->
image[i]));
gtk_widget_show_all(GTK_WIDGET(button->main));
}
if ((button->rclick != NULL) &&
(theme[IMAGE_SET_RCLICK_MENU] != NULL)) {
gtk_image_menu_item_set_image(button->rclick,
GTK_WIDGET(
theme[IMAGE_SET_RCLICK_MENU]->
image[i]));
gtk_widget_show_all(GTK_WIDGET(button->rclick));
}
if ((button->popup != NULL) &&
(theme[IMAGE_SET_POPUP_MENU] != NULL)) {
gtk_image_menu_item_set_image(button->popup,
GTK_WIDGET(
theme[IMAGE_SET_POPUP_MENU]->
image[i]));
gtk_widget_show_all(GTK_WIDGET(button->popup));
}
if ((button->location != -1) && (button->button != NULL) &&
(theme[IMAGE_SET_BUTTONS] != NULL)) {
gtk_tool_button_set_icon_widget(
GTK_TOOL_BUTTON(button->button),
GTK_WIDGET(
theme[IMAGE_SET_BUTTONS]->
image[i]));
gtk_widget_show_all(GTK_WIDGET(button->button));
}
}
/* set search bar images */
search = nsgtk_scaffolding_search(g);
if ((search != NULL) && (theme[IMAGE_SET_MAIN_MENU] != NULL)) {
/* gtk_tool_button_set_icon_widget accepts NULL image */
if (search->buttons[SEARCH_BACK_BUTTON] != NULL) {
gtk_tool_button_set_icon_widget(
search->buttons[SEARCH_BACK_BUTTON],
GTK_WIDGET(theme[IMAGE_SET_MAIN_MENU]->
searchimage[SEARCH_BACK_BUTTON]));
gtk_widget_show_all(GTK_WIDGET(
search->buttons[SEARCH_BACK_BUTTON]));
}
if (search->buttons[SEARCH_FORWARD_BUTTON] != NULL) {
gtk_tool_button_set_icon_widget(
search->buttons[SEARCH_FORWARD_BUTTON],
GTK_WIDGET(theme[IMAGE_SET_MAIN_MENU]->
searchimage[SEARCH_FORWARD_BUTTON]));
gtk_widget_show_all(GTK_WIDGET(
search->buttons[
SEARCH_FORWARD_BUTTON]));
}
if (search->buttons[SEARCH_CLOSE_BUTTON] != NULL) {
gtk_tool_button_set_icon_widget(
search->buttons[SEARCH_CLOSE_BUTTON],
GTK_WIDGET(theme[IMAGE_SET_MAIN_MENU]->
searchimage[SEARCH_CLOSE_BUTTON]));
gtk_widget_show_all(GTK_WIDGET(
search->buttons[SEARCH_CLOSE_BUTTON]));
}
}
for (i = 0; i < IMAGE_SET_COUNT; i++) {
if (theme[i] != NULL) {
free(theme[i]);
}
}
}
bool wxMenu::GtkAppend(wxMenuItem *mitem, int pos)
{
GtkWidget *menuItem;
GtkWidget* prevRadio = m_prevRadio;
m_prevRadio = NULL;
switch (mitem->GetKind())
{
case wxITEM_SEPARATOR:
menuItem = gtk_separator_menu_item_new();
break;
case wxITEM_CHECK:
menuItem = gtk_check_menu_item_new_with_label("");
break;
case wxITEM_RADIO:
{
GSList* group = NULL;
if (prevRadio)
group = gtk_radio_menu_item_get_group(GTK_RADIO_MENU_ITEM(prevRadio));
menuItem = gtk_radio_menu_item_new_with_label(group, "");
m_prevRadio = menuItem;
}
break;
default:
wxFAIL_MSG("unexpected menu item kind");
// fall through
case wxITEM_NORMAL:
const wxBitmap& bitmap = mitem->GetBitmap();
const char* stockid;
if (bitmap.IsOk())
{
// always use pixbuf, because pixmap mask does not
// work with disabled images in some themes
GtkWidget* image = gtk_image_new_from_pixbuf(bitmap.GetPixbuf());
menuItem = gtk_image_menu_item_new_with_label("");
gtk_widget_show(image);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuItem), image);
}
else if ((stockid = wxGetStockGtkID(mitem->GetId())) != NULL)
// use stock bitmap for this item if available on the assumption
// that it never hurts to follow GTK+ conventions more closely
menuItem = gtk_image_menu_item_new_from_stock(stockid, NULL);
else
menuItem = gtk_menu_item_new_with_label("");
break;
}
mitem->SetMenuItem(menuItem);
gtk_menu_shell_insert(GTK_MENU_SHELL(m_menu), menuItem, pos);
gtk_widget_show( menuItem );
if ( !mitem->IsSeparator() )
{
mitem->SetGtkLabel();
g_signal_connect (menuItem, "select",
G_CALLBACK(menuitem_select), mitem);
g_signal_connect (menuItem, "deselect",
G_CALLBACK(menuitem_deselect), mitem);
if ( mitem->IsSubMenu() && mitem->GetKind() != wxITEM_RADIO && mitem->GetKind() != wxITEM_CHECK )
{
gtk_menu_item_set_submenu( GTK_MENU_ITEM(menuItem), mitem->GetSubMenu()->m_menu );
gtk_widget_show( mitem->GetSubMenu()->m_menu );
}
else
{
g_signal_connect(menuItem, "can_activate_accel",
G_CALLBACK(can_activate_accel), this);
g_signal_connect (menuItem, "activate",
G_CALLBACK(menuitem_activate),
mitem);
}
}
return true;
}
static void create_menu()
{
GtkWidget *i;
gchar *s;
menu = GTK_MENU(gtk_menu_new());
g_assert(menu != NULL);
s = toutf("_Dostêpny");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "1");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_AVAILABLE));
s = toutf("_Porozmawiajmy");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "2");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_CHATTY));
s = toutf("_Jestem zajêty");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "3");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_DND));
s = toutf("_Zaraz wracam");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "4");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_AWAY));
s = toutf("_Wrócê pó¼niej");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "5");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_EXT_AWAY));
s = toutf("_Niewidoczny");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "6");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_INVISIBLE));
s = toutf("Niedostêpn_y");
i = gtk_image_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "7");
gtk_widget_show(i);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(i),
get_status_icon_new(TLEN_PRESENCE_UNAVAILABLE));
/* separator */
i = gtk_menu_item_new();
gtk_container_add(GTK_CONTAINER(menu), i);
gtk_widget_set_sensitive(i, FALSE);
gtk_widget_show(i);
s = toutf("_Ustaw stan opisowy");
i = gtk_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "8");
gtk_widget_show(i);
/* separator */
i = gtk_menu_item_new();
gtk_container_add(GTK_CONTAINER(menu), i);
gtk_widget_set_sensitive(i, FALSE);
gtk_widget_show(i);
s = toutf("_Koniec");
i = gtk_menu_item_new_with_mnemonic(s);
g_free(s);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), i);
g_signal_connect_swapped(G_OBJECT(i), "activate",
G_CALLBACK(menu_item_cb), "9");
gtk_widget_show(i);
}
/** \brief Show satellite popup menu.
* \param sat Pointer to the satellite data.
* \param qth The current location.
* \param pview The GtkPolarView widget.
* \param event The mouse-click related event info
* \param toplevel The toplevel window or NULL.
*
*/
void
gtk_polar_view_popup_exec (sat_t *sat,
qth_t *qth,
GtkPolarView *pview,
GdkEventButton *event,
GtkWidget *toplevel)
{
GtkWidget *menu;
GtkWidget *menuitem;
GtkWidget *label;
GtkWidget *image;
gchar *buff;
sat_obj_t *obj = NULL;
gint *catnum;
menu = gtk_menu_new ();
/* first menu item is the satellite name, centered */
menuitem = gtk_image_menu_item_new ();
label = gtk_label_new (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.5, 0.5);
buff = g_strdup_printf ("<b>%s</b>", sat->nickname);
gtk_label_set_markup (GTK_LABEL (label), buff);
g_free (buff);
gtk_container_add (GTK_CONTAINER (menuitem), label);
image = gtk_image_new_from_stock (GTK_STOCK_INFO, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
/* attach data to menuitem and connect callback */
g_object_set_data (G_OBJECT (menuitem), "sat", sat);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate", G_CALLBACK (show_sat_info_menu_cb), toplevel);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* next pass and predict passes */
menuitem = gtk_image_menu_item_new_with_label (_("Show next pass"));
image = gtk_image_new_from_stock (GTK_STOCK_JUSTIFY_FILL, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
g_object_set_data (G_OBJECT (menuitem), "sat", sat);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate", G_CALLBACK (show_next_pass_cb), pview);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
menuitem = gtk_image_menu_item_new_with_label (_("Future passes"));
image = gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
g_object_set_data (G_OBJECT (menuitem), "sat", sat);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_signal_connect (menuitem, "activate", G_CALLBACK (show_next_passes_cb), pview);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
/* get sat obj since we'll need it for the remaining items */
catnum = g_new0 (gint, 1);
*catnum = sat->tle.catnr;
obj = SAT_OBJ (g_hash_table_lookup (pview->obj, catnum));
g_free (catnum);
/* show track */
menuitem = gtk_check_menu_item_new_with_label (_("Sky track"));
g_object_set_data (G_OBJECT (menuitem), "sat", sat);
g_object_set_data (G_OBJECT (menuitem), "qth", qth);
g_object_set_data (G_OBJECT (menuitem), "obj", obj);
gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem);
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), obj->showtrack);
g_signal_connect (menuitem, "activate", G_CALLBACK (track_toggled), pview);
/* disable menu item if satellite is geostationary */
if (sat->otype == ORBIT_TYPE_GEO)
gtk_widget_set_sensitive (menuitem, FALSE);
/* target */
/* menuitem = gtk_check_menu_item_new_with_label (_("Set as target")); */
/* g_object_set_data (G_OBJECT (menuitem), "sat", sat); */
/* g_object_set_data (G_OBJECT (menuitem), "qth", qth); */
/* g_object_set_data (G_OBJECT (menuitem), "obj", obj); */
/* gtk_menu_shell_append (GTK_MENU_SHELL(menu), menuitem); */
/* gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem), obj->istarget); */
/* g_signal_connect (menuitem, "activate", G_CALLBACK (target_toggled), pview); */
gtk_widget_show_all (menu);
/* Note: event can be NULL here when called from view_onPopupMenu;
* gdk_event_get_time() accepts a NULL argument */
gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time ((GdkEvent*) event));
}
WPkgGtk::WPkgGtk(
GtkWidget *wa_parent_wid,
void *wa_parent_ctx)
: WPkg(wa_parent_ctx), parent_wid(wa_parent_wid),
clock_cursor(0)
{
const int window_width = 600;
const int window_height = 600;
int sts;
pwr_tFileName fname;
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", window_height,
"default-width", window_width,
"title", "Distributor",
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);
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_history = gtk_menu_item_new_with_mnemonic( "_History");
g_signal_connect( file_history, "activate",
G_CALLBACK(WPkgGtk::activate_history), this);
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(WPkgGtk::activate_exit), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_history);
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));
// Functions Entry
GtkWidget *functions_distribute = gtk_menu_item_new_with_mnemonic( "_Distribute");
g_signal_connect( functions_distribute, "activate",
G_CALLBACK(WPkgGtk::activate_distribute), this);
gtk_widget_add_accelerator( functions_distribute, "activate", accel_g,
'd', GdkModifierType(GDK_CONTROL_MASK),
GTK_ACCEL_VISIBLE);
GtkWidget *functions_createpkg = gtk_menu_item_new_with_mnemonic( "_Create Package");
g_signal_connect( functions_createpkg, "activate",
G_CALLBACK(WPkgGtk::activate_createpkg), this);
GtkWidget *functions_deletepkg = gtk_menu_item_new_with_mnemonic( "D_elete Package");
g_signal_connect( functions_deletepkg, "activate",
G_CALLBACK(WPkgGtk::activate_deletepkg), this);
GtkMenu *functions_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_distribute);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_createpkg);
gtk_menu_shell_append(GTK_MENU_SHELL(functions_menu), functions_deletepkg);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic("F_unctions");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(functions_menu));
// View menu
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(WPkgGtk::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_from_stock(GTK_STOCK_ZOOM_OUT, NULL);
g_signal_connect(view_zoom_out, "activate", G_CALLBACK(WPkgGtk::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_from_stock(GTK_STOCK_ZOOM_100, NULL);
g_signal_connect(view_zoom_reset, "activate", G_CALLBACK(WPkgGtk::activate_zoom_reset), this);
GtkWidget *view_dmode_filediff = gtk_menu_item_new_with_mnemonic( "_Display File Differences");
g_signal_connect( view_dmode_filediff, "activate",
G_CALLBACK(WPkgGtk::activate_dmode_filediff), this);
GtkWidget *view_dmode_filetime = gtk_menu_item_new_with_mnemonic( "Display Files In _Time Order");
g_signal_connect( view_dmode_filetime, "activate",
G_CALLBACK(WPkgGtk::activate_dmode_filetime), this);
GtkWidget *view_dmode_filepath = gtk_menu_item_new_with_mnemonic( "Display File _Path");
g_signal_connect( view_dmode_filepath, "activate",
G_CALLBACK(WPkgGtk::activate_dmode_filepath), this);
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_dmode_filediff);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_dmode_filetime);
gtk_menu_shell_append(GTK_MENU_SHELL(view_menu), view_dmode_filepath);
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));
// Menu Help
GtkWidget *help_help = gtk_image_menu_item_new_with_mnemonic("_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(WPkgGtk::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("_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_distribute = gtk_button_new();
dcli_translate_filename( fname, "$pwr_exe/wpkg_distribute.png");
gtk_container_add( GTK_CONTAINER(tools_distribute),
gtk_image_new_from_file( fname));
g_signal_connect(tools_distribute, "clicked", G_CALLBACK(WPkgGtk::activate_distribute), this);
g_object_set( tools_distribute, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_distribute, "Distribute", "");
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(WPkgGtk::activate_zoom_in), this);
g_object_set( tools_zoom_in, "can-focus", FALSE, NULL);
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(WPkgGtk::activate_zoom_out), this);
g_object_set( tools_zoom_out, "can-focus", FALSE, NULL);
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(WPkgGtk::activate_zoom_reset), this);
g_object_set( tools_zoom_reset, "can-focus", FALSE, NULL);
gtk_toolbar_append_widget( tools, tools_zoom_reset, "Zoom reset", "");
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
utility = ((WUtility *)parent_ctx)->utype;
wpkgnav = new WPkgNavGtk( (void *)this, vbox, "Packages",
utility, &brow_widget, &sts);
((WPkgNav *)wpkgnav)->message_cb = message_cb;
((WPkgNav *)wpkgnav)->set_clock_cursor_cb = set_clock_cursor_cb;
((WPkgNav *)wpkgnav)->reset_cursor_cb = reset_cursor_cb;
GtkWidget *statusbar = gtk_hbox_new( FALSE, 0);
msg_label = gtk_label_new( "");
gtk_box_pack_start( GTK_BOX(statusbar), msg_label, FALSE, FALSE, 20);
gtk_widget_show_all( statusbar);
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(brow_widget), TRUE, TRUE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(statusbar), FALSE, FALSE, 3);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all( toplevel);
wow = new CoWowGtk( toplevel);
if ( utility == wb_eUtility_Wtt) {
((Wtt *)parent_ctx)->register_utility( (void *) this,
wb_eUtility_Distributor);
}
}
static void
start_element (GMarkupParseContext *context,
const gchar *element_name,
const gchar **attr_names,
const gchar **attr_values,
gpointer user_data,
GError **error)
{
DeskmenuObject *dm_object = user_data;
DeskmenuElementType element_type;
const gchar **ncursor = attr_names, **vcursor = attr_values;
GtkWidget *item, *menu;
gint w, h;
element_type = GPOINTER_TO_INT (g_hash_table_lookup
(element_hash, element_name));
if ((dm_object->menu && !dm_object->current_menu)
|| (!dm_object->menu && element_type != DESKMENU_ELEMENT_MENU))
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num, &char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element '%s' declared outside of "
"toplevel menu element", line_num, char_num, element_name);
return;
}
switch (element_type)
{
case DESKMENU_ELEMENT_MENU:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'menu' cannot be nested "
"inside of an item element", line_num, char_num);
return;
}
if (!dm_object->menu)
{
/*if (strcmp (*ncursor, "size") == 0) {
deskmenu->w = g_strdup (*vcursor);
deskmenu->h = g_strdup (*vcursor);
}
else {
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, deskmenu->w, deskmenu->h);
}*/
dm_object->menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (dm_object->menu), "parent menu",
NULL);
dm_object->current_menu = dm_object->menu;
}
else
{
gchar *name = NULL;
gchar *icon = NULL;
gboolean name_exec = FALSE;
gboolean icon_file = FALSE;
while (*ncursor)
{
if (strcmp (*ncursor, "name") == 0)
name = g_strdup (*vcursor);
else if (strcmp (*ncursor, "icon") == 0)
icon = g_strdup (*vcursor);
else if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
name_exec = TRUE;
else if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
icon_file = TRUE;
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
if (name_exec)
{
GtkWidget *label;
GHook *hook;
item = gtk_image_menu_item_new ();
label = gtk_label_new_with_mnemonic (NULL);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_container_add (GTK_CONTAINER (item), label);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
if (name)
item = gtk_image_menu_item_new_with_mnemonic (name);
else
item = gtk_image_menu_item_new_with_mnemonic ("");
}
if (icon)
{
if (icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM(item),
gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL)));
}
else {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item),
gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU));
}
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item);
menu = gtk_menu_new ();
g_object_set_data (G_OBJECT (menu), "parent menu",
dm_object->current_menu);
dm_object->current_menu = menu;
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item),
dm_object->current_menu);
if (!dm_object->make_from_pipe)
{
GtkWidget *pin = gtk_tearoff_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
pin); //add a pin menu item
dm_object->pin_items = g_slist_prepend (dm_object->pin_items, pin);
}
else
{
if (gtk_menu_get_tearoff_state (GTK_MENU(dm_object->menu)))
{
GtkWidget *pin = gtk_tearoff_menu_item_new();
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu),
pin); //add a pin menu item
}
}
g_free (name);
g_free (icon);
}
break;
case DESKMENU_ELEMENT_SEPARATOR:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'menu' cannot be nested "
"inside of an item element", line_num, char_num);
return;
}
else {
gchar *name = NULL;
gchar *icon = NULL;
gboolean name_exec = FALSE;
gboolean icon_file = FALSE;
gboolean decorate = FALSE;
gint w, h;
item = gtk_separator_menu_item_new();
while (*ncursor)
{
if (strcmp (*ncursor, "name") == 0)
{
name = g_strdup (*vcursor);
if (!decorate)
{
decorate = TRUE;
}
}
else if (strcmp (*ncursor, "icon") == 0)
{
icon = g_strdup (*vcursor);
if (!decorate)
{
decorate = TRUE;
}
}
else if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
name_exec = TRUE;
else if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
icon_file = TRUE;
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
if (decorate)
{
GtkWidget *box = gtk_hbox_new (FALSE, 3);
gtk_container_add (GTK_CONTAINER(item), GTK_WIDGET(box));
if (name_exec)
{
GtkWidget *label;
GHook *hook;
label = gtk_label_new_with_mnemonic (NULL);
g_object_set_data (G_OBJECT (label), "exec", g_strdup (name));
gtk_box_pack_end (GTK_BOX(box), label, TRUE, FALSE, 0);
hook = g_hook_alloc (dm_object->show_hooks);
hook->data = (gpointer) label;
hook->func = (GHookFunc *) launcher_name_exec_update;
g_hook_append (dm_object->show_hooks, hook);
}
else
{
gtk_box_pack_end (GTK_BOX(box), gtk_label_new_with_mnemonic (name), TRUE, FALSE, 0);
}
if (icon)
{
GtkWidget *image;
if (icon_file)
{
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &w, &h);
image = gtk_image_new_from_pixbuf (gdk_pixbuf_new_from_file_at_size (parse_expand_tilde(icon), w, h, NULL));
}
else {
image = gtk_image_new_from_icon_name (icon, GTK_ICON_SIZE_MENU);
}
gtk_box_pack_start (GTK_BOX(box), image, FALSE, FALSE, 0);
}
gtk_widget_set_state (item, GTK_STATE_PRELIGHT); /*derive colors from menu hover*/
g_free (name);
g_free (icon);
}
gtk_menu_shell_append (GTK_MENU_SHELL (dm_object->current_menu), item);
}
break;
case DESKMENU_ELEMENT_ITEM:
if (dm_object->current_item != NULL)
{
gint line_num, char_num;
g_markup_parse_context_get_position (context, &line_num,
&char_num);
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
"Error on line %d char %d: Element 'item' cannot be nested "
"inside of another item element", line_num, char_num);
return;
}
dm_object->current_item = g_slice_new0 (DeskmenuItem);
while (*ncursor)
{
if (strcmp (*ncursor, "type") == 0)
dm_object->current_item->type = GPOINTER_TO_INT
(g_hash_table_lookup (item_hash, *vcursor));
else
g_set_error (error, G_MARKUP_ERROR,
G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE,
"Unknown attribute: %s", *ncursor);
ncursor++;
vcursor++;
}
break;
case DESKMENU_ELEMENT_NAME:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode") == 0)
&& (strcmp (*vcursor, "exec") == 0))
dm_object->current_item->name_exec = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_ICON:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
dm_object->current_item->icon_file = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_VPICON:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode1") == 0)
&& (strcmp (*vcursor, "file") == 0))
dm_object->current_item->vpicon_file = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_COMMAND:
while (*ncursor)
{
if ((strcmp (*ncursor, "mode2") == 0)
&& (strcmp (*vcursor, "pipe") == 0))
dm_object->current_item->command_pipe = TRUE;
if (dm_object->current_item->command_pipe == TRUE
&& (strcmp (*ncursor, "cache") == 0)
&& (strcmp (*vcursor, "true") == 0))
dm_object->current_item->cache_output = TRUE;
ncursor++;
vcursor++;
} /* no break here to let it fall through */
case DESKMENU_ELEMENT_WRAP:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_THISVP:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_MINIONLY:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_QUANTITY:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_SORT:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
case DESKMENU_ELEMENT_AGE:
if (dm_object->current_item)
dm_object->current_item->current_element = element_type;
break;
default:
g_set_error (error, G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
"Unknown element: %s", element_name);
break;
}
}
/****************************************************************
Worklist editor shell.
*****************************************************************/
GtkWidget *create_worklist(void)
{
GtkWidget *editor, *table, *sw, *bbox;
GtkWidget *src_view, *dst_view, *label, *button;
GtkWidget *menubar, *item, *menu, *image;
GtkWidget *table2, *arrow, *check;
GtkSizeGroup *group;
GtkListStore *src_store, *dst_store;
struct worklist_data *ptr;
ptr = fc_malloc(sizeof(*ptr));
src_store = gtk_list_store_new(1, G_TYPE_INT);
dst_store = gtk_list_store_new(1, G_TYPE_INT);
ptr->global_worklist_id = -1;
ptr->pcity = NULL;
ptr->src = src_store;
ptr->dst = dst_store;
ptr->future = FALSE;
/* create shell. */
editor = gtk_grid_new();
gtk_grid_set_row_spacing(GTK_GRID(editor), 6);
gtk_orientable_set_orientation(GTK_ORIENTABLE(editor),
GTK_ORIENTATION_VERTICAL);
g_signal_connect(editor, "destroy", G_CALLBACK(worklist_destroy), ptr);
g_object_set_data(G_OBJECT(editor), "data", ptr);
ptr->editor = editor;
/* add source and target lists. */
table = gtk_grid_new();
gtk_container_add(GTK_CONTAINER(editor), table);
group = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_grid_attach(GTK_GRID(table), sw, 3, 1, 2, 1);
src_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(src_store));
gtk_widget_set_hexpand(src_view, TRUE);
gtk_widget_set_vexpand(src_view, TRUE);
g_object_unref(src_store);
gtk_size_group_add_widget(group, src_view);
gtk_widget_set_name(src_view, "small_font");
populate_view(GTK_TREE_VIEW(src_view), &ptr->pcity, &ptr->src_col);
gtk_container_add(GTK_CONTAINER(sw), src_view);
label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"mnemonic-widget", src_view,
"label", _("Source _Tasks:"),
"xalign", 0.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 3, 0, 1, 1);
check = gtk_check_button_new_with_mnemonic(_("Show _Future Targets"));
gtk_grid_attach(GTK_GRID(table), check, 4, 0, 1, 1);
g_signal_connect(check, "toggled", G_CALLBACK(future_callback), ptr);
table2 = gtk_grid_new();
gtk_grid_attach(GTK_GRID(table), table2, 2, 1, 1, 1);
button = gtk_button_new();
gtk_widget_set_margin_top(button, 24);
gtk_widget_set_margin_bottom(button, 24);
ptr->prepend_cmd = button;
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
gtk_grid_attach(GTK_GRID(table2), button, 0, 0, 1, 1);
arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(button), arrow);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(queue_prepend), ptr);
gtk_widget_set_sensitive(ptr->prepend_cmd, FALSE);
button = gtk_button_new();
ptr->up_cmd = button;
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
gtk_grid_attach(GTK_GRID(table2), button, 0, 1, 1, 1);
arrow = gtk_arrow_new(GTK_ARROW_UP, GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(button), arrow);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(queue_bubble_up), ptr);
gtk_widget_set_sensitive(ptr->up_cmd, FALSE);
button = gtk_button_new();
ptr->down_cmd = button;
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
gtk_grid_attach(GTK_GRID(table2), button, 0, 2, 1, 1);
arrow = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(button), arrow);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(queue_bubble_down), ptr);
gtk_widget_set_sensitive(ptr->down_cmd, FALSE);
button = gtk_button_new();
gtk_widget_set_margin_top(button, 24);
gtk_widget_set_margin_bottom(button, 24);
ptr->append_cmd = button;
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
gtk_grid_attach(GTK_GRID(table2), button, 0, 3, 1, 1);
arrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(button), arrow);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(queue_append), ptr);
gtk_widget_set_sensitive(ptr->append_cmd, FALSE);
button = gtk_button_new();
gtk_widget_set_margin_top(button, 24);
gtk_widget_set_margin_bottom(button, 24);
ptr->remove_cmd = button;
gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);
gtk_grid_attach(GTK_GRID(table2), button, 0, 4, 1, 1);
arrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(button), arrow);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(queue_remove), ptr);
gtk_widget_set_sensitive(ptr->remove_cmd, FALSE);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(sw),
GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_grid_attach(GTK_GRID(table), sw, 0, 1, 2, 1);
dst_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(dst_store));
gtk_widget_set_hexpand(dst_view, TRUE);
gtk_widget_set_vexpand(dst_view, TRUE);
g_object_unref(dst_store);
gtk_size_group_add_widget(group, dst_view);
gtk_widget_set_name(dst_view, "small_font");
populate_view(GTK_TREE_VIEW(dst_view), &ptr->pcity, &ptr->dst_col);
gtk_container_add(GTK_CONTAINER(sw), dst_view);
label = g_object_new(GTK_TYPE_LABEL,
"use-underline", TRUE,
"mnemonic-widget", dst_view,
"label", _("Target _Worklist:"),
"xalign", 0.0, "yalign", 0.5, NULL);
gtk_grid_attach(GTK_GRID(table), label, 0, 0, 1, 1);
/* add bottom menu and buttons. */
bbox = gtk_button_box_new(GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout(GTK_BUTTON_BOX(bbox), GTK_BUTTONBOX_END);
gtk_box_set_spacing(GTK_BOX(bbox), 10);
gtk_container_add(GTK_CONTAINER(editor), bbox);
menubar = gtk_aux_menu_bar_new();
gtk_container_add(GTK_CONTAINER(bbox), menubar);
gtk_button_box_set_child_secondary(GTK_BUTTON_BOX(bbox), menubar, TRUE);
menu = gtk_menu_new();
image = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);
item = gtk_image_menu_item_new_with_mnemonic(_("_Add Global Worklist"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), image);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
gtk_menu_shell_append(GTK_MENU_SHELL(menubar), item);
g_signal_connect(menu, "show",
G_CALLBACK(popup_add_menu), ptr);
ptr->add_cmd = item;
gtk_widget_set_sensitive(ptr->add_cmd, FALSE);
button = gtk_button_new_from_stock(GTK_STOCK_HELP);
gtk_container_add(GTK_CONTAINER(bbox), button);
g_signal_connect(button, "clicked",
G_CALLBACK(help_callback), ptr);
ptr->help_cmd = button;
gtk_widget_set_sensitive(ptr->help_cmd, FALSE);
button = gtk_button_new_with_mnemonic(_("Change Prod_uction"));
gtk_container_add(GTK_CONTAINER(bbox), button);
g_signal_connect(button, "clicked",
G_CALLBACK(change_callback), ptr);
ptr->change_cmd = button;
gtk_widget_set_sensitive(ptr->change_cmd, FALSE);
ptr->src_view = src_view;
ptr->dst_view = dst_view;
ptr->src_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(src_view));
ptr->dst_selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(dst_view));
gtk_tree_selection_set_mode(ptr->dst_selection, GTK_SELECTION_MULTIPLE);
/* DND and other state changing callbacks. */
gtk_tree_view_set_reorderable(GTK_TREE_VIEW(dst_view), TRUE);
g_signal_connect(dst_view, "drag_end",
G_CALLBACK(dst_dnd_callback), ptr);
g_signal_connect(src_view, "row_activated",
G_CALLBACK(src_row_callback), ptr);
g_signal_connect(src_view, "key_press_event",
G_CALLBACK(src_key_press_callback), ptr);
g_signal_connect(dst_view, "row_activated",
G_CALLBACK(dst_row_callback), ptr);
g_signal_connect(dst_view, "key_press_event",
G_CALLBACK(dst_key_press_callback), ptr);
g_signal_connect(ptr->src_selection, "changed",
G_CALLBACK(src_selection_callback), ptr);
g_signal_connect(ptr->dst_selection, "changed",
G_CALLBACK(dst_selection_callback), ptr);
gtk_widget_show_all(table);
gtk_widget_show_all(bbox);
return editor;
}
GtkWidget *
mate_panel_applet_create_menu (AppletInfo *info)
{
GtkWidget *menu;
GtkWidget *menuitem;
GList *l;
PanelWidget *panel_widget;
gboolean added_anything = FALSE;
panel_widget = mate_panel_applet_get_panel_widget (info);
menu = g_object_ref_sink (gtk_menu_new ());
/* connect the show & deactivate signal, so that we can "disallow" and
* "re-allow" autohide when the menu is shown/deactivated.
*/
g_signal_connect (menu, "show",
G_CALLBACK (applet_menu_show), info);
g_signal_connect (menu, "deactivate",
G_CALLBACK (applet_menu_deactivate), info);
for (l = info->user_menu; l; l = l->next) {
AppletUserMenu *user_menu = l->data;
if (user_menu->is_enabled_func && !user_menu->is_enabled_func ())
continue;
add_to_submenus (info, "", user_menu->name, user_menu,
menu, info->user_menu);
added_anything = TRUE;
}
if (!panel_lockdown_get_locked_down ()) {
GtkWidget *image;
gboolean locked;
gboolean lockable;
gboolean movable;
gboolean removable;
lockable = mate_panel_applet_lockable (info);
movable = mate_panel_applet_can_freely_move (info);
removable = panel_profile_id_lists_are_writable ();
locked = panel_widget_get_applet_locked (panel_widget, info->widget);
if (added_anything) {
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Remove From Panel"));
image = gtk_image_new_from_icon_name ("list-remove",
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
image);
g_signal_connect (menuitem, "activate",
G_CALLBACK (applet_remove_callback), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, (!locked || lockable) && removable);
menuitem = gtk_menu_item_new_with_mnemonic (_("_Move"));
g_signal_connect (menuitem, "activate",
G_CALLBACK (move_applet_callback), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, !locked && movable);
g_assert (info->move_item == NULL);
info->move_item = menuitem;
g_object_add_weak_pointer (G_OBJECT (menuitem),
(gpointer *) &info->move_item);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_mnemonic (_("Loc_k To Panel"));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
locked);
g_signal_connect (menuitem, "toggled",
G_CALLBACK (mate_panel_applet_lock), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, lockable);
added_anything = TRUE;
}
if ( ! added_anything) {
g_object_unref (menu);
return NULL;
}
/* Set up theme and transparency support */
GtkWidget *toplevel = gtk_widget_get_toplevel (menu);
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);
/* Set menu and it's toplevel window to follow panel theme */
GtkStyleContext *context;
context = gtk_widget_get_style_context (GTK_WIDGET(toplevel));
gtk_style_context_add_class(context,"gnome-panel-menu-bar");
gtk_style_context_add_class(context,"mate-panel-menu-bar");
return menu;
}
//
// 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;
}
static void aggregate_layer_add_menu_items ( VikAggregateLayer *val, GtkMenu *menu, gpointer vlp )
{
// Data to pass on in menu functions
static menu_array_values values;
values[MA_VAL] = val;
values[MA_VLP] = vlp;
GtkWidget *item = gtk_menu_item_new();
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
GtkWidget *vis_submenu = gtk_menu_new ();
item = gtk_menu_item_new_with_mnemonic ( _("_Visibility") );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), vis_submenu );
item = gtk_image_menu_item_new_with_mnemonic ( _("_Show All") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_APPLY, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_child_visible_on), values );
gtk_menu_shell_append (GTK_MENU_SHELL (vis_submenu), item);
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("_Hide All") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_CLEAR, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_child_visible_off), values );
gtk_menu_shell_append (GTK_MENU_SHELL (vis_submenu), item);
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("_Toggle") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_child_visible_toggle), values );
gtk_menu_shell_append (GTK_MENU_SHELL (vis_submenu), item);
gtk_widget_show ( item );
GtkWidget *submenu_sort = gtk_menu_new ();
item = gtk_image_menu_item_new_with_mnemonic ( _("_Sort") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_REFRESH, GTK_ICON_SIZE_MENU) );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu_sort );
item = gtk_image_menu_item_new_with_mnemonic ( _("Name _Ascending") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_ASCENDING, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_sort_a2z), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item );
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("Name _Descending") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_DESCENDING, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_sort_z2a), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item );
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("Date Ascending") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_ASCENDING, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_sort_timestamp_ascend), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item );
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("Date Descending") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_SORT_DESCENDING, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_sort_timestamp_descend), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(submenu_sort), item );
gtk_widget_show ( item );
item = gtk_menu_item_new_with_mnemonic ( _("_Statistics") );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_analyse), values );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("Track _List...") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_track_list_dialog), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
item = gtk_image_menu_item_new_with_mnemonic ( _("_Waypoint List...") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_INDEX, GTK_ICON_SIZE_MENU) );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_waypoint_list_dialog), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(menu), item );
gtk_widget_show ( item );
GtkWidget *search_submenu = gtk_menu_new ();
item = gtk_image_menu_item_new_with_mnemonic ( _("Searc_h") );
gtk_image_menu_item_set_image ( (GtkImageMenuItem*)item, gtk_image_new_from_stock (GTK_STOCK_JUMP_TO, GTK_ICON_SIZE_MENU) );
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show ( item );
gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), search_submenu );
item = gtk_menu_item_new_with_mnemonic ( _("By _Date...") );
g_signal_connect_swapped ( G_OBJECT(item), "activate", G_CALLBACK(aggregate_layer_search_date), values );
gtk_menu_shell_append ( GTK_MENU_SHELL(search_submenu), item );
gtk_widget_set_tooltip_text (item, _("Find the first item with a specified date"));
gtk_widget_show ( item );
}
static void _context_menu_document(GHtml * ghtml, GtkWidget * menu)
{
GtkWidget * menuitem;
GtkWidget * image;
/* back */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_GO_BACK, NULL);
if(!ghtml_can_go_back(ghtml->widget))
gtk_widget_set_sensitive(menuitem, FALSE);
else
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(
surfer_go_back), ghtml->surfer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* forward */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_GO_FORWARD,
NULL);
if(!ghtml_can_go_forward(ghtml->widget))
gtk_widget_set_sensitive(menuitem, FALSE);
else
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(
surfer_go_forward), ghtml->surfer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* refresh */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_REFRESH, NULL);
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(
surfer_refresh), ghtml->surfer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* save page */
menuitem = gtk_image_menu_item_new_with_mnemonic(
_("_Save page as..."));
image = gtk_image_new_from_stock(GTK_STOCK_SAVE_AS, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(
surfer_save_dialog), ghtml->surfer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* print */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_PRINT, NULL);
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(surfer_print),
ghtml->surfer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* select all */
menuitem = gtk_image_menu_item_new_from_stock(GTK_STOCK_SELECT_ALL,
NULL);
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(
surfer_select_all), ghtml->surfer);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* separator */
menuitem = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
/* view source */
menuitem = gtk_image_menu_item_new_with_mnemonic(_("View so_urce"));
image = gtk_image_new_from_icon_name("surfer-view-html-source",
GTK_ICON_SIZE_MENU);
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(
surfer_view_source), ghtml->surfer);
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menuitem), image);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
#ifdef WITH_INSPECTOR
/* inspect */
menuitem = gtk_image_menu_item_new_with_mnemonic(
_("_Inspect this page"));
g_signal_connect_swapped(menuitem, "activate", G_CALLBACK(
_on_inspect_page), ghtml);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
#endif
}
static void
gimp_action_set_proxy (GimpAction *action,
GtkWidget *proxy)
{
if (! GTK_IS_IMAGE_MENU_ITEM (proxy))
return;
if (action->color)
{
GtkWidget *area;
area = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_COLOR_AREA (area))
{
gimp_color_area_set_color (GIMP_COLOR_AREA (area), action->color);
}
else
{
gint width, height;
area = gimp_color_area_new (action->color,
GIMP_COLOR_AREA_SMALL_CHECKS, 0);
gimp_color_area_set_draw_border (GIMP_COLOR_AREA (area), TRUE);
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy),
GTK_ICON_SIZE_MENU,
&width, &height);
gtk_widget_set_size_request (area, width, height);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), area);
gtk_widget_show (area);
}
}
else if (action->viewable)
{
GtkWidget *view;
view = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_VIEW (view) &&
g_type_is_a (G_TYPE_FROM_INSTANCE (action->viewable),
GIMP_VIEW (view)->renderer->viewable_type))
{
gimp_view_set_viewable (GIMP_VIEW (view), action->viewable);
}
else
{
GtkIconSize size;
gint width, height;
gint border_width;
if (GIMP_IS_IMAGEFILE (action->viewable))
{
size = GTK_ICON_SIZE_LARGE_TOOLBAR;
border_width = 0;
}
else
{
size = GTK_ICON_SIZE_MENU;
border_width = 1;
}
gtk_icon_size_lookup_for_settings (gtk_widget_get_settings (proxy),
size, &width, &height);
view = gimp_view_new_full (action->context, action->viewable,
width, height, border_width,
FALSE, FALSE, FALSE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), view);
gtk_widget_show (view);
}
}
else
{
GtkWidget *image;
image = gtk_image_menu_item_get_image (GTK_IMAGE_MENU_ITEM (proxy));
if (GIMP_IS_VIEW (image) || GIMP_IS_COLOR_AREA (image))
{
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy), NULL);
g_object_notify (G_OBJECT (action), "stock-id");
}
}
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (proxy));
if (GTK_IS_LABEL (child))
{
GtkLabel *label = GTK_LABEL (child);
gtk_label_set_ellipsize (label, action->ellipsize);
gtk_label_set_max_width_chars (label, action->max_width_chars);
}
}
}
GtkWidget *
mate_panel_applet_create_menu (AppletInfo *info)
{
GtkWidget *menu;
GtkWidget *menuitem;
GList *l;
PanelWidget *panel_widget;
gboolean added_anything = FALSE;
panel_widget = mate_panel_applet_get_panel_widget (info);
menu = g_object_ref_sink (gtk_menu_new ());
/* connect the show & deactivate signal, so that we can "disallow" and
* "re-allow" autohide when the menu is shown/deactivated.
*/
g_signal_connect (menu, "show",
G_CALLBACK (applet_menu_show), info);
g_signal_connect (menu, "deactivate",
G_CALLBACK (applet_menu_deactivate), info);
for (l = info->user_menu; l; l = l->next) {
AppletUserMenu *user_menu = l->data;
if (user_menu->is_enabled_func && !user_menu->is_enabled_func ())
continue;
add_to_submenus (info, "", user_menu->name, user_menu,
menu, info->user_menu);
added_anything = TRUE;
}
if (!panel_lockdown_get_locked_down ()) {
GtkWidget *image;
gboolean locked;
gboolean lockable;
gboolean movable;
gboolean removable;
lockable = mate_panel_applet_lockable (info);
movable = mate_panel_applet_can_freely_move (info);
removable = panel_profile_id_lists_are_writable ();
locked = panel_widget_get_applet_locked (panel_widget, info->widget);
if (added_anything) {
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
}
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Remove From Panel"));
image = gtk_image_new_from_stock (GTK_STOCK_REMOVE,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem),
image);
g_signal_connect (menuitem, "activate",
G_CALLBACK (applet_remove_callback), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, (!locked || lockable) && removable);
menuitem = gtk_menu_item_new_with_mnemonic (_("_Move"));
g_signal_connect (menuitem, "activate",
G_CALLBACK (move_applet_callback), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, !locked && movable);
g_assert (info->move_item == NULL);
info->move_item = menuitem;
g_object_add_weak_pointer (G_OBJECT (menuitem),
(gpointer *) &info->move_item);
menuitem = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_show (menuitem);
menuitem = gtk_check_menu_item_new_with_mnemonic (_("Loc_k To Panel"));
gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (menuitem),
locked);
g_signal_connect (menuitem, "toggled",
G_CALLBACK (mate_panel_applet_lock), info);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menuitem);
gtk_widget_set_sensitive (menuitem, lockable);
added_anything = TRUE;
}
if ( ! added_anything) {
g_object_unref (menu);
return NULL;
}
return menu;
}
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;
}
GtkWidget *
panel_context_menu_create (PanelWidget *panel)
{
GtkWidget *retval;
GtkWidget *menuitem;
GtkWidget *image;
if (panel->master_widget) {
gpointer *pointer;
AppletInfo *info;
pointer = g_object_get_data (G_OBJECT (panel->master_widget),
"applet_info");
g_assert (pointer != NULL);
info = (AppletInfo *) pointer;
if (info->menu == NULL) {
info->menu = mate_panel_applet_create_menu (info);
}
return info->menu;
}
retval = create_empty_menu ();
gtk_widget_set_name (retval, "mate-panel-context-menu");
if (!panel_lockdown_get_locked_down ())
panel_context_menu_build_edition (panel, retval);
menuitem = gtk_image_menu_item_new_with_mnemonic (_("_Help"));
image = gtk_image_new_from_stock (GTK_STOCK_HELP, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (retval), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (panel_context_menu_show_help), NULL);
menuitem = gtk_image_menu_item_new_with_mnemonic (_("A_bout Panels"));
image = gtk_image_new_from_stock (GTK_STOCK_ABOUT,
GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menuitem), image);
gtk_widget_show (menuitem);
gtk_menu_shell_append (GTK_MENU_SHELL (retval), menuitem);
g_signal_connect (menuitem, "activate",
G_CALLBACK (panel_context_menu_show_about_dialog),
NULL);
//FIXME: can we get rid of this? (needed by menu_get_panel())
g_object_set_data (G_OBJECT (retval), "menu_panel", panel);
/* Set up theme and transparency support */
#if GTK_CHECK_VERSION (3, 0, 0)
GtkWidget *toplevel = gtk_widget_get_toplevel (retval);
/* Fix any failures of compiz/other wm's to communicate with gtk for transparency */
GdkScreen *screen = gtk_widget_get_screen(GTK_WIDGET(toplevel));
GdkVisual *visual = gdk_screen_get_rgba_visual(screen);
gtk_widget_set_visual(GTK_WIDGET(toplevel), visual);
/* Set menu and it's toplevel window to follow panel theme */
GtkStyleContext *context;
context = gtk_widget_get_style_context (GTK_WIDGET(toplevel));
gtk_style_context_add_class(context,"gnome-panel-menu-bar");
gtk_style_context_add_class(context,"mate-panel-menu-bar");
#endif
return retval;
}
static void
saa_main_window_init (SaaMainWindow * w) {
GtkWidget * vbox_win;
// Barre de menu ----------------------------------------------------------
GtkWidget *menubar;
GtkWidget *image;
GtkWidget *mit_fichier;
GtkWidget *mit_fichier_menu;
GtkWidget *it_charger_xml;
GtkWidget *it_enregistrer_xml;
GtkWidget *mit_exporter;
GtkWidget *mit_exporter_menu;
GtkWidget *it_exporter;
GtkWidget *it_exporter_rb;
GtkWidget *it_sep_fichier;
GtkWidget *it_quitter;
GtkWidget *mit_aide;
GtkWidget *mit_aide_menu;
GtkWidget *it_a_propos;
GtkWidget *hbox_win;
GtkWidget *vbox_prop;
// Onglets ----------------------------------------------------------------
GtkWidget *notebook;
GtkWidget *label_page1;
GtkWidget *page1;
GtkWidget *f_uniform;
GtkWidget *lbl_uniform;
GtkWidget *f_traitement;
GtkWidget *lbl_traitement;
GtkWidget *label_page2;
GtkWidget *page2;
GtkWidget *sw;
GtkWidget *label_page3;
GtkWidget *page3;
// Barre d'état -----------------------------------------------------------
GtkWidget *hbox_status;
GtkWidget *statusbar;
GtkWidget *progressbar;
GtkAccelGroup *accel_group;
int i;
const gchar* const * dirs = g_get_system_data_dirs();
gchar * path;
// TODO init_files();
saa_init_files();
g_set_application_name (PACKAGE_NAME);
w->icon = NULL;
for(i=0; dirs[i] && !w->icon; i++) {
path = g_build_filename(dirs[i], "images", "gsolaar-logo.png", NULL);
if(g_file_test(path, G_FILE_TEST_EXISTS)) {
w->icon = gdk_pixbuf_new_from_file(path, NULL);
gtk_window_set_default_icon (w->icon);
}
g_free(path);
}
w->visuel = saa_visuel_creer();
accel_group = gtk_accel_group_new ();
gtk_window_set_title (GTK_WINDOW (w), "GSolaar");
vbox_win = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_win);
gtk_container_add (GTK_CONTAINER (w), vbox_win);
menubar = gtk_menu_bar_new ();
gtk_widget_show (menubar);
gtk_box_pack_start (GTK_BOX (vbox_win), menubar, FALSE, FALSE, 0);
mit_fichier = gtk_menu_item_new_with_mnemonic(_("_File"));
gtk_widget_show (mit_fichier);
gtk_container_add (GTK_CONTAINER (menubar), mit_fichier);
mit_fichier_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mit_fichier), mit_fichier_menu);
// Chargement -------------------------------------------------------------
it_charger_xml = gtk_image_menu_item_new_from_stock (GTK_STOCK_OPEN, accel_group);
gtk_widget_show (it_charger_xml);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), it_charger_xml);
// Sauvegarde -------------------------------------------------------------
it_enregistrer_xml = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE, accel_group);
gtk_widget_show (it_enregistrer_xml);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), it_enregistrer_xml);
// Patron -----------------------------------------------------------------
mit_exporter = gtk_image_menu_item_new_with_mnemonic(_("_Export"));
gtk_widget_show(mit_exporter);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), mit_exporter);
image = gtk_image_new_from_stock (GTK_STOCK_CONVERT, GTK_ICON_SIZE_MENU);
gtk_widget_show (image);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mit_exporter), image);
mit_exporter_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mit_exporter), mit_exporter_menu);
it_exporter = gtk_image_menu_item_new_with_label (_("Pattern ..."));
gtk_widget_show (it_exporter);
gtk_container_add (GTK_CONTAINER (mit_exporter_menu), it_exporter);
it_exporter_rb = gtk_image_menu_item_new_with_label (_("Ruby script for SketchUp ..."));
gtk_widget_show (it_exporter_rb);
gtk_container_add (GTK_CONTAINER (mit_exporter_menu), it_exporter_rb);
//-------------------------------------------------------------------------
it_sep_fichier = gtk_menu_item_new ();
gtk_widget_show (it_sep_fichier);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), it_sep_fichier);
gtk_widget_set_sensitive (it_sep_fichier, FALSE);
it_quitter = gtk_image_menu_item_new_from_stock (GTK_STOCK_QUIT, accel_group);
gtk_widget_show (it_quitter);
gtk_container_add (GTK_CONTAINER (mit_fichier_menu), it_quitter);
mit_aide = gtk_menu_item_new_with_mnemonic ("_?");
gtk_widget_show (mit_aide);
gtk_container_add (GTK_CONTAINER (menubar), mit_aide);
mit_aide_menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mit_aide), mit_aide_menu);
it_a_propos = gtk_image_menu_item_new_from_stock ( GTK_STOCK_ABOUT, accel_group);
gtk_widget_show (it_a_propos);
gtk_container_add (GTK_CONTAINER (mit_aide_menu), it_a_propos);
//-------------------------------------------------------------------------
hbox_win = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox_win);
gtk_box_pack_start (GTK_BOX (vbox_win), hbox_win, TRUE, TRUE, 0);
vbox_prop = gtk_vbox_new (FALSE, 0);
gtk_widget_show (vbox_prop);
gtk_box_pack_start (GTK_BOX (hbox_win), vbox_prop, TRUE, TRUE, 0);
gtk_widget_set_size_request (vbox_prop, 500, 400);
// Drawing Area
w->area = saa_drawing_area_new_with_visuel (w->visuel);
gtk_widget_show (w->area);
gtk_box_pack_start (GTK_BOX (vbox_prop), w->area, TRUE, TRUE, 0);
gtk_widget_set_size_request (w->area, 600, 400);
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_container_set_border_width (GTK_CONTAINER (notebook), 5);
gtk_box_pack_start (GTK_BOX (hbox_win), notebook, FALSE, FALSE, 0);
label_page1 = gtk_label_new (_("Polyhedron"));
gtk_widget_show (label_page1);
page1 = gtk_vbox_new (FALSE, 5);
gtk_widget_show (page1);
gtk_container_set_border_width (GTK_CONTAINER (page1), 5);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page1, label_page1);
f_uniform = gtk_frame_new (NULL);
gtk_widget_show (f_uniform);
gtk_box_pack_start (GTK_BOX (page1), f_uniform, FALSE, FALSE, 0);
gtk_container_set_border_width (GTK_CONTAINER (f_uniform), 5);
gtk_frame_set_label_align (GTK_FRAME (f_uniform), 0.5, 0.5);
lbl_uniform = gtk_label_new (_("Uniform polyhedra"));
gtk_widget_show (lbl_uniform);
gtk_frame_set_label_widget (GTK_FRAME (f_uniform), lbl_uniform);
gtk_label_set_justify (GTK_LABEL (lbl_uniform), GTK_JUSTIFY_LEFT);
// Solid manager
w->manager = saa_solid_manager_new_with_visuel(w->visuel);
gtk_widget_show(w->manager);
gtk_container_add (GTK_CONTAINER (f_uniform), w->manager);
f_traitement = gtk_frame_new (NULL);
gtk_widget_show (f_traitement);
gtk_box_pack_start (GTK_BOX (page1), f_traitement, TRUE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (f_traitement), 5);
gtk_frame_set_label_align (GTK_FRAME (f_traitement), 0.5, 0.5);
lbl_traitement = gtk_label_new (_("Treatment"));
gtk_widget_show (lbl_traitement);
gtk_frame_set_label_widget (GTK_FRAME (f_traitement), lbl_traitement);
gtk_label_set_justify (GTK_LABEL (lbl_traitement), GTK_JUSTIFY_LEFT);
// Solid Handler
w->handler = saa_solid_handler_new_with_visuel(w->visuel);
gtk_widget_show(w->handler);
gtk_container_add (GTK_CONTAINER (f_traitement), w->handler);
label_page2 = gtk_label_new (_("Navigation"));
gtk_widget_show (label_page2);
page2 = gtk_vbox_new (FALSE, 5);
gtk_widget_show (page2);
gtk_container_set_border_width (GTK_CONTAINER (page2), 5);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page2, label_page2);
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show(sw);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_ETCHED_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (page2), sw, TRUE, TRUE, 0);
// Treeview navigator
w->explorer = saa_tree_view_new_with_visuel(w->visuel);
gtk_widget_show(w->explorer);
gtk_container_add (GTK_CONTAINER (sw), w->explorer);
// TODO a deplacer dans window realize
saa_tree_view_update(SAA_TREE_VIEW(w->explorer));
label_page3 = gtk_label_new (_("Display"));
gtk_widget_show (label_page3);
page3 = gtk_vbox_new (FALSE, 5);
gtk_widget_show (page3);
gtk_container_set_border_width (GTK_CONTAINER (page3), 5);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), page3, label_page3);
// Solid display
w->display = saa_solid_display_new_with_visuel(w->visuel);
gtk_widget_show (w->display);
gtk_box_pack_start(GTK_BOX(page3), w->display, TRUE, TRUE, 0);
hbox_status = gtk_hbox_new (FALSE, 0);
gtk_widget_show (hbox_status);
gtk_box_pack_start (GTK_BOX (vbox_win), hbox_status, FALSE, FALSE, 0);
statusbar = gtk_statusbar_new ();
gtk_widget_show (statusbar);
gtk_box_pack_start (GTK_BOX (hbox_status), statusbar, TRUE, TRUE, 0);
progressbar = gtk_progress_bar_new ();
gtk_widget_show (progressbar);
gtk_box_pack_start (GTK_BOX (hbox_status), progressbar, FALSE, FALSE, 0);
g_signal_connect_swapped ((gpointer)w->manager, "solid-changed",
G_CALLBACK (saa_tree_view_update),
w->explorer);
g_signal_connect_swapped ((gpointer)w->manager, "solid-changed",
G_CALLBACK (gtk_widget_queue_draw),
w->area);
g_signal_connect_swapped ((gpointer)w->display, "solid-changed",
G_CALLBACK (gtk_widget_queue_draw),
w->area);
g_signal_connect_swapped ((gpointer)w->handler, "solid-changed",
G_CALLBACK (saa_tree_view_update),
w->explorer);
g_signal_connect_swapped ((gpointer)w->handler, "solid-changed",
G_CALLBACK (gtk_widget_queue_draw),
w->area);
g_signal_connect_swapped ((gpointer)w->area, "vertex-selected",
G_CALLBACK (saa_tree_view_select_vertex),
w->explorer);
g_signal_connect_swapped ((gpointer)w->area, "edge-selected",
G_CALLBACK (saa_tree_view_select_edge),
w->explorer);
g_signal_connect_swapped ((gpointer)w->area, "wing-selected",
G_CALLBACK (saa_tree_view_select_wing),
w->explorer);
g_signal_connect_swapped ((gpointer)w->explorer, "vertex-selected",
G_CALLBACK (saa_drawing_area_select_vertex),
w->area);
g_signal_connect_swapped ((gpointer)w->explorer, "edge-selected",
G_CALLBACK (saa_drawing_area_select_edge),
w->area);
g_signal_connect_swapped ((gpointer)w->explorer, "wing-selected",
G_CALLBACK (saa_drawing_area_select_wing),
w->area);
g_signal_connect_swapped((gpointer)it_charger_xml, "activate",
G_CALLBACK (saa_main_window_charger_xml_clicked),
w);
g_signal_connect_swapped((gpointer)it_enregistrer_xml, "activate",
G_CALLBACK (saa_main_window_sauver_xml_activate),
w);
g_signal_connect_swapped((gpointer)it_exporter, "activate",
G_CALLBACK (saa_main_window_exporter_activate),
w);
g_signal_connect_swapped((gpointer)it_exporter_rb, "activate",
G_CALLBACK (saa_main_window_exporter_rb_activate),
w);
g_signal_connect_swapped ((gpointer)it_quitter, "activate",
G_CALLBACK (saa_main_window_quitter_activate),
w);
g_signal_connect (G_OBJECT(w), "destroy",
G_CALLBACK (saa_main_window_quitter_activate),
NULL);
g_signal_connect_swapped ((gpointer)it_a_propos, "activate",
G_CALLBACK (saa_main_window_a_propos_activate),
w);
gtk_window_add_accel_group (GTK_WINDOW (w), accel_group);
}
static void
notebook_popup_menu_show (NemoWindowPane *pane,
GdkEventButton *event)
{
GtkWidget *popup;
GtkWidget *item;
GtkWidget *image;
int button, event_time;
gboolean can_move_left, can_move_right;
NemoNotebook *notebook;
notebook = NEMO_NOTEBOOK (pane->notebook);
can_move_left = nemo_notebook_can_reorder_current_child_relative (notebook, -1);
can_move_right = nemo_notebook_can_reorder_current_child_relative (notebook, 1);
popup = gtk_menu_new();
item = gtk_menu_item_new_with_mnemonic (_("_New Tab"));
g_signal_connect (item, "activate",
G_CALLBACK (notebook_popup_menu_new_tab_cb),
pane);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
item);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
gtk_separator_menu_item_new ());
item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Left"));
g_signal_connect (item, "activate",
G_CALLBACK (notebook_popup_menu_move_left_cb),
pane);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
item);
gtk_widget_set_sensitive (item, can_move_left);
item = gtk_menu_item_new_with_mnemonic (_("Move Tab _Right"));
g_signal_connect (item, "activate",
G_CALLBACK (notebook_popup_menu_move_right_cb),
pane);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
item);
gtk_widget_set_sensitive (item, can_move_right);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
gtk_separator_menu_item_new ());
item = gtk_image_menu_item_new_with_mnemonic (_("_Close Tab"));
image = gtk_image_new_from_stock (GTK_STOCK_CLOSE, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
g_signal_connect (item, "activate",
G_CALLBACK (notebook_popup_menu_close_cb), pane);
gtk_menu_shell_append (GTK_MENU_SHELL (popup),
item);
gtk_widget_show_all (popup);
if (event) {
button = event->button;
event_time = event->time;
} else {
button = 0;
event_time = gtk_get_current_event_time ();
}
/* TODO is this correct? */
gtk_menu_attach_to_widget (GTK_MENU (popup),
pane->notebook,
NULL);
gtk_menu_popup (GTK_MENU (popup), NULL, NULL, NULL, NULL,
button, event_time);
}
static void
thunar_chooser_button_pressed (ThunarChooserButton *chooser_button,
GtkWidget *button)
{
ThunarVfsMimeApplication *default_application;
ThunarVfsMimeInfo *info;
ThunarIconFactory *icon_factory;
GtkIconTheme *icon_theme;
const gchar *icon_name;
GdkPixbuf *icon;
GtkWidget *image;
GtkWidget *item;
GtkWidget *menu;
GList *applications;
GList *lp;
gint icon_size;
_thunar_return_if_fail (THUNAR_IS_CHOOSER_BUTTON (chooser_button));
_thunar_return_if_fail (chooser_button->button == button);
_thunar_return_if_fail (GTK_IS_BUTTON (button));
/* verify that we have a valid file */
if (G_UNLIKELY (chooser_button->file == NULL))
return;
/* determine the mime info for the file */
info = thunar_file_get_mime_info (chooser_button->file);
/* determine the default application */
default_application = thunar_vfs_mime_database_get_default_application (chooser_button->database, info);
if (G_UNLIKELY (default_application == NULL))
{
/* no default application, just popup the application chooser */
thunar_chooser_button_activate_other (chooser_button);
return;
}
/* determine all applications that claim to be able to handle the file */
applications = thunar_vfs_mime_database_get_applications (chooser_button->database, info);
/* make sure the default application comes first */
lp = g_list_find (applications, default_application);
if (G_LIKELY (lp != NULL))
{
applications = g_list_delete_link (applications, lp);
g_object_unref (G_OBJECT (default_application));
}
applications = g_list_prepend (applications, default_application);
/* allocate a new popup menu */
menu = gtk_menu_new ();
/* determine the icon size for menus */
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_size, &icon_size);
/* determine the icon factory for our screen */
icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (button));
icon_factory = thunar_icon_factory_get_for_icon_theme (icon_theme);
/* add the other possible applications */
for (lp = applications; lp != NULL; lp = lp->next)
{
item = gtk_image_menu_item_new_with_label (thunar_vfs_mime_handler_get_name (lp->data));
g_object_set_data_full (G_OBJECT (item), I_("thunar-vfs-mime-application"), lp->data, g_object_unref);
g_signal_connect_swapped (G_OBJECT (item), "activate", G_CALLBACK (thunar_chooser_button_activate), chooser_button);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* setup the icon for the application */
icon_name = thunar_vfs_mime_handler_lookup_icon_name (lp->data, icon_theme);
icon = thunar_icon_factory_load_icon (icon_factory, icon_name, icon_size, NULL, FALSE);
image = gtk_image_new_from_pixbuf (icon);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
gtk_widget_show (image);
if (G_LIKELY (icon != NULL))
g_object_unref (icon);
}
/* cleanup */
g_object_unref (G_OBJECT (icon_factory));
/* append a separator */
item = gtk_separator_menu_item_new ();
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* release the applications list */
g_list_free (applications);
/* add the "Other Application..." choice */
item = gtk_image_menu_item_new_with_mnemonic (_("_Other Application..."));
g_signal_connect_swapped (G_OBJECT (item), "activate", G_CALLBACK (thunar_chooser_button_activate_other), chooser_button);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
gtk_widget_show (item);
/* make sure the menu has atleast the same width as the chooser */
if (menu->allocation.width < button->allocation.width)
gtk_widget_set_size_request (menu, button->allocation.width, -1);
/* run the menu on the button's screen (takes over the floating reference of menu) */
thunar_gtk_menu_run (GTK_MENU (menu), button, menu_position, button, 0, gtk_get_current_event_time ());
/* yeppa, that's a requirement */
gtk_button_released (GTK_BUTTON (button));
}
/*
* Windows Main
* Twitter TimeLine Cntent
*
*/
int windows_main(int argc, char **argv){
gtk_init (&argc, &argv);
char *configFile = NULL;
GError *error = NULL;
GtkWidget *window,
*table,
*scroll,
*icon_menu,
*table_into,
//*tweet,
//*avatar,
*scrolled_window,
*menu_bar,
*layout,
*toolbar,
*statusbar,
*statusbar_char,
*new_button,
*text,
*file_menu_obj,
*file_menu_root,
*file_menu_items,
*aiuto_menu_obj,
*aiuto_menu_root,
*aiuto_menu_items;
GtkTextBuffer *buffer;
asprintf(&configFile, "%s%s", g_get_home_dir(), "/.twc/config/user.twc");
/* Set all window options (color, size, position, logo, icon, etc) */
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW(window), 315, 650);
gtk_widget_set_size_request (window, 315, 400);
gtk_window_set_title (GTK_WINDOW(window), "TwitCrusader");
gtk_container_set_border_width (GTK_CONTAINER (window), 0);
gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
gtk_window_set_icon_from_file (GTK_WINDOW(window), ICON_FAVICON, &error);
/* CALLBACK: exit event */
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (gtk_main_quit), NULL);
/* GTK Widget: Menu */
file_menu_obj = gtk_menu_new();
aiuto_menu_obj = gtk_menu_new();
/* SuBMenu File
* Fix Icons Linux
* gconftool-2 --type boolean --set /desktop/gnome/interface/buttons_have_icons true
* gconftool-2 --type boolean --set /desktop/gnome/interface/menus_have_icons true
* */
file_menu_items = gtk_image_menu_item_new_with_label("Nuovo Utente");
icon_menu = gtk_image_new_from_file(ICON_ADDUSER);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (windows_adduser), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_items = gtk_image_menu_item_new_with_label("Opzioni");
icon_menu = gtk_image_new_from_file(ICON_SETTINGS);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (windows_setting), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_items = gtk_image_menu_item_new_with_label("Esci");
icon_menu = gtk_image_new_from_file(ICON_CLOSE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (file_menu_items), icon_menu);
g_signal_connect (G_OBJECT (file_menu_items), "activate", G_CALLBACK (gtk_main_quit), NULL);
gtk_menu_append(GTK_MENU (file_menu_obj), file_menu_items);
file_menu_root = gtk_menu_item_new_with_label("File");
gtk_menu_item_set_submenu(GTK_MENU_ITEM (file_menu_root), file_menu_obj);
/* SubMenu: Help */
aiuto_menu_items = gtk_image_menu_item_new_with_label("Updates");
icon_menu = gtk_image_new_from_file(ICON_UPGRADE);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (aiuto_menu_items), icon_menu);
g_signal_connect (G_OBJECT (aiuto_menu_items), "activate", G_CALLBACK (windows_upgrade), NULL);
gtk_menu_append(GTK_MENU (aiuto_menu_obj), aiuto_menu_items);
aiuto_menu_items = gtk_image_menu_item_new_with_label("Informazioni");
icon_menu = gtk_image_new_from_file(ICON_STAR);
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (aiuto_menu_items), icon_menu);
g_signal_connect (G_OBJECT (aiuto_menu_items), "activate", G_CALLBACK (windows_about), NULL);
gtk_menu_append(GTK_MENU (aiuto_menu_obj), aiuto_menu_items);
aiuto_menu_root = gtk_menu_item_new_with_label("Aiuto");
gtk_menu_item_set_submenu(GTK_MENU_ITEM (aiuto_menu_root), aiuto_menu_obj);
/* Set Layout Position */
layout = gtk_vbox_new(0, 1);
gtk_container_add(GTK_CONTAINER(window), layout);
menu_bar = gtk_menu_bar_new();
gtk_box_pack_start(GTK_BOX(layout), menu_bar, FALSE, FALSE, 0);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), file_menu_root);
gtk_menu_bar_append(GTK_MENU_BAR (menu_bar), aiuto_menu_root);
/* Status Bar */
statusbar = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(statusbar), TRUE);
gtk_statusbar_push (GTK_STATUSBAR(statusbar), 0, "TwitCrusader...");
gtk_box_pack_end (GTK_BOX (layout), statusbar, FALSE, FALSE, 0);
/* GTK Widget: Twitter Menu */
toolbar = gtk_toolbar_new ();
gtk_box_pack_end (GTK_BOX (layout), toolbar, FALSE, FALSE, 0);
gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS);
gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar));
/* Twitter Menu: Buttons */
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_HOME);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_UPDATE);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_MENTION);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_DM);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_FAVORITES);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_LINK);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
new_button = gtk_button_new();
icon_menu = gtk_image_new_from_file(ICON_PHOTO);
gtk_button_set_image(GTK_BUTTON(new_button),icon_menu);
gtk_container_add (GTK_CONTAINER (toolbar), new_button);
/* Status Bar: Twitter 140char */
statusbar_char = gtk_statusbar_new ();
gtk_statusbar_set_has_resize_grip (GTK_STATUSBAR(statusbar_char), FALSE);
gtk_statusbar_push (GTK_STATUSBAR(statusbar_char), 0, "140");
gtk_box_pack_end (GTK_BOX (layout), statusbar_char, FALSE, FALSE, 0);
/* Table Content Tweet/Mentions */
table = gtk_table_new (9, 3, TRUE);
gtk_container_add(GTK_CONTAINER(layout), table);
/* Scrolled */
table_into = gtk_table_new (1, 3, TRUE);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),GTK_POLICY_AUTOMATIC, GTK_POLICY_ALWAYS);
gtk_table_attach (GTK_TABLE (table), scrolled_window, 0, 3, 0, 8, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (scrolled_window), table_into);
/*for ( rows = 0; rows < 40; rows = rows + 4 ) {
for ( cols = 0; cols < 3; cols++ ) {
avatar = gtk_image_new_from_file ("");
tweet = gtk_label_new ("");
gtk_label_set_justify (GTK_LABEL(tweet),GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap_mode (GTK_LABEL(tweet), GTK_WRAP_WORD_CHAR);
gtk_table_attach (GTK_TABLE (table_into ), tweet, 0, 1,rows, rows + 4, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table_into ), tweet, 1, 3,rows, rows + 1, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
tweet = gtk_label_new ("");
gtk_table_attach (GTK_TABLE (table_into ), tweet, 1, 3,rows + 1, rows + 4, GTK_FILL | GTK_EXPAND,GTK_FILL, 0, 0);
}
}*/
// TextArea + Scrollbar
scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_table_attach (GTK_TABLE (table), scroll, 0, 3,8, 9, GTK_FILL | GTK_EXPAND,GTK_FILL | GTK_EXPAND, 0, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
text = gtk_text_view_new();
gtk_text_view_set_editable(GTK_TEXT_VIEW(text), TRUE);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW(text), GTK_WRAP_WORD_CHAR);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (text));
gtk_text_buffer_set_text (buffer, "", -1);
g_signal_connect(buffer, "changed", G_CALLBACK(update_statusbar), statusbar_char);
g_signal_connect(text, "key-press-event", G_CALLBACK(send_tweet_gtk), buffer);
gtk_container_add(GTK_CONTAINER(scroll), text);
// Widget Show
gtk_widget_show_all (window);
//Exist Config File?
if(readUserFile()==1) windows_adduser();
//Show GTK Main
gtk_main ();
return 0;
}
static GtkWidget *
build_suggestion_menu (PlumaAutomaticSpellChecker *spell, const gchar *word)
{
GtkWidget *topmenu, *menu;
GtkWidget *mi;
GSList *suggestions;
GSList *list;
gchar *label_text;
topmenu = menu = gtk_menu_new();
suggestions = pluma_spell_checker_get_suggestions (spell->spell_checker, word, -1);
list = suggestions;
if (suggestions == NULL)
{
/* no suggestions. put something in the menu anyway... */
GtkWidget *label;
/* Translators: Displayed in the "Check Spelling" dialog if there are no suggestions for the current misspelled word */
label = gtk_label_new (_("(no suggested words)"));
mi = gtk_menu_item_new ();
gtk_widget_set_sensitive (mi, FALSE);
gtk_container_add (GTK_CONTAINER(mi), label);
gtk_widget_show_all (mi);
gtk_menu_shell_prepend (GTK_MENU_SHELL (menu), mi);
}
else
{
gint count = 0;
/* build a set of menus with suggestions. */
while (suggestions != NULL)
{
GtkWidget *label;
if (count == 10)
{
/* Separator */
mi = gtk_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
mi = gtk_menu_item_new_with_mnemonic (_("_More..."));
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
menu = gtk_menu_new ();
gtk_menu_item_set_submenu (GTK_MENU_ITEM (mi), menu);
count = 0;
}
label_text = g_strdup_printf ("<b>%s</b>", (gchar*) suggestions->data);
label = gtk_label_new (label_text);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_label_set_xalign (GTK_LABEL (label), 0.0);
mi = gtk_menu_item_new ();
gtk_container_add (GTK_CONTAINER(mi), label);
gtk_widget_show_all (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), mi);
g_object_set_qdata_full (G_OBJECT (mi),
suggestion_id,
g_strdup (suggestions->data),
(GDestroyNotify)g_free);
g_free (label_text);
g_signal_connect (mi,
"activate",
G_CALLBACK (replace_word),
spell);
count++;
suggestions = g_slist_next (suggestions);
}
}
/* free the suggestion list */
suggestions = list;
while (list)
{
g_free (list->data);
list = g_slist_next (list);
}
g_slist_free (suggestions);
/* Separator */
mi = gtk_menu_item_new ();
gtk_widget_show (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
/* Ignore all */
mi = gtk_image_menu_item_new_with_mnemonic (_("_Ignore All"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi),
gtk_image_new_from_icon_name ("go-bottom",
GTK_ICON_SIZE_MENU));
g_signal_connect (mi,
"activate",
G_CALLBACK(ignore_all),
spell);
gtk_widget_show_all (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
/* + Add to Dictionary */
mi = gtk_image_menu_item_new_with_mnemonic (_("_Add"));
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi),
gtk_image_new_from_icon_name ("list-add",
GTK_ICON_SIZE_MENU));
g_signal_connect (mi,
"activate",
G_CALLBACK (add_to_dictionary),
spell);
gtk_widget_show_all (mi);
gtk_menu_shell_append (GTK_MENU_SHELL (topmenu), mi);
return topmenu;
}
