static void gcal_toolbar_constructed (GObject *object) { GcalToolbarPrivate *priv; GtkStyleContext *context; GtkToolItem *spacer; GtkWidget *bin; priv = GCAL_TOOLBAR (object)->priv; if (G_OBJECT_CLASS (gcal_toolbar_parent_class)->constructed != NULL) G_OBJECT_CLASS (gcal_toolbar_parent_class)->constructed (object); priv->widget = gtk_toolbar_new (); gtk_widget_set_hexpand (priv->widget, TRUE); gtk_widget_set_vexpand (priv->widget, TRUE); gtk_toolbar_set_icon_size (GTK_TOOLBAR (priv->widget), GTK_ICON_SIZE_BUTTON); context = gtk_widget_get_style_context (priv->widget); gtk_style_context_add_class (context, "main-toolbar"); /* adding toolbar */ bin = gtk_clutter_actor_get_widget (GTK_CLUTTER_ACTOR (object)); gtk_container_add (GTK_CONTAINER (bin), priv->widget); /* adding sections */ /* left */ priv->left_item = gtk_tool_item_new (); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->left_item, 0); /* spacer */ spacer = gtk_tool_item_new (); gtk_tool_item_set_expand (spacer, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), spacer, -1); /* central */ priv->central_item = gtk_tool_item_new (); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->central_item, -1); /* spacer */ spacer = gtk_tool_item_new (); gtk_tool_item_set_expand (spacer, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), spacer, -1); /* right */ priv->right_item = gtk_tool_item_new (); gtk_toolbar_insert (GTK_TOOLBAR (priv->widget), priv->right_item, -1); gcal_toolbar_set_overview_mode (GCAL_TOOLBAR (object)); gtk_widget_show_all (bin); }
static GtkWidget *create_toolbar(void) { GtkWidget *toolbar, *item; GtkToolItem *tool_item; toolbar = gtk_toolbar_new(); gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); tool_item = gtk_menu_tool_button_new(NULL, NULL); gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(tool_item), GTK_STOCK_JUMP_TO); item = (GtkWidget*)tool_item; gtk_widget_set_tooltip_text(item, _("Show the current document")); gtk_container_add(GTK_CONTAINER(toolbar), item); g_signal_connect(item, "clicked", G_CALLBACK(on_refresh), NULL); item = gtk_menu_new(); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(tool_item), item); g_signal_connect(item, "show", G_CALLBACK(on_doc_menu_show), NULL); tool_item = gtk_tool_item_new(); gtk_tool_item_set_expand(tool_item, TRUE); gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(tool_item)); item = gtk_label_new(NULL); gtk_label_set_ellipsize(GTK_LABEL(item), PANGO_ELLIPSIZE_START); gtk_container_add(GTK_CONTAINER(tool_item), item); edit_window.name_label = item; item = ui_tool_button_new(GTK_STOCK_CLOSE, _("_Unsplit"), NULL); gtk_container_add(GTK_CONTAINER(toolbar), item); g_signal_connect(item, "clicked", G_CALLBACK(on_unsplit), NULL); return toolbar; }
JNIEXPORT void JNICALL Java_org_gnome_gtk_GtkToolItem_gtk_1tool_1item_1set_1expand ( JNIEnv* env, jclass cls, jlong _self, jboolean _expand ) { GtkToolItem* self; gboolean expand; // convert parameter self self = (GtkToolItem*) _self; // convert parameter expand expand = (gboolean) _expand; // call function gtk_tool_item_set_expand(self, expand); // cleanup parameter self // cleanup parameter expand }
void nautilus_navigation_window_activate_spinner (NautilusNavigationWindow *window) { GtkToolItem *item; GtkWidget *spinner; if (window->details->spinner != NULL) { return; } item = gtk_tool_item_new (); gtk_widget_show (GTK_WIDGET (item)); gtk_tool_item_set_expand (item, TRUE); gtk_toolbar_insert (GTK_TOOLBAR (window->details->toolbar), item, -1); spinner = gtk_spinner_new (); gtk_widget_show (GTK_WIDGET (spinner)); item = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (item), spinner); gtk_widget_show (GTK_WIDGET (item)); gtk_toolbar_insert (GTK_TOOLBAR (window->details->toolbar), item, -1); window->details->spinner = spinner; }
static void add_section_toolbar (CEPageIP6 *page, GtkWidget *section, GCallback add_cb) { GtkWidget *toolbar; GtkToolItem *item; GtkStyleContext *context; GtkWidget *box; GtkWidget *button; GtkWidget *image; toolbar = gtk_toolbar_new (); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_toolbar_set_icon_size (GTK_TOOLBAR (toolbar), GTK_ICON_SIZE_MENU); context = gtk_widget_get_style_context (toolbar); gtk_style_context_set_junction_sides (context, GTK_JUNCTION_TOP); gtk_style_context_add_class (context, GTK_STYLE_CLASS_INLINE_TOOLBAR); gtk_container_add (GTK_CONTAINER (section), toolbar); item = gtk_separator_tool_item_new (); gtk_tool_item_set_expand (item, TRUE); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), 0); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); item = gtk_tool_item_new (); gtk_container_add (GTK_CONTAINER (item), box); button = gtk_button_new (); g_signal_connect_swapped (button, "clicked", G_CALLBACK (add_cb), page); image = gtk_image_new_from_icon_name ("list-add-symbolic", GTK_ICON_SIZE_MENU); atk_object_set_name (gtk_widget_get_accessible (button), _("Add")); gtk_button_set_image (GTK_BUTTON (button), image); gtk_container_add (GTK_CONTAINER (box), button); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), GTK_TOOL_ITEM (item), 1); }
static GtkWidget* create_toolbar() { GtkWidget* toolbar=gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL); gtk_toolbar_set_style(GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); GtkToolItem* item; // botao para voltar item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_back_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // botao para ir para url que esta antes item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); g_signal_connect(G_OBJECT (item), "clicked", G_CALLBACK (go_forward_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // form de entrada de url item = gtk_tool_item_new(); gtk_tool_item_set_expand(item, TRUE); uri_entry = gtk_entry_new(); gtk_container_add(GTK_CONTAINER (item), uri_entry); g_signal_connect(G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_box), NULL); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); // botao bara ir e abrir item = gtk_tool_button_new_from_stock(GTK_STOCK_OK); g_signal_connect_swapped(G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_box), (gpointer)uri_entry); gtk_toolbar_insert(GTK_TOOLBAR (toolbar), item, -1); return toolbar; }
/********************************************************************************************************* * gui functions */ void create_filter() { GtkToolItem* toolitem; GtkWidget* label; GtkWidget* hbox; hbox = gtk_hbox_new(FALSE, 0); toolitem = gtk_tool_item_new(); /* This is how gtk does more complex toolbar items. */ gtk_tool_item_set_expand(toolitem, TRUE); g_MainWindow.filterBar = gtk_toolbar_new(); gtk_toolbar_set_orientation(GTK_TOOLBAR(g_MainWindow.filterBar), GTK_ORIENTATION_HORIZONTAL); label = gtk_label_new_with_mnemonic(tr("F_ilter:")); g_MainWindow.filter = gtk_entry_new(); gtk_label_set_mnemonic_widget(GTK_LABEL(label), g_MainWindow.filter); gtk_entry_set_text(GTK_ENTRY(g_MainWindow.filter), ""); g_signal_connect(g_MainWindow.filter, "changed", G_CALLBACK(callback_apply_filter), NULL); g_signal_connect(g_MainWindow.filter, "activate", G_CALLBACK(callback_apply_filter), NULL); g_signal_connect(g_MainWindow.filter, "focus-in-event", G_CALLBACK(callback_filter_selected), NULL); g_signal_connect(g_MainWindow.filter, "focus-out-event", G_CALLBACK(callback_filter_unselected), NULL); g_signal_connect(g_MainWindow.filter, "grab-notify", G_CALLBACK(callback_filter_grab_unselected), NULL); gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 5); gtk_box_pack_start(GTK_BOX(hbox), g_MainWindow.filter, TRUE, TRUE, 5); gtk_container_add(GTK_CONTAINER(toolitem), hbox); gtk_toolbar_insert(GTK_TOOLBAR(g_MainWindow.filterBar), toolitem, 0); gtk_box_pack_start(GTK_BOX(g_MainWindow.toplevelVBox), g_MainWindow.filterBar, FALSE, FALSE, 0); }
static void create_toolbar() { browser->toolbar = gtk_toolbar_new(); #ifndef GTK_ORIENTABLE gtk_toolbar_set_orientation(GTK_TOOLBAR (browser->toolbar), GTK_ORIENTATION_HORIZONTAL); #else gtk_orientable_set_orientation(GTK_ORIENTABLE (browser->toolbar), GTK_ORIENTATION_HORIZONTAL); #endif gtk_toolbar_set_style(GTK_TOOLBAR (browser->toolbar), GTK_TOOLBAR_BOTH_HORIZ); GtkToolItem* item; /* the back button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), (gpointer) browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The forward button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), (gpointer) browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The URL entry */ item = gtk_tool_item_new(); gtk_tool_item_set_expand(item, TRUE); browser->uri_entry = gtk_entry_new(); gtk_container_add(GTK_CONTAINER (item), browser->uri_entry); g_signal_connect (G_OBJECT (browser->uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); /* The go button */ item = gtk_tool_button_new_from_stock(GTK_STOCK_OK); g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)browser->uri_entry); gtk_toolbar_insert(GTK_TOOLBAR (browser->toolbar), item, -1); }
static void nautilus_toolbar_constructed (GObject *obj) { NautilusToolbar *self = NAUTILUS_TOOLBAR (obj); GtkToolItem *item; GtkWidget *hbox, *toolbar, *search; GtkStyleContext *context; const gchar *ui; G_OBJECT_CLASS (nautilus_toolbar_parent_class)->constructed (obj); gtk_style_context_set_junction_sides (gtk_widget_get_style_context (GTK_WIDGET (self)), GTK_JUNCTION_BOTTOM); /* add the UI */ ui = nautilus_ui_string_get ("nautilus-toolbar-ui.xml"); self->priv->ui_manager = gtk_ui_manager_new (); gtk_ui_manager_add_ui_from_string (self->priv->ui_manager, ui, -1, NULL); gtk_ui_manager_insert_action_group (self->priv->ui_manager, self->priv->action_group, 0); toolbar = gtk_ui_manager_get_widget (self->priv->ui_manager, "/Toolbar"); self->priv->toolbar = toolbar; context = gtk_widget_get_style_context (toolbar); gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR); search = gtk_ui_manager_get_widget (self->priv->ui_manager, "/Toolbar/Search"); gtk_style_context_add_class (gtk_widget_get_style_context (search), GTK_STYLE_CLASS_RAISED); gtk_box_pack_start (GTK_BOX (self), self->priv->toolbar, TRUE, TRUE, 0); gtk_widget_show_all (self->priv->toolbar); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_widget_show (hbox); /* regular path bar */ self->priv->path_bar = g_object_new (NAUTILUS_TYPE_PATH_BAR, NULL); gtk_box_pack_start (GTK_BOX (hbox), self->priv->path_bar, TRUE, TRUE, 0); /* entry-like location bar */ self->priv->location_bar = nautilus_location_bar_new (); gtk_box_pack_start (GTK_BOX (hbox), self->priv->location_bar, TRUE, TRUE, 0); item = gtk_tool_item_new (); gtk_tool_item_set_expand (item, TRUE); gtk_container_add (GTK_CONTAINER (item), hbox); gtk_toolbar_insert (GTK_TOOLBAR (self->priv->toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); /* search bar */ self->priv->search_bar = nautilus_search_bar_new (); gtk_box_pack_start (GTK_BOX (self), self->priv->search_bar, TRUE, TRUE, 0); g_signal_connect_swapped (nautilus_preferences, "changed::" NAUTILUS_PREFERENCES_ALWAYS_USE_LOCATION_ENTRY, G_CALLBACK (toolbar_update_appearance), self); toolbar_update_appearance (self); }
static GtkToolItem* expander_new() { GtkToolItem *expander = gtk_separator_tool_item_new(); gtk_separator_tool_item_set_draw(GTK_SEPARATOR_TOOL_ITEM(expander), FALSE); gtk_tool_item_set_expand(GTK_TOOL_ITEM(expander), TRUE); return expander; }
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); }
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 expand_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_expand (tool_item, !gtk_tool_item_get_expand (tool_item)); g_object_unref (tool_item); gtk_tree_model_row_changed (model, path, &iter); gtk_tree_path_free (path); }
static void gigolo_bookmark_panel_init(GigoloBookmarkPanel *self) { GtkWidget *swin, *toolbar; GtkToolItem *toolitem; GigoloBookmarkPanelPrivate *priv = gigolo_bookmark_panel_get_instance_private(self); gtk_orientable_set_orientation (GTK_ORIENTABLE (self), GTK_ORIENTATION_VERTICAL); 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); toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name ("gtk-connect", gtk_toolbar_get_icon_size(GTK_TOOLBAR(toolbar))), NULL); gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _("Connect to the selected bookmark")); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); g_signal_connect(toolitem, "clicked", G_CALLBACK(button_connect_click_cb), self); priv->button_connect = 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); toolitem = gtk_tool_button_new(gtk_image_new_from_icon_name ("gtk-close", gtk_toolbar_get_icon_size(GTK_TOOLBAR(toolbar))), NULL); gtk_widget_set_tooltip_text(GTK_WIDGET(toolitem), _("Close panel")); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); g_signal_connect(toolitem, "clicked", G_CALLBACK(button_close_click_cb), self); tree_prepare(self); swin = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(swin), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(swin), GTK_SHADOW_IN); gtk_container_add(GTK_CONTAINER(swin), priv->tree); gtk_box_pack_start(GTK_BOX(self), toolbar, FALSE, FALSE, 0); gtk_box_pack_start(GTK_BOX(self), swin, TRUE, TRUE, 0); gtk_widget_show_all(toolbar); gtk_widget_show_all(swin); }
static void photos_searchbar_constructed (GObject *object) { PhotosSearchbar *self = PHOTOS_SEARCHBAR (object); PhotosSearchbarPrivate *priv; GApplication *app; GtkToolItem *item; GVariant *state; priv = photos_searchbar_get_instance_private (self); G_OBJECT_CLASS (photos_searchbar_parent_class)->constructed (object); PHOTOS_SEARCHBAR_GET_CLASS (self)->create_search_widgets (self); item = gtk_tool_item_new (); gtk_tool_item_set_expand (item, TRUE); gtk_container_add (GTK_CONTAINER (item), priv->search_container); gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), item, 0); g_signal_connect_swapped (priv->search_entry, "search-changed", G_CALLBACK (photos_searchbar_search_changed), self); app = g_application_get_default (); priv->search = g_action_map_lookup_action (G_ACTION_MAP (app), "search"); /* g_signal_connect_object will not be able to disconnect the * handler in time because we change the state of the action during * dispose. */ priv->search_state_id = g_signal_connect_swapped (priv->search, "change-state", G_CALLBACK (photos_searchbar_change_state), self); state = g_action_get_state (priv->search); photos_searchbar_change_state (self, state); g_variant_unref (state); gtk_widget_show_all (GTK_WIDGET (self)); }
create_statusbar ()void *GtkMain(void * argument) { printf("%s:%d\n", __func__, __LINE__); int argc = 0; char**argv = NULL; unsigned char haveUrl = 0; int argCount = 0; { g_main_statusbar = GTK_STATUSBAR (gtk_statusbar_new ()); gtk_widget_set_can_focus(GTK_WIDGET (g_main_statusbar), false); status_context_id = gtk_statusbar_get_context_id (g_main_statusbar, "Link Hover"); return (GtkWidget*)g_main_statusbar; } static GtkWidget* create_toolbar () { g_toolbar = gtk_toolbar_new (); gtk_widget_set_can_focus(GTK_WIDGET (g_toolbar), false); #if GTK_CHECK_VERSION(2,15,0) gtk_orientable_set_orientation (GTK_ORIENTABLE (g_toolbar), GTK_ORIENTATION_HORIZONTAL); #else gtk_toolbar_set_orientation (GTK_TOOLBAR (g_toolbar), GTK_ORIENTATION_HORIZONTAL); #endif gtk_toolbar_set_style (GTK_TOOLBAR (g_toolbar), GTK_TOOLBAR_BOTH_HORIZ); /* The URL entry */ itemUrl = gtk_tool_item_new (); gtk_widget_set_can_focus(GTK_WIDGET (itemUrl), false); gtk_tool_item_set_expand (itemUrl, TRUE); uri_entry = gtk_entry_new (); gtk_container_add (GTK_CONTAINER (itemUrl), uri_entry); g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (g_toolbar), itemUrl, -1); return g_toolbar; }
GtkWidget *gui_toolbar_new(toolbar_item_t *tbitems) { GtkWidget *icon; GtkWidget *toolbar; GtkToolItem *item; int i; toolbar = gtk_toolbar_new(); gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_HORIZONTAL ); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH); for (i=0; tbitems[i].icon!=NULL; i++) { if (strcmp(tbitems[i].icon,TOOLBAR_ITEM_SEPARATOR)==0) { item = gtk_separator_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1); } else if (strcmp(tbitems[i].icon,TOOLBAR_ITEM_EXPANDER)==0) { item = gtk_separator_tool_item_new(); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM(item),FALSE); gtk_tool_item_set_expand(GTK_TOOL_ITEM(item),TRUE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1); } else { icon = gtk_image_new_from_icon_name(tbitems[i].icon, GTK_ICON_SIZE_LARGE_TOOLBAR); item = gtk_tool_button_new(icon, tbitems[i].text); if (tbitems[i].callback) g_signal_connect(G_OBJECT(item),"clicked",G_CALLBACK(tbitems[i].callback),(gpointer)tbitems[i].callback_data); if (tbitems[i].tooltip) gtk_widget_set_tooltip_text(GTK_WIDGET(item),tbitems[i].tooltip); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(item),-1); } } return toolbar; }
static void photos_searchbar_constructed (GObject *object) { PhotosSearchbar *self = PHOTOS_SEARCHBAR (object); PhotosSearchbarPrivate *priv = self->priv; GtkToolItem *item; GVariant *state; G_OBJECT_CLASS (photos_searchbar_parent_class)->constructed (object); PHOTOS_SEARCHBAR_GET_CLASS (self)->create_search_widgets (self); item = gtk_tool_item_new (); gtk_tool_item_set_expand (item, TRUE); gtk_container_add (GTK_CONTAINER (item), priv->search_container); gtk_toolbar_insert (GTK_TOOLBAR (priv->toolbar), item, 0); g_signal_connect_swapped (priv->search_entry, "key-press-event", G_CALLBACK (photos_searchbar_key_press_event), self); g_signal_connect_swapped (priv->search_entry, "search-changed", G_CALLBACK (photos_searchbar_search_changed), self); /* g_signal_connect_object will not be able to disconnect the * handler in time because we change the state of the action during * dispose. */ priv->search_state_id = g_signal_connect_swapped (priv->app, "action-state-changed::search", G_CALLBACK (photos_searchbar_action_state_changed), self); state = g_action_group_get_action_state (G_ACTION_GROUP (priv->app), "search"); photos_searchbar_action_state_changed (self, "search", state); g_variant_unref (state); gtk_widget_show_all (GTK_WIDGET (self)); }
static GtkWidget *create_toolbar(void) { GtkWidget *toolbar, *item; GtkToolItem *tool_item; toolbar = gtk_toolbar_new(); gtk_toolbar_set_icon_size(GTK_TOOLBAR(toolbar), GTK_ICON_SIZE_MENU); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); tool_item = gtk_menu_tool_button_new(NULL, NULL); gtk_tool_button_set_stock_id(GTK_TOOL_BUTTON(tool_item), GTK_STOCK_JUMP_TO); item = (GtkWidget*)tool_item; gtk_widget_set_tooltip_text(item, _("Show the current document")); gtk_container_add(GTK_CONTAINER(toolbar), item); g_signal_connect(item, "clicked", G_CALLBACK(on_refresh), NULL); item = gtk_menu_new(); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(tool_item), item); #if GTK_CHECK_VERSION (3, 0, 0) /* hack for https://bugzilla.gnome.org/show_bug.cgi?id=769287 */ if (! gtk_check_version(3, 15, 9) && gtk_check_version(3, 21, 4+1)) g_signal_connect(tool_item, "show-menu", G_CALLBACK(show_menu_gtk316_fix), NULL); #endif g_signal_connect(tool_item, "show-menu", G_CALLBACK(on_doc_show_menu), item); tool_item = gtk_tool_item_new(); gtk_tool_item_set_expand(tool_item, TRUE); gtk_container_add(GTK_CONTAINER(toolbar), GTK_WIDGET(tool_item)); item = gtk_label_new(NULL); gtk_label_set_ellipsize(GTK_LABEL(item), PANGO_ELLIPSIZE_START); gtk_container_add(GTK_CONTAINER(tool_item), item); edit_window.name_label = item; item = ui_tool_button_new(GTK_STOCK_CLOSE, _("_Unsplit"), NULL); gtk_container_add(GTK_CONTAINER(toolbar), item); g_signal_connect(item, "clicked", G_CALLBACK(on_unsplit), NULL); return toolbar; }
static GtkWidget* create_toolbar () { GtkWidget* toolbar = gtk_toolbar_new (); #if GTK_CHECK_VERSION(2,15,0) gtk_orientable_set_orientation (GTK_ORIENTABLE (toolbar), GTK_ORIENTATION_HORIZONTAL); #else gtk_toolbar_set_orientation (GTK_TOOLBAR (toolbar), GTK_ORIENTATION_HORIZONTAL); #endif gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_BOTH_HORIZ); GtkToolItem* item; /* the back button */ item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_BACK); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_back_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The forward button */ item = gtk_tool_button_new_from_stock (GTK_STOCK_GO_FORWARD); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (go_forward_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The URL entry */ item = gtk_tool_item_new (); gtk_tool_item_set_expand (item, TRUE); uri_entry = gtk_entry_new (); gtk_container_add (GTK_CONTAINER (item), uri_entry); g_signal_connect (G_OBJECT (uri_entry), "activate", G_CALLBACK (activate_uri_entry_cb), NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); /* The go button */ item = gtk_tool_button_new_from_stock (GTK_STOCK_OK); g_signal_connect_swapped (G_OBJECT (item), "clicked", G_CALLBACK (activate_uri_entry_cb), (gpointer)uri_entry); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); return toolbar; }
void browser_dialog_open (const gchar *plug_in_binary) { GtkWidget *window; GtkWidget *main_vbox; GtkWidget *vbox; GtkWidget *toolbar; GtkWidget *paned; GtkWidget *scrolled; GtkToolItem *item; GtkAction *action; DialogData data = { 720, 560, 240, TRUE, 1.0 }; gimp_ui_init (plug_in_binary, TRUE); gimp_get_data (GIMP_HELP_BROWSER_DIALOG_DATA, &data); /* the dialog window */ window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title (GTK_WINDOW (window), _("GIMP Help Browser")); gtk_window_set_role (GTK_WINDOW (window), plug_in_binary); gtk_window_set_default_size (GTK_WINDOW (window), data.width, data.height); g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL); window_set_icons (window); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2); gtk_container_add (GTK_CONTAINER (window), vbox); gtk_widget_show (vbox); ui_manager = ui_manager_new (window); toolbar = gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar"); gtk_toolbar_set_style (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start (GTK_BOX (vbox), toolbar, FALSE, FALSE, 0); gtk_widget_show (toolbar); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/forward"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_next = GTK_WIDGET (item); item = g_object_new (GTK_TYPE_MENU_TOOL_BUTTON, NULL); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, 0); gtk_widget_show (GTK_WIDGET (item)); action = gtk_ui_manager_get_action (ui_manager, "/ui/help-browser-popup/back"); gtk_activatable_set_related_action (GTK_ACTIVATABLE (item), action); g_object_notify (G_OBJECT (action), "tooltip"); button_prev = GTK_WIDGET (item); item = GTK_TOOL_ITEM (gtk_ui_manager_get_widget (ui_manager, "/help-browser-toolbar/space")); gtk_separator_tool_item_set_draw (GTK_SEPARATOR_TOOL_ITEM (item), FALSE); gtk_tool_item_set_expand (item, TRUE); /* the horizontal paned */ paned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL); gtk_box_pack_start (GTK_BOX (vbox), paned, TRUE, TRUE, 0); gtk_widget_show (paned); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_paned_add1 (GTK_PANED (paned), scrolled); gtk_paned_set_position (GTK_PANED (paned), data.paned_position); sidebar = scrolled; if (data.show_index) gtk_widget_show (sidebar); tree_view = gtk_tree_view_new (); gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (tree_view), FALSE); gtk_container_add (GTK_CONTAINER (scrolled), tree_view); gtk_widget_show (tree_view); gtk_tree_view_insert_column_with_attributes (GTK_TREE_VIEW (tree_view), -1, NULL, gtk_cell_renderer_text_new (), "text", 1, NULL); g_signal_connect (tree_view, "row-activated", G_CALLBACK (row_activated), NULL); /* HTML view */ main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_widget_show (main_vbox); gtk_paned_pack2 (GTK_PANED (paned), main_vbox, TRUE, TRUE); scrolled = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); gtk_widget_set_size_request (scrolled, 300, 200); gtk_box_pack_start (GTK_BOX (main_vbox), scrolled, TRUE, TRUE, 0); gtk_widget_show (scrolled); view = webkit_web_view_new (); webkit_web_view_set_maintains_back_forward_list (WEBKIT_WEB_VIEW (view), TRUE); gtk_container_add (GTK_CONTAINER (scrolled), view); gtk_widget_show (view); g_signal_connect (view, "realize", G_CALLBACK (view_realize), NULL); g_signal_connect (view, "unrealize", G_CALLBACK (view_unrealize), NULL); g_signal_connect (view, "popup-menu", G_CALLBACK (view_popup_menu), NULL); g_signal_connect (view, "button-press-event", G_CALLBACK (view_button_press), NULL); g_signal_connect (view, "key-press-event", G_CALLBACK (view_key_press), NULL); webkit_web_view_set_zoom_level (WEBKIT_WEB_VIEW (view), data.zoom); g_signal_connect (view, "title-changed", G_CALLBACK (title_changed), window); g_signal_connect (view, "load-started", G_CALLBACK (load_started), NULL); g_signal_connect (view, "load-finished", G_CALLBACK (load_finished), NULL); gtk_widget_grab_focus (view); g_signal_connect (window, "unmap", G_CALLBACK (dialog_unmap), paned); update_actions (); /* Searchbar */ searchbar = build_searchbar (); gtk_box_pack_start (GTK_BOX (main_vbox), searchbar, FALSE, FALSE, 0); }
static void pragha_toolbar_init (PraghaToolbar *toolbar) { PraghaPreferences *preferences; GtkToolItem *prev_button, *play_button, *stop_button, *next_button; GtkToolItem *unfull_button, *shuffle_button, *repeat_button; GtkWidget *vol_button; const GBindingFlags binding_flags = G_BINDING_SYNC_CREATE | G_BINDING_BIDIRECTIONAL; preferences = pragha_preferences_get(); /* Setup Left control buttons */ prev_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(prev_button), "media-skip-backward"); gtk_widget_set_tooltip_text(GTK_WIDGET(prev_button), _("Previous Track")); toolbar->prev_button = prev_button; play_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(play_button), "media-playback-start"); gtk_widget_set_tooltip_text(GTK_WIDGET(play_button), _("Play / Pause Track")); toolbar->play_button = play_button; stop_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(stop_button), "media-playback-stop"); gtk_widget_set_tooltip_text(GTK_WIDGET(stop_button), _("Stop playback")); toolbar->stop_button = stop_button; next_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(next_button), "media-skip-forward"); gtk_widget_set_tooltip_text(GTK_WIDGET(next_button), _("Next Track")); toolbar->next_button = next_button; #if GTK_CHECK_VERSION (3, 12, 0) gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(prev_button)); gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(play_button)); gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(stop_button)); gtk_header_bar_pack_start(GTK_HEADER_BAR(toolbar), GTK_WIDGET(next_button)); #else gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(prev_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(play_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(stop_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(next_button)); #endif /* Song info Box */ #if !GTK_CHECK_VERSION (3, 12, 0) GtkToolItem *boxitem = gtk_tool_item_new (); gtk_tool_item_set_expand (GTK_TOOL_ITEM(boxitem), TRUE); gtk_toolbar_insert (GTK_TOOLBAR(toolbar), GTK_TOOL_ITEM(boxitem), -1); GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add (GTK_CONTAINER(boxitem), box); GtkWidget *playing = pragha_toolbar_get_song_box (toolbar); gtk_box_pack_start (GTK_BOX(box), playing, TRUE, TRUE, 5); #endif /* Setup Right control buttons */ unfull_button = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON(unfull_button), "view-restore"); gtk_widget_set_tooltip_text(GTK_WIDGET(unfull_button), _("Leave Fullscreen")); toolbar->unfull_button = unfull_button; shuffle_button = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(shuffle_button), "media-playlist-shuffle"); gtk_widget_set_tooltip_text(GTK_WIDGET(shuffle_button), _("Play songs in a random order")); repeat_button = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(repeat_button), "media-playlist-repeat"); gtk_widget_set_tooltip_text(GTK_WIDGET(repeat_button), _("Repeat playback list at the end")); vol_button = gtk_volume_button_new(); g_object_set(vol_button, "use-symbolic", FALSE, NULL); gtk_button_set_relief(GTK_BUTTON(vol_button), GTK_RELIEF_NONE); g_object_set(G_OBJECT(vol_button), "size", GTK_ICON_SIZE_LARGE_TOOLBAR, NULL); toolbar->vol_button = vol_button; toolbar->extra_button_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); #if GTK_CHECK_VERSION (3, 12, 0) gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(toolbar->extra_button_box)); gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(vol_button)); gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(repeat_button)); gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(shuffle_button)); gtk_header_bar_pack_end(GTK_HEADER_BAR(toolbar), GTK_WIDGET(unfull_button)); #else gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(unfull_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(shuffle_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(repeat_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(vol_button)); gtk_tool_insert_generic_item(GTK_TOOLBAR(toolbar), GTK_WIDGET(toolbar->extra_button_box)); #endif /* Connect signals */ g_signal_connect(G_OBJECT(prev_button), "clicked", G_CALLBACK(prev_button_handler), toolbar); g_signal_connect(G_OBJECT(play_button), "clicked", G_CALLBACK(play_button_handler), toolbar); g_signal_connect(G_OBJECT(stop_button), "clicked", G_CALLBACK(stop_button_handler), toolbar); g_signal_connect(G_OBJECT(next_button), "clicked", G_CALLBACK(next_button_handler), toolbar); g_signal_connect(G_OBJECT(unfull_button), "clicked", G_CALLBACK(unfull_button_handler), toolbar); /*g_signal_connect(G_OBJECT (prev_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (play_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (stop_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (next_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (next_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (unfull_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (shuffle_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (repeat_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar); g_signal_connect(G_OBJECT (vol_button), "key-press-event", G_CALLBACK(panel_button_key_press), toolbar);*/ g_signal_connect (G_OBJECT (vol_button), "value-changed", G_CALLBACK (vol_button_value_changed), toolbar); g_object_bind_property(preferences, "shuffle", shuffle_button, "active", binding_flags); g_object_bind_property(preferences, "repeat", repeat_button, "active", binding_flags); /* Fix styling */ #if GTK_CHECK_VERSION (3, 12, 0) pragha_toolbar_set_style(toolbar, pragha_preferences_get_gnome_style (preferences)); #endif gtk_widget_show(GTK_WIDGET(prev_button)); gtk_widget_show(GTK_WIDGET(play_button)); gtk_widget_show(GTK_WIDGET(stop_button)); gtk_widget_show(GTK_WIDGET(next_button)); gtk_widget_show(GTK_WIDGET(shuffle_button)); gtk_widget_show(GTK_WIDGET(repeat_button)); gtk_widget_show(GTK_WIDGET(vol_button)); gtk_widget_hide(GTK_WIDGET(toolbar->unfull_button)); gtk_widget_show(GTK_WIDGET(toolbar)); g_object_unref(preferences); }
GtkWidget * gu_playdeck_add(gu_window_t *gw, GtkWidget *parent) { GtkToolItem *ti; GtkWidget *w; GtkWidget *l; GtkWidget *vbox; GtkWidget *playdeck; playdeck_t *pd = calloc(1, sizeof(playdeck_t)); prop_courier_t *pc = gw->gw_gu->gu_pc; playdeck = gtk_vbox_new(FALSE, 0); gtk_box_pack_start(GTK_BOX(parent), playdeck, FALSE, TRUE, 0); w = gtk_hseparator_new(); gtk_widget_show(w); gtk_box_pack_start(GTK_BOX(playdeck), w, FALSE, TRUE, 0); pd->root = gtk_hbox_new(FALSE, 1); gtk_widget_show(pd->root); gtk_box_pack_start(GTK_BOX(playdeck), pd->root, FALSE, TRUE, 0); /* Playdeck album art */ w = gtk_image_new(); gtk_widget_show(w); gtk_misc_set_alignment(GTK_MISC(w), 0, 1); gtk_box_pack_start(GTK_BOX(pd->root), w, FALSE, TRUE, 0); pd->sub_album_art = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "album_art"), PROP_TAG_CALLBACK_STRING, pd_set_albumart, w, PROP_TAG_COURIER, pc, NULL); /* Middle vbox */ vbox = gtk_vbox_new(FALSE, 1); gtk_box_pack_start(GTK_BOX(pd->root), vbox, TRUE, TRUE, 0); /* Title of current track */ l = gtk_label_new(""); gtk_misc_set_alignment(GTK_MISC(l), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), l, TRUE, TRUE, 0); g_object_set(G_OBJECT(l), "ellipsize", PANGO_ELLIPSIZE_END, NULL); pd->sub_title = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "title"), PROP_TAG_CALLBACK_STRING, set_current_title, l, PROP_TAG_COURIER, pc, NULL); /* Title of current track */ pd->trackextra = gtk_label_new(""); g_object_set(G_OBJECT(pd->trackextra), "ellipsize", PANGO_ELLIPSIZE_END, NULL); gtk_misc_set_alignment(GTK_MISC(pd->trackextra), 0, 0); gtk_box_pack_start(GTK_BOX(vbox), pd->trackextra, TRUE, TRUE, 0); pd->sub_album = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "album"), PROP_TAG_CALLBACK_STRING, set_current_album, pd, PROP_TAG_COURIER, pc, NULL); pd->sub_artist = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "artist"), PROP_TAG_CALLBACK_STRING, set_current_artist, pd, PROP_TAG_COURIER, pc, NULL); /* The toolbar */ pd->tbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(pd->tbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start(GTK_BOX(vbox), pd->tbar, FALSE, TRUE, 0); /* Prev button */ pd->prev = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PREVIOUS); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(prev_clicked), pd); pd->sub_canSkipBackward = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "canSkipBackward"), PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity, pd->prev, PROP_TAG_COURIER, pc, NULL); /* Play / Pause */ pd->playpause = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_PLAY); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(playpause_clicked), pd); pd->sub_canPause = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "canPause"), PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity, pd->playpause, PROP_TAG_COURIER, pc, NULL); /* Next button */ pd->next = ti = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_NEXT); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); g_signal_connect(G_OBJECT(ti), "clicked", G_CALLBACK(next_clicked), pd); pd->sub_canSkipForward = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "canSkipForward"), PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity, pd->next, PROP_TAG_COURIER, pc, NULL); /* Separator */ ti = gtk_separator_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); /* Subscribe to playstatus */ pd->sub_playstatus = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "playstatus"), PROP_TAG_CALLBACK, update_playstatus, pd, PROP_TAG_COURIER, pc, NULL); /** * Media position */ pd->pos_adjust = gtk_adjustment_new(0, 0, 0, 0, 0, 0); pd->pos_slider = gtk_hscale_new(GTK_ADJUSTMENT(pd->pos_adjust)); gtk_scale_set_value_pos (GTK_SCALE(pd->pos_slider), GTK_POS_LEFT); g_signal_connect(G_OBJECT(pd->pos_slider), "grab-focus", G_CALLBACK(slider_grabbed), pd); g_signal_connect(G_OBJECT(pd->pos_slider), "change-value", G_CALLBACK(slider_updated), pd); g_signal_connect(G_OBJECT(pd->pos_slider), "format-value", G_CALLBACK(slider_value_callback), pd); ti = gtk_tool_item_new(); gtk_tool_item_set_expand(ti, TRUE); gtk_container_add(GTK_CONTAINER(ti), pd->pos_slider); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); /* Subscribe to current track position */ pd->sub_pos = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "currenttime"), PROP_TAG_CALLBACK_FLOAT, update_curtime, pd, PROP_TAG_COURIER, pc, NULL); /* Subscribe to current track duration */ pd->sub_duration = prop_subscribe(0, PROP_TAG_NAME("global", "media", "current", "metadata", "duration"), PROP_TAG_CALLBACK_FLOAT, update_duration, pd, PROP_TAG_COURIER, pc, NULL); /* Separator */ ti = gtk_separator_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); gtk_widget_show_all(vbox); /** * Volume control */ ti = gtk_tool_item_new(); pd->volume = gtk_volume_button_new(); gtk_container_add(GTK_CONTAINER(ti), pd->volume); gtk_toolbar_insert(GTK_TOOLBAR(pd->tbar), ti, -1); g_signal_connect(G_OBJECT(pd->volume), "value-changed", G_CALLBACK(read_mastervol), pd); pd->sub_volume = prop_subscribe(0, PROP_TAG_NAME("global", "audio", "mastervolume"), PROP_TAG_CALLBACK_FLOAT, update_mastervol, pd, PROP_TAG_COURIER, pc, NULL); gtk_widget_show_all(GTK_WIDGET(ti)); g_signal_connect(playdeck, "destroy", G_CALLBACK(playdeck_dtor), pd); return playdeck; }
static void nemo_toolbar_constructed (GObject *obj) { NemoToolbar *self = NEMO_TOOLBAR (obj); GtkWidget *toolbar; GtkWidget *hbox; GtkToolItem *tool_box; GtkWidget *box; GtkStyleContext *context; G_OBJECT_CLASS (nemo_toolbar_parent_class)->constructed (obj); gtk_style_context_set_junction_sides (gtk_widget_get_style_context (GTK_WIDGET (self)), GTK_JUNCTION_BOTTOM); self->priv->show_location_entry = g_settings_get_boolean (nemo_preferences, NEMO_PREFERENCES_SHOW_LOCATION_ENTRY); /* add the UI */ self->priv->ui_manager = gtk_ui_manager_new (); gtk_ui_manager_insert_action_group (self->priv->ui_manager, self->priv->action_group, 0); toolbar = gtk_toolbar_new (); self->priv->toolbar = toolbar; gtk_box_pack_start (GTK_BOX (self), self->priv->toolbar, TRUE, TRUE, 0); context = gtk_widget_get_style_context (GTK_WIDGET(toolbar)); gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR); /* Back/Forward/Up */ self->priv->navigation_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->previous_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_BACK); gtk_container_add (GTK_CONTAINER (box), self->priv->previous_button); self->priv->next_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_FORWARD); gtk_container_add (GTK_CONTAINER (box), self->priv->next_button); self->priv->up_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_UP); gtk_container_add (GTK_CONTAINER (box), self->priv->up_button); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED); gtk_container_add (GTK_CONTAINER (self->priv->navigation_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->navigation_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->navigation_box)); gtk_widget_set_margin_right (GTK_WIDGET (self->priv->navigation_box), 6); /* Refresh */ self->priv->refresh_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->refresh_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_RELOAD); gtk_container_add (GTK_CONTAINER (box), self->priv->refresh_button); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_container_add (GTK_CONTAINER (self->priv->refresh_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->refresh_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->refresh_box)); gtk_widget_set_margin_right (GTK_WIDGET (self->priv->refresh_box), 6); /* Home/Computer */ self->priv->location_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->home_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_HOME); gtk_container_add (GTK_CONTAINER (box), self->priv->home_button); self->priv->computer_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_COMPUTER); gtk_container_add (GTK_CONTAINER (box), self->priv->computer_button); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED); gtk_container_add (GTK_CONTAINER (self->priv->location_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->location_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->location_box)); gtk_widget_set_margin_right (GTK_WIDGET (self->priv->location_box), 6); /* Container to hold the location and pathbars */ self->priv->stack = gtk_stack_new(); gtk_stack_set_transition_type (GTK_STACK (self->priv->stack), GTK_STACK_TRANSITION_TYPE_CROSSFADE); gtk_stack_set_transition_duration (GTK_STACK (self->priv->stack), 150); /* Regular Path Bar */ hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start (GTK_BOX (hbox), GTK_WIDGET (self->priv->stack), TRUE, TRUE, 0); self->priv->path_bar = g_object_new (NEMO_TYPE_PATH_BAR, NULL); gtk_stack_add_named(GTK_STACK (self->priv->stack), GTK_WIDGET (self->priv->path_bar), "path_bar"); /* Entry-Like Location Bar */ self->priv->location_bar = nemo_location_bar_new (); gtk_stack_add_named(GTK_STACK (self->priv->stack), GTK_WIDGET (self->priv->location_bar), "location_bar"); gtk_widget_show_all (hbox); tool_box = gtk_tool_item_new (); gtk_tool_item_set_expand (tool_box, TRUE); gtk_container_add (GTK_CONTAINER (tool_box), hbox); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (tool_box)); gtk_widget_show (GTK_WIDGET (tool_box)); /* Search/Open in Terminal/New Folder/Toggle Location */ self->priv->tools_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->toggle_location_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_TOGGLE_LOCATION); gtk_container_add (GTK_CONTAINER (box), self->priv->toggle_location_button); self->priv->open_terminal_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_OPEN_IN_TERMINAL); gtk_container_add (GTK_CONTAINER (box), self->priv->open_terminal_button); self->priv->new_folder_button = toolbar_create_toolbutton (self, FALSE, NEMO_ACTION_NEW_FOLDER); gtk_container_add (GTK_CONTAINER (box), self->priv->new_folder_button); self->priv->search_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_SEARCH); gtk_container_add (GTK_CONTAINER (box), self->priv->search_button); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED); gtk_container_add (GTK_CONTAINER (self->priv->tools_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->tools_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->tools_box)); gtk_widget_set_margin_left (GTK_WIDGET (self->priv->tools_box), 6); setup_root_info_bar (self); /* View Select */ self->priv->view_box = gtk_tool_item_new (); box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); self->priv->icon_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_ICON_VIEW); gtk_container_add (GTK_CONTAINER (box), self->priv->icon_view_button); self->priv->list_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_LIST_VIEW); gtk_container_add (GTK_CONTAINER (box), self->priv->list_view_button); self->priv->compact_view_button = toolbar_create_toolbutton (self, TRUE, NEMO_ACTION_COMPACT_VIEW); gtk_container_add (GTK_CONTAINER (box), self->priv->compact_view_button); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_RAISED); gtk_style_context_add_class (gtk_widget_get_style_context (box), GTK_STYLE_CLASS_LINKED); gtk_container_add (GTK_CONTAINER (self->priv->view_box), GTK_WIDGET (box)); gtk_container_add (GTK_CONTAINER (self->priv->toolbar), GTK_WIDGET (self->priv->view_box)); gtk_widget_show_all (GTK_WIDGET (self->priv->view_box)); gtk_widget_set_margin_left (GTK_WIDGET (self->priv->view_box), 6); /* nemo patch */ g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_PREVIOUS_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_NEXT_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_UP_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_EDIT_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_RELOAD_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_HOME_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_COMPUTER_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_SEARCH_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_NEW_FOLDER_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_OPEN_IN_TERMINAL_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_ICON_VIEW_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_LIST_VIEW_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); g_signal_connect_swapped (nemo_preferences, "changed::" NEMO_PREFERENCES_SHOW_COMPACT_VIEW_ICON_TOOLBAR, G_CALLBACK (toolbar_update_appearance), self); toolbar_update_appearance (self); }
static void create_map_window (GourmapUi *ui) { GourmapUiPrivate *priv; GtkWidget *hbox; GtkWidget *vbox1, *vbox2; GtkWidget *toolbar; GtkWidget *addr_label; GtkToolItem *item; GtkCellRenderer *renderer; GtkTreeViewColumn *column; GtkTreeSelection *select; priv = GET_PRIVATE (ui); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); vbox1 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); /* map */ priv->map = gtk_champlain_embed_new (); priv->champ_view = gtk_champlain_embed_get_view (GTK_CHAMPLAIN_EMBED (priv->map)); clutter_actor_set_reactive (CLUTTER_ACTOR (priv->champ_view), TRUE); g_object_set (G_OBJECT (priv->champ_view), "kinetic-mode", TRUE, NULL); priv->marker_layer = champlain_marker_layer_new_full (CHAMPLAIN_SELECTION_SINGLE); champlain_view_add_layer (priv->champ_view, CHAMPLAIN_LAYER (priv->marker_layer)); /* sidebar */ vbox2 = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); /* restaurant list */ priv->store = gtk_tree_store_new (N_COLUMNS, G_TYPE_STRING, G_TYPE_UINT); priv->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (priv->store)); renderer = gtk_cell_renderer_text_new (); column = gtk_tree_view_column_new_with_attributes (_("Restaurant List"), renderer, "text", NAME_COLUMN, NULL); select = gtk_tree_view_get_selection (GTK_TREE_VIEW (priv->treeview)); gtk_tree_selection_set_mode (select, GTK_SELECTION_SINGLE); g_signal_connect (G_OBJECT (select), "changed", G_CALLBACK (tree_selection_changed_cb), (gpointer) ui); gtk_tree_view_append_column (GTK_TREE_VIEW (priv->treeview), column); gtk_box_pack_start (GTK_BOX (vbox2), priv->treeview, TRUE, TRUE, 0); /* random button */ priv->rand_button = gtk_button_new_with_label (_("Random Selection!")); g_signal_connect (G_OBJECT (priv->rand_button), "clicked", G_CALLBACK (random_button_cb), (gpointer) ui); gtk_box_pack_start (GTK_BOX (vbox2), priv->rand_button, FALSE, FALSE, 0); gtk_box_pack_start (GTK_BOX (hbox), priv->map, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (hbox), vbox2, FALSE, FALSE, 0); /* address */ toolbar = gtk_toolbar_new (); item = gtk_tool_item_new (); addr_label = gtk_label_new (_("Address")); gtk_container_add (GTK_CONTAINER (item), addr_label); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_item_new (); gtk_tool_item_set_expand (item, TRUE); priv->addr_entry = gtk_entry_new (); gtk_container_add (GTK_CONTAINER (item), priv->addr_entry); g_signal_connect (G_OBJECT (priv->addr_entry), "activate", G_CALLBACK (activate_addr_entry_cb), (gpointer) ui); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new_from_stock (GTK_STOCK_OK); g_signal_connect (G_OBJECT (item), "clicked", G_CALLBACK (activate_addr_entry_cb), (gpointer) ui); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); gtk_box_pack_start (GTK_BOX (vbox1), hbox, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (vbox1), toolbar, FALSE, FALSE, 0); /* main window */ priv->main_window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (priv->main_window), 1024, 768); gtk_widget_set_name (priv->main_window, _("Gourmap")); g_signal_connect (G_OBJECT (priv->main_window), "destroy", G_CALLBACK (destroy_cb), NULL); gtk_container_add (GTK_CONTAINER (priv->main_window), vbox1); }
GtkWidget * gu_toolbar_add(gu_tab_t *gt, GtkWidget *parent) { toolbar_t *t = calloc(1, sizeof(toolbar_t)); prop_courier_t *pc = gt->gt_gw->gw_gu->gu_pc; GtkWidget *toolbar; GtkWidget *w; t->gt = gt; /* Top Toolbar */ toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); gtk_box_pack_start(GTK_BOX(parent), toolbar, FALSE, TRUE, 0); /* Back button */ t->back = gtk_tool_button_new_from_stock(GTK_STOCK_GO_BACK); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), t->back, -1); g_signal_connect(G_OBJECT(t->back), "clicked", G_CALLBACK(back_clicked), gt); gtk_widget_show(GTK_WIDGET(t->back)); /* Forward button */ t->fwd = gtk_tool_button_new_from_stock(GTK_STOCK_GO_FORWARD); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), t->fwd, -1); g_signal_connect(G_OBJECT(t->fwd), "clicked", G_CALLBACK(fwd_clicked), gt); gtk_widget_show(GTK_WIDGET(t->fwd)); /* Up button */ t->up = gtk_tool_button_new_from_stock(GTK_STOCK_GO_UP); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), t->up, -1); g_signal_connect(G_OBJECT(t->up), "clicked", G_CALLBACK(up_clicked), t); gtk_widget_show(GTK_WIDGET(t->up)); /* Home button */ t->home = gtk_tool_button_new_from_stock(GTK_STOCK_HOME); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), t->home, -1); g_signal_connect(G_OBJECT(t->home), "clicked", G_CALLBACK(home_clicked), gt); gtk_widget_show(GTK_WIDGET(t->home)); /* URL entry */ GtkToolItem *ti = gtk_tool_item_new(); t->url = w = gtk_entry_new(); g_signal_connect(G_OBJECT(w), "activate", G_CALLBACK(gu_nav_url_set), gt); gtk_container_add(GTK_CONTAINER(ti), w); gtk_tool_item_set_expand(ti, TRUE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), ti, -1); gtk_widget_show_all(GTK_WIDGET(ti)); g_signal_connect(toolbar, "destroy", G_CALLBACK(toolbar_dtor), t); /* Opts button */ t->opts = gtk_tool_button_new_from_stock(GTK_STOCK_EDIT); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), t->opts, -1); g_signal_connect(G_OBJECT(t->opts), "clicked", G_CALLBACK(opts_clicked), gt); gtk_widget_show(GTK_WIDGET(t->opts)); t->sub_canGoBack = prop_subscribe(0, PROP_TAG_NAME("nav", "canGoBack"), PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity, t->back, PROP_TAG_COURIER, pc, PROP_TAG_NAMED_ROOT, gt->gt_nav, "nav", NULL); t->sub_canGoFwd = prop_subscribe(0, PROP_TAG_NAME("nav", "canGoForward"), PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity, t->fwd, PROP_TAG_COURIER, pc, PROP_TAG_NAMED_ROOT, gt->gt_nav, "nav", NULL); t->sub_parent = prop_subscribe(0, PROP_TAG_NAME("nav", "currentpage", "parent"), PROP_TAG_CALLBACK_STRING, set_go_up, t, PROP_TAG_COURIER, pc, PROP_TAG_NAMED_ROOT, gt->gt_nav, "nav", NULL); t->sub_canGoHome = prop_subscribe(0, PROP_TAG_NAME("nav", "canGoHome"), PROP_TAG_CALLBACK_INT, gu_subscription_set_sensitivity, t->home, PROP_TAG_COURIER, pc, PROP_TAG_NAMED_ROOT, gt->gt_nav, "nav", NULL); t->sub_url = prop_subscribe(0, PROP_TAG_NAME("nav", "currentpage", "url"), PROP_TAG_CALLBACK_STRING, gu_nav_url_updated, t, PROP_TAG_COURIER, pc, PROP_TAG_NAMED_ROOT, gt->gt_nav, "nav", NULL); gtk_widget_show_all(toolbar); return toolbar; }
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()) { #if GTK_CHECK_VERSION(2, 12, 0) if (!gtk_check_version(2, 12, 0)) { gtk_tool_item_set_tooltip_text(tool->m_item, wxGTK_CONV(tool->GetShortHelp())); } else #endif { 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(); 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 (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 gboolean init (void) { search_tool = aud_plugin_lookup_basename ("search-tool"); aud_config_set_defaults ("gtkui", gtkui_defaults); audgui_set_default_icon(); audgui_register_stock_icons(); pw_col_init (); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_has_resize_grip ((GtkWindow *) window, FALSE); g_signal_connect(G_OBJECT(window), "delete-event", G_CALLBACK(window_delete), NULL); accel = gtk_accel_group_new (); gtk_window_add_accel_group ((GtkWindow *) window, accel); vbox_outer = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0); gtk_container_add ((GtkContainer *) window, vbox_outer); menu_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_box_pack_start ((GtkBox *) vbox_outer, menu_box, FALSE, FALSE, 0); toolbar = gtk_toolbar_new (); gtk_toolbar_set_style ((GtkToolbar *) toolbar, GTK_TOOLBAR_ICONS); GtkStyleContext * context = gtk_widget_get_style_context (toolbar); gtk_style_context_add_class (context, GTK_STYLE_CLASS_PRIMARY_TOOLBAR); gtk_box_pack_start ((GtkBox *) vbox_outer, toolbar, FALSE, FALSE, 0); /* search button */ if (search_tool) { search_button = toggle_button_new (GTK_STOCK_FIND, NULL, toggle_search_tool); gtk_toolbar_insert ((GtkToolbar *) toolbar, search_button, -1); gtk_toggle_tool_button_set_active ((GtkToggleToolButton *) search_button, aud_plugin_get_enabled (search_tool)); aud_plugin_add_watch (search_tool, search_tool_toggled, NULL); } /* playback buttons */ toolbar_button_add (toolbar, button_open_pressed, GTK_STOCK_OPEN); toolbar_button_add (toolbar, button_add_pressed, GTK_STOCK_ADD); button_play = toolbar_button_add (toolbar, aud_drct_play_pause, GTK_STOCK_MEDIA_PLAY); button_stop = toolbar_button_add (toolbar, aud_drct_stop, GTK_STOCK_MEDIA_STOP); toolbar_button_add (toolbar, aud_drct_pl_prev, GTK_STOCK_MEDIA_PREVIOUS); toolbar_button_add (toolbar, aud_drct_pl_next, GTK_STOCK_MEDIA_NEXT); /* time slider and label */ GtkToolItem * boxitem1 = gtk_tool_item_new (); gtk_tool_item_set_expand (boxitem1, TRUE); gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem1, -1); GtkWidget * box1 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add ((GtkContainer *) boxitem1, box1); slider = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL); gtk_range_set_increments ((GtkRange *) slider, 5000, 5000); gtk_scale_set_draw_value(GTK_SCALE(slider), FALSE); gtk_widget_set_size_request(slider, 120, -1); gtk_widget_set_valign (slider, GTK_ALIGN_CENTER); gtk_widget_set_can_focus(slider, FALSE); gtk_box_pack_start ((GtkBox *) box1, slider, TRUE, TRUE, 6); label_time = markup_label_new(NULL); gtk_box_pack_end ((GtkBox *) box1, label_time, FALSE, FALSE, 6); gtk_widget_set_no_show_all (slider, TRUE); gtk_widget_set_no_show_all (label_time, TRUE); /* repeat and shuffle buttons */ button_repeat = toggle_button_new ("media-playlist-repeat", "RP", toggle_repeat); gtk_toolbar_insert ((GtkToolbar *) toolbar, button_repeat, -1); button_shuffle = toggle_button_new ("media-playlist-shuffle", "SF", toggle_shuffle); gtk_toolbar_insert ((GtkToolbar *) toolbar, button_shuffle, -1); /* volume button */ GtkToolItem * boxitem2 = gtk_tool_item_new (); gtk_toolbar_insert ((GtkToolbar *) toolbar, boxitem2, -1); GtkWidget * box2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0); gtk_container_add ((GtkContainer *) boxitem2, box2); volume = gtk_volume_button_new(); gtk_button_set_relief(GTK_BUTTON(volume), GTK_RELIEF_NONE); gtk_scale_button_set_adjustment(GTK_SCALE_BUTTON(volume), GTK_ADJUSTMENT(gtk_adjustment_new(0, 0, 100, 1, 5, 0))); gtk_widget_set_can_focus(volume, FALSE); gint lvol = 0, rvol = 0; aud_drct_get_volume(&lvol, &rvol); gtk_scale_button_set_value(GTK_SCALE_BUTTON(volume), (lvol + rvol) / 2); gtk_box_pack_start ((GtkBox *) box2, volume, FALSE, FALSE, 0); /* main UI layout */ layout_load (); GtkWidget * layout = layout_new (); gtk_box_pack_start ((GtkBox *) vbox_outer, layout, TRUE, TRUE, 0); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6); layout_add_center (vbox); ui_playlist_notebook_new (); gtk_box_pack_start ((GtkBox *) vbox, (GtkWidget *) UI_PLAYLIST_NOTEBOOK, TRUE, TRUE, 0); /* optional UI elements */ show_menu (aud_get_bool ("gtkui", "menu_visible")); show_infoarea (aud_get_bool ("gtkui", "infoarea_visible")); if (aud_get_bool ("gtkui", "statusbar_visible")) { statusbar = ui_statusbar_new (); gtk_box_pack_end ((GtkBox *) vbox_outer, statusbar, FALSE, FALSE, 0); } AUDDBG("hooks associate\n"); ui_hooks_associate(); AUDDBG("playlist associate\n"); ui_playlist_notebook_populate(); g_signal_connect(slider, "change-value", G_CALLBACK(ui_slider_change_value_cb), NULL); g_signal_connect(slider, "button-press-event", G_CALLBACK(ui_slider_button_press_cb), NULL); g_signal_connect(slider, "button-release-event", G_CALLBACK(ui_slider_button_release_cb), NULL); volume_change_handler_id = g_signal_connect(volume, "value-changed", G_CALLBACK(ui_volume_value_changed_cb), NULL); g_signal_connect(volume, "pressed", G_CALLBACK(ui_volume_pressed_cb), NULL); g_signal_connect(volume, "released", G_CALLBACK(ui_volume_released_cb), NULL); update_volume_timeout_source = g_timeout_add(250, (GSourceFunc) ui_volume_slider_update, volume); g_signal_connect (window, "map-event", (GCallback) window_mapped_cb, NULL); g_signal_connect (window, "key-press-event", (GCallback) window_keypress_cb, NULL); g_signal_connect (UI_PLAYLIST_NOTEBOOK, "key-press-event", (GCallback) playlist_keypress_cb, NULL); if (aud_drct_get_playing ()) { ui_playback_begin (); if (aud_drct_get_ready ()) ui_playback_ready (); } else ui_playback_stop (); title_change_cb (); gtk_widget_show_all (vbox_outer); update_toggles (NULL, NULL); menu_rclick = make_menu_rclick (accel); menu_tab = make_menu_tab (accel); return TRUE; }
Compose * compose_new(Config * config) { Compose * compose; GtkAccelGroup * group; GtkWidget * vbox; GtkWidget * toolbar; GtkToolItem * toolitem; GtkSizeGroup * sizegroup; GtkWidget * vpaned; GtkWidget * vbox2; GtkWidget * widget; GtkCellRenderer * renderer; GtkTreeViewColumn * column; GtkTreeIter iter; char const * headers[] = { "To:", "Cc:", "Bcc:", "Reply-To:", "Newsgroup:", "Followup-To:" }; size_t i; if((compose = malloc(sizeof(*compose))) == NULL) { compose_error(NULL, strerror(errno), 0); return NULL; } compose->mime = mime_new(NULL); /* check errors */ if(compose->mime == NULL) { free(compose); return NULL; } compose->config = config; compose->standalone = FALSE; /* window */ group = gtk_accel_group_new(); compose->window = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_add_accel_group(GTK_WINDOW(compose->window), group); #ifndef EMBEDDED gtk_window_set_default_size(GTK_WINDOW(compose->window), 512, 384); #else gtk_window_set_default_size(GTK_WINDOW(compose->window), 200, 300); #endif gtk_window_set_title(GTK_WINDOW(compose->window), _("Compose")); #if GTK_CHECK_VERSION(2, 6, 0) gtk_window_set_icon_name(GTK_WINDOW(compose->window), "mailer"); #endif g_signal_connect_swapped(G_OBJECT(compose->window), "delete-event", G_CALLBACK(_compose_on_closex), compose); vbox = gtk_vbox_new(FALSE, 0); /* menubar */ #ifndef EMBEDDED widget = desktop_menubar_create(_compose_menubar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0); #endif /* toolbar */ toolbar = desktop_toolbar_create(_compose_toolbar, compose, group); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, TRUE, 0); /* from */ sizegroup = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL); toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("From: ")); gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); gtk_widget_set_size_request(widget, 80, -1); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); #if GTK_CHECK_VERSION(2, 24, 0) compose->from = gtk_combo_box_text_new_with_entry(); #else compose->from = gtk_combo_box_entry_new_text(); #endif toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->from); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); /* paned */ vpaned = gtk_vpaned_new(); /* headers */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->h_store = gtk_list_store_new(CHC_COUNT, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN); compose->h_store_filter = gtk_tree_model_filter_new(GTK_TREE_MODEL( compose->h_store), NULL); gtk_tree_model_filter_set_visible_func(GTK_TREE_MODEL_FILTER( compose->h_store_filter), _compose_on_headers_filter, compose, NULL); compose->h_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL( compose->h_store_filter)); gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(compose->h_view), FALSE); gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(compose->h_view), TRUE); compose->h_headers = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING); for(i = 0; i < sizeof(headers) / sizeof(*headers); i++) { gtk_list_store_append(compose->h_headers, &iter); gtk_list_store_set(compose->h_headers, &iter, 0, headers[i], 1, headers[i], -1); } renderer = gtk_cell_renderer_combo_new(); g_object_set(renderer, "editable", TRUE, "model", compose->h_headers, "text-column", 1, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_field_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_HEADER, NULL); gtk_tree_view_column_set_min_width(column, 80); gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); renderer = gtk_cell_renderer_text_new(); g_object_set(G_OBJECT(renderer), "editable", TRUE, NULL); g_signal_connect(G_OBJECT(renderer), "edited", G_CALLBACK( _on_header_edited), compose); column = gtk_tree_view_column_new_with_attributes("", renderer, "text", CHC_VALUE, NULL); #if GTK_CHECK_VERSION(2, 4, 0) gtk_tree_view_column_set_expand(column, TRUE); #endif gtk_tree_view_append_column(GTK_TREE_VIEW(compose->h_view), column); /* default to 8-bits transfers with UTF-8 encoding */ compose_set_header(compose, "Content-Transfer-Encoding:", "8bit", FALSE); compose_set_header(compose, "Content-Type:", "text/plain; charset=UTF-8", FALSE); compose_add_field(compose, "To:", NULL); gtk_container_add(GTK_CONTAINER(widget), compose->h_view); gtk_paned_add1(GTK_PANED(vpaned), widget); /* paned */ vbox2 = gtk_vbox_new(FALSE, 0); /* subject */ toolbar = gtk_toolbar_new(); widget = gtk_label_new(_("Subject: ")); gtk_misc_set_alignment(GTK_MISC(widget), 0.1, 0.5); gtk_size_group_add_widget(sizegroup, widget); toolitem = gtk_tool_item_new(); gtk_container_add(GTK_CONTAINER(toolitem), widget); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); compose->subject = gtk_entry_new(); toolitem = gtk_tool_item_new(); gtk_tool_item_set_expand(toolitem, TRUE); gtk_container_add(GTK_CONTAINER(toolitem), compose->subject); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), toolitem, -1); gtk_box_pack_start(GTK_BOX(vbox2), toolbar, FALSE, TRUE, 0); /* view */ widget = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(widget), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); compose->view = _new_text_view(compose); compose_set_font(compose, _compose_get_font(compose)); gtk_container_add(GTK_CONTAINER(widget), compose->view); gtk_box_pack_start(GTK_BOX(vbox2), widget, TRUE, TRUE, 0); gtk_paned_add2(GTK_PANED(vpaned), vbox2); gtk_box_pack_start(GTK_BOX(vbox), vpaned, TRUE, TRUE, 0); /* attachments */ compose->a_window = gtk_scrolled_window_new(NULL, NULL); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(compose->a_window), GTK_POLICY_AUTOMATIC, GTK_POLICY_NEVER); compose->a_store = gtk_list_store_new(CAC_COUNT, G_TYPE_STRING, G_TYPE_STRING, GDK_TYPE_PIXBUF); compose->a_view = gtk_icon_view_new_with_model(GTK_TREE_MODEL( compose->a_store)); gtk_icon_view_set_pixbuf_column(GTK_ICON_VIEW(compose->a_view), CAC_ICON); gtk_icon_view_set_selection_mode(GTK_ICON_VIEW(compose->a_view), GTK_SELECTION_MULTIPLE); gtk_icon_view_set_text_column(GTK_ICON_VIEW(compose->a_view), CAC_BASENAME); gtk_container_add(GTK_CONTAINER(compose->a_window), compose->a_view); gtk_widget_show_all(compose->a_view); gtk_widget_set_no_show_all(compose->a_window, TRUE); gtk_box_pack_start(GTK_BOX(vbox), compose->a_window, FALSE, TRUE, 0); /* statusbar */ compose->statusbar = gtk_statusbar_new(); compose->statusbar_id = 0; gtk_box_pack_start(GTK_BOX(vbox), compose->statusbar, FALSE, TRUE, 0); gtk_container_add(GTK_CONTAINER(compose->window), vbox); /* about dialog */ compose->ab_window = NULL; /* signature */ compose_append_signature(compose); compose_set_modified(compose, FALSE); compose_scroll_to_offset(compose, 0); /* display */ gtk_widget_grab_focus(compose->view); gtk_widget_show_all(vbox); gtk_widget_show(compose->window); return compose; }
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); }