static GtkWidget * create_toolbar (void) { GtkWidget *toolbar; GtkToolItem *item; toolbar = gtk_toolbar_new (); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-new", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "Open another one of these windows"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.new"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "This is a demo button that locks up the demo"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.lock"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "This is a demo button that toggles window decorations"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.decorations"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("document-open", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "This is a demo button that locks the aspect ratio using a hint"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.ratio"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); item = gtk_tool_button_new (gtk_image_new_from_icon_name ("gtk-quit", GTK_ICON_SIZE_SMALL_TOOLBAR), NULL); gtk_tool_item_set_tooltip_markup (item, "This is a demo button with a 'quit' icon"); gtk_actionable_set_action_name (GTK_ACTIONABLE (item), "demo.quit"); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), item, -1); return toolbar; }
static VALUE rg_initialize(int argc, VALUE *argv, VALUE self) { VALUE arg; GtkToolItem *item = NULL; rb_scan_args(argc, argv, "01", &arg); if (NIL_P(arg)) { item = gtk_tool_button_new(NULL, NULL); } else if (TYPE(arg) == T_HASH) { VALUE icon_widget, label, stock_id, buffer; rbg_scan_options(arg, "icon_widget", &icon_widget, "label", &label, "stock_id", &stock_id, NULL); if (!NIL_P(icon_widget)) item = gtk_tool_button_new(RVAL2GTKWIDGET(icon_widget), RVAL2CSTR_ACCEPT_NIL(label)); else if (!NIL_P(stock_id)) item = gtk_tool_button_new_from_stock(RVAL2GLIBID(stock_id, buffer)); } if (!item) rb_raise(rb_eArgError, "Invalid arguments."); RBGTK_INITIALIZE(self, item); return Qnil; }
/* desktop_toolbar_create */ GtkWidget * desktop_toolbar_create(DesktopToolbar * toolbar, gpointer data, GtkAccelGroup * accel) { GtkWidget * ret; size_t i; DesktopToolbar * p; GtkWidget * widget; ret = gtk_toolbar_new(); for(i = 0; toolbar[i].name != NULL; i++) { p = &toolbar[i]; if(p->name[0] == '\0') { p->widget = gtk_separator_tool_item_new(); gtk_toolbar_insert(GTK_TOOLBAR(ret), p->widget, -1); continue; } #if !GTK_CHECK_VERSION(3, 10, 0) else if(strncmp(p->stock, "gtk-", 4) == 0) /* stock icon */ p->widget = gtk_tool_button_new_from_stock(p->stock); #endif else if(p->stock != NULL) /* icon name */ { widget = gtk_image_new_from_icon_name(p->stock, GTK_ICON_SIZE_LARGE_TOOLBAR); p->widget = gtk_tool_button_new(widget, p->name); } else p->widget = gtk_tool_button_new(NULL, _(p->name)); if(p->callback != NULL) g_signal_connect_swapped(G_OBJECT(p->widget), "clicked", G_CALLBACK(p->callback), data); else gtk_widget_set_sensitive(GTK_WIDGET(p->widget), FALSE); if(accel != NULL && p->accel != 0) gtk_widget_add_accelerator(GTK_WIDGET(p->widget), "clicked", accel, p->accel, p->modifier, GTK_ACCEL_VISIBLE); #if 0 /* GTK_CHECK_VERSION(2, 12, 0) */ /* XXX the default is returned instead of the configuration */ if(gtk_toolbar_get_style(GTK_TOOLBAR(ret)) == GTK_TOOLBAR_ICONS) gtk_tool_item_set_tooltip_text(p->widget, p->name); #endif gtk_toolbar_insert(GTK_TOOLBAR(ret), p->widget, -1); } return ret; }
void widgets_get_bottom_toolbar(GtkWidget **toolbar){ GtkToolItem *new_tool_item; GtkWidget *new_tool_item_icon; *toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(*toolbar), GTK_TOOLBAR_ICONS); int i; int nicons = sizeof toolbar_item_icons / sizeof (*toolbar_item_icons); for (i = 0; i < nicons; i++){ new_tool_item_icon = gtk_image_new_from_file(toolbar_item_icons[i].path_to_image); new_tool_item = gtk_tool_button_new(new_tool_item_icon,toolbar_item_icons[i].name); FormShifterToolItemType tool_type = toolbar_item_icons[i].type; switch(tool_type){ /*case XPainter_UNDO_TOOL: g_signal_connect(new_tool_item, "clicked", G_CALLBACK(undo), NULL); break; case XPainter_REDO_TOOL: g_signal_connect(new_tool_item, "clicked", G_CALLBACK(redo), NULL); break;*/ default: g_signal_connect(new_tool_item, "clicked", G_CALLBACK(assign_current_tool), (gpointer) tool_type); break; } gtk_toolbar_insert(GTK_TOOLBAR(*toolbar), new_tool_item, -1); gtk_widget_set_can_focus ((GtkWidget*) new_tool_item, TRUE); } }
static void tm_populate(GtkWidget * toolbar, BalsaToolbarModel * model) { gboolean style_is_both; gboolean make_two_line; GArray *current; guint j; GActionMap *action_map = g_object_get_data(G_OBJECT(toolbar), BALSA_TOOLBAR_ACTION_MAP); style_is_both = (model->style == GTK_TOOLBAR_BOTH || (model->style == (GtkToolbarStyle) - 1 && tm_default_style() == GTK_TOOLBAR_BOTH)); make_two_line = style_is_both && tm_has_second_line(model); current = balsa_toolbar_model_get_current(model); for (j = 0; j < current->len; j++) { BalsaToolbarEntry *entry; GtkToolItem *item; entry = &g_array_index(current, BalsaToolbarEntry, j); if (!*entry->action) { item = gtk_separator_tool_item_new(); } else { GtkWidget *icon; GAction *action; const GVariantType *type; gchar *prefixed_action; icon = gtk_image_new_from_icon_name (balsa_icon_id(entry->icon), GTK_ICON_SIZE_SMALL_TOOLBAR); action = g_action_map_lookup_action(action_map, entry->action); if (action && (type = g_action_get_state_type(action)) && g_variant_type_equal(type, G_VARIANT_TYPE_BOOLEAN)) { item = gtk_toggle_tool_button_new(); g_object_set(G_OBJECT(item), "icon-widget", icon, "label", entry->action, NULL); } else { item = gtk_tool_button_new(icon, entry->action); } tm_set_tool_item_label(GTK_TOOL_ITEM(item), entry->icon, make_two_line); prefixed_action = g_strconcat(action ? "win." : "app.", entry->action, NULL); gtk_actionable_set_action_name(GTK_ACTIONABLE(item), prefixed_action); g_free(prefixed_action); } gtk_toolbar_insert((GtkToolbar *) toolbar, item, -1); } gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), model->style != (GtkToolbarStyle) (-1) ? model->style : tm_default_style()); gtk_widget_show_all(toolbar); }
int main (int argc, char *argv[]) { GtkWidget *window; GtkToolbar *toolbar; GtkToolItem *item; gtk_init (&argc, &argv); window = gtk_window_new (GTK_WINDOW_TOPLEVEL); g_signal_connect (window, "delete-event", G_CALLBACK (on_window_delete), NULL); toolbar = GTK_TOOLBAR (gtk_toolbar_new ()); gtk_toolbar_set_style (toolbar, GTK_TOOLBAR_TEXT); item = gtk_tool_button_new (NULL, "Prompt"); g_signal_connect (item, "clicked", G_CALLBACK (on_prompt_clicked), window); gtk_toolbar_insert (toolbar, item, 0); gtk_container_add (GTK_CONTAINER (window), GTK_WIDGET (toolbar)); gtk_window_set_default_size (GTK_WINDOW (window), 400, 80); gtk_widget_show_all (window); gtk_main (); return 0; }
GtkToolItem * ToolButton::newItem() { XOJ_CHECK_TYPE(ToolButton); GtkToolItem * it; if (!stock.isEmpty()) { if (popupMenu) { it = gtk_menu_tool_button_new_from_stock(stock.c_str()); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu); } else { it = gtk_tool_button_new_from_stock(stock.c_str()); } } else if (group != GROUP_NOGROUP) { if (popupMenu) { it = gtk_menu_tool_toggle_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); gtk_menu_tool_toggle_button_set_menu(GTK_MENU_TOOL_TOGGLE_BUTTON(it), popupMenu); } else { it = gtk_toggle_tool_button_new(); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(it), this->gui->loadIcon(iconName.c_str())); } } else { if (popupMenu) { it = gtk_menu_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(it), popupMenu); } else { it = gtk_tool_button_new(this->gui->loadIcon(iconName.c_str()), description.c_str()); } } gtk_tool_item_set_tooltip_text(GTK_TOOL_ITEM(it), description.c_str()); gtk_tool_button_set_label(GTK_TOOL_BUTTON(it), description.c_str()); return it; }
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; }
static void schema_browser_perspective_customize (BrowserPerspective *perspective, GtkToolbar *toolbar, GtkHeaderBar *header) { g_print ("%s ()\n", __FUNCTION__); customization_data_init (G_OBJECT (perspective), toolbar, header); /* add perspective's actions */ customization_data_add_actions (G_OBJECT (perspective), win_entries, G_N_ELEMENTS (win_entries)); /* add to toolbar */ GtkToolItem *titem; titem = gtk_toggle_tool_button_new (); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "user-bookmarks-symbolic"); gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Show favorites")); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1); gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.show-favorites"); gtk_widget_show (GTK_WIDGET (titem)); customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem)); #ifdef HAVE_GOOCANVAS titem = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "tab-new-symbolic"); gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Create a new diagram")); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1); gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.action-diagram-new"); gtk_widget_show (GTK_WIDGET (titem)); customization_data_add_part (G_OBJECT (perspective), G_OBJECT (titem)); #endif }
static int filter_button_add(const char *label, const char *expr, struct filter_expression *newfe) { struct filter_expression *fe; /* No duplicate buttons when adding a new one */ if (newfe == NULL) fe = filter_expression_new(label, expr, TRUE); else fe = newfe; if (fe->enabled == FALSE) return(0); /* Create the "Label" button */ fe->button = gtk_tool_button_new(NULL, fe->label); g_signal_connect(fe->button, "clicked", G_CALLBACK(filter_button_cb), NULL); gtk_widget_set_sensitive(GTK_WIDGET(fe->button), FALSE); gtk_widget_show(GTK_WIDGET(fe->button)); gtk_toolbar_insert(GTK_TOOLBAR(_filter_tb), (GtkToolItem *)fe->button, -1); gtk_widget_set_sensitive(GTK_WIDGET(fe->button), TRUE); gtk_widget_set_tooltip_text(GTK_WIDGET(fe->button), fe->expression); return(0); }
static GtkToolItem * toolbar_button_add (GtkWidget * toolbar, void (* callback) (void), const char * icon) { GtkToolItem * item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name ((GtkToolButton *) item, icon); gtk_toolbar_insert ((GtkToolbar *) toolbar, item, -1); g_signal_connect (item, "clicked", callback, NULL); return item; }
static void load_icon_items (GtkToolPalette *palette) { GList *contexts; GList *l; GtkIconTheme *icon_theme; icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (palette))); contexts = gtk_icon_theme_list_contexts (icon_theme); for (l = contexts; l; l = g_list_next (l)) { gchar *context = l->data; GList *icon_names; GList *ll; const guint max_icons = 10; guint icons_count = 0; GtkWidget *group = gtk_tool_item_group_new (context); gtk_container_add (GTK_CONTAINER (palette), group); if (g_strcmp0 (context, "Animations") == 0) continue; g_message ("Got context '%s'", context); icon_names = gtk_icon_theme_list_icons (icon_theme, context); icon_names = g_list_sort (icon_names, (GCompareFunc) strcmp); for (ll = icon_names; ll; ll = g_list_next (ll)) { GtkToolItem *item; gchar *id = ll->data; if (g_str_equal (id, "emblem-desktop")) continue; if (g_str_has_suffix (id, "-symbolic")) continue; g_message ("Got id '%s'", id); item = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), id); gtk_tool_item_set_tooltip_text (GTK_TOOL_ITEM (item), id); gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1); /* Prevent us having an insane number of icons: */ ++icons_count; if(icons_count >= max_icons) break; } g_list_free_full (icon_names, g_free); } g_list_free_full (contexts, g_free); }
static void tab_panel_browser_add_tab_cb (MidoriBrowser* browser, GtkWidget* view, MidoriExtension* extension) { GtkWidget* notebook = katze_object_get_object (browser, "notebook"); gint page = gtk_notebook_page_num (GTK_NOTEBOOK (notebook), view); MidoriWebSettings* settings = midori_browser_get_settings (browser); gboolean minimized = katze_object_get_boolean (view, "minimized"); GdkPixbuf* icon = midori_view_get_icon (MIDORI_VIEW (view)); const gchar* title = midori_view_get_display_title (MIDORI_VIEW (view)); GtkTreeModel* model = tab_panel_get_model_for_browser (browser); if (minimized) { GtkWidget* toolbar = tab_panel_get_toolbar_for_browser (browser); GtkWidget* image = gtk_image_new_from_pixbuf ( midori_view_get_icon (MIDORI_VIEW (view))); GtkToolItem* toolitem = gtk_tool_button_new (image, NULL); gtk_tool_item_set_tooltip_text (toolitem, title); gtk_widget_show (image); g_object_set_data (G_OBJECT (view), "tab-panel-ext-toolitem", toolitem); gtk_widget_show (GTK_WIDGET (toolitem)); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), toolitem, -1); tab_panel_toggle_toolbook (toolbar); g_signal_connect (toolitem, "clicked", G_CALLBACK (tab_panel_toolitem_clicked_cb), view); g_signal_connect (gtk_bin_get_child (GTK_BIN (toolitem)), "button-press-event", G_CALLBACK (tab_panel_toolitem_button_press_event_cb), view); } else { GtkTreeIter iter; gboolean buttons = katze_object_get_boolean (settings, "close-buttons-on-tabs"); gint ellipsize = midori_view_get_label_ellipsize (MIDORI_VIEW (view)); gtk_tree_store_insert_with_values (GTK_TREE_STORE (model), &iter, NULL, page, 0, view, 1, GTK_STOCK_CLOSE, 2, buttons, 3, icon, 4, title, 5, ellipsize, 6, NULL, -1); } if (!g_signal_handler_find (view, G_SIGNAL_MATCH_FUNC, g_signal_lookup ("notify", MIDORI_TYPE_VIEW), 0, NULL, tab_panel_view_notify_minimized_cb, extension)) { g_signal_connect (settings, "notify::close-buttons-on-tabs", G_CALLBACK (tab_panel_settings_notify_cb), model); g_signal_connect (view, "notify::minimized", G_CALLBACK (tab_panel_view_notify_minimized_cb), extension); g_signal_connect (view, "notify::icon", G_CALLBACK (tab_panel_view_notify_icon_cb), extension); g_signal_connect (view, "notify::title", G_CALLBACK (tab_panel_view_notify_title_cb), extension); } g_object_unref (notebook); }
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); }
gboolean download_handle(WebKitDownload *download, gchar *suggested_filename, gpointer data) { gchar *sug_clean, *path, *path2 = NULL, *uri; GtkToolItem *tb; int suffix = 1; size_t i; sug_clean = g_strdup(suggested_filename); for (i = 0; i < strlen(sug_clean); i++) if (sug_clean[i] == G_DIR_SEPARATOR) sug_clean[i] = '_'; path = g_build_filename(download_dir, sug_clean, NULL); path2 = g_strdup(path); while (g_file_test(path2, G_FILE_TEST_EXISTS) && suffix < 1000) { g_free(path2); path2 = g_strdup_printf("%s.%d", path, suffix); suffix++; } if (suffix == 1000) { fprintf(stderr, __NAME__": Suffix reached limit for download.\n"); webkit_download_cancel(download); } else { uri = g_filename_to_uri(path2, NULL, NULL); webkit_download_set_destination(download, uri); g_free(uri); tb = gtk_tool_button_new(NULL, NULL); gtk_tool_button_set_icon_name(GTK_TOOL_BUTTON(tb), "gtk-delete"); gtk_tool_button_set_label(GTK_TOOL_BUTTON(tb), sug_clean); gtk_toolbar_insert(GTK_TOOLBAR(dm.toolbar), tb, 0); gtk_widget_show_all(dm.win); g_signal_connect(G_OBJECT(download), "notify::estimated-progress", G_CALLBACK(changed_download_progress), tb); g_object_ref(download); g_signal_connect(G_OBJECT(tb), "clicked", G_CALLBACK(downloadmanager_cancel), download); } g_free(sug_clean); g_free(path); g_free(path2); /* Propagate -- to whom it may concern. */ return FALSE; }
/* Checks the passed xmlNode for a recognized item (ToolButton, ToggleToolButton, Separator) * Returns the widget or NULL if nothing useful is found */ GtkWidget* ToolbarCreator::createToolItem(xml::Node& node, GtkToolbar* toolbar) { const std::string nodeName = node.getName(); GtkWidget* toolItem; if (nodeName == "separator") { toolItem = GTK_WIDGET(gtk_separator_tool_item_new()); } else if (nodeName == "toolbutton" || nodeName == "toggletoolbutton") { // Found a button, load the values that are shared by both types const std::string name = node.getAttributeValue("name"); const std::string icon = node.getAttributeValue("icon"); const std::string tooltip = _(node.getAttributeValue("tooltip").c_str()); const std::string action = node.getAttributeValue("action"); if (nodeName == "toolbutton") { // Create a new GtkToolButton and assign the right callback toolItem = GTK_WIDGET(gtk_tool_button_new(NULL, name.c_str())); } else { // Create a new GtkToggleToolButton and assign the right callback toolItem = GTK_WIDGET(gtk_toggle_tool_button_new()); } IEvent* event = GlobalEventManager().findEvent(action); if (event != NULL) { event->connectWidget(GTK_WIDGET(toolItem)); // Tell the event to update the state of this button event->updateWidgets(); } else { globalErrorStream() << "ToolbarCreator: Failed to lookup command " << action << "\n"; } // Set the tooltip, if not empty if (!tooltip.empty()) { gtk_tooltips_set_tip(_tooltips, GTK_WIDGET(toolItem), tooltip.c_str(), ""); //gtk_tool_item_set_tooltip(GTK_TOOL_ITEM(toolItem), _tooltips, tooltip.c_str(), ""); } // Load and assign the icon, if specified if (icon != "") { GtkWidget* image = gtk_image_new_from_pixbuf(gtkutil::getLocalPixbufWithMask(icon)); gtk_widget_show(image); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(toolItem), image); } } else { return NULL; } gtk_widget_show(toolItem); return toolItem; }
GTKToolButton::GTKToolButton(const char *Text, bool Stock) : GTKToolItem(), Icon(NULL) { g_object_unref(Widget); if (Stock) ToolItem = gtk_tool_button_new_from_stock(Text); else ToolItem = gtk_tool_button_new(NULL, Text); Widget = GTK_WIDGET(ToolItem); Container = GTK_CONTAINER(Widget); ToolButton = GTK_TOOL_BUTTON(ToolItem); }
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)); }
GtkToolItem* makeNewToolItem(const char* stock,const char* label) { GtkToolItem* button; GtkWidget* image; #ifdef _USEGTK3_ image=gtk_image_new_from_icon_name(stock,GTK_ICON_SIZE_LARGE_TOOLBAR); button=gtk_tool_button_new(image,label); #else button=gtk_tool_button_new_from_stock(stock); #endif return(button); }
/** * called when hovering an item above the toolbar */ gboolean nsgtk_toolbar_action(GtkWidget *widget, GdkDragContext *gdc, gint x, gint y, guint time, gpointer data) { nsgtk_scaffolding *g = (nsgtk_scaffolding *)data; GtkToolItem *item = gtk_tool_button_new(NULL, NULL); if (item != NULL) gtk_toolbar_set_drop_highlight_item( nsgtk_scaffolding_toolbar(g), GTK_TOOL_ITEM(item), gtk_toolbar_get_drop_index( nsgtk_scaffolding_toolbar(g), x, y)); return FALSE; }
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; }
GtkToolItem *hwidget_get_tool_button(const gchar *image_file, const gchar *label, const gchar *tooltips_string, gpointer callback, gpointer data, guint type) { GtkToolItem *button; GtkWidget *pixmap; GtkTooltips *tooltips; switch (type) { case HWIDGET_TOGGLE_TOOL_BUTTON: button = gtk_toggle_tool_button_new(); if (callback) { g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(callback), data); } break; case HWIDGET_TOOL_BUTTON: button = gtk_tool_button_new(NULL, NULL); if (callback) { g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(callback), data); } break; default: return NULL; } if (image_file) { pixmap = hutil_create_pixmap(image_file); gtk_tool_button_set_icon_widget(GTK_TOOL_BUTTON(button), pixmap); } if (label) { gtk_tool_button_set_label(GTK_TOOL_BUTTON(button), label); } if (tooltips_string) { tooltips = gtk_tooltips_new(); gtk_tool_item_set_tooltip(button, tooltips, tooltips_string, NULL); } return button; }
SelectionSetToolmenu::SelectionSetToolmenu() : _toolItem(gtk_tool_item_new()), _listStore(gtk_list_store_new(1, G_TYPE_STRING)), _clearSetsButton(NULL), _entry(gtk_combo_box_entry_new_with_model(GTK_TREE_MODEL(_listStore), 0)) { // Hbox containing all our items GtkWidget* hbox = gtk_hbox_new(FALSE, 3); gtk_container_add(GTK_CONTAINER(_toolItem), hbox); // Pack Label gtk_box_pack_start(GTK_BOX(hbox), gtkutil::LeftAlignedLabel(_("Selection Set: ")), FALSE, FALSE, 0); // Pack Combo Box gtk_box_pack_start(GTK_BOX(hbox), _entry, TRUE, TRUE, 0); // Add tooltip gtk_widget_set_tooltip_markup(_entry, _(ENTRY_TOOLTIP)); // Add clear button { GtkWidget* image = gtk_image_new_from_pixbuf(GlobalUIManager().getLocalPixbufWithMask("delete.png")); gtk_widget_show(image); _clearSetsButton = gtk_tool_button_new(image, _("Clear Selection Sets")); // Set tooltip gtk_tool_item_set_tooltip_text(_clearSetsButton, _("Clear Selection Sets")); // Connect event g_signal_connect(G_OBJECT(_clearSetsButton), "clicked", G_CALLBACK(onDeleteAllSetsClicked), this); gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(_clearSetsButton), FALSE, FALSE, 0); } // Connect the signals GtkWidget* childEntry = gtk_bin_get_child(GTK_BIN(_entry)); g_signal_connect(G_OBJECT(childEntry), "activate", G_CALLBACK(onEntryActivated), this); g_signal_connect(G_OBJECT(_entry), "changed", G_CALLBACK(onSelectionChanged), this); // Populate the list update(); // Add self as observer GlobalSelectionSetManager().addObserver(*this); }
/*# @class GtkToolButton @brief A GtkToolItem subclass that displays buttons @param icon_widget a GtkMisc widget that will be used as icon widget, or NULL. @param label a string that will be used as label, or NULL. GtkToolButtons are GtkToolItems containing buttons. The label of a GtkToolButton is determined by the properties "label-widget", "label", and "stock-id". If "label-widget" is non-NULL, then that widget is used as the label. Otherwise, if "label" is non-NULL, that string is used as the label. Otherwise, if "stock-id" is non-NULL, the label is determined by the stock item. Otherwise, the button does not have a label. The icon of a GtkToolButton is determined by the properties "icon-widget" and "stock-id". If "icon-widget" is non-NULL, then that widget is used as the icon. Otherwise, if "stock-id" is non-NULL, the icon is determined by the stock item. Otherwise, the button does not have a icon. */ FALCON_FUNC ToolButton::init( VMARG ) { MYSELF; if ( self->getObject() ) return; const char* spec = "[GtkWidget,S]"; Gtk::ArgCheck1 args( vm, spec ); CoreGObject* o_ico = args.getCoreGObject( 0, false ); const gchar* lbl = args.getCString( 1, false ); #ifndef NO_PARAMETER_CHECK if ( o_ico && !CoreObject_IS_DERIVED( o_ico, GtkWidget ) ) throw_inv_params( spec ); #endif GtkWidget* ico = o_ico ? (GtkWidget*) o_ico->getObject() : NULL; self->setObject( (GObject*) gtk_tool_button_new( ico, lbl ) ); }
static void add_toolbutton (GtkToolbar *toolbar) { GtkWidget* button; char *text; text = g_strdup_printf ("Remove %d", ++count); button = (GtkWidget *)gtk_tool_button_new (NULL, text); g_free (text); gtk_style_context_add_class (gtk_widget_get_style_context (button), "play"); g_signal_connect_swapped (button, "clicked", G_CALLBACK (remove_widget), button); gtk_widget_show (button); gtk_container_add (GTK_CONTAINER (toolbar), button); }
/** * Création d'un GtkToolButton à partir d'une image et d'un label * * \param image_name filename * \param label_name label for button * * \return a GtkToolItem or NULL * */ GtkToolItem *utils_buttons_new_from_image_label ( const gchar *image_name, const gchar *label_name ) { GtkToolItem *button = NULL; gchar *filename; filename = g_build_filename ( gsb_dirs_get_pixmaps_dir (), image_name, NULL ); if ( filename ) { GtkWidget *image; image = gtk_image_new_from_file ( filename ); g_free ( filename ); button = gtk_tool_button_new ( image, label_name ); } return button; }
static void collecturiCallback(BrowserWindow *window, GtkEntryIconPosition iconPosition, GdkEvent *event) { if (iconPosition == GTK_ENTRY_ICON_SECONDARY) { g_print("add bookmarkbutton\n"); /* GtkWidget *bookmarkbtn = gtk_button_new(); GtkBox *hBox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));` GtkWidget *image = gtk_image_new_from_pixbuf(window->favicon); GtkWidget *lab = gtk_label_new(webkit_web_view_get_title(window->webView)); gtk_box_pack_start(hBox, image, FALSE, FALSE, 0); gtk_box_pack_start(hBox, lab, FALSE, FALSE, 0); gtk_container_add(GTK_CONTAINER(bookmarkbtn), hBox); gtk_box_pack_start(window->bookmarkbox, bookmarkbtn, FALSE, FALSE, 0); gtk_widget_show_all(bookmarkbtn); */ GtkToolItem *item = gtk_tool_button_new(NULL, ""); GtkWidget *image = gtk_image_new_from_pixbuf(window->favicon); cairo_surface_t* fivacon = webkit_web_view_get_favicon(window->webView); gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), fivacon); GtkWidget* label = gtk_label_new (webkit_web_view_get_title(window->webView)); gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5); gtk_label_set_max_width_chars (GTK_LABEL (label), 25); gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE); gtk_widget_show (label); gtk_tool_button_set_label_widget (GTK_TOOL_BUTTON (item), label); // g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window); gtk_toolbar_insert(GTK_TOOLBAR(window->bookmarkbar), item, -1); gtk_widget_show_all(GTK_WIDGET(item)); /* GtkToolItem *item = gtk_tool_button_new_from_stock(GTK_STOCK_HOME); // g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window); gtk_toolbar_insert(GTK_TOOLBAR(window->bookmarkbar), item, -1); gtk_widget_show(GTK_WIDGET(item)); */ // GdkEventButton *eventButton = (GdkEventButton *)event; //todo 弹出对话框 } }
static VALUE rg_initialize(int argc, VALUE *argv, VALUE self) { VALUE obj, label; GtkToolItem* item; rb_scan_args(argc, argv, "02", &obj, &label); if (TYPE(obj) == T_SYMBOL){ item = gtk_tool_button_new_from_stock(rb_id2name(SYM2ID(obj))); } else if (TYPE(obj) == T_STRING){ item = gtk_tool_button_new_from_stock(RVAL2CSTR(obj)); } else { item = gtk_tool_button_new(GTK_WIDGET(RVAL2GOBJ(obj)), NIL_P(label) ? NULL : RVAL2CSTR(label)); } RBGTK_INITIALIZE(self, item); return Qnil; }
static void relations_diagram_customize (BrowserPage *page, GtkToolbar *toolbar, GtkHeaderBar *header) { g_print ("%s ()\n", __FUNCTION__); customization_data_init (G_OBJECT (page), toolbar, header); /* add perspective's actions */ customization_data_add_actions (G_OBJECT (page), win_entries, G_N_ELEMENTS (win_entries)); /* add to toolbar */ GtkToolItem *titem; titem = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "go-jump-symbolic"); gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Manage data in selected tables")); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1); gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.ViewContents"); gtk_widget_show (GTK_WIDGET (titem)); customization_data_add_part (G_OBJECT (page), G_OBJECT (titem)); }
static void query_console_customize (BrowserPage *page, GtkToolbar *toolbar, GtkHeaderBar *header) { g_print ("%s ()\n", __FUNCTION__); customization_data_init (G_OBJECT (page), toolbar, header); /* add perspective's actions */ customization_data_add_actions (G_OBJECT (page), win_entries, G_N_ELEMENTS (win_entries)); /* add to toolbar */ GtkToolItem *titem; titem = gtk_tool_button_new (NULL, NULL); gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (titem), "system-run-symbolic"); gtk_widget_set_tooltip_text (GTK_WIDGET (titem), _("Execute query")); gtk_toolbar_insert (GTK_TOOLBAR (toolbar), titem, -1); gtk_actionable_set_action_name (GTK_ACTIONABLE (titem), "win.ExecuteQuery"); gtk_widget_show (GTK_WIDGET (titem)); customization_data_add_part (G_OBJECT (page), G_OBJECT (titem)); }