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);
}
}
