static void volume_mount_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { PanelVolumeMountData *mount_data = user_data; GError *error; char *primary; char *name; error = NULL; if (!g_volume_mount_finish (G_VOLUME (source_object), res, &error)) { if (error->code != G_IO_ERROR_FAILED_HANDLED) { name = g_volume_get_name (G_VOLUME (source_object)); primary = g_strdup_printf (_("Unable to mount %s"), name); g_free (name); panel_error_dialog (NULL, mount_data->screen, "cannot_mount_volume", TRUE, primary, error->message); g_free (primary); } g_error_free (error); } //FIXME: should we activate the root of the new mount? g_object_unref (mount_data->mount_op); g_slice_free (PanelVolumeMountData, mount_data); }
static gboolean ignore_volume (GVolume *volume) { gboolean ret = TRUE; char *path; GDrive *drive; /* Ignore drive? */ drive = g_volume_get_drive (volume); if (drive != NULL && ignore_drive (drive)) { g_object_unref (drive); return TRUE; } g_clear_object (&drive); path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE); if (path != NULL) { ret = FALSE; g_free (path); } else { GRL_DEBUG ("%s: Not adding volume %s as it has no identifier", __FUNCTION__, g_volume_get_name (volume)); } return ret; }
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 void do_volume_tests (GDrive *drive, GVolume *volume) { GDrive *d; gchar *name; GMount *mount; gchar *uuid; name = g_volume_get_name (volume); g_assert (name != NULL); g_free (name); d = g_volume_get_drive (volume); g_assert (d == drive); if (d != NULL) g_object_unref (d); mount = g_volume_get_mount (volume); if (mount != NULL) { do_mount_tests (drive, volume, mount); g_object_unref (mount); } uuid = g_volume_get_uuid (volume); if (uuid) { GVolume *v; v = g_volume_monitor_get_volume_for_uuid (monitor, uuid); g_assert (v == volume); g_object_unref (v); g_free (uuid); } }
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 monitor_volume_changed (GVolumeMonitor *volume_monitor, GVolume *volume) { char *name; name = g_volume_get_name (volume); g_print ("Volume changed: '%s'\n", name); g_free (name); monitor_print_volume (volume); }
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 gchar *_cd_find_volume_name_from_drive_name (const gchar *cName) { g_return_val_if_fail (cName != NULL, NULL); cd_message ("%s (%s)", __func__, cName); GDrive *pDrive = _cd_find_drive_from_name (cName); g_return_val_if_fail (pDrive != NULL, NULL); gchar *cVolumeName = NULL; GList *pAssociatedVolumes = g_drive_get_volumes (pDrive); if (pAssociatedVolumes != NULL) { GVolume *pVolume; GList *av; if (pAssociatedVolumes->next != NULL) { cd_message ("ce disque contient plus d'un volume, on garde le nom du disque plutot que de selectionner le nom d'un volume"); cd_message ("Pour info, la liste des volumes disponibles sur ce disque est :"); for (av = pAssociatedVolumes; av != NULL; av = av->next) { pVolume = av->data; cd_message (" - %s", g_volume_get_name (pVolume)); /*if (cVolumeName == NULL) cVolumeName = g_volume_get_name (pVolume); else cd_warning ("Attention : this drive (%s) has more than 1 volume but we only consider the first one (%s), ignoring %s", cName, cVolumeName, g_volume_get_name (pVolume));*/ g_object_unref (pVolume); } } else { return g_strdup ("discard"); pVolume = pAssociatedVolumes->data; cVolumeName = g_volume_get_name (pVolume); g_object_unref (pVolume); cd_message ("ce disque contient 1 seul volume (%s), on prend son nom", cVolumeName); } g_list_free (pAssociatedVolumes); } //g_object_unref (pDrive); return cVolumeName; }
const gchar * xfdesktop_volume_icon_peek_label(XfdesktopIcon *icon) { XfdesktopVolumeIcon *volume_icon = XFDESKTOP_VOLUME_ICON(icon); g_return_val_if_fail(XFDESKTOP_IS_VOLUME_ICON(icon), NULL); if(!volume_icon->priv->label) { volume_icon->priv->label = g_volume_get_name(volume_icon->priv->volume); } return volume_icon->priv->label; }
void GioLister::DeviceInfo::ReadVolumeInfo(GVolume* volume) { this->volume.reset_without_add(volume); if (!volume) return; volume_name = ConvertAndFree(g_volume_get_name(volume)); volume_uuid = ConvertAndFree(g_volume_get_uuid(volume)); volume_unix_device = ConvertAndFree(g_volume_get_identifier( volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE)); GFile* root = g_volume_get_activation_root(volume); if (root) { volume_root_uri = g_file_get_uri(root); g_object_unref(root); } }
static void xfdesktop_volume_icon_eject_finish(GObject *object, GAsyncResult *result, gpointer user_data) { XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(user_data); GtkWidget *icon_view = xfdesktop_icon_peek_icon_view(XFDESKTOP_ICON(icon)); GtkWidget *toplevel = icon_view ? gtk_widget_get_toplevel(icon_view) : NULL; GVolume *volume = G_VOLUME(object); GError *error = NULL; gboolean eject_successful; g_return_if_fail(G_IS_VOLUME(object)); g_return_if_fail(G_IS_ASYNC_RESULT(result)); g_return_if_fail(XFDESKTOP_IS_VOLUME_ICON(icon)); eject_successful = g_volume_eject_with_operation_finish(volume, result, &error); if(!eject_successful) { /* ignore GIO errors handled internally */ if(error->domain != G_IO_ERROR || error->code != G_IO_ERROR_FAILED_HANDLED) { gchar *volume_name = g_volume_get_name(volume); gchar *primary = g_markup_printf_escaped(_("Failed to eject \"%s\""), volume_name); /* display an error dialog to inform the user */ xfce_message_dialog(toplevel ? GTK_WINDOW(toplevel) : NULL, _("Eject Failed"), GTK_STOCK_DIALOG_ERROR, primary, error->message, GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL); g_free(primary); g_free(volume_name); } g_error_free(error); } #ifdef HAVE_LIBNOTIFY xfdesktop_notify_eject_finish(volume, eject_successful); #endif g_object_unref(icon); }
/** * 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; 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_symbolic_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_symbolic_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-symbolic"); } g_object_set (source, "name", display_name, "icon", icon, NULL); g_free (display_name); g_clear_object (&mount); g_clear_object (&volume); g_clear_object (&icon); }
static void volume_mount_cb (GObject *source_object, GAsyncResult *res, gpointer user_data) { PanelVolumeMountData *mount_data = user_data; GError *error; error = NULL; if (!g_volume_mount_finish (G_VOLUME (source_object), res, &error)) { char *primary; char *name; if (error->code != G_IO_ERROR_FAILED_HANDLED) { name = g_volume_get_name (G_VOLUME (source_object)); primary = g_strdup_printf (_("Unable to mount %s"), name); g_free (name); panel_error_dialog (NULL, mount_data->screen, "cannot_mount_volume", TRUE, primary, error->message); g_free (primary); } g_error_free (error); } else { GMount *mount; GFile *root; char *rooturi; mount = g_volume_get_mount (G_VOLUME (source_object)); root = g_mount_get_root (mount); rooturi = g_file_get_uri (root); activate_uri_on_screen (rooturi, mount_data->screen); g_object_unref (mount); g_object_unref (root); g_free (rooturi); } g_object_unref (mount_data->mount_op); g_slice_free (PanelVolumeMountData, mount_data); }
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); }
static void volume_added (GVolumeMonitor *monitor, GVolume *volume, GObject *unused) { ASVolume *v; char* name = g_volume_get_name (volume); if (name == NULL) return; /* check if existing - could have been added at the initialization phase */ v = name2Volume (name); free (name); if (v != NULL) return; v = ASVolume_newGVolume (volume); SHOW_CHECKPOINT; if (v) { show_progress ("Volume \"%s\" added", v->name); append_bidirelem (AppState.volumes, v); redecorateVolumes(); } }
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); }
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); }
static void xfdesktop_volume_icon_mount_finish(GObject *object, GAsyncResult *result, gpointer user_data) { XfdesktopVolumeIcon *icon = XFDESKTOP_VOLUME_ICON(user_data); GtkWidget *icon_view = xfdesktop_icon_peek_icon_view(XFDESKTOP_ICON(icon)); GtkWidget *toplevel = gtk_widget_get_toplevel(icon_view); GVolume *volume = G_VOLUME(object); GError *error = NULL; if(!g_volume_mount_finish(volume, result, &error)) { if(error->domain != G_IO_ERROR || error->code != G_IO_ERROR_FAILED_HANDLED) { gchar *volume_name = g_volume_get_name(volume); gchar *primary = g_markup_printf_escaped(_("Failed to mount \"%s\""), volume_name); xfce_message_dialog(toplevel ? GTK_WINDOW(toplevel) : NULL, _("Mount Failed"), GTK_STOCK_DIALOG_ERROR, primary, error->message, GTK_STOCK_CLOSE, GTK_RESPONSE_ACCEPT, NULL); g_free(primary); g_free(volume_name); } g_error_free(error); } else { GMount *mount = g_volume_get_mount(volume); GFile *file = NULL; GFileInfo *info = NULL; if(mount) { file = g_mount_get_root(mount); info = g_file_query_info(file, XFDESKTOP_FILE_INFO_NAMESPACE, G_FILE_QUERY_INFO_NONE, NULL, NULL); g_object_unref(mount); } if(file && info) { gboolean activated = FALSE; if(icon->priv->file) g_object_unref(icon->priv->file); icon->priv->file = g_object_ref(file); xfdesktop_file_icon_update_file_info(XFDESKTOP_FILE_ICON(icon), info); activated = GPOINTER_TO_UINT(g_object_get_qdata(G_OBJECT(icon), xfdesktop_volume_icon_activated_quark)); if(activated) { XfdesktopIcon *icon_p = XFDESKTOP_ICON(icon); XFDESKTOP_ICON_CLASS(xfdesktop_volume_icon_parent_class)->activated(icon_p); } g_object_set_qdata(G_OBJECT(icon), xfdesktop_volume_icon_activated_quark, NULL); } else { if(icon->priv->file) g_object_unref(icon->priv->file); icon->priv->file = NULL; xfdesktop_file_icon_update_file_info(XFDESKTOP_FILE_ICON(icon), NULL); } if(file) g_object_unref(file); if(info) g_object_unref(info); } }
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); } } }
GList *vfs_backend_list_volumes (void) { GVolumeMonitor *pVolumeMonitor = g_volume_monitor_get (); GList *pIconsList = NULL; Icon *pNewIcon; //\___________________ On chope les disques connectes (lecteur de CD/disquette/etc) et on liste leurs volumes. GList *pDrivesList = g_volume_monitor_get_connected_drives (pVolumeMonitor); GList *pAssociatedVolumes; GList *dl, *av; GDrive *pDrive; GVolume *pVolume; for (dl = pDrivesList; dl != NULL; dl = dl->next) { pDrive = dl->data; cd_message ("drive '%s'", g_drive_get_name (pDrive)); pAssociatedVolumes = g_drive_get_volumes (pDrive); if (pAssociatedVolumes != NULL) { for (av = pAssociatedVolumes; av != NULL; av = av->next) { pVolume = av->data; cd_message (" + volume '%s'", g_volume_get_name (pVolume)); pNewIcon = _cd_get_icon_for_volume (pVolume, NULL); if (pNewIcon != NULL) pIconsList = g_list_prepend (pIconsList, pNewIcon); //g_object_unref (pVolume); } g_list_free (pAssociatedVolumes); } else // le disque n'a aucun volume montable { cd_message (" le disque n'a aucun volume montable"); /*if (g_drive_is_media_removable (pDrive) && ! g_drive_is_media_check_automatic (pDrive)) { g_drive_get_icon (pDrive); g_drive_get_name (pDrive); }*/ } //g_object_unref (pDrive); } g_list_free (pDrivesList); //\___________________ On chope les volumes qui ne sont pas associes a un disque. GList *pVolumesList = g_volume_monitor_get_volumes (pVolumeMonitor); GList *v; for (v = pVolumesList; v != NULL; v = v->next) { pVolume = v->data; cd_message ("volume '%s'", g_volume_get_name (pVolume)); pDrive = g_volume_get_drive (pVolume); if (pDrive != NULL) // on l'a deja liste dans la 1ere boucle. { cd_message (" drive '%s' est deja liste", g_drive_get_name (pDrive)); //g_object_unref (pDrive); } else { cd_message (" + volume '%s'\n", g_volume_get_name (pVolume)); if (pNewIcon != NULL) pNewIcon = _cd_get_icon_for_volume (pVolume, NULL); pIconsList = g_list_prepend (pIconsList, pNewIcon); } //g_object_unref (pVolume); } g_list_free (pVolumesList); //\___________________ On chope les points de montage qui n'ont pas de volumes. (montage de mtab, ftp, etc) GList *pMountsList = g_volume_monitor_get_mounts (pVolumeMonitor); GMount *pMount; GList *m; for (m = pMountsList; m != NULL; m = m->next) { pMount = m->data; cd_message ("mount '%s'", g_mount_get_name (pMount)); pVolume = g_mount_get_volume (pMount); if (pVolume != NULL) // on l'a deja liste precedemment. { cd_message ("volume '%s' est deja liste", g_volume_get_name (pVolume)); //g_object_unref (pVolume); } else { cd_message ("+ volume '%s'", g_volume_get_name (pVolume)); if (pNewIcon != NULL) pNewIcon = _cd_get_icon_for_volume (NULL, pMount); pIconsList = g_list_prepend (pIconsList, pNewIcon); } //g_object_unref (pMount); } g_list_free (pMountsList); return pIconsList; }
static char* g_udisks_mount_get_name (GMount* base) { GUDisksMount* mnt = G_UDISKS_MOUNT(base); return mnt->vol ? g_volume_get_name(G_VOLUME(mnt->vol)) : NULL; }
GList *vfs_backend_list_directory (const gchar *cBaseURI, CairoDockFMSortType iSortType, int iNewIconsType, gboolean bListHiddenFiles, gchar **cFullURI) { g_return_val_if_fail (cBaseURI != NULL, NULL); cd_message ("%s (%s)", __func__, cBaseURI); gchar *cURI; gboolean bAddHome = FALSE; if (strcmp (cBaseURI, CAIRO_DOCK_FM_VFS_ROOT) == 0) { cURI = g_strdup ("computer://"); bAddHome = TRUE; ///*cFullURI = cURI; ///return vfs_backend_list_volumes (); //vfs_backend_list_volumes (); } else if (strcmp (cBaseURI, CAIRO_DOCK_FM_NETWORK) == 0) cURI = g_strdup ("network://"); else cURI = (*cBaseURI == '/' ? g_strconcat ("file://", cBaseURI, NULL) : g_strdup (cBaseURI)); *cFullURI = cURI; GFile *pFile = g_file_new_for_uri (cURI); GError *erreur = NULL; const gchar *cAttributes = G_FILE_ATTRIBUTE_STANDARD_TYPE"," G_FILE_ATTRIBUTE_STANDARD_SIZE"," G_FILE_ATTRIBUTE_TIME_MODIFIED"," G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE"," G_FILE_ATTRIBUTE_STANDARD_NAME"," G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN"," G_FILE_ATTRIBUTE_STANDARD_ICON"," G_FILE_ATTRIBUTE_STANDARD_TARGET_URI"," G_FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE; GFileEnumerator *pFileEnum = g_file_enumerate_children (pFile, cAttributes, G_FILE_QUERY_INFO_NONE, /// G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS NULL, &erreur); //g_object_unref (pFile); if (erreur != NULL) { cd_warning ("gnome_integration : %s", erreur->message); g_error_free (erreur); return NULL; } int iOrder = 0; GList *pIconList = NULL; Icon *icon; GFileInfo *pFileInfo; do { pFileInfo = g_file_enumerator_next_file (pFileEnum, NULL, &erreur); if (erreur != NULL) { cd_warning ("gnome_integration : %s", erreur->message); g_error_free (erreur); erreur = NULL; continue; } if (pFileInfo == NULL) break ; gboolean bIsHidden = g_file_info_get_is_hidden (pFileInfo); if (bListHiddenFiles || ! bIsHidden) { GFileType iFileType = g_file_info_get_file_type (pFileInfo); GIcon *pFileIcon = g_file_info_get_icon (pFileInfo); if (pFileIcon == NULL) { cd_message ("AUCUNE ICONE"); continue; } const gchar *cFileName = g_file_info_get_name (pFileInfo); const gchar *cMimeType = g_file_info_get_content_type (pFileInfo); gchar *cName = NULL; icon = g_new0 (Icon, 1); icon->iType = iNewIconsType; icon->cBaseURI = g_strconcat (*cFullURI, "/", cFileName, NULL); cd_message ("+ %s (mime:%s)", icon->cBaseURI, cMimeType); if (iFileType == G_FILE_TYPE_MOUNTABLE) { const gchar *cTargetURI = g_file_info_get_attribute_string (pFileInfo, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI); cd_message (" c'est un point de montage correspondant a %s", cTargetURI); GMount *pMount = NULL; if (cTargetURI != NULL) { icon->acCommand = g_strdup (cTargetURI); GFile *file = g_file_new_for_uri (cTargetURI); pMount = g_file_find_enclosing_mount (file, NULL, NULL); //g_object_unref (file); } if (pMount != NULL) { cName = g_mount_get_name (pMount); cd_message ("un GMount existe (%s)", cName); GVolume *volume = g_mount_get_volume (pMount); if (volume) cd_message (" volume associe : %s", g_volume_get_name (volume)); GDrive *drive = g_mount_get_drive (pMount); if (drive) cd_message (" disque associe : %s", g_drive_get_name (drive)); ///pFileIcon = g_mount_get_icon (pMount); } else { cName = g_strdup (cFileName); gchar *str = strrchr (cName, '.'); // on vire l'extension ".volume" ou ".drive". if (str != NULL) { *str = '\0'; if (strcmp (str+1, "link") == 0) { if (strcmp (cName, "root") == 0) { g_free (cName); cName = g_strdup ("/"); } } else if (strcmp (str+1, "drive") == 0) // on cherche un nom plus parlant si possible. { gchar *cVolumeName = _cd_find_volume_name_from_drive_name (cName); if (cVolumeName != NULL) { g_free (cName); g_free (cVolumeName); continue; /// apparemment il n'est plus necessaire d'afficher les .drives qui ont 1 (ou plusieurs ?) volumes, car ces derniers sont dans la liste, donc ca fait redondant. /**if (strcmp (cVolumeName, "discard") == 0) continue; g_free (cName); cName = cVolumeName;*/ } } } } icon->iVolumeID = 1; cd_message ("le nom de ce volume est : %s", cName); } else cName = g_strdup (cFileName); if (icon->acCommand == NULL) icon->acCommand = g_strdup (icon->cBaseURI); icon->acName = cName; icon->acFileName = NULL; if (cMimeType != NULL && strncmp (cMimeType, "image", 5) == 0) { gchar *cHostname = NULL; gchar *cFilePath = g_filename_from_uri (icon->cBaseURI, &cHostname, &erreur); if (erreur != NULL) { g_error_free (erreur); erreur = NULL; } else if (cHostname == NULL || strcmp (cHostname, "localhost") == 0) // on ne recupere la vignette que sur les fichiers locaux. { icon->acFileName = g_strdup (cFilePath); cairo_dock_remove_html_spaces (icon->acFileName); } g_free (cHostname); g_free (cFilePath); } if (icon->acFileName == NULL) { icon->acFileName = _cd_get_icon_path (pFileIcon); cd_message ("icon->acFileName : %s", icon->acFileName); } if (iSortType == CAIRO_DOCK_FM_SORT_BY_SIZE) icon->fOrder = g_file_info_get_size (pFileInfo); else if (iSortType == CAIRO_DOCK_FM_SORT_BY_DATE) { GTimeVal t; g_file_info_get_modification_time (pFileInfo, &t); icon->fOrder = t.tv_sec; } else if (iSortType == CAIRO_DOCK_FM_SORT_BY_TYPE) icon->fOrder = (cMimeType != NULL ? *((int *) cMimeType) : 0); if (icon->fOrder == 0) // un peu moyen mais mieux que rien non ? icon->fOrder = iOrder; pIconList = g_list_insert_sorted (pIconList, icon, (GCompareFunc) cairo_dock_compare_icons_order); //g_list_prepend (pIconList, icon); iOrder ++; } } while (TRUE); // 'g_file_enumerator_close' est appelee lors du dernier 'g_file_enumerator_next_file'. if (bAddHome && pIconList != NULL) { icon = g_new0 (Icon, 1); icon->iType = iNewIconsType; icon->cBaseURI = g_strdup_printf ("file://%s", "/home"); icon->acCommand = g_strdup ("/home"); //icon->acCommand = g_strdup (icon->cBaseURI); icon->iVolumeID = 0; icon->acName = g_strdup ("home"); Icon *pRootIcon = cairo_dock_get_icon_with_name (pIconList, "/"); if (pRootIcon == NULL) { pRootIcon = cairo_dock_get_first_icon (pIconList); g_print ("domage ! (%s:%s)\n", pRootIcon->acCommand, pRootIcon->acName); } icon->acFileName = g_strdup (pRootIcon->acFileName); icon->fOrder = iOrder++; pIconList = g_list_insert_sorted (pIconList, icon, (GCompareFunc) cairo_dock_compare_icons_order); } if (iSortType == CAIRO_DOCK_FM_SORT_BY_NAME) pIconList = cairo_dock_sort_icons_by_name (pIconList); else pIconList = cairo_dock_sort_icons_by_order (pIconList); return pIconList; }
static VALUE rg_name(VALUE self) { return CSTR2RVAL_FREE(g_volume_get_name(_SELF(self))); }
/** * 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); } }