void make_toolbar(Viewer *viewer, GtkWidget *parent) { GtkWidget *toolbar = gtk_toolbar_new(); gtk_box_pack_start(GTK_BOX(parent), toolbar, FALSE, FALSE, 0); // add a recording button to the toolbar viewer->record_button = GTK_WIDGET( gtk_toggle_tool_button_new_from_stock (GTK_STOCK_MEDIA_RECORD)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (viewer->record_button), TRUE); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (viewer->record_button), viewer->tips, "Record an AVI of the viewport, saved in the current directory", NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (viewer->record_button), 0); gtk_widget_show (viewer->record_button); g_signal_connect (G_OBJECT (viewer->record_button), "toggled", G_CALLBACK (on_record_toggled), viewer); // screenshot button GtkToolItem *ssbt = gtk_tool_button_new_from_stock (GTK_STOCK_FLOPPY); gtk_tool_button_set_label (GTK_TOOL_BUTTON (ssbt), "Screenshot"); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (ssbt), TRUE); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (ssbt), viewer->tips, "Save a PPM screenshot of the viewport to the current directory", NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), ssbt, 1); gtk_widget_show (GTK_WIDGET (ssbt)); g_signal_connect (G_OBJECT (ssbt), "clicked", G_CALLBACK (on_screenshot_clicked), viewer); // quit button GtkToolItem *quitbt = gtk_tool_button_new_from_stock (GTK_STOCK_QUIT); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (quitbt), viewer->tips, "Quit", NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), quitbt, 2); gtk_widget_show (GTK_WIDGET (quitbt)); g_signal_connect (G_OBJECT (quitbt), "clicked", gtk_main_quit, NULL); GtkToolItem * sep = gtk_separator_tool_item_new (); gtk_widget_show (GTK_WIDGET (sep)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), sep, 3); GtkWidget * hbox = gtk_hbox_new (FALSE, 5); GtkWidget * label = gtk_label_new ("Record FPS"); gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0); viewer->fps_spin = gtk_spin_button_new_with_range (0.1, 120.0, 1.0); gtk_spin_button_set_digits (GTK_SPIN_BUTTON (viewer->fps_spin), 1); gtk_spin_button_set_value (GTK_SPIN_BUTTON (viewer->fps_spin), 30); gtk_box_pack_start (GTK_BOX (hbox), viewer->fps_spin, FALSE, FALSE, 0); GtkToolItem * toolitem = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (toolitem), hbox); gtk_widget_show_all (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, 4); viewer->toolbar = GTK_TOOLBAR (toolbar); }
static void page_holder_app_add_browser_cb (MidoriApp* app, MidoriBrowser* browser, MidoriExtension* extension) { GtkWidget* panel; GtkWidget* notebook; GtkWidget* toolbar; GtkToolItem* toolitem; panel = katze_object_get_object (browser, "panel"); notebook = gtk_notebook_new (); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_RIGHT); gtk_notebook_set_scrollable (GTK_NOTEBOOK (notebook), TRUE); gtk_widget_show (notebook); toolbar = gtk_toolbar_new (); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_BUTTON); gtk_widget_show (toolbar); toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_JUMP_TO); gtk_tool_item_set_is_important (toolitem, TRUE); g_signal_connect (toolitem, "clicked", G_CALLBACK (page_holder_button_jump_to_clicked_cb), notebook); gtk_widget_show (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); toolitem = gtk_separator_tool_item_new (); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (toolitem), FALSE); gtk_tool_item_set_expand (toolitem, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); gtk_widget_show (GTK_WIDGET (toolitem)); toolitem = gtk_tool_button_new_from_stock (GTK_STOCK_ADD); gtk_tool_item_set_is_important (toolitem, TRUE); g_signal_connect (toolitem, "clicked", G_CALLBACK (page_holder_button_add_clicked_cb), notebook); gtk_widget_show (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); midori_panel_append_widget (MIDORI_PANEL (panel), notebook, /* i18n: A panel showing a user specified web page */ STOCK_PAGE_HOLDER, _("Pageholder"), toolbar); g_signal_connect (extension, "deactivate", G_CALLBACK (page_holder_deactivate_cb), notebook); g_object_unref (panel); }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkToolItem_gtk_1tool_1item_1set_1is_1important ( JNIEnv* env, jclass cls, jlong _self, jboolean _isImportant ) { GtkToolItem* self; gboolean isImportant; // convert parameter self self = (GtkToolItem*) _self; // convert parameter isImportant isImportant = (gboolean) _isImportant; // call function gtk_tool_item_set_is_important(self, isImportant); // cleanup parameter self // cleanup parameter isImportant }
static void gtk_tool_item_update (GtkActivatable *activatable, GtkAction *action, const gchar *property_name) { if (strcmp (property_name, "visible") == 0) { if (gtk_action_is_visible (action)) gtk_widget_show (GTK_WIDGET (activatable)); else gtk_widget_hide (GTK_WIDGET (activatable)); } else if (strcmp (property_name, "sensitive") == 0) gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action)); else if (strcmp (property_name, "tooltip") == 0) gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (activatable), gtk_action_get_tooltip (action)); else if (strcmp (property_name, "visible-horizontal") == 0) gtk_tool_item_set_visible_horizontal (GTK_TOOL_ITEM (activatable), gtk_action_get_visible_horizontal (action)); else if (strcmp (property_name, "visible-vertical") == 0) gtk_tool_item_set_visible_vertical (GTK_TOOL_ITEM (activatable), gtk_action_get_visible_vertical (action)); else if (strcmp (property_name, "is-important") == 0) gtk_tool_item_set_is_important (GTK_TOOL_ITEM (activatable), gtk_action_get_is_important (action)); }
static void gtk_tool_item_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkToolItem *toolitem = GTK_TOOL_ITEM (object); switch (prop_id) { case PROP_VISIBLE_HORIZONTAL: gtk_tool_item_set_visible_horizontal (toolitem, g_value_get_boolean (value)); break; case PROP_VISIBLE_VERTICAL: gtk_tool_item_set_visible_vertical (toolitem, g_value_get_boolean (value)); break; case PROP_IS_IMPORTANT: gtk_tool_item_set_is_important (toolitem, g_value_get_boolean (value)); break; case PROP_ACTIVATABLE_RELATED_ACTION: gtk_tool_item_set_related_action (toolitem, g_value_get_object (value)); break; case PROP_ACTIVATABLE_USE_ACTION_APPEARANCE: gtk_tool_item_set_use_action_appearance (toolitem, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
/* * Sets the properties of the widget. This is used for both applying the * properties changed in the property editor, and also for loading. */ static void gb_tool_item_set_properties (GtkWidget * widget, GbWidgetSetArgData * data) { gboolean visible_horz, visible_vert, is_important; visible_horz = gb_widget_input_bool (data, VisibleHorz); if (data->apply) { gtk_object_set_data (GTK_OBJECT (widget), VisibleHorz, visible_horz ? NULL : "FALSE"); } visible_vert = gb_widget_input_bool (data, VisibleVert); if (data->apply) { gtk_object_set_data (GTK_OBJECT (widget), VisibleVert, visible_vert ? NULL : "FALSE"); } is_important = gb_widget_input_bool (data, IsImportant); if (data->apply) { gtk_tool_item_set_is_important (GTK_TOOL_ITEM (widget), is_important); } }
GtkWidget * gtk_utils_append_toolbar_button (GtkToolbar *toolbar, GtkUtilsToolbarEntry *entry, GtkUtilsToolbarButtonFlags flags, gpointer user_data) { #if GTK_2_4_OR_LATER GtkToolItem *button; g_return_val_if_fail (entry, NULL); button = gtk_tool_button_new ((gtk_image_new_from_stock (entry->icon_stock_id, gtk_toolbar_get_icon_size (toolbar))), (entry->label_text ? _(entry->label_text) : NULL)); if (entry->tooltip_text) { gtk_tool_item_set_tooltip (button, toolbar->tooltips, _(entry->tooltip_text), NULL); } gtk_tool_item_set_homogeneous (button, ((flags & GTK_UTILS_HOMOGENEOUS) ? TRUE : FALSE)); gtk_tool_item_set_is_important (button, ((flags & GTK_UTILS_IS_IMPORTANT) ? TRUE : FALSE)); g_signal_connect (button, "clicked", G_CALLBACK (invoke_toolbar_button_callback), user_data); gtk_toolbar_insert (toolbar, button, -1); #else GtkWidget *button; g_return_val_if_fail (entry, NULL); UNUSED (flags); button = (gtk_toolbar_append_item (toolbar, (entry->label_text ? _(entry->label_text) : NULL), _(entry->tooltip_text), NULL, gtk_image_new_from_stock (entry->icon_stock_id, gtk_toolbar_get_icon_size (toolbar)), (GtkSignalFunc) invoke_toolbar_button_callback, user_data)); #endif if (!toolbar_button_entry_quark) { toolbar_button_entry_quark = g_quark_from_static_string ("quarry-toolbar-button-entry"); } g_object_set_qdata (G_OBJECT (button), toolbar_button_entry_quark, entry); /* For GTK+ 2.4 and up. It is certainly a widget. */ return (GtkWidget *) button; }
void edit_metadata__gth_browser_construct_cb (GthBrowser *browser) { BrowserData *data; GError *error = NULL; g_return_if_fail (GTH_IS_BROWSER (browser)); data = g_new0 (BrowserData, 1); data->browser = browser; data->actions = gtk_action_group_new ("Edit Metadata Actions"); gtk_action_group_set_translation_domain (data->actions, NULL); gtk_action_group_add_actions (data->actions, edit_metadata_action_entries, G_N_ELEMENTS (edit_metadata_action_entries), browser); gtk_ui_manager_insert_action_group (gth_browser_get_ui_manager (browser), data->actions, 0); if (! gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), fixed_ui_info, -1, &error)) { g_message ("building menus failed: %s", error->message); g_error_free (error); } gtk_tool_item_set_is_important (GTK_TOOL_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/Fullscreen_ToolBar/Edit_Actions/Edit_Metadata")), TRUE); g_object_set_data_full (G_OBJECT (browser), BROWSER_DATA_KEY, data, (GDestroyNotify) browser_data_free); }
static void cm_create_toolbar(CookieManagerPage *cmp) { CookieManagerPagePrivate *priv = cmp->priv; GtkWidget *toolbar; GtkToolItem *toolitem; priv->toolbar = toolbar = gtk_toolbar_new(); toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE); gtk_tool_item_set_is_important(toolitem, TRUE); g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_button_delete_clicked_cb), cmp); gtk_widget_show(GTK_WIDGET(toolitem)); gtk_widget_set_sensitive(GTK_WIDGET(toolitem), FALSE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); priv->delete_button = GTK_WIDGET(toolitem); toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_DELETE); gtk_tool_button_set_label(GTK_TOOL_BUTTON(toolitem), _("Delete All")); gtk_tool_item_set_tooltip_text(toolitem, _("Deletes all shown cookies. " "If a filter is set, only those cookies are deleted which match the filter.")); gtk_tool_item_set_is_important(toolitem, TRUE); g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_button_delete_all_clicked_cb), cmp); gtk_widget_show(GTK_WIDGET(toolitem)); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); priv->delete_all_button = GTK_WIDGET(toolitem); toolitem = gtk_separator_tool_item_new(); gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(toolitem), FALSE); gtk_tool_item_set_expand(toolitem, TRUE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_widget_show(GTK_WIDGET(toolitem)); toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_ADD); gtk_tool_item_set_tooltip_text(toolitem, _("Expand All")); g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_tree_popup_expand_activate_cb), cmp); gtk_widget_show(GTK_WIDGET(toolitem)); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); priv->expand_buttons[0] = GTK_WIDGET(toolitem); toolitem = gtk_tool_button_new_from_stock(GTK_STOCK_REMOVE); gtk_tool_item_set_tooltip_text(toolitem, _("Collapse All")); g_signal_connect(toolitem, "clicked", G_CALLBACK(cm_tree_popup_collapse_activate_cb), cmp); gtk_widget_show(GTK_WIDGET(toolitem)); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); priv->expand_buttons[1] = GTK_WIDGET(toolitem); }
static void load_stock_items (GtkToolPalette *palette) { GtkWidget *group_af = gtk_tool_item_group_new ("Stock Icons (A-F)"); GtkWidget *group_gn = gtk_tool_item_group_new ("Stock Icons (G-N)"); GtkWidget *group_or = gtk_tool_item_group_new ("Stock Icons (O-R)"); GtkWidget *group_sz = gtk_tool_item_group_new ("Stock Icons (S-Z)"); GtkWidget *group = NULL; GtkToolItem *item; GSList *stock_ids; GSList *iter; stock_ids = gtk_stock_list_ids (); stock_ids = g_slist_sort (stock_ids, (GCompareFunc) strcmp); gtk_container_add (GTK_CONTAINER (palette), group_af); gtk_container_add (GTK_CONTAINER (palette), group_gn); gtk_container_add (GTK_CONTAINER (palette), group_or); gtk_container_add (GTK_CONTAINER (palette), group_sz); for (iter = stock_ids; iter; iter = g_slist_next (iter)) { GtkStockItem stock_item; gchar *id = iter->data; switch (id[4]) { case 'a': group = group_af; break; case 'g': group = group_gn; break; case 'o': group = group_or; break; case 's': group = group_sz; break; } item = gtk_tool_button_new_from_stock (id); gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (item), id); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (item), TRUE); gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1); if (!gtk_stock_lookup (id, &stock_item) || !stock_item.label) gtk_tool_button_set_label (GTK_TOOL_BUTTON (item), id); g_free (id); } g_slist_free (stock_ids); }
void edit_metadata__gth_browser_set_current_page_cb (GthBrowser *browser) { BrowserData *data; GError *error = NULL; data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY); g_return_if_fail (data != NULL); switch (gth_window_get_current_page (GTH_WINDOW (browser))) { case GTH_BROWSER_PAGE_BROWSER: if (data->viewer_ui_merge_id != 0) { gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->viewer_ui_merge_id); data->viewer_ui_merge_id = 0; } if (data->browser_ui_merge_id != 0) return; data->browser_ui_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), browser_ui_info, -1, &error); if (data->browser_ui_merge_id == 0) { g_warning ("ui building failed: %s", error->message); g_clear_error (&error); } gtk_tool_item_set_is_important (GTK_TOOL_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/ToolBar/Edit_Actions/Edit_Metadata")), TRUE); break; case GTH_BROWSER_PAGE_VIEWER: if (data->browser_ui_merge_id != 0) { gtk_ui_manager_remove_ui (gth_browser_get_ui_manager (browser), data->browser_ui_merge_id); data->browser_ui_merge_id = 0; } if (data->viewer_ui_merge_id != 0) return; data->viewer_ui_merge_id = gtk_ui_manager_add_ui_from_string (gth_browser_get_ui_manager (browser), viewer_ui_info, -1, &error); if (data->viewer_ui_merge_id == 0) { g_warning ("ui building failed: %s", error->message); g_clear_error (&error); } gtk_tool_item_set_is_important (GTK_TOOL_ITEM (gtk_ui_manager_get_widget (gth_browser_get_ui_manager (browser), "/ViewerToolBar/Edit_Actions/Edit_Metadata")), TRUE); break; default: break; } }
static void add_button(gpointer compose) { GtkWidget *toolbar; PrefsCommon *prefs; gint n = 0; GtkToolItem *item; GtkWidget *icon; GdkPixbuf *pixbuf; if (!config.enable_autoenc) { debug_print("autoenc: autoenc is disabled\n"); return; } toolbar = syl_plugin_compose_get_toolbar(compose); //n = gtk_toolbar_get_n_items(GTK_TOOLBAR(toolbar)); prefs = prefs_common_get(); if (prefs->compose_toolbar_setting) { gint i; gchar **namev; namev = g_strsplit(prefs->compose_toolbar_setting, ",", -1); for (i = 0; namev[i] != NULL; i++) { if (!strcmp(namev[i], "send")) { debug_print("send pos: %d\n", i); n = i + 1; break; } } g_strfreev(namev); } else { /* send,send-later,draft,... */ n = 1; } //icon = stock_pixbuf_widget_for_toolbar(STOCK_PIXMAP_MAIL_SEND); pixbuf = gdk_pixbuf_new_from_inline(sizeof(send_enc), send_enc, FALSE, NULL); icon = gtk_image_new_from_pixbuf(pixbuf); item = gtk_tool_button_new(icon, _("Send with encryption")); gtk_tool_item_set_is_important(item, TRUE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), item, n); //gtk_widget_show_all(GTK_WIDGET(toolbar)); gtk_widget_show_all(GTK_WIDGET(item)); g_object_set_data(G_OBJECT(toolbar), "send-enc-button", item); g_signal_connect(G_OBJECT(item), "clicked", G_CALLBACK(send_encryption_clicked), compose); change_button_sensitive(compose, GTK_WIDGET(item)); }
GtkWidget *hwidget_get_toggle_toolbar(HviewWidgetsT *w) { GtkWidget *bar; GtkToolItem *but; bar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(bar), GTK_TOOLBAR_BOTH_HORIZ); but = hwidget_get_tool_button("message_log.png", "Messages", NULL, hview_toggled_call, w, HWIDGET_TOGGLE_TOOL_BUTTON); gtk_tool_item_set_is_important(GTK_TOOL_ITEM(but), TRUE); gtk_toolbar_insert(GTK_TOOLBAR(bar), but, -1); but = hwidget_get_tool_button("event_log.png", "Events", NULL, hview_toggled_call, w, HWIDGET_TOGGLE_TOOL_BUTTON); gtk_tool_item_set_is_important(GTK_TOOL_ITEM(but), TRUE); gtk_toolbar_insert(GTK_TOOLBAR(bar), but, -1); return bar; }
static void important_toggled(GtkCellRendererToggle *cell, const gchar *path_str, GtkTreeModel *model) { GtkTreePath *path; GtkTreeIter iter; GtkToolItem *tool_item; path = gtk_tree_path_new_from_string (path_str); gtk_tree_model_get_iter (model, &iter, path); gtk_tree_model_get (model, &iter, 0, &tool_item, -1); gtk_tool_item_set_is_important (tool_item, !gtk_tool_item_get_is_important (tool_item)); g_object_unref (tool_item); gtk_tree_model_row_changed (model, path, &iter); gtk_tree_path_free (path); }
void gu_textwindow_init(GuTextwindow *window) { window->priv = G_TYPE_INSTANCE_GET_PRIVATE(window, GU_TYPE_TEXTWINDOW, GuTextwindowPrivate); GuTextwindowPrivate *priv = window->priv; gtk_window_set_default_size(GTK_WINDOW(window), 400, 300); gtk_window_set_title(GTK_WINDOW(window), "Text File Viewer"); gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER); g_signal_connect(GTK_WIDGET(window), "destroy", G_CALLBACK(gtk_main_quit), NULL); /* Toolbar */ GtkWidget* toolbar = gtk_toolbar_new(); GtkStyleContext* style_context = gtk_widget_get_style_context(toolbar); gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR); GtkToolItem* open_btn = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_tool_item_set_is_important(open_btn, TRUE); g_signal_connect( GTK_WIDGET(open_btn), "clicked", G_CALLBACK(on_open_clicked), (gpointer)window); gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(open_btn)); /* TextView */ priv->text_view = GTK_TEXT_VIEW(gtk_text_view_new()); gtk_text_view_set_editable(priv->text_view, FALSE); gtk_text_view_set_cursor_visible(priv->text_view, FALSE); /* ScrollView */ GtkWidget *scroll = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_container_add(GTK_CONTAINER(scroll), GTK_WIDGET(priv->text_view)); /* Packing */ GtkWidget *box = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); gtk_box_pack_start(GTK_BOX(box), toolbar, FALSE, TRUE, 0); gtk_box_pack_start(GTK_BOX(box), scroll, TRUE, TRUE, 0); gtk_container_add(GTK_CONTAINER(window), box); }
GtkWidget * create_toolbar (void) { GtkWidget *toolbar; GtkToolItem *item; toolbar = gtk_toolbar_new (); gtk_widget_set_valign (toolbar, GTK_ALIGN_CENTER); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-next"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "go-previous"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (NULL, "Hello World"); gtk_tool_item_set_is_important (item, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); return toolbar; }
static void gtk_tool_item_sync_action_properties (GtkActivatable *activatable, GtkAction *action) { if (!action) return; if (gtk_action_is_visible (action)) gtk_widget_show (GTK_WIDGET (activatable)); else gtk_widget_hide (GTK_WIDGET (activatable)); gtk_widget_set_sensitive (GTK_WIDGET (activatable), gtk_action_is_sensitive (action)); gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (activatable), gtk_action_get_tooltip (action)); gtk_tool_item_set_visible_horizontal (GTK_TOOL_ITEM (activatable), gtk_action_get_visible_horizontal (action)); gtk_tool_item_set_visible_vertical (GTK_TOOL_ITEM (activatable), gtk_action_get_visible_vertical (action)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (activatable), gtk_action_get_is_important (action)); }
static void gtk_tool_item_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) { GtkToolItem *toolitem = GTK_TOOL_ITEM (object); switch (prop_id) { case PROP_VISIBLE_HORIZONTAL: gtk_tool_item_set_visible_horizontal (toolitem, g_value_get_boolean (value)); break; case PROP_VISIBLE_VERTICAL: gtk_tool_item_set_visible_vertical (toolitem, g_value_get_boolean (value)); break; case PROP_IS_IMPORTANT: gtk_tool_item_set_is_important (toolitem, g_value_get_boolean (value)); break; default: G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec); break; } }
static gint tm_set_tool_item_label(GtkToolItem * tool_item, const gchar * stock_id, gboolean make_two_line) { gint button = get_toolbar_button_index(stock_id); const gchar *text; gchar *label; if (button < 0) return button; text = balsa_toolbar_button_text(button); if (balsa_app.toolbar_wrap_button_text) { /* Make sure all buttons have the same number of lines of * text (1 or 2), to keep icons aligned */ label = make_two_line && !strchr(text, '\n') ? g_strconcat(text, "\n", NULL) : g_strdup(text); } else { gchar *p = label = g_strdup(text); while ((p = strchr(p, '\n'))) *p++ = ' '; } gtk_tool_button_set_label(GTK_TOOL_BUTTON(tool_item), label); g_free(label); gtk_tool_item_set_is_important(tool_item, toolbar_buttons[button].is_important); if (strcmp(toolbar_buttons[button].pixmap_id, BALSA_PIXMAP_SEND) == 0 && balsa_app.always_queue_sent_mail) gtk_tool_item_set_tooltip_text(tool_item, _("Queue this message for sending")); return button; }
static void egg_find_bar_init (EggFindBar *find_bar) { EggFindBarPrivate *priv; GtkWidget *label; GtkWidget *alignment; GtkWidget *box; GtkToolItem *item; GtkWidget *arrow; /* Data */ priv = EGG_FIND_BAR_GET_PRIVATE (find_bar); find_bar->priv = priv; priv->search_string = NULL; gtk_toolbar_set_style (GTK_TOOLBAR (find_bar), GTK_TOOLBAR_BOTH_HORIZ); /* Find: |_____| */ item = gtk_tool_item_new (); box = gtk_hbox_new (FALSE, 12); alignment = gtk_alignment_new (0.0, 0.5, 1.0, 0.0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 2, 2); label = gtk_label_new_with_mnemonic (_("Find:")); priv->find_entry = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (priv->find_entry), 32); gtk_entry_set_max_length (GTK_ENTRY (priv->find_entry), 512); gtk_label_set_mnemonic_widget (GTK_LABEL (label), priv->find_entry); /* Prev */ arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE); priv->previous_button = gtk_tool_button_new (arrow, Q_("Find Previous")); gtk_tool_item_set_is_important (priv->previous_button, TRUE); gtk_tool_item_set_tooltip (priv->previous_button, GTK_TOOLBAR (find_bar)->tooltips, _("Find previous occurrence of the search string"), NULL); /* Next */ arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE); priv->next_button = gtk_tool_button_new (arrow, Q_("Find Next")); gtk_tool_item_set_is_important (priv->next_button, TRUE); gtk_tool_item_set_tooltip (priv->next_button, GTK_TOOLBAR (find_bar)->tooltips, _("Find next occurrence of the search string"), NULL); /* Separator*/ priv->status_separator = gtk_separator_tool_item_new(); /* Case button */ priv->case_button = gtk_toggle_tool_button_new (); g_object_set (G_OBJECT (priv->case_button), "label", _("C_ase Sensitive"), NULL); gtk_tool_button_set_use_underline (GTK_TOOL_BUTTON (priv->case_button), TRUE); gtk_tool_item_set_is_important (priv->case_button, TRUE); gtk_tool_item_set_tooltip (priv->case_button, GTK_TOOLBAR (find_bar)->tooltips, _("Toggle case sensitive search"), NULL); /* Status */ priv->status_item = gtk_tool_item_new(); gtk_tool_item_set_expand (priv->status_item, TRUE); priv->status_label = gtk_label_new (NULL); gtk_label_set_ellipsize (GTK_LABEL (priv->status_label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC (priv->status_label), 0.0, 0.5); g_signal_connect (priv->find_entry, "changed", G_CALLBACK (entry_changed_callback), find_bar); g_signal_connect (priv->find_entry, "activate", G_CALLBACK (entry_activate_callback), find_bar); g_signal_connect (priv->next_button, "clicked", G_CALLBACK (next_clicked_callback), find_bar); g_signal_connect (priv->previous_button, "clicked", G_CALLBACK (previous_clicked_callback), find_bar); g_signal_connect (priv->case_button, "toggled", G_CALLBACK (case_sensitive_toggled_callback), find_bar); gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (box), priv->find_entry, TRUE, TRUE, 0); gtk_container_add (GTK_CONTAINER (alignment), box); gtk_container_add (GTK_CONTAINER (item), alignment); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), item, -1); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->previous_button, -1); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->next_button, -1); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->case_button, -1); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_separator, -1); gtk_container_add (GTK_CONTAINER (priv->status_item), priv->status_label); gtk_toolbar_insert (GTK_TOOLBAR (find_bar), priv->status_item, -1); /* don't show status separator/label until they are set */ gtk_widget_show_all (GTK_WIDGET (item)); gtk_widget_show_all (GTK_WIDGET (priv->next_button)); gtk_widget_show_all (GTK_WIDGET (priv->previous_button)); gtk_widget_show (priv->status_label); }
GtkWidget * empathy_main_window_show (void) { EmpathyMainWindow *window; EmpathyContactList *list_iface; EmpathyContactMonitor *monitor; GtkBuilder *gui; EmpathyConf *conf; GtkWidget *sw; GtkToggleAction *show_offline_widget; GtkWidget *ebox; GtkAction *show_map_widget; GtkToolItem *item; gboolean show_offline; gchar *filename; GSList *l; if (main_window) { empathy_window_present (GTK_WINDOW (main_window->window)); return main_window->window; } main_window = g_new0 (EmpathyMainWindow, 1); window = main_window; /* Set up interface */ filename = empathy_file_lookup ("empathy-main-window.ui", "src"); gui = empathy_builder_get_file (filename, "main_window", &window->window, "main_vbox", &window->main_vbox, "errors_vbox", &window->errors_vbox, "ui_manager", &window->ui_manager, "view_show_offline", &show_offline_widget, "view_show_protocols", &window->show_protocols, "view_sort_by_name", &window->sort_by_name, "view_sort_by_status", &window->sort_by_status, "view_normal_size_with_avatars", &window->normal_with_avatars, "view_normal_size", &window->normal_size, "view_compact_size", &window->compact_size, "view_history", &window->view_history, "view_show_map", &show_map_widget, "room_join_favorites", &window->room_join_favorites, "presence_toolbar", &window->presence_toolbar, "roster_scrolledwindow", &sw, NULL); g_free (filename); empathy_builder_connect (gui, window, "main_window", "destroy", main_window_destroy_cb, "main_window", "key-press-event", main_window_key_press_event_cb, "chat_quit", "activate", main_window_chat_quit_cb, "chat_new_message", "activate", main_window_chat_new_message_cb, "chat_new_call", "activate", main_window_chat_new_call_cb, "view_history", "activate", main_window_view_history_cb, "room_join_new", "activate", main_window_room_join_new_cb, "room_join_favorites", "activate", main_window_room_join_favorites_cb, "room_manage_favorites", "activate", main_window_room_manage_favorites_cb, "chat_add_contact", "activate", main_window_chat_add_contact_cb, "view_show_ft_manager", "activate", main_window_view_show_ft_manager, "view_show_offline", "toggled", main_window_view_show_offline_cb, "view_show_protocols", "toggled", main_window_view_show_protocols_cb, "view_sort_by_name", "changed", main_window_view_sort_contacts_cb, "view_normal_size_with_avatars", "changed", main_window_view_contacts_list_size_cb, "view_show_map", "activate", main_window_view_show_map_cb, "edit", "activate", main_window_edit_cb, "edit_accounts", "activate", main_window_edit_accounts_cb, "edit_personal_information", "activate", main_window_edit_personal_information_cb, "edit_preferences", "activate", main_window_edit_preferences_cb, "help_about", "activate", main_window_help_about_cb, "help_debug", "activate", main_window_help_debug_cb, "help_contents", "activate", main_window_help_contents_cb, NULL); /* Set up connection related widgets. */ main_window_connection_items_setup (window, gui); g_object_ref (window->ui_manager); g_object_unref (gui); #if !HAVE_LIBCHAMPLAIN gtk_action_set_visible (show_map_widget, FALSE); #endif window->account_manager = tp_account_manager_dup (); tp_account_manager_prepare_async (window->account_manager, NULL, account_manager_prepared_cb, window); window->errors = g_hash_table_new_full (g_direct_hash, g_direct_equal, g_object_unref, NULL); window->status_changed_handlers = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, NULL); /* Set up menu */ main_window_favorite_chatroom_menu_setup (window); window->edit_context = gtk_ui_manager_get_widget (window->ui_manager, "/menubar/edit/edit_context"); window->edit_context_separator = gtk_ui_manager_get_widget (window->ui_manager, "/menubar/edit/edit_context_separator"); gtk_widget_hide (window->edit_context); gtk_widget_hide (window->edit_context_separator); /* Set up contact list. */ empathy_status_presets_get_all (); /* Set up presence chooser */ window->presence_chooser = empathy_presence_chooser_new (); gtk_widget_show (window->presence_chooser); item = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_container_add (GTK_CONTAINER (item), window->presence_chooser); gtk_tool_item_set_is_important (item, TRUE); gtk_tool_item_set_expand (item, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (window->presence_toolbar), item, -1); /* Set up the throbber */ ebox = gtk_event_box_new (); gtk_event_box_set_visible_window (GTK_EVENT_BOX (ebox), FALSE); gtk_widget_set_tooltip_text (ebox, _("Show and edit accounts")); g_signal_connect (ebox, "button-press-event", G_CALLBACK (main_window_throbber_button_press_event_cb), window); gtk_widget_show (ebox); window->throbber = ephy_spinner_new (); ephy_spinner_set_size (EPHY_SPINNER (window->throbber), GTK_ICON_SIZE_LARGE_TOOLBAR); gtk_container_add (GTK_CONTAINER (ebox), window->throbber); gtk_widget_show (window->throbber); item = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (item), ebox); gtk_toolbar_insert (GTK_TOOLBAR (window->presence_toolbar), item, -1); gtk_widget_show (GTK_WIDGET (item)); list_iface = EMPATHY_CONTACT_LIST (empathy_contact_manager_dup_singleton ()); monitor = empathy_contact_list_get_monitor (list_iface); window->list_store = empathy_contact_list_store_new (list_iface); window->list_view = empathy_contact_list_view_new (window->list_store, EMPATHY_CONTACT_LIST_FEATURE_ALL, EMPATHY_CONTACT_FEATURE_ALL); g_signal_connect (monitor, "contact-presence-changed", G_CALLBACK (main_window_contact_presence_changed_cb), window); window->butterfly_log_migration_contact_added_id = g_signal_connect (monitor, "contact-added", G_CALLBACK (main_window_contact_added_cb), window); g_object_unref (list_iface); gtk_widget_show (GTK_WIDGET (window->list_view)); gtk_container_add (GTK_CONTAINER (sw), GTK_WIDGET (window->list_view)); g_signal_connect (window->list_view, "row-activated", G_CALLBACK (main_window_row_activated_cb), window); /* Load user-defined accelerators. */ main_window_accels_load (); /* Set window size. */ empathy_geometry_bind (GTK_WINDOW (window->window), GEOMETRY_NAME); /* Enable event handling */ window->event_manager = empathy_event_manager_dup_singleton (); g_signal_connect (window->event_manager, "event-added", G_CALLBACK (main_window_event_added_cb), window); g_signal_connect (window->event_manager, "event-removed", G_CALLBACK (main_window_event_removed_cb), window); g_signal_connect (window->account_manager, "account-validity-changed", G_CALLBACK (main_window_account_validity_changed_cb), window); g_signal_connect (window->account_manager, "account-removed", G_CALLBACK (main_window_account_removed_cb), window); g_signal_connect (window->account_manager, "account-disabled", G_CALLBACK (main_window_account_disabled_cb), window); l = empathy_event_manager_get_events (window->event_manager); while (l) { main_window_event_added_cb (window->event_manager, l->data, window); l = l->next; } conf = empathy_conf_get (); /* Show offline ? */ empathy_conf_get_bool (conf, EMPATHY_PREFS_CONTACTS_SHOW_OFFLINE, &show_offline); empathy_conf_notify_add (conf, EMPATHY_PREFS_CONTACTS_SHOW_OFFLINE, main_window_notify_show_offline_cb, show_offline_widget); gtk_toggle_action_set_active (show_offline_widget, show_offline); /* Show protocol ? */ empathy_conf_notify_add (conf, EMPATHY_PREFS_UI_SHOW_PROTOCOLS, (EmpathyConfNotifyFunc) main_window_notify_show_protocols_cb, window); main_window_notify_show_protocols_cb (conf, EMPATHY_PREFS_UI_SHOW_PROTOCOLS, window); /* Sort by name / by status ? */ empathy_conf_notify_add (conf, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM, (EmpathyConfNotifyFunc) main_window_notify_sort_contact_cb, window); main_window_notify_sort_contact_cb (conf, EMPATHY_PREFS_CONTACTS_SORT_CRITERIUM, window); /* Contacts list size */ empathy_conf_notify_add (conf, EMPATHY_PREFS_UI_COMPACT_CONTACT_LIST, (EmpathyConfNotifyFunc) main_window_notify_contact_list_size_cb, window); empathy_conf_notify_add (conf, EMPATHY_PREFS_UI_SHOW_AVATARS, (EmpathyConfNotifyFunc) main_window_notify_contact_list_size_cb, window); main_window_notify_contact_list_size_cb (conf, EMPATHY_PREFS_UI_SHOW_AVATARS, window); return window->window; }
static void ephy_find_toolbar_init (EphyFindToolbar *toolbar) { EphyFindToolbarPrivate *priv; GtkToolbar *gtoolbar; GtkToolItem *item; GtkWidget *alignment, *arrow, *box; GtkWidget *checkbox; priv = toolbar->priv = EPHY_FIND_TOOLBAR_GET_PRIVATE (toolbar); gtoolbar = GTK_TOOLBAR (toolbar); gtk_toolbar_set_style (gtoolbar, GTK_TOOLBAR_BOTH_HORIZ); /* Find: |_____| */ alignment = gtk_alignment_new (0.0, 0.5, 1.0, 0.0); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment), 0, 0, 2, 2); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12); gtk_container_add (GTK_CONTAINER (alignment), box); priv->label = gtk_label_new (NULL); gtk_box_pack_start (GTK_BOX (box), priv->label, FALSE, FALSE, 0); priv->entry = gtk_entry_new (); gtk_entry_set_width_chars (GTK_ENTRY (priv->entry), 32); gtk_entry_set_max_length (GTK_ENTRY (priv->entry), 512); gtk_box_pack_start (GTK_BOX (box), priv->entry, TRUE, TRUE, 0); item = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (item), alignment); /* gtk_tool_item_set_expand (item, TRUE); */ gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_widget_show_all (GTK_WIDGET (item)); /* Prev */ arrow = gtk_arrow_new (GTK_ARROW_LEFT, GTK_SHADOW_NONE); priv->prev = gtk_tool_button_new (arrow, _("Find Previous")); gtk_tool_item_set_is_important (priv->prev, TRUE); gtk_tool_item_set_tooltip_text (priv->prev, _("Find previous occurrence of the search string")); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->prev, -1); gtk_widget_show_all (GTK_WIDGET (priv->prev)); /* Next */ arrow = gtk_arrow_new (GTK_ARROW_RIGHT, GTK_SHADOW_NONE); priv->next = gtk_tool_button_new (arrow, _("Find Next")); gtk_tool_item_set_is_important (priv->next, TRUE); gtk_tool_item_set_tooltip_text (priv->next, _("Find next occurrence of the search string")); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->next, -1); gtk_widget_show_all (GTK_WIDGET (priv->next)); /* Case sensitivity */ checkbox = gtk_check_button_new_with_mnemonic (_("_Case sensitive")); priv->case_sensitive = checkbox; item = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (item), checkbox); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_widget_show_all (GTK_WIDGET (item)); /* Populate the overflow menu */ g_signal_connect (item, "create-menu-proxy", G_CALLBACK (toolitem_create_menu_proxy_cb), toolbar); priv->sep = gtk_separator_tool_item_new (); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->sep, -1); priv->status_item = gtk_tool_item_new (); gtk_tool_item_set_expand (priv->status_item, TRUE); priv->status_label = gtk_label_new (""); gtk_misc_set_alignment (GTK_MISC (priv->status_label), 0.0, 0.5); gtk_label_set_ellipsize (GTK_LABEL (priv->status_label), PANGO_ELLIPSIZE_END); gtk_container_add (GTK_CONTAINER (priv->status_item), priv->status_label); gtk_widget_show (priv->status_label); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->status_item, -1); /* connect signals */ g_signal_connect (priv->entry, "key-press-event", G_CALLBACK (entry_key_press_event_cb), toolbar); g_signal_connect_after (priv->entry, "changed", G_CALLBACK (entry_changed_cb), toolbar); g_signal_connect (priv->entry, "activate", G_CALLBACK (entry_activate_cb), toolbar); g_signal_connect_swapped (priv->next, "clicked", G_CALLBACK (find_next_cb), toolbar); g_signal_connect_swapped (priv->prev, "clicked", G_CALLBACK (find_prev_cb), toolbar); g_signal_connect (priv->case_sensitive, "toggled", G_CALLBACK (case_sensitive_toggled_cb), toolbar); }
void e_mail_shell_view_update_send_receive_menus (EMailShellView *mail_shell_view) { EMailShellViewPrivate *priv; EShellWindow *shell_window; EShellView *shell_view; GtkWidget *widget; const gchar *widget_path; g_return_if_fail (E_IS_MAIL_SHELL_VIEW (mail_shell_view)); priv = E_MAIL_SHELL_VIEW_GET_PRIVATE (mail_shell_view); shell_view = E_SHELL_VIEW (mail_shell_view); shell_window = e_shell_view_get_shell_window (shell_view); if (!e_shell_view_is_active (shell_view)) { if (priv->send_receive_tool_item) { GtkWidget *toolbar; toolbar = e_shell_window_get_managed_widget ( shell_window, "/main-toolbar"); g_return_if_fail (toolbar != NULL); gtk_container_remove ( GTK_CONTAINER (toolbar), GTK_WIDGET (priv->send_receive_tool_item)); gtk_container_remove ( GTK_CONTAINER (toolbar), GTK_WIDGET (priv->send_receive_tool_separator)); priv->send_receive_tool_item = NULL; priv->send_receive_tool_separator = NULL; } return; } widget_path = "/main-menu/file-menu" "/mail-send-receiver/mail-send-receive-submenu"; widget = e_shell_window_get_managed_widget (shell_window, widget_path); if (widget != NULL) gtk_menu_item_set_submenu ( GTK_MENU_ITEM (widget), create_send_receive_submenu (mail_shell_view)); if (!priv->send_receive_tool_item) { GtkWidget *toolbar; GtkToolItem *tool_item; gint index; toolbar = e_shell_window_get_managed_widget ( shell_window, "/main-toolbar"); g_return_if_fail (toolbar != NULL); widget_path = "/main-toolbar/toolbar-actions/mail-send-receiver"; widget = e_shell_window_get_managed_widget ( shell_window, widget_path); g_return_if_fail (widget != NULL); index = gtk_toolbar_get_item_index ( GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (widget)); tool_item = gtk_separator_tool_item_new (); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), tool_item, index); gtk_widget_show (GTK_WIDGET (tool_item)); priv->send_receive_tool_separator = tool_item; tool_item = GTK_TOOL_ITEM ( e_menu_tool_button_new (_("Send / Receive"))); gtk_tool_item_set_is_important (tool_item, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), tool_item, index); gtk_widget_show (GTK_WIDGET (tool_item)); priv->send_receive_tool_item = tool_item; e_binding_bind_property ( ACTION (MAIL_SEND_RECEIVE), "sensitive", tool_item, "sensitive", G_BINDING_SYNC_CREATE); } if (priv->send_receive_tool_item) gtk_menu_tool_button_set_menu ( GTK_MENU_TOOL_BUTTON (priv->send_receive_tool_item), create_send_receive_submenu (mail_shell_view)); }
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase) { wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase); GSList* radioGroup; GtkWidget* bin_child; switch ( tool->GetStyle() ) { case wxTOOL_STYLE_BUTTON: switch (tool->GetKind()) { case wxITEM_CHECK: tool->m_item = gtk_toggle_tool_button_new(); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; case wxITEM_RADIO: radioGroup = GetRadioGroup(pos); if (!radioGroup) { // this is the first button in the radio button group, // it will be toggled automatically by GTK so bring the // internal flag in sync tool->Toggle(true); } tool->m_item = gtk_radio_tool_button_new(radioGroup); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; default: wxFAIL_MSG("unknown toolbar child type"); // fall through case wxITEM_DROPDOWN: case wxITEM_NORMAL: tool->m_item = gtk_tool_button_new(NULL, ""); g_signal_connect(tool->m_item, "clicked", G_CALLBACK(item_clicked), tool); break; } if (!HasFlag(wxTB_NOICONS)) { GtkWidget* image = gtk_image_new(); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(tool->m_item), image); tool->SetImage(); gtk_widget_show(image); #ifdef __WXGTK3__ g_signal_connect(image, "draw", G_CALLBACK(image_draw), tool); #else g_signal_connect(image, "expose_event", G_CALLBACK(image_expose_event), tool); #endif } if (!tool->GetLabel().empty()) { gtk_tool_button_set_label( GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel())); // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT gtk_tool_item_set_is_important(tool->m_item, true); } if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty()) { #if GTK_CHECK_VERSION(2, 12, 0) if (GTK_CHECK_VERSION(3,0,0) || gtk_check_version(2,12,0) == NULL) { gtk_tool_item_set_tooltip_text(tool->m_item, wxGTK_CONV(tool->GetShortHelp())); } else #endif { #ifndef __WXGTK3__ gtk_tool_item_set_tooltip(tool->m_item, m_tooltips, wxGTK_CONV(tool->GetShortHelp()), ""); #endif } } bin_child = gtk_bin_get_child(GTK_BIN(tool->m_item)); g_signal_connect(bin_child, "button_press_event", G_CALLBACK(button_press_event), tool); g_signal_connect(bin_child, "enter_notify_event", G_CALLBACK(enter_notify_event), tool); g_signal_connect(bin_child, "leave_notify_event", G_CALLBACK(enter_notify_event), tool); if (tool->GetKind() == wxITEM_DROPDOWN) tool->CreateDropDown(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_SEPARATOR: tool->m_item = gtk_separator_tool_item_new(); if ( tool->IsStretchable() ) { gtk_separator_tool_item_set_draw ( GTK_SEPARATOR_TOOL_ITEM(tool->m_item), FALSE ); gtk_tool_item_set_expand(tool->m_item, TRUE); } gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_CONTROL: wxWindow* control = tool->GetControl(); if (gtk_widget_get_parent(control->m_widget) == NULL) AddChildGTK(control); tool->m_item = GTK_TOOL_ITEM(gtk_widget_get_parent(gtk_widget_get_parent(control->m_widget))); if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos)) { g_object_ref(tool->m_item); gtk_container_remove( GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item)); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); g_object_unref(tool->m_item); } break; } gtk_widget_show(GTK_WIDGET(tool->m_item)); InvalidateBestSize(); return true; }
static void remmina_main_init(RemminaMain *remminamain) { RemminaMainPriv *priv; GtkWidget *vbox; GtkWidget *menubar; GtkWidget *hbox; GtkWidget *quickconnect; GtkWidget *tool_item; GtkUIManager *uimanager; GtkActionGroup *action_group; GtkWidget *scrolledwindow; GtkWidget *tree; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GError *error; priv = g_new0(RemminaMainPriv, 1); remminamain->priv = priv; remminamain->priv->expanded_group = remmina_string_array_new_from_string(remmina_pref.expanded_group); /* Create main window */ g_signal_connect(G_OBJECT(remminamain), "delete-event", G_CALLBACK(remmina_main_on_delete_event), NULL); g_signal_connect(G_OBJECT(remminamain), "destroy", G_CALLBACK(remmina_main_destroy), NULL); g_signal_connect(G_OBJECT(remminamain), "window-state-event", G_CALLBACK(remmina_main_on_window_state_event), NULL); gtk_container_set_border_width(GTK_CONTAINER(remminamain), 0); gtk_window_set_title(GTK_WINDOW(remminamain), _("Remmina Remote Desktop Client")); gtk_window_set_default_size(GTK_WINDOW(remminamain), remmina_pref.main_width, remmina_pref.main_height); gtk_window_set_position(GTK_WINDOW(remminamain), GTK_WIN_POS_CENTER); if (remmina_pref.main_maximize) { gtk_window_maximize(GTK_WINDOW(remminamain)); } /* Create the main container */ #if GTK_VERSION == 3 vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0); #elif GTK_VERSION == 2 vbox = gtk_vbox_new(FALSE, 0); #endif gtk_container_add(GTK_CONTAINER(remminamain), vbox); gtk_widget_show(vbox); /* Create the menubar and toolbar */ uimanager = gtk_ui_manager_new(); priv->uimanager = uimanager; action_group = gtk_action_group_new("RemminaMainActions"); gtk_action_group_set_translation_domain(action_group, NULL); gtk_action_group_add_actions(action_group, remmina_main_ui_menu_entries, G_N_ELEMENTS(remmina_main_ui_menu_entries), remminamain); gtk_action_group_add_toggle_actions(action_group, remmina_main_ui_toggle_menu_entries, G_N_ELEMENTS(remmina_main_ui_toggle_menu_entries), remminamain); gtk_action_group_add_radio_actions(action_group, remmina_main_ui_view_file_mode_entries, G_N_ELEMENTS(remmina_main_ui_view_file_mode_entries), remmina_pref.view_file_mode, G_CALLBACK(remmina_main_action_view_file_mode), remminamain); gtk_ui_manager_insert_action_group(uimanager, action_group, 0); g_object_unref(action_group); priv->main_group = action_group; action_group = gtk_action_group_new("RemminaMainFileSensitiveActions"); gtk_action_group_set_translation_domain(action_group, NULL); gtk_action_group_add_actions(action_group, remmina_main_ui_file_sensitive_menu_entries, G_N_ELEMENTS(remmina_main_ui_file_sensitive_menu_entries), remminamain); gtk_ui_manager_insert_action_group(uimanager, action_group, 0); g_object_unref(action_group); priv->file_sensitive_group = action_group; error = NULL; gtk_ui_manager_add_ui_from_string(uimanager, remmina_main_ui_xml, -1, &error); if (error) { g_message("building menus failed: %s", error->message); g_error_free(error); } remmina_plugin_manager_for_each_plugin(REMMINA_PLUGIN_TYPE_TOOL, remmina_main_add_tool_plugin, remminamain); menubar = gtk_ui_manager_get_widget(uimanager, "/MenuBar"); gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0); priv->toolbar = gtk_ui_manager_get_widget(uimanager, "/ToolBar"); #if GTK_VERSION == 3 gtk_style_context_add_class(gtk_widget_get_style_context(priv->toolbar), GTK_STYLE_CLASS_PRIMARY_TOOLBAR); #endif gtk_box_pack_start(GTK_BOX(vbox), priv->toolbar, FALSE, FALSE, 0); tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionConnect"); gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE); tool_item = gtk_ui_manager_get_widget(uimanager, "/ToolBar/ConnectionNew"); gtk_tool_item_set_is_important (GTK_TOOL_ITEM(tool_item), TRUE); remmina_main_create_quick_search(remminamain); gtk_window_add_accel_group(GTK_WINDOW(remminamain), gtk_ui_manager_get_accel_group(uimanager)); gtk_action_group_set_sensitive(priv->file_sensitive_group, FALSE); /* Add a Fast Connection box */ #if GTK_VERSION == 3 hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0); #elif GTK_VERSION == 2 hbox = gtk_hbox_new(FALSE, 0); #endif priv->quickconnect_protocol = gtk_combo_box_text_new(); #if GTK_VERSION == 3 gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP", "RDP"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC", "VNC"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX", "NX"); gtk_combo_box_text_append(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH", "SSH"); #elif GTK_VERSION == 2 gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "RDP"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "VNC"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "NX"); gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(priv->quickconnect_protocol), "SSH"); #endif gtk_combo_box_set_active(GTK_COMBO_BOX(priv->quickconnect_protocol), 0); gtk_widget_show(priv->quickconnect_protocol); gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_protocol, FALSE, FALSE, 0); priv->quickconnect_server = gtk_entry_new(); gtk_entry_set_width_chars(GTK_ENTRY(priv->quickconnect_server), 25); gtk_widget_show(priv->quickconnect_server); gtk_box_pack_start(GTK_BOX(hbox), priv->quickconnect_server, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(priv->quickconnect_server), "key-press-event", G_CALLBACK(remmina_main_quickconnect_on_key_press), remminamain); quickconnect = gtk_button_new_with_label("Connect !"); gtk_widget_show(quickconnect); gtk_box_pack_start(GTK_BOX(hbox), quickconnect, FALSE, FALSE, 0); g_signal_connect(G_OBJECT(quickconnect), "clicked", G_CALLBACK(remmina_main_quickconnect_on_click), remminamain); gtk_container_add(GTK_CONTAINER(vbox), hbox); gtk_widget_show(hbox); /* Create the scrolled window for the file list */ scrolledwindow = gtk_scrolled_window_new(NULL, NULL); gtk_widget_show(scrolledwindow); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolledwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_box_pack_start(GTK_BOX(vbox), scrolledwindow, TRUE, TRUE, 0); /* Create the remmina file list */ tree = gtk_tree_view_new(); column = gtk_tree_view_column_new(); gtk_tree_view_column_set_title(column, _("Name")); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, NAME_COLUMN); renderer = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "icon-name", PROTOCOL_COLUMN); g_object_set(G_OBJECT(renderer), "stock-size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL); renderer = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(column, renderer, FALSE); gtk_tree_view_column_add_attribute(column, renderer, "text", NAME_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Group"), renderer, "text", GROUP_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, GROUP_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); priv->group_column = column; renderer = gtk_cell_renderer_text_new(); column = gtk_tree_view_column_new_with_attributes(_("Server"), renderer, "text", SERVER_COLUMN, NULL); gtk_tree_view_column_set_resizable(column, TRUE); gtk_tree_view_column_set_sort_column_id(column, SERVER_COLUMN); gtk_tree_view_append_column(GTK_TREE_VIEW(tree), column); gtk_container_add(GTK_CONTAINER(scrolledwindow), tree); gtk_widget_show(tree); gtk_tree_selection_set_select_function(gtk_tree_view_get_selection(GTK_TREE_VIEW(tree)), remmina_main_selection_func, remminamain, NULL); g_signal_connect(G_OBJECT(tree), "button-press-event", G_CALLBACK(remmina_main_file_list_on_button_press), remminamain); g_signal_connect(G_OBJECT(tree), "key-press-event", G_CALLBACK(remmina_main_file_list_on_key_press), remminamain); priv->file_list = tree; /* Create statusbar */ priv->statusbar = gtk_statusbar_new(); gtk_box_pack_start(GTK_BOX(vbox), priv->statusbar, FALSE, FALSE, 0); gtk_widget_show(priv->statusbar); /* Prepare the data */ remmina_main_load_files(remminamain, FALSE); /* Load the preferences */ if (remmina_pref.hide_toolbar) { gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewToolbar")), FALSE); } if (remmina_pref.hide_statusbar) { gtk_toggle_action_set_active(GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewStatusbar")), FALSE); } if (remmina_pref.show_quick_search) { gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewQuickSearch")), TRUE); } if (remmina_pref.small_toolbutton) { gtk_toggle_action_set_active( GTK_TOGGLE_ACTION(gtk_action_group_get_action(priv->main_group, "ViewSmallToolbutton")), TRUE); } /* Drag-n-drop support */ gtk_drag_dest_set(GTK_WIDGET(remminamain), GTK_DEST_DEFAULT_ALL, remmina_drop_types, 1, GDK_ACTION_COPY); g_signal_connect(G_OBJECT(remminamain), "drag-data-received", G_CALLBACK(remmina_main_on_drag_data_received), NULL); priv->initialized = TRUE; remmina_widget_pool_register(GTK_WIDGET(remminamain)); }
GtkWidget* create_dialog1 (void) { GtkWidget *dialog1; GtkWidget *dialog_vbox1; GtkWidget *vbox3b; GtkWidget *toolbar1; GtkIconSize tmp_toolbar_icon_size; GtkWidget *toolbuttonOpen; GtkWidget *toolbuttonSave; GtkWidget *tmp_image; GtkWidget *toolbuttonScript; GtkWidget *toolbuttonDVD; GtkWidget *toolbuttonHalfD1; GtkWidget *toolbuttonSVCD; GtkWidget *toolbuttonVCD; GtkWidget *hbox11; GtkWidget *frame1; GtkWidget *alignment1; GtkWidget *vbox2; GtkWidget *notebook1; GtkWidget *scrolledwindow1; GtkWidget *treeview1; GtkWidget *hbox5; GtkWidget *image1; GtkWidget *label11; GtkWidget *scrolledwindow2; GtkWidget *treeview2; GtkWidget *hbox6; GtkWidget *image2; GtkWidget *label17; GtkWidget *scrolledwindow3; GtkWidget *treeview3; GtkWidget *hbox7; GtkWidget *image3; GtkWidget *label18; GtkWidget *scrolledwindow4; GtkWidget *treeview4; GtkWidget *hbox8; GtkWidget *image4; GtkWidget *label19; GtkWidget *scrolledwindow5; GtkWidget *treeview5; GtkWidget *hbox9; GtkWidget *image5; GtkWidget *label20; GtkWidget *scrolledwindow6; GtkWidget *treeview6; GtkWidget *hbox10; GtkWidget *image6; GtkWidget *label21; GtkWidget *scrolledwindow7; GtkWidget *treeview7; GtkWidget *hbox4; GtkWidget *image7; GtkWidget *label22; GtkWidget *treeview8; GtkWidget *label28; GtkWidget *hbox13; GtkWidget *buttonAdd; GtkWidget *image11; GtkWidget *label23; GtkWidget *frame2; GtkWidget *alignment2; GtkWidget *hbox1; GtkWidget *vbox3; GtkWidget *scrolledwindow9; GtkWidget *treeview0; GtkWidget *hbox14; GtkWidget *buttonRemove; GtkWidget *image15; GtkWidget *buttonDown; GtkWidget *image14; GtkWidget *buttonUp; GtkWidget *image13; GtkWidget *buttonPartial; GtkWidget *buttonProperties; GtkWidget *alignment4; GtkWidget *hbox16; GtkWidget *label25; GtkWidget *label2; GtkWidget *dialog_action_area1; GtkWidget *buttonPreview; GtkWidget *alignment5; GtkWidget *hbox17; GtkWidget *image17; GtkWidget *label26; GtkWidget *buttonClose; GtkAccelGroup *accel_group; GtkTooltips *tooltips; tooltips = gtk_tooltips_new (); accel_group = gtk_accel_group_new (); dialog1 = gtk_dialog_new (); gtk_container_set_border_width (GTK_CONTAINER (dialog1), 6); gtk_window_set_title (GTK_WINDOW (dialog1), QT_TR_NOOP("Video Filter Manager")); gtk_window_set_type_hint (GTK_WINDOW (dialog1), GDK_WINDOW_TYPE_HINT_DIALOG); gtk_dialog_set_has_separator (GTK_DIALOG (dialog1), FALSE); dialog_vbox1 = GTK_DIALOG (dialog1)->vbox; gtk_box_set_spacing (GTK_BOX(dialog_vbox1), 12); gtk_widget_show (dialog_vbox1); vbox3b = gtk_vbox_new (FALSE, 12); gtk_widget_show (vbox3b); gtk_box_pack_start (GTK_BOX (dialog_vbox1), vbox3b, TRUE, TRUE, 0); gtk_container_set_border_width (GTK_CONTAINER (vbox3b), 6); toolbar1 = gtk_toolbar_new (); gtk_widget_show (toolbar1); gtk_box_pack_start (GTK_BOX (vbox3b), toolbar1, FALSE, FALSE, 0); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar1), GTK_TOOLBAR_BOTH); tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar1)); toolbuttonOpen = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-open"); gtk_widget_show (toolbuttonOpen); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonOpen); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonOpen), tooltips, QT_TR_NOOP("Open filter list [Ctrl-O]"), NULL); gtk_widget_add_accelerator (toolbuttonOpen, "clicked", accel_group, GDK_O, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonOpen), TRUE); toolbuttonSave = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-save"); gtk_widget_show (toolbuttonSave); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonSave); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonSave), tooltips, QT_TR_NOOP("Save filter list [Ctrl-S]"), NULL); gtk_widget_add_accelerator (toolbuttonSave, "clicked", accel_group, GDK_S, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonSave), TRUE); tmp_image = gtk_image_new_from_stock ("gtk-save-as", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonScript = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Save Script")); gtk_widget_show (toolbuttonScript); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonScript); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonScript), tooltips, QT_TR_NOOP("Save as script [Ctrl-J]"), NULL); gtk_widget_add_accelerator (toolbuttonScript, "clicked", accel_group, GDK_J, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonScript), TRUE); tmp_image = gtk_image_new_from_stock ("gtk-cdrom", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonDVD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("DVD Res")); gtk_widget_show (toolbuttonDVD); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonDVD); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonDVD), tooltips, QT_TR_NOOP("DVD resolution [Ctrl-1]"), NULL); gtk_widget_add_accelerator (toolbuttonDVD, "clicked", accel_group, GDK_1, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonDVD), TRUE); tmp_image = gtk_image_new_from_stock ("gtk-cdrom", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonHalfD1 = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("Half D1 Res")); gtk_widget_show (toolbuttonHalfD1); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonHalfD1); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonHalfD1), tooltips, QT_TR_NOOP("Half D1 resolution [Ctrl-2]"), NULL); gtk_widget_add_accelerator (toolbuttonHalfD1, "clicked", accel_group, GDK_2, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonHalfD1), TRUE); tmp_image = gtk_image_new_from_stock ("gtk-cdrom", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonSVCD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("SVCD Res")); gtk_widget_show (toolbuttonSVCD); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonSVCD); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonSVCD), tooltips, QT_TR_NOOP("SVCD resolution [Ctrl-3]"), NULL); gtk_widget_add_accelerator (toolbuttonSVCD, "clicked", accel_group, GDK_3, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonSVCD), TRUE); tmp_image = gtk_image_new_from_stock ("gtk-cdrom", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); toolbuttonVCD = (GtkWidget*) gtk_tool_button_new (tmp_image, QT_TR_NOOP("VCD Res")); gtk_widget_show (toolbuttonVCD); gtk_container_add (GTK_CONTAINER (toolbar1), toolbuttonVCD); gtk_tool_item_set_tooltip (GTK_TOOL_ITEM (toolbuttonVCD), tooltips, QT_TR_NOOP("VCD resolution [Ctrl-4]"), NULL); gtk_widget_add_accelerator (toolbuttonVCD, "clicked", accel_group, GDK_4, (GdkModifierType) GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (toolbuttonVCD), TRUE); hbox11 = gtk_hbox_new (FALSE, 12); gtk_widget_show (hbox11); gtk_box_pack_start (GTK_BOX (vbox3b), hbox11, TRUE, TRUE, 0); frame1 = gtk_frame_new (NULL); gtk_widget_show (frame1); gtk_box_pack_start (GTK_BOX (hbox11), frame1, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_NONE); alignment1 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment1); gtk_container_add (GTK_CONTAINER (frame1), alignment1); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment1), 6, 0, 18, 0); vbox2 = gtk_vbox_new (FALSE, 6); gtk_widget_show (vbox2); gtk_container_add (GTK_CONTAINER (alignment1), vbox2); notebook1 = gtk_notebook_new (); gtk_widget_show (notebook1); gtk_box_pack_start (GTK_BOX (vbox2), notebook1, TRUE, TRUE, 0); gtk_notebook_set_show_border (GTK_NOTEBOOK (notebook1), FALSE); gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook1), GTK_POS_LEFT); scrolledwindow1 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow1); gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow1); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow1), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); treeview1 = gtk_tree_view_new (); gtk_widget_show (treeview1); gtk_container_add (GTK_CONTAINER (scrolledwindow1), treeview1); gtk_widget_set_size_request (treeview1, 288, 336); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview1), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview1), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview1), FALSE); hbox5 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox5); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), hbox5); image1 = create_pixmap (dialog1, "1.png"); gtk_widget_show (image1); gtk_box_pack_start (GTK_BOX (hbox5), image1, FALSE, FALSE, 0); label11 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Transform")); gtk_widget_show (label11); gtk_box_pack_start (GTK_BOX (hbox5), label11, FALSE, FALSE, 4); gtk_label_set_use_markup (GTK_LABEL (label11), TRUE); scrolledwindow2 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow2); gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow2); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow2), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); treeview2 = gtk_tree_view_new (); gtk_widget_show (treeview2); gtk_container_add (GTK_CONTAINER (scrolledwindow2), treeview2); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview2), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview2), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview2), FALSE); hbox6 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox6); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), hbox6); image2 = create_pixmap (dialog1, "2.png"); gtk_widget_show (image2); gtk_box_pack_start (GTK_BOX (hbox6), image2, FALSE, FALSE, 0); label17 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Interlacing")); gtk_widget_show (label17); gtk_box_pack_start (GTK_BOX (hbox6), label17, FALSE, FALSE, 4); scrolledwindow3 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow3); gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow3); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow3), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); treeview3 = gtk_tree_view_new (); gtk_widget_show (treeview3); gtk_container_add (GTK_CONTAINER (scrolledwindow3), treeview3); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview3), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview3), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview3), FALSE); hbox7 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox7); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 2), hbox7); image3 = create_pixmap (dialog1, "4.png"); gtk_widget_show (image3); gtk_box_pack_start (GTK_BOX (hbox7), image3, FALSE, FALSE, 0); label18 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Colors")); gtk_widget_show (label18); gtk_box_pack_start (GTK_BOX (hbox7), label18, FALSE, FALSE, 4); scrolledwindow4 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow4); gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow4); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow4), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); treeview4 = gtk_tree_view_new (); gtk_widget_show (treeview4); gtk_container_add (GTK_CONTAINER (scrolledwindow4), treeview4); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview4), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview4), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview4), FALSE); hbox8 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox8); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 3), hbox8); image4 = create_pixmap (dialog1, "5.png"); gtk_widget_show (image4); gtk_box_pack_start (GTK_BOX (hbox8), image4, FALSE, FALSE, 0); label19 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Noise")); gtk_widget_show (label19); gtk_box_pack_start (GTK_BOX (hbox8), label19, FALSE, FALSE, 4); scrolledwindow5 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow5); gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow5); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow5), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); treeview5 = gtk_tree_view_new (); gtk_widget_show (treeview5); gtk_container_add (GTK_CONTAINER (scrolledwindow5), treeview5); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview5), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview5), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview5), FALSE); hbox9 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox9); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 4), hbox9); image5 = create_pixmap (dialog1, "3.png"); gtk_widget_show (image5); gtk_box_pack_start (GTK_BOX (hbox9), image5, FALSE, FALSE, 0); label20 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Sharpness")); gtk_widget_show (label20); gtk_box_pack_start (GTK_BOX (hbox9), label20, FALSE, FALSE, 4); scrolledwindow6 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow6); gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow6); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow6), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); treeview6 = gtk_tree_view_new (); gtk_widget_show (treeview6); gtk_container_add (GTK_CONTAINER (scrolledwindow6), treeview6); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview6), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview6), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview6), FALSE); hbox10 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox10); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 5), hbox10); image6 = create_pixmap (dialog1, "7.png"); gtk_widget_show (image6); gtk_box_pack_start (GTK_BOX (hbox10), image6, FALSE, FALSE, 0); label21 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Subtitles")); gtk_widget_show (label21); gtk_box_pack_start (GTK_BOX (hbox10), label21, FALSE, FALSE, 4); scrolledwindow7 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow7); gtk_container_add (GTK_CONTAINER (notebook1), scrolledwindow7); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow7), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); treeview7 = gtk_tree_view_new (); gtk_widget_show (treeview7); gtk_container_add (GTK_CONTAINER (scrolledwindow7), treeview7); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview7), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview7), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview7), FALSE); hbox4 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox4); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 6), hbox4); image7 = create_pixmap (dialog1, "6.png"); gtk_widget_show (image7); gtk_box_pack_start (GTK_BOX (hbox4), image7, FALSE, FALSE, 0); label22 = gtk_label_new_with_mnemonic (QT_TR_NOOP("Misc")); gtk_widget_show (label22); gtk_box_pack_start (GTK_BOX (hbox4), label22, FALSE, FALSE, 4); treeview8 = gtk_tree_view_new (); gtk_widget_show (treeview8); gtk_container_add (GTK_CONTAINER (notebook1), treeview8); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview8), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview8), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview8), FALSE); label28 = gtk_label_new (QT_TR_NOOP("External")); gtk_widget_show (label28); gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 7), label28); hbox13 = gtk_hbox_new (FALSE, 6); gtk_widget_show (hbox13); gtk_box_pack_start (GTK_BOX (vbox2), hbox13, FALSE, FALSE, 0); buttonAdd = gtk_button_new (); gtk_widget_show (buttonAdd); gtk_box_pack_end (GTK_BOX (hbox13), buttonAdd, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, buttonAdd, QT_TR_NOOP("Add selected filter to the Active Filters list"), NULL); image11 = gtk_image_new_from_stock ("gtk-add", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image11); gtk_container_add (GTK_CONTAINER (buttonAdd), image11); label23 = gtk_label_new (QT_TR_NOOP("<b>Available Filters</b>")); gtk_widget_show (label23); gtk_frame_set_label_widget (GTK_FRAME (frame1), label23); gtk_label_set_use_markup (GTK_LABEL (label23), TRUE); gtk_misc_set_alignment (GTK_MISC (label23), 1, 1); frame2 = gtk_frame_new (NULL); gtk_widget_show (frame2); gtk_box_pack_start (GTK_BOX (hbox11), frame2, TRUE, TRUE, 0); gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_NONE); alignment2 = gtk_alignment_new (0.5, 0.5, 1, 1); gtk_widget_show (alignment2); gtk_container_add (GTK_CONTAINER (frame2), alignment2); gtk_alignment_set_padding (GTK_ALIGNMENT (alignment2), 6, 0, 18, 0); hbox1 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox1); gtk_container_add (GTK_CONTAINER (alignment2), hbox1); vbox3 = gtk_vbox_new (FALSE, 6); gtk_widget_show (vbox3); gtk_box_pack_start (GTK_BOX (hbox1), vbox3, TRUE, TRUE, 0); scrolledwindow9 = gtk_scrolled_window_new (NULL, NULL); gtk_widget_show (scrolledwindow9); gtk_box_pack_start (GTK_BOX (vbox3), scrolledwindow9, TRUE, TRUE, 0); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow9), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (scrolledwindow9), GTK_SHADOW_OUT); treeview0 = gtk_tree_view_new (); gtk_widget_show (treeview0); gtk_container_add (GTK_CONTAINER (scrolledwindow9), treeview0); gtk_widget_set_size_request (treeview0, 288, 336); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview0), FALSE); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (treeview0), TRUE); gtk_tree_view_set_enable_search (GTK_TREE_VIEW (treeview0), FALSE); hbox14 = gtk_hbox_new (FALSE, 6); gtk_widget_show (hbox14); gtk_box_pack_start (GTK_BOX (vbox3), hbox14, FALSE, FALSE, 0); buttonRemove = gtk_button_new (); gtk_widget_show (buttonRemove); gtk_box_pack_end (GTK_BOX (hbox14), buttonRemove, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, buttonRemove, QT_TR_NOOP("Remove filter"), NULL); image15 = gtk_image_new_from_stock ("gtk-remove", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image15); gtk_container_add (GTK_CONTAINER (buttonRemove), image15); buttonDown = gtk_button_new (); gtk_widget_show (buttonDown); gtk_box_pack_end (GTK_BOX (hbox14), buttonDown, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, buttonDown, QT_TR_NOOP("Move filter down"), NULL); image14 = gtk_image_new_from_icon_name ("gtk-go-down", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image14); gtk_container_add (GTK_CONTAINER (buttonDown), image14); buttonUp = gtk_button_new (); gtk_widget_show (buttonUp); gtk_box_pack_end (GTK_BOX (hbox14), buttonUp, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, buttonUp, QT_TR_NOOP("Move filter up"), NULL); image13 = gtk_image_new_from_icon_name ("gtk-go-up", GTK_ICON_SIZE_BUTTON); gtk_widget_show (image13); gtk_container_add (GTK_CONTAINER (buttonUp), image13); buttonPartial = gtk_button_new_with_mnemonic (QT_TR_NOOP("P_artial")); gtk_widget_show (buttonPartial); gtk_box_pack_end (GTK_BOX (hbox14), buttonPartial, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, buttonPartial, QT_TR_NOOP("Apply the current filter only to a part of the file"), NULL); buttonProperties = gtk_button_new (); gtk_widget_show (buttonProperties); gtk_box_pack_end (GTK_BOX (hbox14), buttonProperties, FALSE, FALSE, 0); gtk_tooltips_set_tip (tooltips, buttonProperties, QT_TR_NOOP("Configure filter"), NULL); alignment4 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment4); gtk_container_add (GTK_CONTAINER (buttonProperties), alignment4); hbox16 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox16); gtk_container_add (GTK_CONTAINER (alignment4), hbox16); label25 = gtk_label_new_with_mnemonic (QT_TR_NOOP("C_onfigure")); gtk_widget_show (label25); gtk_box_pack_start (GTK_BOX (hbox16), label25, FALSE, FALSE, 0); label2 = gtk_label_new (QT_TR_NOOP("<b >Active Filters</b>")); gtk_widget_show (label2); gtk_frame_set_label_widget (GTK_FRAME (frame2), label2); gtk_label_set_use_markup (GTK_LABEL (label2), TRUE); gtk_misc_set_alignment (GTK_MISC (label2), 1, 1); dialog_action_area1 = GTK_DIALOG (dialog1)->action_area; gtk_widget_show (dialog_action_area1); gtk_button_box_set_layout (GTK_BUTTON_BOX (dialog_action_area1), GTK_BUTTONBOX_END); buttonPreview = gtk_button_new (); gtk_widget_show (buttonPreview); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), buttonPreview, GTK_RESPONSE_APPLY); GTK_WIDGET_SET_FLAGS (buttonPreview, GTK_CAN_DEFAULT); alignment5 = gtk_alignment_new (0.5, 0.5, 0, 0); gtk_widget_show (alignment5); gtk_container_add (GTK_CONTAINER (buttonPreview), alignment5); hbox17 = gtk_hbox_new (FALSE, 2); gtk_widget_show (hbox17); gtk_container_add (GTK_CONTAINER (alignment5), hbox17); image17 = create_pixmap (dialog1, "preview-button.png"); gtk_widget_show (image17); gtk_box_pack_start (GTK_BOX (hbox17), image17, FALSE, FALSE, 0); label26 = gtk_label_new_with_mnemonic (QT_TR_NOOP("_Preview")); gtk_widget_show (label26); gtk_box_pack_start (GTK_BOX (hbox17), label26, FALSE, FALSE, 0); buttonClose = gtk_button_new_from_stock ("gtk-close"); gtk_widget_show (buttonClose); gtk_dialog_add_action_widget (GTK_DIALOG (dialog1), buttonClose, GTK_RESPONSE_CLOSE); GTK_WIDGET_SET_FLAGS (buttonClose, GTK_CAN_DEFAULT); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog1, "dialog1"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_vbox1, "dialog_vbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox3b, "vbox3b"); GLADE_HOOKUP_OBJECT (dialog1, toolbar1, "toolbar1"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonOpen, "toolbuttonOpen"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonSave, "toolbuttonSave"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonScript, "toolbuttonScript"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonDVD, "toolbuttonDVD"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonHalfD1, "toolbuttonHalfD1"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonSVCD, "toolbuttonSVCD"); GLADE_HOOKUP_OBJECT (dialog1, toolbuttonVCD, "toolbuttonVCD"); GLADE_HOOKUP_OBJECT (dialog1, hbox11, "hbox11"); GLADE_HOOKUP_OBJECT (dialog1, frame1, "frame1"); GLADE_HOOKUP_OBJECT (dialog1, alignment1, "alignment1"); GLADE_HOOKUP_OBJECT (dialog1, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (dialog1, notebook1, "notebook1"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow1, "scrolledwindow1"); GLADE_HOOKUP_OBJECT (dialog1, treeview1, "treeview1"); GLADE_HOOKUP_OBJECT (dialog1, hbox5, "hbox5"); GLADE_HOOKUP_OBJECT (dialog1, image1, "image1"); GLADE_HOOKUP_OBJECT (dialog1, label11, "label11"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow2, "scrolledwindow2"); GLADE_HOOKUP_OBJECT (dialog1, treeview2, "treeview2"); GLADE_HOOKUP_OBJECT (dialog1, hbox6, "hbox6"); GLADE_HOOKUP_OBJECT (dialog1, image2, "image2"); GLADE_HOOKUP_OBJECT (dialog1, label17, "label17"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow3, "scrolledwindow3"); GLADE_HOOKUP_OBJECT (dialog1, treeview3, "treeview3"); GLADE_HOOKUP_OBJECT (dialog1, hbox7, "hbox7"); GLADE_HOOKUP_OBJECT (dialog1, image3, "image3"); GLADE_HOOKUP_OBJECT (dialog1, label18, "label18"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow4, "scrolledwindow4"); GLADE_HOOKUP_OBJECT (dialog1, treeview4, "treeview4"); GLADE_HOOKUP_OBJECT (dialog1, hbox8, "hbox8"); GLADE_HOOKUP_OBJECT (dialog1, image4, "image4"); GLADE_HOOKUP_OBJECT (dialog1, label19, "label19"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow5, "scrolledwindow5"); GLADE_HOOKUP_OBJECT (dialog1, treeview5, "treeview5"); GLADE_HOOKUP_OBJECT (dialog1, hbox9, "hbox9"); GLADE_HOOKUP_OBJECT (dialog1, image5, "image5"); GLADE_HOOKUP_OBJECT (dialog1, label20, "label20"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow6, "scrolledwindow6"); GLADE_HOOKUP_OBJECT (dialog1, treeview6, "treeview6"); GLADE_HOOKUP_OBJECT (dialog1, hbox10, "hbox10"); GLADE_HOOKUP_OBJECT (dialog1, image6, "image6"); GLADE_HOOKUP_OBJECT (dialog1, label21, "label21"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow7, "scrolledwindow7"); GLADE_HOOKUP_OBJECT (dialog1, treeview7, "treeview7"); GLADE_HOOKUP_OBJECT (dialog1, hbox4, "hbox4"); GLADE_HOOKUP_OBJECT (dialog1, image7, "image7"); GLADE_HOOKUP_OBJECT (dialog1, label22, "label22"); GLADE_HOOKUP_OBJECT (dialog1, treeview8, "treeview8"); GLADE_HOOKUP_OBJECT (dialog1, label28, "label28"); GLADE_HOOKUP_OBJECT (dialog1, hbox13, "hbox13"); GLADE_HOOKUP_OBJECT (dialog1, buttonAdd, "buttonAdd"); GLADE_HOOKUP_OBJECT (dialog1, image11, "image11"); GLADE_HOOKUP_OBJECT (dialog1, label23, "label23"); GLADE_HOOKUP_OBJECT (dialog1, frame2, "frame2"); GLADE_HOOKUP_OBJECT (dialog1, alignment2, "alignment2"); GLADE_HOOKUP_OBJECT (dialog1, hbox1, "hbox1"); GLADE_HOOKUP_OBJECT (dialog1, vbox3, "vbox3"); GLADE_HOOKUP_OBJECT (dialog1, scrolledwindow9, "scrolledwindow9"); GLADE_HOOKUP_OBJECT (dialog1, treeview0, "treeview0"); GLADE_HOOKUP_OBJECT (dialog1, hbox14, "hbox14"); GLADE_HOOKUP_OBJECT (dialog1, buttonRemove, "buttonRemove"); GLADE_HOOKUP_OBJECT (dialog1, image15, "image15"); GLADE_HOOKUP_OBJECT (dialog1, buttonDown, "buttonDown"); GLADE_HOOKUP_OBJECT (dialog1, image14, "image14"); GLADE_HOOKUP_OBJECT (dialog1, buttonUp, "buttonUp"); GLADE_HOOKUP_OBJECT (dialog1, image13, "image13"); GLADE_HOOKUP_OBJECT (dialog1, buttonPartial, "buttonPartial"); GLADE_HOOKUP_OBJECT (dialog1, buttonProperties, "buttonProperties"); GLADE_HOOKUP_OBJECT (dialog1, alignment4, "alignment4"); GLADE_HOOKUP_OBJECT (dialog1, hbox16, "hbox16"); GLADE_HOOKUP_OBJECT (dialog1, label25, "label25"); GLADE_HOOKUP_OBJECT (dialog1, label2, "label2"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, dialog_action_area1, "dialog_action_area1"); GLADE_HOOKUP_OBJECT (dialog1, buttonPreview, "buttonPreview"); GLADE_HOOKUP_OBJECT (dialog1, alignment5, "alignment5"); GLADE_HOOKUP_OBJECT (dialog1, hbox17, "hbox17"); GLADE_HOOKUP_OBJECT (dialog1, image17, "image17"); GLADE_HOOKUP_OBJECT (dialog1, label26, "label26"); GLADE_HOOKUP_OBJECT (dialog1, buttonClose, "buttonClose"); GLADE_HOOKUP_OBJECT_NO_REF (dialog1, tooltips, "tooltips"); gtk_window_add_accel_group (GTK_WINDOW (dialog1), accel_group); return dialog1; }
GtkWidget* create_YappiWindow (void) { GtkWidget *YappiWindow; GtkWidget *vbox2; GtkWidget *hbox4; GtkWidget *vbox4; GtkWidget *hbox5; GtkWidget *CommandLabel1; GtkWidget *InputBox; GtkWidget *OkButton; GtkWidget *handlebox1; GtkWidget *toolbar4; GtkIconSize tmp_toolbar_icon_size; GtkWidget *PlayBt; GtkWidget *StopBt; GtkWidget *scrollBt; GtkWidget *tmp_image; GtkWidget *MaximazeBt; GtkWidget *textview1; GtkWidget *statusbar1; YappiWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (YappiWindow), _("Yappi !")); vbox2 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox2); gtk_container_add (GTK_CONTAINER (YappiWindow), vbox2); hbox4 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox4); gtk_box_pack_start (GTK_BOX (vbox2), hbox4, FALSE, FALSE, 0); vbox4 = gtk_vbox_new (FALSE, 0); gtk_widget_show (vbox4); gtk_box_pack_start (GTK_BOX (hbox4), vbox4, FALSE, FALSE, 0); hbox5 = gtk_hbox_new (FALSE, 0); gtk_widget_show (hbox5); gtk_box_pack_start (GTK_BOX (vbox4), hbox5, TRUE, FALSE, 0); CommandLabel1 = gtk_label_new (_(" CODE: ")); gtk_widget_show (CommandLabel1); gtk_box_pack_start (GTK_BOX (hbox5), CommandLabel1, TRUE, TRUE, 0); InputBox = gtk_entry_new (); gtk_widget_show (InputBox); gtk_box_pack_start (GTK_BOX (hbox5), InputBox, TRUE, TRUE, 0); gtk_widget_set_size_request (InputBox, 115, -1); gtk_entry_set_text (GTK_ENTRY (InputBox), _("PRUEBA")); gtk_entry_set_activates_default (GTK_ENTRY (InputBox), TRUE); OkButton = gtk_image_new_from_stock ("gtk-ok", GTK_ICON_SIZE_BUTTON); gtk_widget_show (OkButton); gtk_box_pack_start (GTK_BOX (hbox5), OkButton, TRUE, TRUE, 0); handlebox1 = gtk_handle_box_new (); gtk_widget_show (handlebox1); gtk_box_pack_start (GTK_BOX (hbox4), handlebox1, TRUE, TRUE, 0); toolbar4 = gtk_toolbar_new (); gtk_widget_show (toolbar4); gtk_container_add (GTK_CONTAINER (handlebox1), toolbar4); gtk_widget_set_size_request (toolbar4, 209, 0); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar4), GTK_TOOLBAR_ICONS); tmp_toolbar_icon_size = gtk_toolbar_get_icon_size (GTK_TOOLBAR (toolbar4)); PlayBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-media-play"); gtk_widget_show (PlayBt); gtk_container_add (GTK_CONTAINER (toolbar4), PlayBt); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (PlayBt), TRUE); StopBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-media-pause"); gtk_widget_show (StopBt); gtk_container_add (GTK_CONTAINER (toolbar4), StopBt); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (StopBt), TRUE); scrollBt = (GtkWidget*) gtk_tool_button_new_from_stock ("gtk-go-down"); gtk_widget_show (scrollBt); gtk_container_add (GTK_CONTAINER (toolbar4), scrollBt); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (scrollBt), TRUE); tmp_image = gtk_image_new_from_stock ("gtk-zoom-in", tmp_toolbar_icon_size); gtk_widget_show (tmp_image); MaximazeBt = (GtkWidget*) gtk_tool_button_new (tmp_image, ""); gtk_widget_show (MaximazeBt); gtk_container_add (GTK_CONTAINER (toolbar4), MaximazeBt); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (MaximazeBt), TRUE); textview1 = gtk_text_view_new (); gtk_widget_show (textview1); gtk_box_pack_start (GTK_BOX (vbox2), textview1, TRUE, TRUE, 1); gtk_widget_set_size_request (textview1, 136, 87); gtk_container_set_border_width (GTK_CONTAINER (textview1), 5); statusbar1 = gtk_statusbar_new (); gtk_widget_show (statusbar1); gtk_box_pack_start (GTK_BOX (vbox2), statusbar1, FALSE, FALSE, 0); g_signal_connect ((gpointer) InputBox, "activate", G_CALLBACK (on_InputBox_activate), NULL); g_signal_connect ((gpointer) InputBox, "grab_focus", G_CALLBACK (InputBox_grab_focus), NULL); g_signal_connect ((gpointer) OkButton, "button_press_event", G_CALLBACK (on_OkButton_button_press_event), NULL); /* Store pointers to all widgets, for use by lookup_widget(). */ GLADE_HOOKUP_OBJECT_NO_REF (YappiWindow, YappiWindow, "YappiWindow"); GLADE_HOOKUP_OBJECT (YappiWindow, vbox2, "vbox2"); GLADE_HOOKUP_OBJECT (YappiWindow, hbox4, "hbox4"); GLADE_HOOKUP_OBJECT (YappiWindow, vbox4, "vbox4"); GLADE_HOOKUP_OBJECT (YappiWindow, hbox5, "hbox5"); GLADE_HOOKUP_OBJECT (YappiWindow, CommandLabel1, "CommandLabel1"); GLADE_HOOKUP_OBJECT (YappiWindow, InputBox, "InputBox"); GLADE_HOOKUP_OBJECT (YappiWindow, OkButton, "OkButton"); GLADE_HOOKUP_OBJECT (YappiWindow, handlebox1, "handlebox1"); GLADE_HOOKUP_OBJECT (YappiWindow, toolbar4, "toolbar4"); GLADE_HOOKUP_OBJECT (YappiWindow, PlayBt, "PlayBt"); GLADE_HOOKUP_OBJECT (YappiWindow, StopBt, "StopBt"); GLADE_HOOKUP_OBJECT (YappiWindow, scrollBt, "scrollBt"); GLADE_HOOKUP_OBJECT (YappiWindow, MaximazeBt, "MaximazeBt"); GLADE_HOOKUP_OBJECT (YappiWindow, textview1, "textview1"); GLADE_HOOKUP_OBJECT (YappiWindow, statusbar1, "statusbar1"); return YappiWindow; }
void e_composer_private_constructed (EMsgComposer *composer) { EMsgComposerPrivate *priv = composer->priv; EFocusTracker *focus_tracker; EComposerHeader *header; EShell *shell; EClientCache *client_cache; EHTMLEditor *editor; EHTMLEditorView *view; GtkUIManager *ui_manager; GtkAction *action; GtkWidget *container; GtkWidget *widget; GtkWidget *send_widget; GtkWindow *window; GSettings *settings; const gchar *path; gchar *filename, *gallery_path; gint ii; GError *error = NULL; editor = e_msg_composer_get_editor (composer); ui_manager = e_html_editor_get_ui_manager (editor); view = e_html_editor_get_view (editor); settings = e_util_ref_settings ("org.gnome.evolution.mail"); shell = e_msg_composer_get_shell (composer); client_cache = e_shell_get_client_cache (shell); /* Each composer window gets its own window group. */ window = GTK_WINDOW (composer); priv->window_group = gtk_window_group_new (); gtk_window_group_add_window (priv->window_group, window); priv->async_actions = gtk_action_group_new ("async"); priv->charset_actions = gtk_action_group_new ("charset"); priv->composer_actions = gtk_action_group_new ("composer"); priv->extra_hdr_names = g_ptr_array_new (); priv->extra_hdr_values = g_ptr_array_new (); priv->charset = e_composer_get_default_charset (); priv->is_from_new_message = FALSE; priv->set_signature_from_message = FALSE; priv->disable_signature = FALSE; priv->busy = FALSE; priv->saved_editable = FALSE; priv->drop_occured = FALSE; priv->dnd_is_uri = FALSE; priv->check_if_signature_is_changed = FALSE; priv->ignore_next_signature_change = FALSE; priv->dnd_history_saved = FALSE; priv->focused_entry = NULL; e_composer_actions_init (composer); filename = e_composer_find_data_file ("evolution-composer.ui"); gtk_ui_manager_add_ui_from_file (ui_manager, filename, &error); g_free (filename); /* We set the send button as important to have a label */ path = "/main-toolbar/pre-main-toolbar/send"; send_widget = gtk_ui_manager_get_widget (ui_manager, path); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (send_widget), TRUE); composer_setup_charset_menu (composer); if (error != NULL) { /* Henceforth, bad things start happening. */ g_critical ("%s", error->message); g_clear_error (&error); } /* Configure an EFocusTracker to manage selection actions. */ focus_tracker = e_focus_tracker_new (GTK_WINDOW (composer)); action = e_html_editor_get_action (editor, "cut"); e_focus_tracker_set_cut_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "copy"); e_focus_tracker_set_copy_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "paste"); e_focus_tracker_set_paste_clipboard_action (focus_tracker, action); action = e_html_editor_get_action (editor, "select-all"); e_focus_tracker_set_select_all_action (focus_tracker, action); action = e_html_editor_get_action (editor, "undo"); e_focus_tracker_set_undo_action (focus_tracker, action); action = e_html_editor_get_action (editor, "redo"); e_focus_tracker_set_redo_action (focus_tracker, action); priv->focus_tracker = focus_tracker; widget = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add (GTK_CONTAINER (composer), widget); gtk_widget_show (widget); container = widget; /* Construct the main menu and toolbar. */ widget = e_html_editor_get_managed_widget (editor, "/main-menu"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); widget = e_html_editor_get_managed_widget (editor, "/main-toolbar"); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); /* Construct the header table. */ widget = e_composer_header_table_new (client_cache); gtk_container_set_border_width (GTK_CONTAINER (widget), 6); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); priv->header_table = g_object_ref (widget); gtk_widget_show (widget); header = e_composer_header_table_get_header ( E_COMPOSER_HEADER_TABLE (widget), E_COMPOSER_HEADER_SUBJECT); e_binding_bind_property ( view, "spell-checker", header->input_widget, "spell-checker", G_BINDING_SYNC_CREATE); /* Construct the editing toolbars. We'll have to reparent * the embedded EHTMLEditorView a little further down. */ widget = GTK_WIDGET (editor); gtk_box_pack_start (GTK_BOX (container), widget, FALSE, FALSE, 0); gtk_widget_show (widget); /* Construct the attachment paned. */ widget = e_attachment_paned_new (); gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0); priv->attachment_paned = g_object_ref_sink (widget); gtk_widget_show (widget); e_binding_bind_property ( view, "editable", widget, "sensitive", G_BINDING_SYNC_CREATE); container = e_attachment_paned_get_content_area ( E_ATTACHMENT_PANED (priv->attachment_paned)); widget = gtk_paned_new (GTK_ORIENTATION_VERTICAL); gtk_box_pack_start (GTK_BOX (container), widget, TRUE, TRUE, 0); gtk_widget_show (widget); container = widget; widget = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy ( GTK_SCROLLED_WINDOW (widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (widget, -1, GALLERY_INITIAL_HEIGHT); gtk_paned_pack1 (GTK_PANED (container), widget, FALSE, FALSE); priv->gallery_scrolled_window = g_object_ref (widget); gtk_widget_show (widget); /* Reparent the scrolled window containing the web view * widget into the content area of the top attachment pane. */ widget = GTK_WIDGET (view); widget = gtk_widget_get_parent (widget); gtk_widget_reparent (widget, container); /* Construct the picture gallery. */ container = priv->gallery_scrolled_window; /* FIXME This should be an EMsgComposer property. */ gallery_path = g_settings_get_string ( settings, "composer-gallery-path"); widget = e_picture_gallery_new (gallery_path); gtk_container_add (GTK_CONTAINER (container), widget); priv->gallery_icon_view = g_object_ref_sink (widget); g_free (gallery_path); e_signal_connect_notify_swapped ( view, "notify::mode", G_CALLBACK (composer_update_gallery_visibility), composer); g_signal_connect_swapped ( ACTION (PICTURE_GALLERY), "toggled", G_CALLBACK (composer_update_gallery_visibility), composer); /* Initial sync */ composer_update_gallery_visibility (composer); /* Bind headers to their corresponding actions. */ for (ii = 0; ii < E_COMPOSER_NUM_HEADERS; ii++) { EComposerHeaderTable *table; EComposerHeader *header; GtkAction *action; table = E_COMPOSER_HEADER_TABLE (priv->header_table); header = e_composer_header_table_get_header (table, ii); switch (ii) { case E_COMPOSER_HEADER_FROM: e_widget_undo_attach ( GTK_WIDGET (e_composer_from_header_get_name_entry (E_COMPOSER_FROM_HEADER (header))), focus_tracker); e_widget_undo_attach ( GTK_WIDGET (e_composer_from_header_get_address_entry (E_COMPOSER_FROM_HEADER (header))), focus_tracker); action = ACTION (VIEW_FROM_OVERRIDE); e_binding_bind_property ( header, "override-visible", action, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); continue; case E_COMPOSER_HEADER_BCC: action = ACTION (VIEW_BCC); break; case E_COMPOSER_HEADER_CC: action = ACTION (VIEW_CC); break; case E_COMPOSER_HEADER_REPLY_TO: action = ACTION (VIEW_REPLY_TO); e_widget_undo_attach ( GTK_WIDGET (header->input_widget), focus_tracker); break; case E_COMPOSER_HEADER_SUBJECT: e_widget_undo_attach ( GTK_WIDGET (header->input_widget), focus_tracker); continue; default: continue; } e_binding_bind_property ( header, "sensitive", action, "sensitive", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); e_binding_bind_property ( header, "visible", action, "active", G_BINDING_BIDIRECTIONAL | G_BINDING_SYNC_CREATE); } /* Disable actions that start asynchronous activities while an * asynchronous activity is in progress. We enforce this with * a simple inverted binding to EMsgComposer's "busy" property. */ e_binding_bind_property ( composer, "busy", priv->async_actions, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); e_binding_bind_property ( composer, "busy", priv->header_table, "sensitive", G_BINDING_SYNC_CREATE | G_BINDING_INVERT_BOOLEAN); g_object_unref (settings); }
bool wxToolBar::DoInsertTool(size_t pos, wxToolBarToolBase *toolBase) { wxToolBarTool* tool = static_cast<wxToolBarTool*>(toolBase); GSList* radioGroup; switch ( tool->GetStyle() ) { case wxTOOL_STYLE_BUTTON: switch (tool->GetKind()) { case wxITEM_CHECK: tool->m_item = gtk_toggle_tool_button_new(); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; case wxITEM_RADIO: radioGroup = GetRadioGroup(pos); if (radioGroup) { // this is the first button in the radio button group, // it will be toggled automatically by GTK so bring the // internal flag in sync tool->Toggle(true); } tool->m_item = gtk_radio_tool_button_new(radioGroup); g_signal_connect(tool->m_item, "toggled", G_CALLBACK(item_toggled), tool); break; default: wxFAIL_MSG("unknown toolbar child type"); // fall through case wxITEM_DROPDOWN: case wxITEM_NORMAL: tool->m_item = gtk_tool_button_new(NULL, ""); g_signal_connect(tool->m_item, "clicked", G_CALLBACK(item_clicked), tool); break; } if (!HasFlag(wxTB_NOICONS)) { GtkWidget* image = gtk_image_new(); gtk_tool_button_set_icon_widget( GTK_TOOL_BUTTON(tool->m_item), image); tool->SetImage(); gtk_widget_show(image); g_signal_connect(image, "expose_event", G_CALLBACK(image_expose_event), tool); } if (!tool->GetLabel().empty()) { gtk_tool_button_set_label( GTK_TOOL_BUTTON(tool->m_item), wxGTK_CONV(tool->GetLabel())); // needed for labels in horizontal toolbar with wxTB_HORZ_LAYOUT gtk_tool_item_set_is_important(tool->m_item, true); } if (!HasFlag(wxTB_NO_TOOLTIPS) && !tool->GetShortHelp().empty()) { gtk_tool_item_set_tooltip(tool->m_item, m_tooltips, wxGTK_CONV(tool->GetShortHelp()), ""); } g_signal_connect(GTK_BIN(tool->m_item)->child, "button_press_event", G_CALLBACK(button_press_event), tool); g_signal_connect(tool->m_item, "enter_notify_event", G_CALLBACK(enter_notify_event), tool); g_signal_connect(tool->m_item, "leave_notify_event", G_CALLBACK(enter_notify_event), tool); if (tool->GetKind() == wxITEM_DROPDOWN) tool->CreateDropDown(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_SEPARATOR: tool->m_item = gtk_separator_tool_item_new(); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); break; case wxTOOL_STYLE_CONTROL: wxWindow* control = tool->GetControl(); if (control->m_widget->parent == NULL) AddChildGTK(control); tool->m_item = GTK_TOOL_ITEM(control->m_widget->parent->parent); if (gtk_toolbar_get_item_index(m_toolbar, tool->m_item) != int(pos)) { g_object_ref(tool->m_item); gtk_container_remove( GTK_CONTAINER(m_toolbar), GTK_WIDGET(tool->m_item)); gtk_toolbar_insert(m_toolbar, tool->m_item, int(pos)); g_object_unref(tool->m_item); } // Inserted items "slide" into place using an animated effect that // causes multiple size events on the item. Must set size request // to keep item size from getting permanently set too small by the // first of these size events. const wxSize size = control->GetSize(); gtk_widget_set_size_request(control->m_widget, size.x, size.y); break; } gtk_widget_show(GTK_WIDGET(tool->m_item)); InvalidateBestSize(); return true; }
static GObject * debug_dialog_constructor (GType type, guint n_construct_params, GObjectConstructParam *construct_params) { GObject *object; EmpathyDebugDialogPriv *priv; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *image; GtkWidget *label; GtkToolItem *item; GtkCellRenderer *renderer; GtkListStore *level_store; GtkTreeIter iter; object = G_OBJECT_CLASS (empathy_debug_dialog_parent_class)->constructor (type, n_construct_params, construct_params); priv = GET_PRIV (object); gtk_window_set_title (GTK_WINDOW (object), _("Debug Window")); gtk_window_set_default_size (GTK_WINDOW (object), 800, 400); vbox = GTK_DIALOG (object)->vbox; toolbar = gtk_toolbar_new (); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); gtk_toolbar_set_show_arrow (GTK_TOOLBAR (toolbar), TRUE); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_SMALL_TOOLBAR); gtk_widget_show (toolbar); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); /* CM */ priv->cm_chooser = gtk_combo_box_new_text (); priv->cms = gtk_list_store_new (NUM_COLS_CM, G_TYPE_STRING, G_TYPE_STRING); gtk_combo_box_set_model (GTK_COMBO_BOX (priv->cm_chooser), GTK_TREE_MODEL (priv->cms)); gtk_widget_show (priv->cm_chooser); item = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_container_add (GTK_CONTAINER (item), priv->cm_chooser); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); g_signal_connect (priv->cm_chooser, "changed", G_CALLBACK (debug_dialog_cm_chooser_changed_cb), object); gtk_widget_show (GTK_WIDGET (priv->cm_chooser)); item = gtk_separator_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Save */ priv->save_button = gtk_tool_button_new_from_stock (GTK_STOCK_SAVE); g_signal_connect (priv->save_button, "clicked", G_CALLBACK (debug_dialog_save_clicked_cb), object); gtk_widget_show (GTK_WIDGET (priv->save_button)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->save_button), TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->save_button, -1); /* Copy */ priv->copy_button = gtk_tool_button_new_from_stock (GTK_STOCK_COPY); g_signal_connect (priv->copy_button, "clicked", G_CALLBACK (debug_dialog_copy_clicked_cb), object); gtk_widget_show (GTK_WIDGET (priv->copy_button)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->copy_button), TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->copy_button, -1); /* Clear */ priv->clear_button = gtk_tool_button_new_from_stock (GTK_STOCK_CLEAR); g_signal_connect (priv->clear_button, "clicked", G_CALLBACK (debug_dialog_clear_clicked_cb), object); gtk_widget_show (GTK_WIDGET (priv->clear_button)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->clear_button), TRUE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->clear_button, -1); item = gtk_separator_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Pause */ priv->paused = FALSE; image = gtk_image_new_from_stock (GTK_STOCK_MEDIA_PAUSE, GTK_ICON_SIZE_MENU); gtk_widget_show (image); priv->pause_button = gtk_toggle_tool_button_new (); gtk_toggle_tool_button_set_active ( GTK_TOGGLE_TOOL_BUTTON (priv->pause_button), priv->paused); g_signal_connect (priv->pause_button, "toggled", G_CALLBACK (debug_dialog_pause_toggled_cb), object); gtk_widget_show (GTK_WIDGET (priv->pause_button)); gtk_tool_item_set_is_important (GTK_TOOL_ITEM (priv->pause_button), TRUE); gtk_tool_button_set_label (GTK_TOOL_BUTTON (priv->pause_button), _("Pause")); gtk_tool_button_set_icon_widget ( GTK_TOOL_BUTTON (priv->pause_button), image); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->pause_button, -1); item = gtk_separator_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* Level */ priv->level_label = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (priv->level_label)); label = gtk_label_new (_("Level ")); gtk_widget_show (label); gtk_container_add (GTK_CONTAINER (priv->level_label), label); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), priv->level_label, -1); priv->level_filter = gtk_combo_box_new_text (); gtk_widget_show (priv->level_filter); item = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_container_add (GTK_CONTAINER (item), priv->level_filter); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); level_store = gtk_list_store_new (NUM_COLS_LEVEL, G_TYPE_STRING, G_TYPE_UINT); gtk_combo_box_set_model (GTK_COMBO_BOX (priv->level_filter), GTK_TREE_MODEL (level_store)); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Debug"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_DEBUG, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Info"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_INFO, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Message"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_MESSAGE, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Warning"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_WARNING, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Critical"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_CRITICAL, -1); gtk_list_store_append (level_store, &iter); gtk_list_store_set (level_store, &iter, COL_LEVEL_NAME, _("Error"), COL_LEVEL_VALUE, EMP_DEBUG_LEVEL_ERROR, -1); gtk_combo_box_set_active (GTK_COMBO_BOX (priv->level_filter), 0); g_signal_connect (priv->level_filter, "changed", G_CALLBACK (debug_dialog_filter_changed_cb), object); /* Debug treeview */ priv->view = gtk_tree_view_new (); gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (priv->view), TRUE); g_signal_connect (priv->view, "button-press-event", G_CALLBACK (debug_dialog_button_press_event_cb), object); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "yalign", 0, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Time"), renderer, "text", COL_DEBUG_TIMESTAMP, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Domain"), renderer, "text", COL_DEBUG_DOMAIN, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Category"), renderer, "text", COL_DEBUG_CATEGORY, NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Level"), renderer, "text", COL_DEBUG_LEVEL_STRING, NULL); renderer = gtk_cell_renderer_text_new (); g_object_set (renderer, "family", "Monospace", NULL); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (priv->view), -1, _("Message"), renderer, "text", COL_DEBUG_MESSAGE, NULL); priv->store = gtk_list_store_new (NUM_DEBUG_COLS, G_TYPE_DOUBLE, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT); priv->store_filter = gtk_tree_model_filter_new ( GTK_TREE_MODEL (priv->store), NULL); gtk_tree_model_filter_set_visible_func ( GTK_TREE_MODEL_FILTER (priv->store_filter), debug_dialog_visible_func, object, NULL); gtk_tree_view_set_model (GTK_TREE_VIEW (priv->view), priv->store_filter); /* Scrolled window */ priv->scrolled_win = g_object_ref (gtk_scrolled_window_new (NULL, NULL)); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (priv->scrolled_win), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_show (priv->view); gtk_container_add (GTK_CONTAINER (priv->scrolled_win), priv->view); gtk_widget_show (priv->scrolled_win); /* Not supported label */ priv->not_supported_label = g_object_ref (gtk_label_new ( _("The selected connection manager does not support the remote " "debugging extension."))); gtk_widget_show (priv->not_supported_label); gtk_box_pack_start (GTK_BOX (vbox), priv->not_supported_label, TRUE, TRUE, 0); priv->view_visible = FALSE; debug_dialog_set_toolbar_sensitivity (EMPATHY_DEBUG_DIALOG (object), FALSE); debug_dialog_fill_cm_chooser (EMPATHY_DEBUG_DIALOG (object)); gtk_widget_show (GTK_WIDGET (object)); return object; }