static void brasero_medium_selection_update_no_disc_entry (BraseroMediumSelection *self, GtkTreeModel *model, GtkTreeIter *iter) { BraseroMediumMonitor *monitor; GIcon *icon; monitor = brasero_medium_monitor_get_default (); if (brasero_medium_monitor_is_probing (monitor)) { icon = g_themed_icon_new_with_default_fallbacks ("image-loading"); gtk_list_store_set (GTK_LIST_STORE (model), iter, NAME_COL, _("Searching for available discs"), ICON_COL, icon, VISIBLE_TEXT_COL, TRUE, VISIBLE_PROGRESS_COL, FALSE, -1); } else { icon = g_themed_icon_new_with_default_fallbacks ("drive-optical"); gtk_list_store_set (GTK_LIST_STORE (model), iter, NAME_COL, _("No disc available"), ICON_COL, icon, VISIBLE_TEXT_COL, TRUE, VISIBLE_PROGRESS_COL, FALSE, -1); } g_object_unref (icon); g_object_unref (monitor); gtk_combo_box_set_active_iter (GTK_COMBO_BOX (self), iter); brasero_medium_selection_set_current_medium (self, iter); }
static void customize_for_search_mode (GeditViewFrame *frame) { GIcon *icon; if (frame->priv->search_mode == SEARCH) { icon = g_themed_icon_new_with_default_fallbacks ("edit-find-symbolic"); gtk_widget_set_tooltip_text (frame->priv->search_entry, _("String you want to search for")); gtk_widget_show (frame->priv->go_up_button); gtk_widget_show (frame->priv->go_down_button); } else { icon = g_themed_icon_new_with_default_fallbacks ("go-jump-symbolic"); gtk_widget_set_tooltip_text (frame->priv->search_entry, _("Line you want to move the cursor to")); gtk_widget_hide (frame->priv->go_up_button); gtk_widget_hide (frame->priv->go_down_button); } gtk_entry_set_icon_from_gicon (GTK_ENTRY (frame->priv->search_entry), GTK_ENTRY_ICON_PRIMARY, icon); g_object_unref (icon); }
static void udisks_client_get_object_info_for_loop (UDisksClient *client, UDisksLoop *loop, UDisksBlock *block, UDisksPartition *partition, UDisksObjectInfo *info) { guint64 size = 0; gchar *size_str = NULL; gchar *s; size = udisks_block_get_size (block); if (size > 0) size_str = udisks_client_get_size_for_display (client, size, FALSE, FALSE); info->icon = g_themed_icon_new_with_default_fallbacks ("drive-removable-media"); info->icon_symbolic = g_themed_icon_new_with_default_fallbacks ("drive-removable-media-symbolic"); info->name = udisks_loop_dup_backing_file (loop); if (size_str != NULL) { info->description = g_strdup_printf (_("%s Loop Device"), size_str); } else { info->description = g_strdup (_("Loop Device")); } if (partition != NULL) { /* Translators: Used to describe a partition of a loop device. * The %d is the partition number. * The %s is the description for the loop device (e.g. "5 GB Loop Device"). */ s = g_strdup_printf (C_("part-loop", "Partition %d of %s"), udisks_partition_get_number (partition), info->description); g_free (info->description); info->description = s; } /* Translators: String used for one-liner description of a loop device. * The first %s is the description of the object (e.g. "2 GB Loop Device"). * The second %s is the name of the backing file (e.g. "/home/davidz/file.iso"). * The third %s is the special device file (e.g. "/dev/loop2"). */ info->one_liner = g_strdup_printf (C_("one-liner-loop", "%s — %s (%s)"), info->description, info->name, udisks_block_get_preferred_device (block)); info->sort_key = g_strdup_printf ("03_loop_%s_%d", last_segment (g_dbus_object_get_object_path (G_DBUS_OBJECT (info->object))), partition != NULL ? udisks_partition_get_number (partition) : 0); }
static void fill_info (GFileInfo *info, GVfsAfpVolumeData *vol_data, GVfsBackendAfpBrowse *afp_backend) { GIcon *icon; GMountSpec *mount_spec; char *uri; g_file_info_set_name (info, vol_data->name); g_file_info_set_display_name (info, vol_data->name); g_file_info_set_edit_name (info, vol_data->name); g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL, TRUE); g_file_info_set_content_type (info, "inode/directory"); g_file_info_set_file_type (info, G_FILE_TYPE_MOUNTABLE); g_file_info_set_attribute_boolean (info, "afp::volume-password-protected", (vol_data->flags & 0x01)); icon = g_themed_icon_new_with_default_fallbacks ("folder-remote-afp"); g_file_info_set_icon (info, icon); g_object_unref (icon); icon = g_themed_icon_new_with_default_fallbacks ("folder-remote-symbolic"); g_file_info_set_symbolic_icon (info, icon); g_object_unref (icon); mount_spec = g_mount_spec_new ("afp-volume"); g_mount_spec_set (mount_spec, "host", g_network_address_get_hostname (G_NETWORK_ADDRESS (afp_backend->addr))); g_mount_spec_set (mount_spec, "volume", vol_data->name); g_mount_spec_set (mount_spec, "user", afp_backend->logged_in_user); if (g_mount_tracker_has_mount_spec (afp_backend->mount_tracker, mount_spec)) { g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT, FALSE); g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT, TRUE); } else { g_file_info_set_attribute_boolean (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT, TRUE); g_file_info_set_attribute_boolean(info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT, FALSE); } g_mount_spec_unref (mount_spec); uri = g_strdup_printf ("afp://%s/%s", g_network_address_get_hostname (G_NETWORK_ADDRESS (afp_backend->addr)), vol_data->name); g_file_info_set_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI, uri); g_free (uri); }
void st_icon_set_icon_name (StIcon *icon, const gchar *icon_name) { StIconPrivate *priv = icon->priv; GIcon *gicon = NULL; g_return_if_fail (ST_IS_ICON (icon)); if (icon_name) gicon = g_themed_icon_new_with_default_fallbacks (icon_name); if (g_icon_equal (priv->gicon, gicon)) /* do nothing */ { g_object_unref (gicon); return; } if (priv->gicon) g_object_unref (priv->gicon); g_object_freeze_notify (G_OBJECT (icon)); priv->gicon = gicon; g_object_notify (G_OBJECT (icon), "gicon"); g_object_notify (G_OBJECT (icon), "icon-name"); g_object_thaw_notify (G_OBJECT (icon)); st_icon_update (icon); }
/* TODO: Is this unnecessarily complicated? */ static VALUE rg_initialize(int argc, VALUE *argv, VALUE self) { VALUE iconnames, with_default_fallbacks; GIcon *icon; rb_scan_args(argc, argv, "11", &iconnames, &with_default_fallbacks); if (TYPE(iconnames) != T_ARRAY) { const char *iconname = RVAL2CSTR(iconnames); icon = RVAL2CBOOL(with_default_fallbacks) ? g_themed_icon_new_with_default_fallbacks(iconname) : g_themed_icon_new(iconname); G_INITIALIZE(self, icon); return Qnil; } if (argc > 1) rb_raise(rb_eArgError, "only one argument allowed when first argument is an Array"); icon = g_themed_icon_new_from_names(RVAL2STRV_DUP(iconnames), -1); G_INITIALIZE(self, icon); return Qnil; }
/** * gtk_numerable_icon_set_background_icon_name: * @self: a #GtkNumerableIcon * @icon_name: (allow-none): an icon name, or %NULL * * Updates the icon to use the icon named @icon_name from the * current icon theme as the base background image. If @icon_name * is %NULL, @self will go back using style information or default * theming for its background image. * * If this method is called and a #GIcon was already set as * background for the icon, @icon_name will be used, i.e. the * last method called between gtk_numerable_icon_set_background_icon_name() * and gtk_numerable_icon_set_background_gicon() has always priority. * * Since: 3.0 */ void gtk_numerable_icon_set_background_icon_name (GtkNumerableIcon *self, const gchar *icon_name) { GIcon *icon = NULL; gboolean res; g_return_if_fail (GTK_IS_NUMERABLE_ICON (self)); if (g_strcmp0 (icon_name, self->priv->background_icon_name) != 0) { g_free (self->priv->background_icon_name); self->priv->background_icon_name = g_strdup (icon_name); } if (icon_name != NULL) icon = g_themed_icon_new_with_default_fallbacks (icon_name); res = real_set_background_icon (self, icon); if (res) g_object_notify_by_pspec (G_OBJECT (self), properties[PROP_BACKGROUND_ICON_NAME]); if (icon != NULL) g_object_unref (icon); }
static GList * mx_icon_theme_get_icons (MxIconTheme *theme, const gchar *icon_name) { gint i; GIcon *icon; GList *data; const gchar * const *names = NULL; MxIconThemePrivate *priv = theme->priv; /* Load the icon, or a fallback */ icon = g_themed_icon_new_with_default_fallbacks (icon_name); names = g_themed_icon_get_names (G_THEMED_ICON (icon)); if (!names) { g_object_unref (icon); return NULL; } data = NULL; for (i = 0; names[i]; i++) { /* See if we've loaded this before */ GIcon *single_icon = g_themed_icon_new (names[i]); gboolean success = g_hash_table_lookup_extended (priv->icon_hash, single_icon, NULL, (gpointer *)&data); g_object_unref (single_icon); /* Found in cache on first hit, break */ if (success && (i == 0)) break; /* Found in cache after searching the disk, store again as a new icon */ if (success) { /* If we found this as a fallback, store it so we don't look on * disk again. */ if (data) data = mx_icon_theme_copy_data_list (data); g_hash_table_insert (priv->icon_hash, g_object_ref (icon), data); break; } /* Try to load from disk */ if ((data = mx_icon_theme_load_icon (theme, names[i], icon))) break; } g_object_unref (icon); return data; }
GtkStatusIcon *init_notification(void) { notify_init("bluetooth-manager"); icon_enabled = g_themed_icon_new_with_default_fallbacks (ACTIVE_ICON_NAME"-symbolic"); icon_disabled = g_themed_icon_new_with_default_fallbacks (DISABLE_ICON_NAME"-symbolic"); statusicon = gtk_status_icon_new_from_gicon(bt_enabled ? icon_enabled : icon_disabled); gtk_status_icon_set_title (GTK_STATUS_ICON (statusicon), _("Bluetooth")); gtk_status_icon_set_tooltip_markup(statusicon, tooltip); /* XXX: Make sure the status icon is actually shown */ gtk_status_icon_set_visible(statusicon, FALSE); gtk_status_icon_set_visible(statusicon, TRUE); return statusicon; }
static GIcon* g_udisks_drive_get_icon (GDrive* base) { GUDisksDrive* drv = G_UDISKS_DRIVE(base); if(!drv->icon) { const char* icon_name = g_udisks_device_get_icon_name(drv->dev); drv->icon = g_themed_icon_new_with_default_fallbacks(icon_name); } return (GIcon*)g_object_ref(drv->icon); }
GtkWidget * get_icon (gchar *icon) { GIcon *gi; GtkWidget *retval; gi = g_themed_icon_new_with_default_fallbacks (icon); retval = gtk_image_new_from_gicon (gi, GTK_ICON_SIZE_BUTTON); g_object_unref (gi); return retval; }
/** * st_texture_cache_load_icon_name: * @cache: The texture cache instance * @theme_node: (allow-none): a #StThemeNode * @name: Name of a themed icon * @icon_type: the type of icon to load * @size: Size of themed icon * * Load a themed icon into a texture. See the #StIconType documentation * for an explanation of how @icon_type affects the returned icon. The * colors used for symbolic icons are derived from @theme_node. * * Return Value: (transfer none): A new #ClutterTexture for the icon */ ClutterActor * st_texture_cache_load_icon_name (StTextureCache *cache, StThemeNode *theme_node, const char *name, StIconType icon_type, gint size) { ClutterActor *texture; GIcon *themed; char **names; g_return_val_if_fail (!(icon_type == ST_ICON_SYMBOLIC && theme_node == NULL), NULL); switch (icon_type) { case ST_ICON_SYMBOLIC: names = symbolic_names_for_icon (name); themed = g_themed_icon_new_from_names (names, -1); g_strfreev (names); texture = load_gicon_with_colors (cache, themed, size, st_theme_node_get_icon_colors (theme_node)); g_object_unref (themed); if (texture == NULL) { /* We don't have an equivalent of image-missing * for the symbolic icon theme, so just create a blank * actor. */ texture = (ClutterActor *) create_default_texture (); clutter_actor_set_size (texture, size, size); } return texture; break; case ST_ICON_FULLCOLOR: themed = g_themed_icon_new_with_default_fallbacks (name); texture = load_gicon_with_colors (cache, themed, size, NULL); g_object_unref (themed); if (texture == NULL) { themed = g_themed_icon_new ("image-missing"); texture = load_gicon_with_colors (cache, themed, size, NULL); g_object_unref (themed); } return texture; break; default: g_assert_not_reached (); } }
static GdkPaintable * gtk_icon_helper_load_paintable (GtkIconHelper *self, gboolean *out_symbolic) { GdkPaintable *paintable; GIcon *gicon; gboolean symbolic; switch (gtk_image_definition_get_storage_type (self->def)) { case GTK_IMAGE_PAINTABLE: paintable = g_object_ref (gtk_image_definition_get_paintable (self->def)); symbolic = FALSE; break; case GTK_IMAGE_ICON_NAME: if (self->use_fallback) gicon = g_themed_icon_new_with_default_fallbacks (gtk_image_definition_get_icon_name (self->def)); else gicon = g_themed_icon_new (gtk_image_definition_get_icon_name (self->def)); paintable = ensure_paintable_for_gicon (self, gtk_css_node_get_style (self->node), gtk_widget_get_direction (self->owner), gtk_widget_get_scale_factor (self->owner), gicon, &symbolic); g_object_unref (gicon); break; case GTK_IMAGE_GICON: paintable = ensure_paintable_for_gicon (self, gtk_css_node_get_style (self->node), gtk_widget_get_direction (self->owner), gtk_widget_get_scale_factor (self->owner), gtk_image_definition_get_gicon (self->def), &symbolic); break; case GTK_IMAGE_EMPTY: default: paintable = NULL; symbolic = FALSE; break; } *out_symbolic = symbolic; return paintable; }
/** * fm_icon_from_name * @name: a name for icon * * Retrives a #FmIcon corresponding to @name from cache inserting new * one if there was no such icon there yet. * * Returns: (transfer full): a #FmIcon object. * * Since: 0.1.0 */ FmIcon* fm_icon_from_name(const char* name) { if(G_LIKELY(name)) { FmIcon* icon; GIcon* gicon; gchar *dot; if(g_path_is_absolute(name)) { GFile* gicon_file = g_file_new_for_path(name); gicon = g_file_icon_new(gicon_file); g_object_unref(gicon_file); } else if(G_UNLIKELY((dot = strrchr(name, '.')) != NULL && dot > name && (g_ascii_strcasecmp(&dot[1], "png") == 0 || g_ascii_strcasecmp(&dot[1], "svg") == 0 || g_ascii_strcasecmp(&dot[1], "xpm") == 0))) { /* some desktop entries have invalid icon name which contains suffix so let strip the suffix from such invalid name */ dot = g_strndup(name, dot - name); gicon = g_themed_icon_new_with_default_fallbacks(dot); g_free(dot); } else gicon = g_themed_icon_new_with_default_fallbacks(name); if(G_LIKELY(gicon)) { icon = fm_icon_from_gicon(gicon); g_object_unref(gicon); return icon; } } return NULL; }
static void volume_widget_init (VolumeWidget *self) { //g_debug("VolumeWidget::volume_widget_init"); VolumeWidgetPrivate * priv = VOLUME_WIDGET_GET_PRIVATE(self); priv->ido_volume_slider = ido_scale_menu_item_new_with_range ("VOLUME", IDO_RANGE_STYLE_DEFAULT, 0, 0, 100, 1); g_object_ref (priv->ido_volume_slider); ido_scale_menu_item_set_primary_label (IDO_SCALE_MENU_ITEM(priv->ido_volume_slider), "VOLUME"); ido_scale_menu_item_set_style (IDO_SCALE_MENU_ITEM (priv->ido_volume_slider), IDO_SCALE_MENU_ITEM_STYLE_IMAGE); g_object_set(priv->ido_volume_slider, "reverse-scroll-events", TRUE, NULL); g_signal_connect (priv->ido_volume_slider, "notify::parent", G_CALLBACK (volume_widget_parent_changed), NULL); GtkWidget* volume_widget = ido_scale_menu_item_get_scale((IdoScaleMenuItem*)priv->ido_volume_slider); g_signal_connect(volume_widget, "change-value", G_CALLBACK(volume_widget_change_value_cb), self); g_signal_connect(volume_widget, "value-changed", G_CALLBACK(volume_widget_value_changed_cb), self); g_signal_connect(priv->ido_volume_slider, "slider-grabbed", G_CALLBACK(volume_widget_slider_grabbed), self); g_signal_connect(priv->ido_volume_slider, "slider-released", G_CALLBACK(volume_widget_slider_released), self); GtkWidget* primary_image = ido_scale_menu_item_get_primary_image((IdoScaleMenuItem*)priv->ido_volume_slider); GIcon * primary_gicon = g_themed_icon_new_with_default_fallbacks("audio-volume-low-zero-panel"); gtk_image_set_from_gicon(GTK_IMAGE(primary_image), primary_gicon, GTK_ICON_SIZE_MENU); g_object_unref(primary_gicon); GtkWidget* secondary_image = ido_scale_menu_item_get_secondary_image((IdoScaleMenuItem*)priv->ido_volume_slider); GIcon * secondary_gicon = g_themed_icon_new_with_default_fallbacks("audio-volume-high-panel"); gtk_image_set_from_gicon(GTK_IMAGE(secondary_image), secondary_gicon, GTK_ICON_SIZE_MENU); g_object_unref(secondary_gicon); GtkAdjustment *adj = gtk_range_get_adjustment (GTK_RANGE (volume_widget)); gtk_adjustment_set_step_increment(adj, 4); }
GIcon * gvfs_udisks2_utils_icon_from_fs_type (const gchar *fs_type) { const gchar *icon_name; if (g_strcmp0 (fs_type, "nfs") == 0 || g_strcmp0 (fs_type, "nfs4") == 0 || g_strcmp0 (fs_type, "cifs") == 0) { icon_name = "folder-remote"; } else { icon_name = "drive-removable-media"; } return g_themed_icon_new_with_default_fallbacks (icon_name); }
/** * g_drive_get_symbolic_icon: * @drive: a #GDrive. * * Gets the icon for @drive. * * Returns: (transfer full): symbolic #GIcon for the @drive. * Free the returned object with g_object_unref(). * * Since: 2.34 **/ GIcon * g_drive_get_symbolic_icon (GDrive *drive) { GDriveIface *iface; GIcon *ret; g_return_val_if_fail (G_IS_DRIVE (drive), NULL); iface = G_DRIVE_GET_IFACE (drive); if (iface->get_symbolic_icon != NULL) ret = iface->get_symbolic_icon (drive); else ret = g_themed_icon_new_with_default_fallbacks ("drive-removable-media-symbolic"); return ret; }
/** * g_volume_get_symbolic_icon: * @volume: a #GVolume * * Gets the symbolic icon for @volume. * * Returns: (transfer full): a #GIcon. * The returned object should be unreffed with g_object_unref() * when no longer needed. * * Since: 2.34 */ GIcon * g_volume_get_symbolic_icon (GVolume *volume) { GVolumeIface *iface; GIcon *ret; g_return_val_if_fail (G_IS_VOLUME (volume), NULL); iface = G_VOLUME_GET_IFACE (volume); if (iface->get_symbolic_icon != NULL) ret = iface->get_symbolic_icon (volume); else ret = g_themed_icon_new_with_default_fallbacks ("folder-remote-symbolic"); return ret; }
void _gtk_icon_helper_set_icon_name (GtkIconHelper *self, const gchar *icon_name, GtkIconSize icon_size) { _gtk_icon_helper_clear (self); if (icon_name != NULL && icon_name[0] != '\0') { self->priv->storage_type = GTK_IMAGE_ICON_NAME; if (self->priv->use_fallback) self->priv->gicon = g_themed_icon_new_with_default_fallbacks (icon_name); else self->priv->gicon = g_themed_icon_new (icon_name); _gtk_icon_helper_set_icon_size (self, icon_size); } }
static void photos_dlna_renderers_dialog_add_renderer (PhotosDlnaRenderersDialog *self, PhotosDlnaRenderer *renderer) { PhotosDlnaRenderersDialogPrivate *priv = self->priv; GIcon *icon; GtkWidget *row; GtkWidget *row_grid; GtkWidget *image; GtkWidget *label; const gchar *name; row = gtk_list_box_row_new (); gtk_container_add (GTK_CONTAINER (priv->listbox), row); row_grid = gtk_grid_new (); gtk_container_set_border_width (GTK_CONTAINER (row_grid), 12); gtk_orientable_set_orientation (GTK_ORIENTABLE (row_grid), GTK_ORIENTATION_HORIZONTAL); gtk_grid_set_column_spacing (GTK_GRID (row_grid), 12); gtk_container_add (GTK_CONTAINER (row), row_grid); g_object_set_data_full (G_OBJECT (row), "renderer", renderer, g_object_unref); name = photos_dlna_renderer_get_friendly_name (renderer); icon = g_themed_icon_new_with_default_fallbacks (PHOTOS_ICON_VIDEO_DISPLAY_SYMBOLIC); image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG); g_object_ref (image); /* keep a ref for the following async call and release it in the callback */ photos_dlna_renderer_get_icon (renderer, "", "", GTK_ICON_SIZE_DIALOG, NULL, photos_dlna_renderers_dialog_set_icon_cb, image); gtk_container_add (GTK_CONTAINER (row_grid), image); label = gtk_label_new (NULL); gtk_label_set_text (GTK_LABEL (label), name); gtk_container_add (GTK_CONTAINER (row_grid), label); }
static void progress_ui_handler_ensure_status_icon (NautilusProgressUIHandler *self) { GIcon *icon; GtkStatusIcon *status_icon; if (self->priv->status_icon != NULL) { return; } icon = g_themed_icon_new_with_default_fallbacks ("system-file-manager-symbolic"); status_icon = gtk_status_icon_new_from_gicon (icon); g_signal_connect (status_icon, "activate", (GCallback) status_icon_activate_cb, self); gtk_status_icon_set_visible (status_icon, FALSE); g_object_unref (icon); self->priv->status_icon = status_icon; }
gboolean _gtk_icon_helper_set_use_fallback (GtkIconHelper *self, gboolean use_fallback) { if (self->priv->use_fallback != use_fallback) { self->priv->use_fallback = use_fallback; _gtk_icon_helper_invalidate (self); if (self->priv->storage_type == GTK_IMAGE_ICON_NAME) { GIcon *old_icon = self->priv->gicon; const char *icon_name = g_themed_icon_get_names (G_THEMED_ICON (self->priv->gicon))[0]; if (self->priv->use_fallback) self->priv->gicon = g_themed_icon_new_with_default_fallbacks (icon_name); else self->priv->gicon = g_themed_icon_new (icon_name); g_object_unref (old_icon); } return TRUE; } return FALSE; }
/** * fm_icon_from_name * @name: a name for icon * * Retrives a #FmIcon corresponding to @name from cache inserting new * one if there was no such icon there yet. * * Returns: (transfer full): a #FmIcon object. * * Since: 0.1.0 */ FmIcon* fm_icon_from_name(const char* name) { if(G_LIKELY(name)) { FmIcon* icon; GIcon* gicon; if(g_path_is_absolute(name)) { GFile* gicon_file = g_file_new_for_path(name); gicon = g_file_icon_new(gicon_file); g_object_unref(gicon_file); } else gicon = g_themed_icon_new_with_default_fallbacks(name); if(G_LIKELY(gicon)) { icon = fm_icon_from_gicon(gicon); g_object_unref(gicon); return icon; } } return NULL; }
static GIcon * special_directory_get_gicon (GUserDirectory directory) { #define ICON_CASE(x) \ case G_USER_DIRECTORY_ ## x: \ return g_themed_icon_new_with_default_fallbacks (ICON_NAME_FOLDER_ ## x); switch (directory) { ICON_CASE (DESKTOP); ICON_CASE (DOCUMENTS); ICON_CASE (DOWNLOAD); ICON_CASE (MUSIC); ICON_CASE (PICTURES); ICON_CASE (PUBLIC_SHARE); ICON_CASE (TEMPLATES); ICON_CASE (VIDEOS); default: return g_themed_icon_new_with_default_fallbacks (ICON_NAME_FOLDER); } #undef ICON_CASE }
GtkWidget * do_images (GtkWidget *do_widget) { GtkWidget *video; GtkWidget *frame; GtkWidget *vbox; GtkWidget *hbox; GtkWidget *base_vbox; GtkWidget *image; GtkWidget *picture; GtkWidget *label; GtkWidget *button; GdkPaintable *paintable; GIcon *gicon; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_display (GTK_WINDOW (window), gtk_widget_get_display (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Images"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); g_signal_connect (window, "destroy", G_CALLBACK (cleanup_callback), NULL); base_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); g_object_set (base_vbox, "margin", 16, NULL); gtk_container_add (GTK_CONTAINER (window), base_vbox); hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 16); gtk_container_add (GTK_CONTAINER (base_vbox), hbox); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (hbox), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Image loaded from a file</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); image = gtk_image_new_from_icon_name ("gtk3-demo"); gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE); gtk_container_add (GTK_CONTAINER (frame), image); /* Animation */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Animation loaded from a file</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); picture = gtk_picture_new_for_resource ("/images/floppybuddy.gif"); gtk_container_add (GTK_CONTAINER (frame), picture); /* Symbolic icon */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Symbolic themed icon</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic"); image = gtk_image_new_from_gicon (gicon); gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE); gtk_container_add (GTK_CONTAINER (frame), image); /* Progressive */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (hbox), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Progressive image loading</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); /* Create an empty image for now; the progressive loader * will create the pixbuf and fill it in. */ picture = gtk_picture_new (); gtk_container_add (GTK_CONTAINER (frame), picture); start_progressive_loading (picture); /* Video */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (hbox), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Displaying video</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_container_add (GTK_CONTAINER (vbox), frame); video = gtk_video_new_for_resource ("/images/gtk-logo.webm"); gtk_media_stream_set_loop (gtk_video_get_media_stream (GTK_VIDEO (video)), TRUE); gtk_container_add (GTK_CONTAINER (frame), video); /* Widget paintables */ vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_add (GTK_CONTAINER (hbox), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>GtkWidgetPaintable</u>"); gtk_container_add (GTK_CONTAINER (vbox), label); paintable = gtk_widget_paintable_new (do_widget); picture = gtk_picture_new_for_paintable (paintable); gtk_widget_set_size_request (picture, 100, 100); gtk_widget_set_valign (picture, GTK_ALIGN_START); gtk_container_add (GTK_CONTAINER (vbox), picture); /* Sensitivity control */ button = gtk_toggle_button_new_with_mnemonic ("_Insensitive"); gtk_container_add (GTK_CONTAINER (base_vbox), button); g_signal_connect (button, "toggled", G_CALLBACK (toggle_sensitivity_callback), base_vbox); } if (!gtk_widget_get_visible (window)) gtk_widget_show (window); else gtk_widget_destroy (window); return window; }
int main (int argc, char **argv) { GtkWidget *window, *grid; GtkWidget *label, *image, *box; GtkIconTheme *theme; GdkPixbuf *pixbuf; GtkIconSet *iconset; GtkIconSource *iconsource; gchar *icon_name = "gnome-terminal"; gchar *anim_filename = NULL; GIcon *icon; GFile *file; gtk_init (&argc, &argv); if (argc > 1) icon_name = argv[1]; if (argc > 2) anim_filename = argv[2]; window = gtk_window_new (GTK_WINDOW_TOPLEVEL); grid = gtk_grid_new (); gtk_container_add (GTK_CONTAINER (window), grid); label = gtk_label_new ("symbolic size"); gtk_grid_attach (GTK_GRID (grid), label, 1, 0, 1, 1); label = gtk_label_new ("fixed size"); gtk_grid_attach (GTK_GRID (grid), label, 2, 0, 1, 1); label = gtk_label_new ("GTK_IMAGE_PIXBUF"); gtk_grid_attach (GTK_GRID (grid), label, 0, 1, 1, 1); theme = gtk_icon_theme_get_default (); pixbuf = gtk_icon_theme_load_icon (theme, icon_name, 48, 0, NULL); image = gtk_image_new_from_pixbuf (pixbuf); box = gtk_event_box_new (); gtk_container_add (GTK_CONTAINER (box), image); gtk_grid_attach (GTK_GRID (grid), box, 2, 1, 1, 1); gtk_drag_source_set (box, GDK_BUTTON1_MASK, NULL, 0, GDK_ACTION_COPY); gtk_drag_source_add_image_targets (box); g_signal_connect (box, "drag_begin", G_CALLBACK (drag_begin), image); g_signal_connect (box, "drag_data_get", G_CALLBACK (drag_data_get), image); gtk_drag_dest_set (box, GTK_DEST_DEFAULT_MOTION | GTK_DEST_DEFAULT_HIGHLIGHT | GTK_DEST_DEFAULT_DROP, NULL, 0, GDK_ACTION_COPY); gtk_drag_dest_add_image_targets (box); g_signal_connect (box, "drag_data_received", G_CALLBACK (drag_data_received), image); label = gtk_label_new ("GTK_IMAGE_STOCK"); gtk_grid_attach (GTK_GRID (grid), label, 0, 2, 1, 1); image = gtk_image_new_from_stock (GTK_STOCK_REDO, GTK_ICON_SIZE_DIALOG); gtk_grid_attach (GTK_GRID (grid), image, 1, 2, 1, 1); label = gtk_label_new ("GTK_IMAGE_ICON_SET"); gtk_grid_attach (GTK_GRID (grid), label, 0, 3, 1, 1); iconsource = gtk_icon_source_new (); gtk_icon_source_set_icon_name (iconsource, icon_name); iconset = gtk_icon_set_new (); gtk_icon_set_add_source (iconset, iconsource); image = gtk_image_new_from_icon_set (iconset, GTK_ICON_SIZE_DIALOG); gtk_grid_attach (GTK_GRID (grid), image, 1, 3, 1, 1); label = gtk_label_new ("GTK_IMAGE_ICON_NAME"); gtk_grid_attach (GTK_GRID (grid), label, 0, 4, 1, 1); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG); gtk_grid_attach (GTK_GRID (grid), image, 1, 4, 1, 1); image = gtk_image_new_from_icon_name (icon_name, GTK_ICON_SIZE_DIALOG); gtk_image_set_pixel_size (GTK_IMAGE (image), 30); gtk_grid_attach (GTK_GRID (grid), image, 2, 4, 1, 1); label = gtk_label_new ("GTK_IMAGE_GICON"); gtk_grid_attach (GTK_GRID (grid), label, 0, 5, 1, 1); icon = g_themed_icon_new_with_default_fallbacks ("folder-remote"); image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG); g_object_unref (icon); gtk_grid_attach (GTK_GRID (grid), image, 1, 5, 1, 1); file = g_file_new_for_path ("apple-red.png"); icon = g_file_icon_new (file); image = gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_DIALOG); g_object_unref (icon); gtk_image_set_pixel_size (GTK_IMAGE (image), 30); gtk_grid_attach (GTK_GRID (grid), image, 2, 5, 1, 1); if (anim_filename) { label = gtk_label_new ("GTK_IMAGE_ANIMATION (from file)"); gtk_grid_attach (GTK_GRID (grid), label, 0, 6, 1, 1); image = gtk_image_new_from_file (anim_filename); gtk_image_set_pixel_size (GTK_IMAGE (image), 30); gtk_grid_attach (GTK_GRID (grid), image, 2, 6, 1, 1); /* produce high load */ g_signal_connect_after (image, "draw", G_CALLBACK (anim_image_draw), NULL); } gtk_widget_show_all (window); gtk_main (); return 0; }
static void panel_place_menu_item_append_gtk_bookmarks (GtkWidget *menu) { typedef struct { char *full_uri; char *label; } PanelBookmark; GtkWidget *add_menu; char *filename; GIOChannel *io_channel; GHashTable *table; int i; GSList *lines = NULL; GSList *add_bookmarks, *l; PanelBookmark *bookmark; filename = g_build_filename (g_get_home_dir (), BOOKMARKS_FILENAME, NULL); io_channel = g_io_channel_new_file (filename, "r", NULL); g_free (filename); if (!io_channel) return; /* We use a hard limit to avoid having users shooting their * own feet, and to avoid crashing the system if a misbehaving * application creates a big bookmars file. */ for (i = 0; i < MAX_BOOKMARK_ITEMS; i++) { char *contents; gsize length; gsize terminator_pos; GIOStatus status; status = g_io_channel_read_line (io_channel, &contents, &length, &terminator_pos, NULL); if (status != G_IO_STATUS_NORMAL) break; if (length == 0) break; /* Clear the line terminator (\n), if any */ if (terminator_pos > 0) contents[terminator_pos] = '\0'; lines = g_slist_prepend (lines, contents); } g_io_channel_shutdown (io_channel, FALSE, NULL); g_io_channel_unref (io_channel); if (!lines) return; lines = g_slist_reverse (lines); table = g_hash_table_new (g_str_hash, g_str_equal); add_bookmarks = NULL; for (l = lines; l; l = l->next) { char *line = (char*) l->data; if (line[0] && !g_hash_table_lookup (table, line)) { GFile *file; char *space; char *label; gboolean keep; g_hash_table_insert (table, line, line); space = strchr (line, ' '); if (space) { *space = '\0'; label = g_strdup (space + 1); } else { label = NULL; } keep = FALSE; if (g_str_has_prefix (line, "x-caja-search:")) keep = TRUE; if (!keep) { file = g_file_new_for_uri (line); keep = !g_file_is_native (file) || g_file_query_exists (file, NULL); g_object_unref (file); } if (!keep) { if (label) g_free (label); continue; } bookmark = g_malloc (sizeof (PanelBookmark)); bookmark->full_uri = g_strdup (line); bookmark->label = label; add_bookmarks = g_slist_prepend (add_bookmarks, bookmark); } } g_hash_table_destroy (table); g_slist_foreach (lines, (GFunc) g_free, NULL); g_slist_free (lines); add_bookmarks = g_slist_reverse (add_bookmarks); if (g_slist_length (add_bookmarks) <= MAX_ITEMS_OR_SUBMENU) { add_menu = menu; } else { GtkWidget *item; item = gtk_image_menu_item_new (); setup_menu_item_with_icon (item, panel_menu_icon_get_size (), PANEL_ICON_BOOKMARKS, NULL, NULL, _("Bookmarks")); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); gtk_widget_show (item); add_menu = create_empty_menu (); gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), add_menu); } for (l = add_bookmarks; l; l = l->next) { char *display_name; char *tooltip; char *label; char *icon; GFile *file; GIcon *gicon; bookmark = l->data; file = g_file_new_for_uri (bookmark->full_uri); display_name = g_file_get_parse_name (file); g_object_unref (file); /* Translators: %s is a URI */ tooltip = g_strdup_printf (_("Open '%s'"), display_name); g_free (display_name); label = NULL; if (bookmark->label) { label = g_strdup (g_strstrip (bookmark->label)); if (!label [0]) { g_free (label); label = NULL; } } if (!label) { label = panel_util_get_label_for_uri (bookmark->full_uri); if (!label) { g_free (tooltip); g_free (bookmark->full_uri); if (bookmark->label) g_free (bookmark->label); g_free (bookmark); continue; } } icon = panel_util_get_icon_for_uri (bookmark->full_uri); /*FIXME: we should probably get a GIcon if possible, so that we * have customized icons for cd-rom, eg */ if (!icon) icon = g_strdup (PANEL_ICON_FOLDER); gicon = g_themed_icon_new_with_default_fallbacks (icon); //FIXME: drag and drop will be broken for x-caja-search uris panel_menu_items_append_place_item (icon, gicon, label, tooltip, add_menu, G_CALLBACK (activate_uri), bookmark->full_uri); g_free (icon); g_object_unref (gicon); g_free (tooltip); g_free (label); g_free (bookmark->full_uri); if (bookmark->label) g_free (bookmark->label); g_free (bookmark); } g_slist_free (add_bookmarks); }
GtkWidget * do_images (GtkWidget *do_widget) { GtkWidget *frame; GtkWidget *vbox; GtkWidget *image; GtkWidget *label; GtkWidget *button; GIcon *gicon; if (!window) { window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_screen (GTK_WINDOW (window), gtk_widget_get_screen (do_widget)); gtk_window_set_title (GTK_WINDOW (window), "Images"); g_signal_connect (window, "destroy", G_CALLBACK (gtk_widget_destroyed), &window); g_signal_connect (window, "destroy", G_CALLBACK (cleanup_callback), NULL); gtk_container_set_border_width (GTK_CONTAINER (window), 8); vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 8); gtk_container_set_border_width (GTK_CONTAINER (vbox), 8); gtk_container_add (GTK_CONTAINER (window), vbox); label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Image loaded from a file</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); image = gtk_image_new_from_icon_name ("gtk3-demo", GTK_ICON_SIZE_DIALOG); gtk_container_add (GTK_CONTAINER (frame), image); /* Animation */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Animation loaded from a file</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); image = gtk_image_new_from_resource ("/images/floppybuddy.gif"); gtk_container_add (GTK_CONTAINER (frame), image); /* Symbolic icon */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Symbolic themed icon</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); gicon = g_themed_icon_new_with_default_fallbacks ("battery-caution-charging-symbolic"); image = gtk_image_new_from_gicon (gicon, GTK_ICON_SIZE_DIALOG); gtk_container_add (GTK_CONTAINER (frame), image); /* Progressive */ label = gtk_label_new (NULL); gtk_label_set_markup (GTK_LABEL (label), "<u>Progressive image loading</u>"); gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, FALSE, 0); frame = gtk_frame_new (NULL); gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN); gtk_widget_set_halign (frame, GTK_ALIGN_CENTER); gtk_widget_set_valign (frame, GTK_ALIGN_CENTER); gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, FALSE, 0); /* Create an empty image for now; the progressive loader * will create the pixbuf and fill it in. */ image = gtk_image_new_from_pixbuf (NULL); gtk_container_add (GTK_CONTAINER (frame), image); start_progressive_loading (image); /* Sensitivity control */ button = gtk_toggle_button_new_with_mnemonic ("_Insensitive"); gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0); g_signal_connect (button, "toggled", G_CALLBACK (toggle_sensitivity_callback), vbox); } if (!gtk_widget_get_visible (window)) gtk_widget_show_all (window); else gtk_widget_destroy (window); return window; }
static void udisks_client_get_object_info_for_mdraid (UDisksClient *client, UDisksMDRaid *mdraid, UDisksPartition *partition, UDisksObjectInfo *info) { UDisksBlock *block = NULL; guint64 size = 0; gchar *size_str = NULL; const gchar *name; const gchar *level; gchar *s; block = udisks_client_get_block_for_mdraid (client, mdraid); size = udisks_mdraid_get_size (mdraid); if (size > 0) size_str = udisks_client_get_size_for_display (client, size, FALSE, FALSE); name = udisks_mdraid_get_name (mdraid); s = strstr (name, ":"); if (s != NULL && strlen (s) > 1) info->name = g_strdup (s + 1); else info->name = g_strdup (name); info->icon = g_themed_icon_new_with_default_fallbacks ("drive-multidisk"); info->icon_symbolic = g_themed_icon_new_with_default_fallbacks ("drive-multidisk-symbolic"); level = udisks_mdraid_get_level (mdraid); if (size_str != NULL) { /* Translators: Used to format the description for a RAID array. * The first %s is the size (e.g. '42.0 GB'). * The second %s is the level (e.g. 'RAID-5 Array'). */ info->description = g_strdup_printf (C_("mdraid-desc", "%s %s"), size_str, format_mdraid_level (level)); } else { info->description = g_strdup (format_mdraid_level (level)); } if (partition != NULL) { /* Translators: Used to describe a partition of a RAID Array. * The %d is the partition number. * The %s is the description for the drive (e.g. "2 TB RAID-5"). */ s = g_strdup_printf (C_("part-raid", "Partition %d of %s"), udisks_partition_get_number (partition), info->description); g_free (info->description); info->description = s; } if (strlen (info->name) > 0) { if (block != NULL) { /* Translators: String used for one-liner description of running RAID array. * The first %s is the array name (e.g. "AlphaGo"). * The second %s is the size and level (e.g. "2 TB RAID-5"). * The third %s is the special device file (e.g. "/dev/sda"). */ info->one_liner = g_strdup_printf (C_("one-liner-mdraid-running", "%s — %s (%s)"), info->name, info->description, udisks_block_get_preferred_device (block)); } else { /* Translators: String used for one-liner description of non-running RAID array. * The first %s is the array name (e.g. "AlphaGo"). * The second %s is the size and level (e.g. "2 TB RAID-5"). */ info->one_liner = g_strdup_printf (C_("one-liner-mdraid-not-running", "%s — %s"), info->name, info->description); } } else { if (block != NULL) { /* Translators: String used for one-liner description of running RAID array w/o a name. * The first %s is the array name (e.g. "AlphaGo"). * The second %s is the size and level (e.g. "2 TB RAID-5"). * The third %s is the special device file (e.g. "/dev/sda"). */ info->one_liner = g_strdup_printf (C_("one-liner-mdraid-no-name-running", "%s — %s"), info->description, udisks_block_get_preferred_device (block)); } else { /* Translators: String used for one-liner description of non-running RAID array w/o a name. * The first %s is the array name (e.g. "AlphaGo"). * The second %s is the size and level (e.g. "2 TB RAID-5"). */ info->one_liner = g_strdup_printf (C_("one-liner-mdraid-no-name-not-running", "%s"), info->description); } } g_clear_object (&block); info->sort_key = g_strdup_printf ("01_mdraid_%s_%d", udisks_mdraid_get_uuid (mdraid), partition != NULL ? udisks_partition_get_number (partition) : 0); }
static void udisks_client_get_object_info_for_drive (UDisksClient *client, UDisksDrive *drive, UDisksPartition *partition, UDisksObjectInfo *info) { const gchar *vendor; const gchar *model; const gchar *media; const gchar *const *media_compat; gboolean media_available; gboolean media_removable; gint rotation_rate; guint64 size; gchar *size_str; guint n; GString *desc_str; DriveType desc_type; gchar *hyphenated_connection_bus; const gchar *connection_bus; UDisksBlock *block = NULL; gchar *s; const gchar *cs; UDisksBlock *block_for_partition = NULL; g_return_if_fail (UDISKS_IS_DRIVE (drive)); size_str = NULL; vendor = udisks_drive_get_vendor (drive); model = udisks_drive_get_model (drive); size = udisks_drive_get_size (drive); media_removable = udisks_drive_get_media_removable (drive); media_available = udisks_drive_get_media_available (drive); rotation_rate = udisks_drive_get_rotation_rate (drive); if (size > 0) size_str = udisks_client_get_size_for_display (client, size, FALSE, FALSE); media = udisks_drive_get_media (drive); media_compat = udisks_drive_get_media_compatibility (drive); connection_bus = udisks_drive_get_connection_bus (drive); if (strlen (connection_bus) > 0) hyphenated_connection_bus = g_strdup_printf ("-%s", connection_bus); else hyphenated_connection_bus = g_strdup (""); /* Name is easy - that's just "$vendor $model" */ if (strlen (vendor) == 0) vendor = NULL; if (strlen (model) == 0) model = NULL; info->name = g_strdup_printf ("%s%s%s", vendor != NULL ? vendor : "", vendor != NULL ? " " : "", model != NULL ? model : ""); desc_type = DRIVE_TYPE_UNSET; desc_str = g_string_new (NULL); for (n = 0; n < G_N_ELEMENTS (media_data) - 1; n++) { /* media_compat */ if (strv_has (media_compat, media_data[n].id)) { if (info->icon == NULL) info->icon = g_themed_icon_new_with_default_fallbacks (media_data[n].drive_icon); if (info->icon_symbolic == NULL) info->icon_symbolic = g_themed_icon_new_with_default_fallbacks (media_data[n].drive_icon_symbolic); if (strstr (desc_str->str, media_data[n].media_family) == NULL) { if (desc_str->len > 0) g_string_append (desc_str, "/"); g_string_append (desc_str, g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_family)); } desc_type = media_data[n].media_type; } if (media_removable && media_available) { /* media */ if (g_strcmp0 (media, media_data[n].id) == 0) { if (info->media_description == NULL) { switch (media_data[n].media_type) { case DRIVE_TYPE_UNSET: g_assert_not_reached (); break; case DRIVE_TYPE_DRIVE: /* Translators: Used to describe drive without removable media. The %s is the type, e.g. 'Thumb' */ info->media_description = g_strdup_printf (C_("drive-with-fixed-media", "%s Drive"), g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_name)); break; case DRIVE_TYPE_DISK: /* Translators: Used to describe generic media. The %s is the type, e.g. 'Zip' or 'Floppy' */ info->media_description = g_strdup_printf (C_("drive-with-generic-media", "%s Disk"), g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_name)); break; case DRIVE_TYPE_CARD: /* Translators: Used to describe flash media. The %s is the type, e.g. 'SD' or 'CompactFlash' */ info->media_description = g_strdup_printf (C_("flash-media", "%s Card"), g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_name)); break; case DRIVE_TYPE_DISC: /* Translators: Used to describe optical discs. The %s is the type, e.g. 'CD-R' or 'DVD-ROM' */ info->media_description = g_strdup_printf (C_("optical-media", "%s Disc"), g_dpgettext2 (GETTEXT_PACKAGE, "media-type", media_data[n].media_name)); break; } } if (info->media_icon == NULL) info->media_icon = g_themed_icon_new_with_default_fallbacks (media_data[n].media_icon); if (info->media_icon_symbolic == NULL) info->media_icon_symbolic = g_themed_icon_new_with_default_fallbacks (media_data[n].media_icon_symbolic); } } } switch (desc_type) { case DRIVE_TYPE_UNSET: if (media_removable) { if (size_str != NULL) { /* Translators: Used to describe a drive. The %s is the size, e.g. '20 GB' */ info->description = g_strdup_printf (C_("drive-with-size", "%s Drive"), size_str); } else { /* Translators: Used to describe a drive we know very little about (removable media or size not known) */ info->description = g_strdup (C_("generic-drive", "Drive")); } } else { if (rotation_rate == 0) { if (size_str != NULL) { /* Translators: Used to describe a non-rotating drive (rotation rate either unknown * or it's a solid-state drive). The %s is the size, e.g. '20 GB'. */ info->description = g_strdup_printf (C_("disk-non-rotational", "%s Disk"), size_str); } else { /* Translators: Used to describe a non-rotating drive (rotation rate either unknown * or it's a solid-state drive). The drive is either using removable media or its * size not known. */ info->description = g_strdup (C_("disk-non-rotational", "Disk")); } } else { if (size_str != NULL) { /* Translators: Used to describe a hard-disk drive (HDD). The %s is the size, e.g. '20 GB'. */ info->description = g_strdup_printf (C_("disk-hdd", "%s Hard Disk"), size_str); } else { /* Translators: Used to describe a hard-disk drive (HDD) (removable media or size not known) */ info->description = g_strdup (C_("disk-hdd", "Hard Disk")); } } } break; case DRIVE_TYPE_CARD: /* Translators: Used to describe a card reader. The %s is the card type e.g. 'CompactFlash'. */ info->description = g_strdup_printf (C_("drive-card-reader", "%s Card Reader"), desc_str->str); break; case DRIVE_TYPE_DRIVE: /* explicit fall-through */ case DRIVE_TYPE_DISK: /* explicit fall-through */ case DRIVE_TYPE_DISC: if (!media_removable && size_str != NULL) { /* Translators: Used to describe drive. The first %s is the size e.g. '20 GB' and the * second %s is the drive type e.g. 'Thumb'. */ info->description = g_strdup_printf (C_("drive-with-size-and-type", "%s %s Drive"), size_str, desc_str->str); } else { /* Translators: Used to describe drive. The first %s is the drive type e.g. 'Thumb'. */ info->description = g_strdup_printf (C_("drive-with-type", "%s Drive"), desc_str->str); } break; } g_string_free (desc_str, TRUE); /* fallback for icon */ if (info->icon == NULL) { if (media_removable) { s = g_strdup_printf ("drive-removable-media%s", hyphenated_connection_bus); } else { if (rotation_rate == 0) s = g_strdup_printf ("drive-harddisk-solidstate%s", hyphenated_connection_bus); else s = g_strdup_printf ("drive-harddisk%s", hyphenated_connection_bus); } info->icon = g_themed_icon_new_with_default_fallbacks (s); g_free (s); } /* fallback for icon_symbolic */ if (info->icon_symbolic == NULL) { if (media_removable) { s = g_strdup_printf ("drive-removable-media%s-symbolic", hyphenated_connection_bus); } else { if (rotation_rate == 0) s = g_strdup_printf ("drive-harddisk-solidstate%s-symbolic", hyphenated_connection_bus); else s = g_strdup_printf ("drive-harddisk%s-symbolic", hyphenated_connection_bus); } info->icon_symbolic = g_themed_icon_new_with_default_fallbacks (s); g_free (s); } /* fallback for media_icon */ if (media_removable && media_available && info->media_icon == NULL) { if (media_removable) { s = g_strdup_printf ("drive-removable-media%s", hyphenated_connection_bus); } else { if (rotation_rate == 0) s = g_strdup_printf ("drive-harddisk-solidstate%s", hyphenated_connection_bus); else s = g_strdup_printf ("drive-harddisk%s", hyphenated_connection_bus); } info->media_icon = g_themed_icon_new_with_default_fallbacks (s); g_free (s); } /* fallback for media_icon_symbolic */ if (media_removable && media_available && info->media_icon_symbolic == NULL) { if (media_removable) { s = g_strdup_printf ("drive-removable-media%s-symbolic", hyphenated_connection_bus); } else { if (rotation_rate == 0) s = g_strdup_printf ("drive-harddisk-solidstate%s-symbolic", hyphenated_connection_bus); else s = g_strdup_printf ("drive-harddisk%s-symbolic", hyphenated_connection_bus); } info->media_icon_symbolic = g_themed_icon_new_with_default_fallbacks (s); g_free (s); } /* prepend a qualifier to the media description, based on the disc state */ if (udisks_drive_get_optical_blank (drive)) { /* Translators: String used for a blank disc. The %s is the disc type e.g. "CD-RW Disc" */ s = g_strdup_printf (C_("optical-media", "Blank %s"), info->media_description); g_free (info->media_description); info->media_description = s; } else if (udisks_drive_get_optical_num_audio_tracks (drive) > 0 && udisks_drive_get_optical_num_data_tracks (drive) > 0) { /* Translators: String used for a mixed disc. The %s is the disc type e.g. "CD-ROM Disc" */ s = g_strdup_printf (C_("optical-media", "Mixed %s"), info->media_description); g_free (info->media_description); info->media_description = s; } else if (udisks_drive_get_optical_num_audio_tracks (drive) > 0 && udisks_drive_get_optical_num_data_tracks (drive) == 0) { /* Translators: String used for an audio disc. The %s is the disc type e.g. "CD-ROM Disc" */ s = g_strdup_printf (C_("optical-media", "Audio %s"), info->media_description); g_free (info->media_description); info->media_description = s; } /* Apply UDISKS_NAME, UDISKS_ICON_NAME, UDISKS_SYMBOLIC_ICON_NAME hints, if available */ block = udisks_client_get_block_for_drive (client, drive, TRUE); if (block != NULL) { cs = udisks_block_get_hint_name (block); if (cs != NULL && strlen (cs) > 0) { g_free (info->description); g_free (info->media_description); info->description = g_strdup (cs); info->media_description = g_strdup (cs); } cs = udisks_block_get_hint_icon_name (block); if (cs != NULL && strlen (cs) > 0) { g_clear_object (&info->icon); g_clear_object (&info->media_icon); info->icon = g_themed_icon_new_with_default_fallbacks (cs); info->media_icon = g_themed_icon_new_with_default_fallbacks (cs); } cs = udisks_block_get_hint_symbolic_icon_name (block); if (cs != NULL && strlen (cs) > 0) { g_clear_object (&info->icon_symbolic); g_clear_object (&info->media_icon_symbolic); info->icon_symbolic = g_themed_icon_new_with_default_fallbacks (cs); info->media_icon_symbolic = g_themed_icon_new_with_default_fallbacks (cs); } } if (partition != NULL) { GDBusObject *object_for_partition; object_for_partition = g_dbus_interface_get_object (G_DBUS_INTERFACE (partition)); if (object_for_partition != NULL) block_for_partition = udisks_object_peek_block (UDISKS_OBJECT (object_for_partition)); } if (block_for_partition == NULL) block_for_partition = block; if (partition != NULL) { /* Translators: Used to describe a partition of a drive. * The %d is the partition number. * The %s is the description for the drive (e.g. "2 GB Thumb Drive"). */ s = g_strdup_printf (C_("part-drive", "Partition %d of %s"), udisks_partition_get_number (partition), info->description); g_free (info->description); info->description = s; } /* calculate and set one-liner */ if (block != NULL) { const gchar *drive_revision = udisks_drive_get_revision (drive); if (strlen (drive_revision) > 0) { /* Translators: String used for one-liner description of drive. * The first %s is the description of the object (e.g. "80 GB Disk" or "Partition 2 of 2 GB Thumb Drive"). * The second %s is the name of the object (e.g. "INTEL SSDSA2MH080G1GC"). * The third %s is the fw revision (e.g "45ABX21"). * The fourth %s is the special device file (e.g. "/dev/sda"). */ info->one_liner = g_strdup_printf (C_("one-liner-drive", "%s — %s [%s] (%s)"), info->description, info->name, drive_revision, udisks_block_get_preferred_device (block_for_partition)); } else { /* Translators: String used for one-liner description of drive w/o known fw revision. * The first %s is the description of the object (e.g. "80 GB Disk"). * The second %s is the name of the object (e.g. "INTEL SSDSA2MH080G1GC"). * The third %s is the special device file (e.g. "/dev/sda"). */ info->one_liner = g_strdup_printf (C_("one-liner-drive", "%s — %s (%s)"), info->description, info->name, udisks_block_get_preferred_device (block_for_partition)); } } g_free (hyphenated_connection_bus); g_free (size_str); info->sort_key = g_strdup_printf ("00_drive_%s", udisks_drive_get_sort_key (drive)); g_clear_object (&block); }