int main(int argc, char *argv[]) { DHCPCD_CONNECTION *con; setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, NULL); bind_textdomain_codeset(PACKAGE, "UTF-8"); textdomain(PACKAGE); gtk_init(&argc, &argv); g_set_application_name("Network Configurator"); gtk_icon_theme_append_search_path(gtk_icon_theme_get_default(), ICONDIR); status_icon = gtk_status_icon_new_from_icon_name("network-offline"); gtk_status_icon_set_tooltip_text(status_icon, _("Connecting to dhcpcd ...")); gtk_status_icon_set_visible(status_icon, true); online = false; #ifdef NOTIFY notify_init(PACKAGE); #endif g_message(_("Connecting ...")); con = dhcpcd_new(); if (con == NULL) { g_critical("libdhcpcd: %s", strerror(errno)); exit(EXIT_FAILURE); } dhcpcd_set_progname(con, "dhcpcd-gtk"); dhcpcd_set_status_callback(con, dhcpcd_status_cb, NULL); dhcpcd_set_if_callback(con, dhcpcd_if_cb, NULL); dhcpcd_wpa_set_scan_callback(con, dhcpcd_wpa_scan_cb, NULL); //dhcpcd_wpa_set_status_callback(con, dhcpcd_wpa_status_cb, NULL); if (dhcpcd_try_open(con)) g_timeout_add(DHCPCD_RETRYOPEN, dhcpcd_try_open, con); menu_init(status_icon, con); gtk_main(); dhcpcd_close(con); dhcpcd_free(con); return 0; }
GtkWidget * xfce_mailwatch_custom_button_new(const gchar *text, const gchar *icon) { GtkWidget *btn, *hbox, *img, *lbl; GdkPixbuf *pix; gint iw, ih; g_return_val_if_fail((text && *text) || icon, NULL); btn = gtk_button_new(); hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4); gtk_container_set_border_width(GTK_CONTAINER(hbox), 0); gtk_widget_show(hbox); gtk_container_add(GTK_CONTAINER(btn), hbox); if(icon) { img = gtk_image_new_from_stock(icon, GTK_ICON_SIZE_BUTTON); if(!img || gtk_image_get_storage_type(GTK_IMAGE(img)) == GTK_IMAGE_EMPTY) { gtk_icon_size_lookup(GTK_ICON_SIZE_BUTTON, &iw, &ih); pix = gtk_icon_theme_load_icon (gtk_icon_theme_get_default(), icon, iw, GTK_ICON_LOOKUP_GENERIC_FALLBACK, NULL); if(pix) { if(img) gtk_image_set_from_pixbuf(GTK_IMAGE(img), pix); else img = gtk_image_new_from_pixbuf(pix); g_object_unref(G_OBJECT(pix)); } } if(img) { gtk_widget_show(img); gtk_box_pack_start(GTK_BOX(hbox), img, FALSE, FALSE, 0); } } if(text) { lbl = gtk_label_new_with_mnemonic(text); gtk_widget_show(lbl); gtk_box_pack_start(GTK_BOX(hbox), lbl, FALSE, FALSE, 0); gtk_label_set_mnemonic_widget(GTK_LABEL(lbl), btn); } return btn; }
static void set_calibration_status (CalibArea *area) { GtkIconTheme *icon_theme; GtkIconInfo *icon_info; GdkRGBA white; icon_theme = gtk_icon_theme_get_default (); icon_info = gtk_icon_theme_lookup_icon (icon_theme, ICON_SUCCESS, ICON_SIZE, GTK_ICON_LOOKUP_USE_BUILTIN); if (icon_info == NULL) { g_warning ("Failed to find icon \"%s\"", ICON_SUCCESS); goto out; } gdk_rgba_parse (&white, "White"); area->icon_success = gtk_icon_info_load_symbolic (icon_info, &white, NULL, NULL, NULL, NULL, NULL); g_object_unref (icon_info); if (!area->icon_success) g_warning ("Failed to load icon \"%s\"", ICON_SUCCESS); out: area->success = finish (&area->calibrator, &area->axis, &area->swap); if (area->success && area->icon_success) { set_success (area); g_timeout_add (END_TIME, (GSourceFunc) draw_success_end_wait_callback, area); } else { on_delete_event (NULL, NULL, area); } }
static void ensure_surface_for_icon_name_or_gicon (GtkIconHelper *self, GtkStyleContext *context) { GtkIconTheme *icon_theme; gint width, height, scale; GtkIconInfo *info; GtkIconLookupFlags flags; if (!check_invalidate_surface (self, context)) return; icon_theme = gtk_icon_theme_get_default (); flags = get_icon_lookup_flags (self); ensure_icon_size (self, context, &width, &height); scale = get_scale_factor (self, context); if (self->priv->storage_type == GTK_IMAGE_ICON_NAME && self->priv->icon_name != NULL) { info = gtk_icon_theme_lookup_icon_for_scale (icon_theme, self->priv->icon_name, MIN (width, height), scale, flags); } else if (self->priv->storage_type == GTK_IMAGE_GICON && self->priv->gicon != NULL) { info = gtk_icon_theme_lookup_by_gicon_for_scale (icon_theme, self->priv->gicon, MIN (width, height), scale, flags); } else { g_assert_not_reached (); return; } ensure_stated_surface_from_info (self, context, info, scale); if (info) g_object_unref (info); }
static void rb_missing_files_source_init (RBMissingFilesSource *source) { gint size; GdkPixbuf *pixbuf; source->priv = G_TYPE_INSTANCE_GET_PRIVATE (source, RB_TYPE_MISSING_FILES_SOURCE, RBMissingFilesSourcePrivate); gtk_icon_size_lookup (RB_SOURCE_ICON_SIZE, &size, NULL); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "dialog-warning", size, 0, NULL); rb_source_set_pixbuf (RB_SOURCE (source), pixbuf); if (pixbuf != NULL) { g_object_unref (pixbuf); } }
static void rb_import_errors_source_init (RBImportErrorsSource *source) { gint size; GdkPixbuf *pixbuf; source->priv = G_TYPE_INSTANCE_GET_PRIVATE (source, RB_TYPE_IMPORT_ERRORS_SOURCE, RBImportErrorsSourcePrivate); gtk_icon_size_lookup (RB_SOURCE_ICON_SIZE, &size, NULL); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "dialog-error", size, 0, NULL); rb_source_set_pixbuf (RB_SOURCE (source), pixbuf); if (pixbuf != NULL) { g_object_unref (pixbuf); } }
/* consumes reference on icon */ static GtkWidget *_gtk_image_new_for_icon(FmIcon *icon, gint size) { GtkWidget * img = gtk_image_new(); ImgData * data = g_new0(ImgData, 1); data->icon = icon; data->size = size; if (img_data_id == 0) img_data_id = g_quark_from_static_string("ImgData"); g_object_set_qdata_full(G_OBJECT(img), img_data_id, data, (GDestroyNotify) img_data_free); _gtk_image_set_from_file_scaled(img, data); if (G_IS_THEMED_ICON(data->icon)) { /* This image is loaded from icon theme. Update the image if the icon theme is changed. */ data->theme_changed_handler = g_signal_connect(gtk_icon_theme_get_default(), "changed", G_CALLBACK(on_theme_changed), img); } return img; }
static void window_set_icons (GtkWidget *window) { GtkIconTheme *theme = gtk_icon_theme_get_default (); gint sizes[] = { 16, 24, 32, 64 }; GList *list = NULL; gint i; for (i = 0; i < G_N_ELEMENTS (sizes); i++) list = g_list_prepend (list, gtk_icon_theme_load_icon (theme, GIMP_STOCK_USER_MANUAL, sizes[i], 0, NULL)); gtk_window_set_icon_list (GTK_WINDOW (window), list); g_list_free_full (list, (GDestroyNotify) g_object_unref); }
static gboolean has_icon_path (const char *path) { char **paths; int i; gboolean has = FALSE; gtk_icon_theme_get_search_path(gtk_icon_theme_get_default(), &paths, NULL); for (i = 0; paths[i]; i++) if (! strcmp(paths[i], path)) { has = TRUE; break; } g_strfreev(paths); return has; }
static void setup_icons (GdmUserChooserWidget *widget) { if (gtk_widget_has_screen (GTK_WIDGET (widget))) { widget->priv->icon_theme = gtk_icon_theme_get_for_screen (gtk_widget_get_screen (GTK_WIDGET (widget))); } else { widget->priv->icon_theme = gtk_icon_theme_get_default (); } if (widget->priv->icon_theme != NULL) { g_signal_connect (widget->priv->icon_theme, "changed", G_CALLBACK (on_icon_theme_changed), widget); } load_icons (widget); }
/** * Looks up icons based on the currently selected theme. * * @param iconname icon name to look up * @param size size of the icon * @return the corresponding theme icon, NULL on failure, * use g_object_unref() to release the reference to the icon */ static GdkPixbuf * pixbuf_new_from_stock(const gchar *iconname, gint size) { static GtkIconTheme *icon_theme = NULL; GError *err = NULL; GdkPixbuf *pixbuf = NULL; if (icon_theme == NULL) icon_theme = gtk_icon_theme_get_default(); pixbuf = gtk_icon_theme_load_icon(icon_theme, iconname, size, 0, &err); if (!pixbuf) { WARN("Unable to load icon '%s': %s", iconname, err->message); g_error_free(err); } return pixbuf; }
static void impl_constructed (GObject *object) { RBPodcastMainSource *source; RBPodcastManager *podcast_mgr; GdkPixbuf *pixbuf; gint size; RB_CHAIN_GOBJECT_METHOD (rb_podcast_main_source_parent_class, constructed, object); source = RB_PODCAST_MAIN_SOURCE (object); g_object_get (source, "podcast-manager", &podcast_mgr, NULL); g_signal_connect_object (podcast_mgr, "start_download", G_CALLBACK (start_download_cb), source, 0); g_signal_connect_object (podcast_mgr, "finish_download", G_CALLBACK (finish_download_cb), source, 0); g_signal_connect_object (podcast_mgr, "feed_updates_available", G_CALLBACK (feed_updates_available_cb), source, 0); g_signal_connect_object (podcast_mgr, "process_error", G_CALLBACK (feed_error_cb), source, 0); gtk_icon_size_lookup (RB_SOURCE_ICON_SIZE, &size, NULL); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), RB_STOCK_PODCAST, size, 0, NULL); if (pixbuf != NULL) { rb_source_set_pixbuf (RB_SOURCE (source), pixbuf); g_object_unref (pixbuf); } }
void matekbd_indicator_config_init (MatekbdIndicatorConfig * ind_config, MateConfClient * conf_client, XklEngine * engine) { GError *gerror = NULL; gchar *sp; memset (ind_config, 0, sizeof (*ind_config)); ind_config->conf_client = conf_client; ind_config->engine = engine; g_object_ref (ind_config->conf_client); mateconf_client_add_dir (ind_config->conf_client, MATEKBD_INDICATOR_CONFIG_DIR, MATECONF_CLIENT_PRELOAD_NONE, &gerror); if (gerror != NULL) { g_warning ("err1:%s\n", gerror->message); g_error_free (gerror); gerror = NULL; } ind_config->icon_theme = gtk_icon_theme_get_default (); gtk_icon_theme_append_search_path (ind_config->icon_theme, sp = g_build_filename (g_get_home_dir (), ".icons/flags", NULL)); g_free (sp); gtk_icon_theme_append_search_path (ind_config->icon_theme, sp = g_build_filename (DATADIR, "pixmaps/flags", NULL)); g_free (sp); gtk_icon_theme_append_search_path (ind_config->icon_theme, sp = g_build_filename (DATADIR, "icons/flags", NULL)); g_free (sp); }
/** * @brief Initialize the GTK user interface. * * @param display_name name of the X display to use or NULL (using the DISPLAY environment variable) */ void gtkInit(char *display_name) { int argc = 0; char *arg[3], **argv = arg; char *env; GtkIconTheme *theme; GdkPixmap *gdkIcon; GdkBitmap *gdkIconMask; mp_msg(MSGT_GPLAYER, MSGL_V, "GTK init.\n"); arg[argc++] = gmplayer; if (display_name) { // MPlayer option '-display' was given arg[argc++] = "--display"; // Pass corresponding command line arguments to GTK, arg[argc++] = display_name; // to open the requested display for the GUI, too. } gtk_disable_setlocale(); env = getenv("G_FILENAME_ENCODING"); if ((!env && getenv("G_BROKEN_FILENAMES")) || (gstrncmp(env, "@locale", 7) == 0)) mp_msg(MSGT_GPLAYER, MSGL_WARN, MSGTR_GUI_MSG_LocaleEncoding); gtk_init(&argc, &argv); wsSetErrorHandler(); // GDK has just set its own handler theme = gtk_icon_theme_get_default(); if (gtkLoadIcon(theme, 16, &gdkIcon, &gdkIconMask)) { guiIcon.small = GDK_PIXMAP_XID(gdkIcon); guiIcon.small_mask = GDK_PIXMAP_XID(gdkIconMask); } if (gtkLoadIcon(theme, 32, &gdkIcon, &gdkIconMask)) { guiIcon.normal = GDK_PIXMAP_XID(gdkIcon); guiIcon.normal_mask = GDK_PIXMAP_XID(gdkIconMask); } gtkLoadIcon(theme, 48, &gdkIcon, &gdkIconMask); gtkInitialized = True; }
void initialize_data (void) { if (initialized) return; initialized = TRUE; ProgramsCache = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (), PKG_DATA_DIR G_DIR_SEPARATOR_S "icons"); migrate_options_directory (); register_archives (); compute_supported_archive_types (); }
static void power_action(const PowerActionData* action) { g_return_if_fail(config.power.enabled && action->get_allow()); if(*action->show_prompt_ptr) { GtkWidget* dialog = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, GTK_MESSAGE_QUESTION, GTK_BUTTONS_NONE, "%s", _(action->prompt)); gtk_dialog_add_buttons(GTK_DIALOG(dialog), _("Return to Login"), GTK_RESPONSE_CANCEL, _(action->name), GTK_RESPONSE_OK, NULL); gtk_widget_set_name(dialog, "power_dialog"); gtk_window_set_title(GTK_WINDOW(dialog), action->name); setup_window(GTK_WINDOW(dialog)); if(action->icon && gtk_icon_theme_has_icon(gtk_icon_theme_get_default(), action->icon)) { GtkWidget* image = gtk_image_new_from_icon_name(action->icon, GTK_ICON_SIZE_DIALOG); gtk_message_dialog_set_image(GTK_MESSAGE_DIALOG(dialog), image); } gtk_widget_hide(greeter.ui.login_window); gtk_widget_set_sensitive(greeter.ui.power.widget, FALSE); gtk_widget_show_all(dialog); set_window_position(dialog, &WINDOW_POSITION_CENTER); gboolean result = gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK; gtk_widget_destroy(dialog); gtk_widget_show(greeter.ui.login_window); update_windows_layout(); gtk_widget_set_sensitive(greeter.ui.power.widget, TRUE); if(!result) return; } GError* error = NULL; if(!action->do_action(&error) && error) { g_warning("Action \"%s\" failed with error: %s.", action->name, error->message); show_error(_(action->name), _("Action \"%s\" failed with error: %s."), _(action->name), error->message); g_clear_error(&error); } }
static void fm_dir_tree_model_finalize (GObject *object) { FmDirTreeModel *dir_tree_model; g_return_if_fail (object != NULL); g_return_if_fail (FM_IS_DIR_TREE_MODEL (object)); dir_tree_model = FM_DIR_TREE_MODEL (object); fm_foreach (dir_tree_model->root_list, (GFunc) fm_dir_tree_item_free_l, NULL); g_list_free (dir_tree_model->root_list); // Check Subdirectories job... g_object_unref (dir_tree_model->subdir_cancellable); g_signal_handlers_disconnect_by_func (gtk_icon_theme_get_default (), on_theme_changed, dir_tree_model); G_OBJECT_CLASS (fm_dir_tree_model_parent_class)->finalize (object); }
static void book_view_gtk_update_contact (BookViewGtk *self, Ekiga::ContactPtr contact, GtkTreeIter *iter) { GtkListStore *store = NULL; GdkPixbuf *pixbuf = NULL; store = GTK_LIST_STORE (gtk_tree_view_get_model (self->priv->tree_view)); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), "avatar-default", GTK_ICON_SIZE_MENU, (GtkIconLookupFlags) 0, NULL); gtk_list_store_set (store, iter, COLUMN_PIXBUF, pixbuf, COLUMN_NAME, contact->get_name ().c_str (), -1); if (pixbuf) g_object_unref (pixbuf); }
gboolean nautilus_icon_theme_can_render (GThemedIcon *icon) { GtkIconTheme *icon_theme; const gchar * const *names; gint idx; names = g_themed_icon_get_names (icon); icon_theme = gtk_icon_theme_get_default (); for (idx = 0; names[idx] != NULL; idx++) { if (gtk_icon_theme_has_icon (icon_theme, names[idx])) { return TRUE; } } return FALSE; }
//_______________________________________________________ void DemoWidget::realize( void ) { assert( !_mainWidget ); assert( _widget ); // create main widget (vbox) _mainWidget = gtk_box_new( GTK_ORIENTATION_VERTICAL, 0 ); gtk_box_set_spacing( GTK_BOX( _mainWidget ), 10 ); gtk_widget_show( _mainWidget ); // horizontal box GtkWidget* hbox( gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 0 ) ); gtk_box_pack_start( GTK_BOX( _mainWidget ), hbox, false, true, 0 ); gtk_widget_show( hbox ); // label std::string comments( _comments.empty() ? _name:_comments ); GtkWidget* label( gtk_label_new( comments.c_str() ) ); PangoAttrList* attributes( pango_attr_list_new() ); pango_attr_list_insert( attributes, pango_attr_weight_new( PANGO_WEIGHT_BOLD ) ); gtk_label_set_attributes( GTK_LABEL( label ), attributes ); pango_attr_list_unref( attributes ); gtk_box_pack_start( GTK_BOX( hbox ), label, false, true, 0 ); gtk_widget_show( label ); // icon if( !_iconName.empty() ) { GtkIconTheme* theme( gtk_icon_theme_get_default() ); GdkPixbuf* icon( gtk_icon_theme_load_icon( theme, _iconName.c_str(), 22, (GtkIconLookupFlags) 0, 0L ) ); GtkWidget* image( gtk_image_new_from_pixbuf( icon ) ); gtk_box_pack_end( GTK_BOX( hbox ), image, false, false, 0 ); gtk_widget_show( image ); } // main content gtk_box_pack_start( GTK_BOX( _mainWidget ), _widget, true, true, 0 ); gtk_widget_show( _widget ); }
static void ipreferences_merge(IAnjutaPreferences* ipref, AnjutaPreferences* prefs, GError** e) { GdkPixbuf *pixbuf; GError *error = NULL; SJCDPlugin* plugin = SJCD_PLUGIN(ipref); plugin->prefs = init_sjcd_preferences(); if (plugin->prefs == NULL) return; pixbuf = gtk_icon_theme_load_icon(gtk_icon_theme_get_default(), PREFERENCE_ICON, 48, 0, &error); if (!pixbuf) { g_warning (N_("Couldn't load icon: %s"), error->message); g_error_free(error); } anjuta_preferences_dialog_add_page(ANJUTA_PREFERENCES_DIALOG (anjuta_preferences_get_dialog (prefs)), "gtkpod-track-display-settings", TAB_NAME, pixbuf, plugin->prefs); g_object_unref(pixbuf); }
static void on_model_destroy(gpointer unused, GObject* _model) { GtkTreeIter it; if(gtk_tree_model_get_iter_first(GTK_TREE_MODEL(model), &it)) { do { PlaceItem* item; gtk_tree_model_get(GTK_TREE_MODEL(model), &it, COL_INFO, &item, -1); if(G_LIKELY(item)) place_item_free(item); }while(gtk_tree_model_iter_next(GTK_TREE_MODEL(model), &it)); } model = NULL; g_signal_handler_disconnect(gtk_icon_theme_get_default(), theme_change_handler); theme_change_handler = 0; g_signal_handler_disconnect(fm_config, use_trash_change_handler); use_trash_change_handler = 0; g_signal_handler_disconnect(fm_config, pane_icon_size_change_handler); pane_icon_size_change_handler = 0; g_signal_handlers_disconnect_by_func(vol_mon, on_vol_added, NULL); g_signal_handlers_disconnect_by_func(vol_mon, on_vol_removed, NULL); g_signal_handlers_disconnect_by_func(vol_mon, on_vol_changed, NULL); g_object_unref(vol_mon); vol_mon = NULL; if(trash_monitor) { g_signal_handlers_disconnect_by_func(trash_monitor, on_trash_changed, NULL); g_object_unref(trash_monitor); trash_monitor = NULL; } if(trash_idle) g_source_remove(trash_idle); trash_idle = 0; memset(&trash_it, 0, sizeof(GtkTreeIter)); memset(&sep_it, 0, sizeof(GtkTreeIter)); }
static void ol_osd_module_init_osd (OlOsdModule *osd) { osd->window = OL_OSD_WINDOW (ol_osd_window_new ()); if (osd->window == NULL) return; GtkIconTheme *icontheme = gtk_icon_theme_get_default (); GdkPixbuf *bg = gtk_icon_theme_load_icon (icontheme, OL_STOCK_OSD_BG, 32, 0, NULL); ol_osd_window_set_bg (osd->window, bg); g_object_unref (bg); osd->toolbar = OL_OSD_TOOLBAR (ol_osd_toolbar_new ()); if (osd->toolbar != NULL) { gtk_container_add (GTK_CONTAINER (osd->window), GTK_WIDGET (osd->toolbar)); gtk_widget_show_all (GTK_WIDGET (osd->toolbar)); g_object_ref (osd->toolbar); ol_osd_toolbar_set_player (osd->toolbar, osd->player); } osd->display = FALSE; OlConfigProxy *config = ol_config_proxy_get_instance (); ol_assert (config != NULL); _bind_all_config (osd); g_signal_connect (osd->window, "moved", G_CALLBACK (ol_osd_moved_handler), NULL); g_signal_connect (osd->window, "resize", G_CALLBACK (ol_osd_resize_handler), NULL); g_signal_connect (osd->window, "button-release-event", G_CALLBACK (ol_osd_button_release), NULL); g_signal_connect (osd->window, "scroll-event", G_CALLBACK (ol_osd_scroll), NULL); }
static void test_window (void) { GsdOsdDrawContext ctx; ClutterActor *stage, *actor; ClutterContent *canvas; GtkWidgetPath *widget_path; /* create a resizable stage */ stage = clutter_stage_new (); clutter_stage_set_title (CLUTTER_STAGE (stage), "OSD Test"); clutter_stage_set_user_resizable (CLUTTER_STAGE (stage), TRUE); clutter_actor_set_background_color (stage, CLUTTER_COLOR_Red); clutter_actor_set_size (stage, 300, 300); clutter_actor_show (stage); /* box canvas */ canvas = clutter_canvas_new (); clutter_canvas_set_size (CLUTTER_CANVAS (canvas), 300, 300); actor = clutter_actor_new (); clutter_actor_add_constraint (actor, clutter_bind_constraint_new (stage, CLUTTER_BIND_SIZE, 0)); clutter_actor_set_content (actor, canvas); g_object_unref (canvas); clutter_actor_add_child (stage, actor); memset (&ctx, 0, sizeof(ctx)); widget_path = gtk_widget_path_new (); gtk_widget_path_append_type (widget_path, GTK_TYPE_WINDOW); ctx.style = gtk_style_context_new (); gtk_style_context_set_path (ctx.style, widget_path); ctx.direction = clutter_get_default_text_direction (); ctx.theme = gtk_icon_theme_get_default (); g_signal_connect (canvas, "draw", G_CALLBACK (draw_box), &ctx); clutter_content_invalidate (canvas); g_signal_connect (stage, "destroy", G_CALLBACK (gtk_main_quit), NULL); }
char * panel_util_get_icon_name_from_g_icon (GIcon *gicon) { const char * const *names; GtkIconTheme *icon_theme; int i; if (!G_IS_THEMED_ICON (gicon)) return NULL; names = g_themed_icon_get_names (G_THEMED_ICON (gicon)); icon_theme = gtk_icon_theme_get_default (); for (i = 0; names[i] != NULL; i++) { if (gtk_icon_theme_has_icon (icon_theme, names[i])) return g_strdup (names[i]); } return NULL; }
GdkPixbuf * _g_mime_type_get_icon (const char *mime_type, int icon_size, GtkIconTheme *icon_theme) { GdkPixbuf *pixbuf = NULL; GIcon *icon; if (icon_theme == NULL) icon_theme = gtk_icon_theme_get_default (); icon = g_content_type_get_icon (mime_type); if (icon == NULL) icon = g_themed_icon_new ("text-x-generic"); pixbuf = _g_icon_get_pixbuf (icon, icon_size, icon_theme); g_object_unref (icon); return pixbuf; }
GdkPixbuf * gedit_file_browser_utils_pixbuf_from_theme (gchar const *name, GtkIconSize size) { gint width; GError *error = NULL; GdkPixbuf *pixbuf; gtk_icon_size_lookup (size, &width, NULL); pixbuf = gtk_icon_theme_load_icon (gtk_icon_theme_get_default (), name, width, 0, &error); pixbuf = process_icon_pixbuf (pixbuf, name, width, error); return pixbuf; }
static void etc_load_icon (ETableCol *etc) { /* FIXME This ignores theme changes. */ GtkIconTheme *icon_theme; gint width, height; GError *error = NULL; icon_theme = gtk_icon_theme_get_default (); gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &width, &height); etc->pixbuf = gtk_icon_theme_load_icon ( icon_theme, etc->icon_name, height, GTK_ICON_LOOKUP_FORCE_SIZE, &error); if (error != NULL) { g_warning ("%s", error->message); g_error_free (error); } }
/* compose_attach_dialog */ void compose_attach_dialog(Compose * compose) { GtkWidget * dialog; GSList * filenames = NULL; GSList * p; char const * type; GdkPixbuf * pixbuf; GtkIconTheme * theme; GtkTreeIter iter; dialog = gtk_file_chooser_dialog_new(_("Attach file..."), GTK_WINDOW(compose->window), GTK_FILE_CHOOSER_ACTION_OPEN, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OPEN, GTK_RESPONSE_OK, NULL); gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE); if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK) filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER( dialog)); gtk_widget_destroy(dialog); if(filenames == NULL) return; compose_set_modified(compose, TRUE); theme = gtk_icon_theme_get_default(); for(p = filenames; p != NULL; p = p->next) { pixbuf = NULL; if((type = mime_type(compose->mime, p->data)) != NULL) mime_icons(compose->mime, type, 48, &pixbuf, -1); if(pixbuf == NULL) pixbuf = gtk_icon_theme_load_icon(theme, GTK_STOCK_FILE, 48, 0, NULL); gtk_list_store_append(compose->a_store, &iter); gtk_list_store_set(compose->a_store, &iter, CAC_FILENAME, p->data, CAC_BASENAME, basename(p->data), CAC_ICON, pixbuf, -1); } g_slist_foreach(filenames, (GFunc)g_free, NULL); g_slist_free(filenames); gtk_widget_show(compose->a_window); }
static GdkPixbuf * _mime_icon_emblem(GdkPixbuf * pixbuf, int size, char const * emblem) { int esize; GdkPixbuf * epixbuf; GtkIconTheme * icontheme; #if GTK_CHECK_VERSION(2, 14, 0) const unsigned int flags = GTK_ICON_LOOKUP_USE_BUILTIN | GTK_ICON_LOOKUP_FORCE_SIZE; #else const unsigned int flags = GTK_ICON_LOOKUP_USE_BUILTIN; #endif /* work on a copy */ epixbuf = gdk_pixbuf_copy(pixbuf); g_object_unref(pixbuf); pixbuf = epixbuf; /* determine the size of the emblem */ if(size >= 96) esize = 32; else if(size >= 48) esize = 24; else esize = 12; /* obtain the emblem's icon */ icontheme = gtk_icon_theme_get_default(); if((epixbuf = gtk_icon_theme_load_icon(icontheme, emblem, esize, flags, NULL)) == NULL) return pixbuf; /* blit the emblem */ #if 0 /* XXX does not show anything (bottom right) */ gdk_pixbuf_composite(epixbuf, pixbuf, size - esize, size - esize, esize, esize, 0, 0, 1.0, 1.0, GDK_INTERP_NEAREST, 255); #else /* blitting at the top left instead */ gdk_pixbuf_composite(epixbuf, pixbuf, 0, 0, esize, esize, 0, 0, 1.0, 1.0, GDK_INTERP_NEAREST, 255); #endif g_object_unref(epixbuf); return pixbuf; }