static void panel_menu_item_append_volume (GtkWidget *menu, GVolume *volume) { GtkWidget *item; GIcon *icon; char *title; char *tooltip; icon = g_volume_get_icon (volume); title = g_volume_get_name (volume); item = panel_image_menu_item_new (); setup_menu_item_with_icon (item, panel_menu_icon_get_size (), NULL, NULL, icon, title); g_object_unref (icon); tooltip = g_strdup_printf (_("Mount %s"), title); panel_util_set_tooltip_text (item, tooltip); g_free (tooltip); g_free (title); gtk_menu_shell_append (GTK_MENU_SHELL (menu), item); g_signal_connect_data (item, "activate", G_CALLBACK (panel_menu_item_mount_volume), g_object_ref (volume), (GClosureNotify) g_object_unref, 0); g_signal_connect (G_OBJECT (item), "button_press_event", G_CALLBACK (menu_dummy_button_press_event), NULL); }
static GList * add_volume (GList *media_list, GVolume *volume, GDrive *drive, GrlOpticalMediaSource *source) { char *name, *icon_uri; GIcon *icon; char *device_path, *id; GrlMedia * media; GMount *mount; device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (device_path == NULL) return media_list; /* Is it an audio CD or a blank media */ mount = g_volume_get_mount (volume); if (mount != NULL) { GFile *root; root = g_mount_get_root (mount); g_object_unref (mount); if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) { /* We don't add Audio CDs, or blank media */ g_object_unref (root); g_free (device_path); return media_list; } g_object_unref (root); } media = grl_media_video_new (); id = g_filename_to_uri (device_path, NULL, NULL); g_free (device_path); grl_media_set_id (media, id); g_free (id); /* Work out an icon to display */ icon = g_volume_get_icon (volume); icon_uri = get_uri_for_gicon (icon); g_object_unref (icon); grl_media_set_thumbnail (media, icon_uri); g_free (icon_uri); /* Get the volume's pretty name for the menu label */ name = g_volume_get_name (volume); g_strstrip (name); grl_media_set_title (media, name); g_free (name); grl_media_set_mime (media, "x-special/device-block"); return g_list_prepend (media_list, media); }
static void update_vol(FmPlacesModel* model, FmPlaceItem* item, GtkTreeIter* it, FmFileInfoJob* job) { FmIcon* icon; GIcon* gicon; char* name; GdkPixbuf* pix; GMount* mount; FmPath* path; name = g_volume_get_name(item->vol); if(item->fi->icon) fm_icon_unref(item->fi->icon); gicon = g_volume_get_icon(item->vol); icon = fm_icon_from_gicon(gicon); item->fi->icon = icon; g_object_unref(gicon); mount = g_volume_get_mount(item->vol); if(mount) { GFile* gf = g_mount_get_root(mount); path = fm_path_new_for_gfile(gf); g_object_unref(gf); g_object_unref(mount); item->vol_mounted = TRUE; } else { path = NULL; item->vol_mounted = FALSE; } if(!fm_path_equal(item->fi->path, path)) { fm_file_info_set_path(item->fi, path); if(path) { if(job) fm_file_info_job_add(job, path); else { job = fm_file_info_job_new(NULL, FM_FILE_INFO_JOB_FOLLOW_SYMLINK); model->jobs = g_slist_prepend(model->jobs, job); g_signal_connect(job, "finished", G_CALLBACK(on_file_info_job_finished), model); fm_job_run_async(FM_JOB(job)); } fm_path_unref(path); } } pix = fm_icon_get_pixbuf(item->fi->icon, fm_config->pane_icon_size); gtk_list_store_set(GTK_LIST_STORE(model), it, FM_PLACES_MODEL_COL_ICON, pix, FM_PLACES_MODEL_COL_LABEL, name, -1); g_object_unref(pix); g_free(name); }
static Icon *_cd_get_icon_for_volume (GVolume *pVolume, GMount *pMount) { Icon *pNewIcon = NULL; GIcon *pIcon; GFile *pRootDir; if (pVolume != NULL) pMount = g_volume_get_mount (pVolume); else if (pMount == NULL) return NULL; if (pMount != NULL) // ce volume est monte. { pNewIcon = g_new0 (Icon, 1); pNewIcon->acName = g_mount_get_name (pMount); pRootDir = g_mount_get_root (pMount); pNewIcon->acCommand = g_file_get_uri (pRootDir); //g_object_unref (pRootDir); pIcon = g_mount_get_icon (pMount); pNewIcon->acFileName = _cd_get_icon_path (pIcon); //g_object_unref (pIcon); //g_object_unref (pMount); } else // ce volume est demonte, on le montre quand meme (l'automount peut etre off). { pNewIcon = g_new0 (Icon, 1); pNewIcon->acName = g_volume_get_name (pVolume); pIcon = g_volume_get_icon (pVolume); pNewIcon->acFileName = _cd_get_icon_path (pIcon); //g_object_unref (pIcon); pNewIcon->acCommand = g_strdup (pNewIcon->acName); } pNewIcon->iVolumeID = 1; pNewIcon->cBaseURI = g_strdup (pNewIcon->acCommand); cd_message (" => %s", pNewIcon->acCommand); return pNewIcon; }
static void update_vol(PlaceItem* item, GtkTreeIter* it) { FmIcon* icon; GIcon* gicon; char* name; GdkPixbuf* pix; name = g_volume_get_name(item->vol); if(item->icon) fm_icon_unref(item->icon); gicon = g_volume_get_icon(item->vol); icon = fm_icon_from_gicon(gicon); item->icon = icon; g_object_unref(gicon); pix = fm_icon_get_pixbuf(item->icon, fm_config->pane_icon_size); gtk_list_store_set(model, it, COL_ICON, pix, COL_LABEL, name, -1); g_object_unref(pix); g_free(name); }
void GVolume2ASVolume (ASVolume *v, GVolume *g_v) { GMount *mount = g_volume_get_mount (g_v); v->gVolume = g_v; ASVolume_freeData (v); set_string (&(v->name), g_volume_get_name (v->gVolume)); LOCAL_DEBUG_OUT ("mount = %p", mount); v->flags = 0; if (g_volume_can_eject (g_v)) set_flags (v->flags, ASVolume_Ejectable); if (mount) { set_flags (v->flags, ASVolume_Mounted); g_object_unref (mount); } if (check_audio_cd (g_v)) set_flags (v->flags, ASVolume_Audio); else if (check_dvd_video (g_v)) set_flags (v->flags, ASVolume_Video); v->icon = g_volume_get_icon (g_v); ASVolume_parseGnomeIconString (v); }
static GIcon * xfdesktop_volume_icon_load_icon(XfdesktopIcon *icon) { XfdesktopVolumeIcon *volume_icon = XFDESKTOP_VOLUME_ICON(icon); XfdesktopFileIcon *file_icon = XFDESKTOP_FILE_ICON(icon); GIcon *gicon = NULL; TRACE("entering"); /* load icon and keep a ref to it */ if(volume_icon->priv->volume) { gicon = g_volume_get_icon(volume_icon->priv->volume); if(G_IS_ICON(gicon)) g_object_ref(gicon); g_object_set(file_icon, "gicon", gicon, NULL); /* Add any user set emblems */ gicon = xfdesktop_file_icon_add_emblems(file_icon); } return gicon; }
static void list_volumes (GList *volumes, int indent, gboolean only_with_no_drive) { GList *l, *mounts; int c, i; GMount *mount; GVolume *volume; GDrive *drive; char *name; char *uuid; GFile *activation_root; char **ids; GIcon *icon; char *type_name; const gchar *sort_key; for (c = 0, l = volumes; l != NULL; l = l->next, c++) { volume = (GVolume *) l->data; if (only_with_no_drive) { drive = g_volume_get_drive (volume); if (drive != NULL) { g_object_unref (drive); continue; } } name = g_volume_get_name (volume); g_print ("%*sVolume(%d): %s\n", indent, "", c, name); g_free (name); type_name = get_type_name (volume); g_print ("%*sType: %s\n", indent+2, "", type_name); g_free (type_name); if (extra_detail) { ids = g_volume_enumerate_identifiers (volume); if (ids && ids[0] != NULL) { g_print ("%*sids:\n", indent+2, ""); for (i = 0; ids[i] != NULL; i++) { char *id = g_volume_get_identifier (volume, ids[i]); g_print ("%*s %s: '%s'\n", indent+2, "", ids[i], id); g_free (id); } } g_strfreev (ids); uuid = g_volume_get_uuid (volume); if (uuid) g_print ("%*suuid=%s\n", indent + 2, "", uuid); activation_root = g_volume_get_activation_root (volume); if (activation_root) { char *uri; uri = g_file_get_uri (activation_root); g_print ("%*sactivation_root=%s\n", indent + 2, "", uri); g_free (uri); g_object_unref (activation_root); } icon = g_volume_get_icon (volume); if (icon) { if (G_IS_THEMED_ICON (icon)) show_themed_icon_names (G_THEMED_ICON (icon), indent + 2); g_object_unref (icon); } g_print ("%*scan_mount=%d\n", indent + 2, "", g_volume_can_mount (volume)); g_print ("%*scan_eject=%d\n", indent + 2, "", g_volume_can_eject (volume)); g_print ("%*sshould_automount=%d\n", indent + 2, "", g_volume_should_automount (volume)); sort_key = g_volume_get_sort_key (volume); if (sort_key != NULL) g_print ("%*ssort_key=%s\n", indent + 2, "", sort_key); g_free (uuid); } mount = g_volume_get_mount (volume); if (mount) { mounts = g_list_prepend (NULL, mount); list_mounts (mounts, indent + 2, FALSE); g_list_free (mounts); g_object_unref (mount); } } }
static VALUE rg_icon(VALUE self) { return GOBJ2RVAL_UNREF(g_volume_get_icon(_SELF(self))); }
void thunar_notify_eject (GVolume *volume) { const gchar * const *icon_names; NotifyNotification *notification = NULL; const gchar *summary; GFileInfo *info; gboolean read_only = FALSE; GMount *mount; GFile *icon_file; GFile *mount_point; GIcon *icon; gchar *icon_name = NULL; gchar *message; gchar *name; g_return_if_fail (G_IS_VOLUME (volume)); if (!thunar_notify_init ()) return; mount = g_volume_get_mount (volume); if (mount != NULL) { mount_point = g_mount_get_root (mount); info = g_file_query_info (mount_point, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE, G_FILE_QUERY_INFO_NONE, NULL, NULL); if (info != NULL) { read_only = !g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE); g_object_unref (info); } g_object_unref (mount_point); } name = g_volume_get_name (volume); icon = g_volume_get_icon (volume); if (G_IS_THEMED_ICON (icon)) { icon_names = g_themed_icon_get_names (G_THEMED_ICON (icon)); if (icon_names != NULL) icon_name = g_strdup (icon_names[0]); } else if (G_IS_FILE_ICON (icon)) { icon_file = g_file_icon_get_file (G_FILE_ICON (icon)); if (icon_file != NULL) { icon_name = g_file_get_path (icon_file); g_object_unref (icon_file); } } g_object_unref (icon); if (icon_name == NULL) icon_name = g_strdup ("drive-removable-media"); if (read_only) { summary = _("Ejecting device"); message = g_strdup_printf (_("The device \"%s\" is being ejected. " "This may take some time"), name); } else { summary = _("Writing data to device"); message = g_strdup_printf (_("There is data that needs to be written to the " "device \"%s\" before it can be removed. Please " "do not remove the media or disconnect the drive"), name); } #ifdef NOTIFY_CHECK_VERSION #if NOTIFY_CHECK_VERSION (0, 7, 0) notification = notify_notification_new (summary, message, icon_name); #else notification = notify_notification_new (summary, message, icon_name, NULL); #endif #else notification = notify_notification_new (summary, message, icon_name, NULL); #endif notify_notification_set_urgency (notification, NOTIFY_URGENCY_CRITICAL); notify_notification_set_timeout (notification, NOTIFY_EXPIRES_NEVER); notify_notification_show (notification, NULL); g_object_set_data_full (G_OBJECT (volume), "thunar-notification", notification, g_object_unref); g_free (message); g_free (icon_name); g_free (name); }
inline static void show_autorun_dlg(GVolume* vol, GMount* mount) { GtkBuilder* builder; GtkTreeIter it; GtkTreeViewColumn* col; GtkTreeSelection* tree_sel; GtkCellRenderer*render; GtkImage* icon; GIcon* gicon; AutoRun* data; data = g_slice_new(AutoRun); data->cancel = g_cancellable_new(); builder = gtk_builder_new(); gtk_builder_add_from_file(builder, PACKAGE_UI_DIR "/autorun.glade", NULL); data->dlg = GTK_DIALOG(gtk_builder_get_object(builder, "dlg")); data->view = GTK_TREE_VIEW(gtk_builder_get_object(builder, "listview")); data->type = GTK_LABEL(gtk_builder_get_object(builder, "type")); icon = GTK_IMAGE(gtk_builder_get_object(builder, "icon")); g_object_unref(builder); gicon = g_volume_get_icon(vol); gtk_image_set_from_gicon(icon, gicon, GTK_ICON_SIZE_DIALOG); g_object_unref(gicon); gtk_dialog_set_default_response(data->dlg, GTK_RESPONSE_OK); gtk_dialog_set_alternative_button_order(data->dlg, GTK_RESPONSE_OK, GTK_RESPONSE_CANCEL, -1); tree_sel = gtk_tree_view_get_selection(data->view); gtk_tree_selection_set_mode(tree_sel, GTK_SELECTION_BROWSE); col = gtk_tree_view_column_new(); render = gtk_cell_renderer_pixbuf_new(); gtk_tree_view_column_pack_start(col, render, FALSE); gtk_tree_view_column_set_attributes(col, render, "gicon", 0, NULL); render = gtk_cell_renderer_text_new(); gtk_tree_view_column_pack_start(col, render, FALSE); gtk_tree_view_column_set_attributes(col, render, "text", 1, NULL); gtk_tree_view_append_column(data->view, col); data->store = gtk_list_store_new(3, G_TYPE_ICON, G_TYPE_STRING, G_TYPE_OBJECT); data->mount = (GMount*)g_object_ref(mount); gtk_list_store_append(data->store, &it); gicon = g_themed_icon_new("system-file-manager"); gtk_list_store_set(data->store, &it, 0, gicon, 1, _("Open in File Manager"), -1); g_object_unref(gicon); gtk_tree_view_set_model(data->view, GTK_TREE_MODEL(data->store)); gtk_tree_model_get_iter_first(GTK_TREE_MODEL(data->store), &it); gtk_tree_selection_select_iter(tree_sel, &it); g_signal_connect(data->view, "row-activated", G_CALLBACK(on_row_activated), data); g_signal_connect(data->dlg, "response", G_CALLBACK(on_dlg_response), data); g_signal_connect(data->mount, "unmounted", G_CALLBACK(on_unmount), data); gtk_window_set_keep_above(GTK_WINDOW(data->dlg), TRUE); gtk_window_present(GTK_WINDOW(data->dlg)); g_mount_guess_content_type(mount, TRUE, data->cancel, on_content_type_finished, data); pcmanfm_ref(); }
static GIcon* g_udisks_mount_get_icon (GMount* base) { GUDisksMount* mnt = G_UDISKS_MOUNT(base); return mnt->vol ? g_volume_get_icon(G_VOLUME(mnt->vol)) : NULL; }
/** * rb_device_source_set_display_details: * @source: a #RBDeviceSource * * Sets the icon and display name for a device-based source. * The details come from the mount and/or volume. This should * be called in the source's constructed method. */ void rb_device_source_set_display_details (RBDeviceSource *source) { GMount *mount = NULL; GVolume *volume = NULL; GIcon *icon = NULL; char *display_name; GdkPixbuf *pixbuf = NULL; if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "volume")) { g_object_get (source, "volume", &volume, NULL); } if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "mount")) { g_object_get (source, "mount", &mount, NULL); } /* prefer mount details to volume details, as the nautilus sidebar does */ if (mount != NULL) { mount = g_object_ref (mount); } else if (volume != NULL) { mount = g_volume_get_mount (volume); } else { mount = NULL; } if (mount != NULL) { display_name = g_mount_get_name (mount); icon = g_mount_get_icon (mount); rb_debug ("details from mount: display name = %s, icon = %p", display_name, icon); } else if (volume != NULL) { display_name = g_volume_get_name (volume); icon = g_volume_get_icon (volume); rb_debug ("details from volume: display name = %s, icon = %p", display_name, icon); } else { display_name = g_strdup ("Unknown Device"); icon = g_themed_icon_new ("multimedia-player"); } g_object_set (source, "name", display_name, NULL); g_free (display_name); if (icon == NULL) { rb_debug ("no icon set"); pixbuf = NULL; } else if (G_IS_THEMED_ICON (icon)) { GtkIconTheme *theme; const char * const *names; gint size; int i; theme = gtk_icon_theme_get_default (); gtk_icon_size_lookup (RB_SOURCE_ICON_SIZE, &size, NULL); i = 0; names = g_themed_icon_get_names (G_THEMED_ICON (icon)); while (names[i] != NULL && pixbuf == NULL) { rb_debug ("looking up themed icon: %s", names[i]); pixbuf = gtk_icon_theme_load_icon (theme, names[i], size, 0, NULL); i++; } } else if (G_IS_LOADABLE_ICON (icon)) { rb_debug ("loading of GLoadableIcons is not implemented yet"); pixbuf = NULL; } if (pixbuf != NULL) { g_object_set (source, "pixbuf", pixbuf, NULL); g_object_unref (pixbuf); } if (mount != NULL) { g_object_unref (mount); } if (volume != NULL) { g_object_unref (volume); } if (icon != NULL) { g_object_unref (icon); } }