/**
* rb_uri_get_filesystem_type:
* @uri: URI to get filesystem type for
*
* Return value: a string describing the type of the filesystem containing the URI
*/
char *
rb_uri_get_filesystem_type (const char *uri)
{
GFile *file;
GFile *extant;
GFileInfo *info;
char *fstype = NULL;
GError *error = NULL;
/* if the file doesn't exist, walk up the directory structure
* until we find something that does.
*/
file = g_file_new_for_uri (uri);
extant = rb_file_find_extant_parent (file);
if (extant == NULL) {
rb_debug ("unable to get filesystem type for %s: none of the directory structure exists", uri);
g_object_unref (file);
return NULL;
}
info = g_file_query_filesystem_info (extant, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, NULL, &error);
if (info != NULL) {
fstype = g_file_info_get_attribute_as_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE);
g_object_unref (info);
} else {
rb_debug ("error querying filesystem info: %s", error->message);
}
g_clear_error (&error);
g_object_unref (file);
g_object_unref (extant);
return fstype;
}
void GioLister::UpdateDeviceFreeSpace(const QString& id) {
{
QMutexLocker l(&mutex_);
if (!devices_.contains(id))
return;
DeviceInfo& device_info = devices_[id];
GFile* root = g_mount_get_root(device_info.mount);
GError* error = NULL;
GFileInfo* info = g_file_query_filesystem_info(
root, G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, &error);
if (error) {
qLog(Warning) << error->message;
g_error_free(error);
} else {
device_info.filesystem_free = g_file_info_get_attribute_uint64(
info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
g_object_unref(info);
}
g_object_unref(root);
}
emit DeviceChanged(id);
}
static void
xfdesktop_volume_icon_update_file_info(XfdesktopFileIcon *icon,
GFileInfo *info)
{
XfdesktopVolumeIcon *volume_icon = XFDESKTOP_VOLUME_ICON(icon);
g_return_if_fail(XFDESKTOP_IS_VOLUME_ICON(icon));
DBG("entering");
/* just replace the file info here */
if(volume_icon->priv->file_info)
g_object_unref(volume_icon->priv->file_info);
volume_icon->priv->file_info = info ? g_object_ref(info) : NULL;
/* update the filesystem info as well */
if(volume_icon->priv->filesystem_info)
g_object_unref(volume_icon->priv->filesystem_info);
if(volume_icon->priv->file) {
volume_icon->priv->filesystem_info = g_file_query_filesystem_info(volume_icon->priv->file,
XFDESKTOP_FILE_INFO_NAMESPACE,
NULL, NULL);
}
/* invalidate the tooltip */
if(volume_icon->priv->tooltip) {
g_free(volume_icon->priv->tooltip);
volume_icon->priv->tooltip = NULL;
}
/* not really easy to check if this changed or not, so just invalidate it */
xfdesktop_file_icon_invalidate_icon(XFDESKTOP_FILE_ICON(icon));
xfdesktop_icon_invalidate_pixbuf(XFDESKTOP_ICON(icon));
xfdesktop_icon_pixbuf_changed(XFDESKTOP_ICON(icon));
}
static GFileInfo *
thunar_file_info_get_filesystem_info (ThunarxFileInfo *file_info)
{
return g_file_query_filesystem_info (THUNAR_PLUGGER_FILE (file_info)->gfile,
THUNARX_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
}
uint64_t getVolumeFreeSizeForPath(const char* path)
{
GRefPtr<GFile> file = adoptGRef(g_file_new_for_path(path));
GRefPtr<GFileInfo> fileInfo = adoptGRef(g_file_query_filesystem_info(file.get(), G_FILE_ATTRIBUTE_FILESYSTEM_FREE, 0, 0));
if (!fileInfo)
return 0;
return g_file_info_get_attribute_uint64(fileInfo.get(), G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
}
static GObject *
impl_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
RBGenericPlayerSource *source;
RBGenericPlayerSourcePrivate *priv;
GMount *mount;
char *mount_name;
RBShell *shell;
GFile *root;
GFileInfo *info;
GError *error = NULL;
source = RB_GENERIC_PLAYER_SOURCE (G_OBJECT_CLASS (rb_generic_player_source_parent_class)->
constructor (type, n_construct_properties, construct_properties));
priv = GENERIC_PLAYER_SOURCE_GET_PRIVATE (source);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell, "db", &priv->db, NULL);
priv->import_errors = rb_import_errors_source_new (shell, priv->error_type);
g_object_unref (shell);
g_object_get (source, "mount", &mount, NULL);
root = g_mount_get_root (mount);
mount_name = g_mount_get_name (mount);
info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, NULL, &error);
if (error != NULL) {
rb_debug ("error querying filesystem info for %s: %s", mount_name, error->message);
g_error_free (error);
priv->read_only = FALSE;
} else {
priv->read_only = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY);
g_object_unref (info);
}
g_free (mount_name);
g_object_unref (root);
g_object_unref (mount);
priv->folder_depth = -1; /* 0 is a possible value, I guess */
priv->playlist_format_unknown = TRUE;
get_device_info (source);
load_songs (source);
return G_OBJECT (source);
}
static void
xfdesktop_regular_file_icon_update_file_info(XfdesktopFileIcon *icon,
GFileInfo *info)
{
XfdesktopRegularFileIcon *regular_file_icon = XFDESKTOP_REGULAR_FILE_ICON(icon);
const gchar *old_display_name;
gchar *new_display_name;
g_return_if_fail(XFDESKTOP_IS_REGULAR_FILE_ICON(icon));
g_return_if_fail(G_IS_FILE_INFO(info));
/* release the old file info */
if(regular_file_icon->priv->file_info) {
g_object_unref(regular_file_icon->priv->file_info);
regular_file_icon->priv->file_info = NULL;
}
regular_file_icon->priv->file_info = g_object_ref(info);
if(regular_file_icon->priv->filesystem_info)
g_object_unref(regular_file_icon->priv->filesystem_info);
regular_file_icon->priv->filesystem_info = g_file_query_filesystem_info(regular_file_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
/* get both, old and new display name */
old_display_name = regular_file_icon->priv->display_name;
new_display_name = xfdesktop_file_utils_get_display_name(regular_file_icon->priv->file,
regular_file_icon->priv->file_info);
/* check whether the display name has changed with the info update */
if(g_strcmp0 (old_display_name, new_display_name) != 0) {
/* replace the display name */
g_free (regular_file_icon->priv->display_name);
regular_file_icon->priv->display_name = new_display_name;
/* notify listeners of the label change */
xfdesktop_icon_label_changed(XFDESKTOP_ICON(icon));
} else {
/* no change, release the new display name */
g_free (new_display_name);
}
/* invalidate the tooltip */
g_free(regular_file_icon->priv->tooltip);
regular_file_icon->priv->tooltip = NULL;
/* not really easy to check if this changed or not, so just invalidate it */
xfdesktop_file_icon_invalidate_icon(XFDESKTOP_FILE_ICON(icon));
xfdesktop_icon_invalidate_pixbuf(XFDESKTOP_ICON(icon));
xfdesktop_icon_pixbuf_changed(XFDESKTOP_ICON(icon));
}
static void
xfdesktop_special_file_icon_changed(GFileMonitor *monitor,
GFile *file,
GFile *other_file,
GFileMonitorEvent event,
XfdesktopSpecialFileIcon *special_file_icon)
{
g_return_if_fail(G_IS_FILE_MONITOR(monitor));
g_return_if_fail(G_IS_FILE(file));
g_return_if_fail(XFDESKTOP_IS_SPECIAL_FILE_ICON(special_file_icon));
/* We don't care about change events only created/deleted */
if(event == G_FILE_MONITOR_EVENT_CHANGED ||
event == G_FILE_MONITOR_EVENT_ATTRIBUTE_CHANGED ||
event == G_FILE_MONITOR_EVENT_CHANGES_DONE_HINT)
return;
/* release the old file information */
if(special_file_icon->priv->file_info) {
g_object_unref(special_file_icon->priv->file_info);
special_file_icon->priv->file_info = NULL;
}
/* release the old file system information */
if(special_file_icon->priv->filesystem_info) {
g_object_unref(special_file_icon->priv->filesystem_info);
special_file_icon->priv->filesystem_info = NULL;
}
/* reload the file information */
special_file_icon->priv->file_info = g_file_query_info(special_file_icon->priv->file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
/* reload the file system information */
special_file_icon->priv->filesystem_info = g_file_query_filesystem_info(special_file_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
/* update the trash full state */
if(special_file_icon->priv->type == XFDESKTOP_SPECIAL_FILE_ICON_TRASH)
xfdesktop_special_file_icon_update_trash_count(special_file_icon);
/* invalidate the tooltip */
g_free(special_file_icon->priv->tooltip);
special_file_icon->priv->tooltip = NULL;
/* update the icon */
xfdesktop_file_icon_invalidate_icon(XFDESKTOP_FILE_ICON(special_file_icon));
xfdesktop_icon_invalidate_pixbuf(XFDESKTOP_ICON(special_file_icon));
xfdesktop_icon_pixbuf_changed(XFDESKTOP_ICON(special_file_icon));
}
guint64 get_fs_property (const char *mountpoint, const char *attr)
{
GFile *root;
GFileInfo *info;
guint64 value;
root = g_file_new_for_path (mountpoint);
info = g_file_query_filesystem_info (root, attr, NULL, NULL);
g_object_unref (G_OBJECT (root));
if (info == NULL) {
return 0;
}
if (!g_file_info_has_attribute (info, attr)) {
g_object_unref (G_OBJECT (info));
return 0;
}
value = g_file_info_get_attribute_uint64 (info, attr);
g_object_unref (G_OBJECT (info));
return value;
}
gboolean
rb_check_dir_has_space (GFile *file,
guint64 bytes_needed)
{
GFile *extant;
GFileInfo *fs_info;
GError *error = NULL;
guint64 free_bytes;
extant = rb_file_find_extant_parent (file);
if (extant == NULL) {
char *uri = g_file_get_uri (file);
g_warning ("Cannot get free space at %s: none of the directory structure exists", uri);
g_free (uri);
return FALSE;
}
fs_info = g_file_query_filesystem_info (extant,
G_FILE_ATTRIBUTE_FILESYSTEM_FREE,
NULL,
&error);
g_object_unref (extant);
if (error != NULL) {
char *uri;
uri = g_file_get_uri (file);
g_warning (_("Cannot get free space at %s: %s"), uri, error->message);
g_free (uri);
return FALSE;
}
free_bytes = g_file_info_get_attribute_uint64 (fs_info,
G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
g_object_unref (fs_info);
if (bytes_needed >= free_bytes)
return FALSE;
return TRUE;
}
static guint64
get_fs_property (RBGenericPlayerSource *source, const char *attr)
{
char *mountpoint;
GFile *root;
GFileInfo *info;
guint64 value = 0;
mountpoint = rb_generic_player_source_get_mount_path (source);
root = g_file_new_for_uri (mountpoint);
g_free (mountpoint);
info = g_file_query_filesystem_info (root, attr, NULL, NULL);
g_object_unref (root);
if (info != NULL) {
if (g_file_info_has_attribute (info, attr)) {
value = g_file_info_get_attribute_uint64 (info, attr);
}
g_object_unref (info);
}
return value;
}
XfdesktopVolumeIcon *
xfdesktop_volume_icon_new(GVolume *volume,
GdkScreen *screen)
{
XfdesktopVolumeIcon *volume_icon;
GMount *mount;
g_return_val_if_fail(G_IS_VOLUME(volume), NULL);
volume_icon = g_object_new(XFDESKTOP_TYPE_VOLUME_ICON, NULL);
volume_icon->priv->volume = g_object_ref(G_OBJECT(volume));
volume_icon->priv->gscreen = screen;
mount = g_volume_get_mount(volume);
if(mount) {
volume_icon->priv->file = g_mount_get_root(mount);
volume_icon->priv->file_info = g_file_query_info(volume_icon->priv->file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
volume_icon->priv->filesystem_info = g_file_query_filesystem_info(volume_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
g_object_unref(mount);
}
g_signal_connect_swapped(G_OBJECT(gtk_icon_theme_get_for_screen(screen)),
"changed",
G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),
volume_icon);
g_signal_connect(volume, "changed",
G_CALLBACK(xfdesktop_volume_icon_changed),
volume_icon);
return volume_icon;
}
void GioLister::DeviceInfo::ReadMountInfo(GMount* mount) {
// Get basic information
this->mount.reset_without_add(mount);
if (!mount)
return;
mount_name = ConvertAndFree(g_mount_get_name(mount));
// Get the icon name(s)
mount_icon_names.clear();
GIcon* icon = g_mount_get_icon(mount);
if (G_IS_THEMED_ICON(icon)) {
const char* const * icons = g_themed_icon_get_names(G_THEMED_ICON(icon));
for (const char* const * p = icons ; *p ; ++p) {
mount_icon_names << QString::fromUtf8(*p);
}
}
g_object_unref(icon);
GFile* root = g_mount_get_root(mount);
// Get the mount path
mount_path = ConvertAndFree(g_file_get_path(root));
mount_uri = ConvertAndFree(g_file_get_uri(root));
// Do a sanity check to make sure the root is actually this mount - when a
// device is unmounted GIO sends a changed signal before the removed signal,
// and we end up reading information about the / filesystem by mistake.
GError* error = NULL;
GMount* actual_mount = g_file_find_enclosing_mount(root, NULL, &error);
if (error || !actual_mount) {
g_error_free(error);
invalid_enclosing_mount = true;
} else if (actual_mount) {
g_object_unref(actual_mount);
}
// Query the filesystem info for size, free space, and type
error = NULL;
GFileInfo* info = g_file_query_filesystem_info(root,
G_FILE_ATTRIBUTE_FILESYSTEM_SIZE "," G_FILE_ATTRIBUTE_FILESYSTEM_FREE ","
G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, NULL, &error);
if (error) {
qLog(Warning) << error->message;
g_error_free(error);
} else {
filesystem_size = g_file_info_get_attribute_uint64(
info, G_FILE_ATTRIBUTE_FILESYSTEM_SIZE);
filesystem_free = g_file_info_get_attribute_uint64(
info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
filesystem_type = QString::fromUtf8(g_file_info_get_attribute_string(
info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE));
g_object_unref(info);
}
// Query the file's info for a filesystem ID
// Only afc devices (that I know of) give reliably unique IDs
if (filesystem_type == "afc") {
error = NULL;
info = g_file_query_info(root, G_FILE_ATTRIBUTE_ID_FILESYSTEM,
G_FILE_QUERY_INFO_NONE, NULL, &error);
if (error) {
qLog(Warning) << error->message;
g_error_free(error);
} else {
mount_uuid = QString::fromUtf8(g_file_info_get_attribute_string(
info, G_FILE_ATTRIBUTE_ID_FILESYSTEM));
g_object_unref(info);
}
}
g_object_unref(root);
}
XfdesktopSpecialFileIcon *
xfdesktop_special_file_icon_new(XfdesktopSpecialFileIconType type,
GdkScreen *screen)
{
XfdesktopSpecialFileIcon *special_file_icon;
GFile *file = NULL;
switch(type) {
case XFDESKTOP_SPECIAL_FILE_ICON_FILESYSTEM:
file = g_file_new_for_uri("file:///");
break;
case XFDESKTOP_SPECIAL_FILE_ICON_HOME:
file = g_file_new_for_path(xfce_get_homedir());
break;
case XFDESKTOP_SPECIAL_FILE_ICON_TRASH:
file = g_file_new_for_uri("trash:///");
break;
default:
g_return_val_if_reached(NULL);
}
special_file_icon = g_object_new(XFDESKTOP_TYPE_SPECIAL_FILE_ICON, NULL);
special_file_icon->priv->type = type;
special_file_icon->priv->gscreen = screen;
special_file_icon->priv->file = file;
special_file_icon->priv->file_info = g_file_query_info(file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if(!special_file_icon->priv->file_info) {
g_object_unref(special_file_icon);
return NULL;
}
/* query file system information from GIO */
special_file_icon->priv->filesystem_info = g_file_query_filesystem_info(special_file_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
/* update the trash full state */
if(type == XFDESKTOP_SPECIAL_FILE_ICON_TRASH)
xfdesktop_special_file_icon_update_trash_count(special_file_icon);
g_signal_connect_swapped(G_OBJECT(gtk_icon_theme_get_for_screen(screen)),
"changed",
G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),
special_file_icon);
special_file_icon->priv->monitor = g_file_monitor(special_file_icon->priv->file,
G_FILE_MONITOR_NONE,
NULL, NULL);
if(special_file_icon->priv->monitor) {
g_signal_connect(special_file_icon->priv->monitor,
"changed",
G_CALLBACK(xfdesktop_special_file_icon_changed),
special_file_icon);
}
return special_file_icon;
}
static gboolean
validate_settings(signal_user_data_t *ud, GValue *settings, gint batch)
{
// Check to see if the dest file exists or is
// already in the queue
gchar *message, *dest;
gint count, ii;
gint titleindex;
titleindex = ghb_settings_combo_int(settings, "title");
if (titleindex < 0) return FALSE;
dest = ghb_settings_get_string(settings, "destination");
count = ghb_array_len(ud->queue);
for (ii = 0; ii < count; ii++)
{
GValue *js;
gchar *filename;
js = ghb_array_get_nth(ud->queue, ii);
filename = ghb_settings_get_string(js, "destination");
if (strcmp(dest, filename) == 0)
{
message = g_strdup_printf(
"Destination: %s\n\n"
"Another queued job has specified the same destination.\n"
"Do you want to overwrite?",
dest);
if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Overwrite"))
{
g_free(filename);
g_free(dest);
g_free(message);
return FALSE;
}
g_free(message);
break;
}
g_free(filename);
}
gchar *destdir = g_path_get_dirname(dest);
if (!g_file_test(destdir, G_FILE_TEST_IS_DIR))
{
message = g_strdup_printf(
"Destination: %s\n\n"
"This is not a valid directory.",
destdir);
ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL);
g_free(dest);
g_free(message);
g_free(destdir);
return FALSE;
}
#if !defined(_WIN32)
// This doesn't work properly on windows
if (g_access(destdir, R_OK|W_OK) != 0)
{
message = g_strdup_printf(
"Destination: %s\n\n"
"Can not read or write the directory.",
destdir);
ghb_message_dialog(GTK_MESSAGE_ERROR, message, "Cancel", NULL);
g_free(dest);
g_free(message);
g_free(destdir);
return FALSE;
}
#endif
if (!batch)
{
GFile *gfile;
GFileInfo *info;
guint64 size;
gchar *resolved = ghb_resolve_symlink(destdir);
gfile = g_file_new_for_path(resolved);
info = g_file_query_filesystem_info(gfile,
G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, NULL);
if (info != NULL)
{
if (g_file_info_has_attribute(info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE))
{
size = g_file_info_get_attribute_uint64(info,
G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
gint64 fsize = (guint64)10 * 1024 * 1024 * 1024;
if (size < fsize)
{
message = g_strdup_printf(
"Destination filesystem is almost full: %uM free\n\n"
"Encode may be incomplete if you proceed.\n",
(guint)(size / (1024L*1024L)));
if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Proceed"))
{
g_free(dest);
g_free(message);
return FALSE;
}
g_free(message);
}
}
g_object_unref(info);
}
g_object_unref(gfile);
g_free(resolved);
}
g_free(destdir);
if (g_file_test(dest, G_FILE_TEST_EXISTS))
{
message = g_strdup_printf(
"Destination: %s\n\n"
"File already exists.\n"
"Do you want to overwrite?",
dest);
if (!ghb_message_dialog(GTK_MESSAGE_QUESTION, message, "Cancel", "Overwrite"))
{
g_free(dest);
g_free(message);
return FALSE;
}
g_free(message);
g_unlink(dest);
}
g_free(dest);
// Validate video quality is in a reasonable range
if (!ghb_validate_vquality(settings))
{
return FALSE;
}
// Validate audio settings
if (!ghb_validate_audio(settings))
{
return FALSE;
}
// Validate audio settings
if (!ghb_validate_subtitles(settings))
{
return FALSE;
}
// Validate video settings
if (!ghb_validate_video(settings))
{
return FALSE;
}
// Validate filter settings
if (!ghb_validate_filters(settings))
{
return FALSE;
}
return TRUE;
}
static GObject *
impl_constructor (GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
RBGenericPlayerSource *source;
RBGenericPlayerSourcePrivate *priv;
GMount *mount;
char **playlist_formats;
char *mount_name;
RBShell *shell;
GFile *root;
GFileInfo *info;
GError *error = NULL;
source = RB_GENERIC_PLAYER_SOURCE (G_OBJECT_CLASS (rb_generic_player_source_parent_class)->
constructor (type, n_construct_properties, construct_properties));
priv = GENERIC_PLAYER_SOURCE_GET_PRIVATE (source);
g_object_get (source, "shell", &shell, NULL);
g_object_get (shell, "db", &priv->db, NULL);
priv->import_errors = rb_import_errors_source_new (shell, priv->error_type);
g_object_unref (shell);
g_object_get (source, "mount", &mount, NULL);
root = g_mount_get_root (mount);
mount_name = g_mount_get_name (mount);
info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, NULL, &error);
if (error != NULL) {
rb_debug ("error querying filesystem info for %s: %s", mount_name, error->message);
g_error_free (error);
priv->read_only = FALSE;
} else {
priv->read_only = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY);
g_object_unref (info);
}
g_free (mount_name);
g_object_unref (root);
g_object_unref (mount);
g_object_get (priv->device_info, "playlist-formats", &playlist_formats, NULL);
if (playlist_formats != NULL && g_strv_length (playlist_formats) > 0) {
RhythmDBEntryType entry_type;
g_object_get (source, "entry-type", &entry_type, NULL);
entry_type->has_playlists = TRUE;
g_boxed_free (RHYTHMDB_TYPE_ENTRY_TYPE, entry_type);
}
g_strfreev (playlist_formats);
load_songs (source);
return G_OBJECT (source);
}
XfdesktopRegularFileIcon *
xfdesktop_regular_file_icon_new(GFile *file,
GFileInfo *file_info,
GdkScreen *screen,
XfdesktopFileIconManager *fmanager)
{
XfdesktopRegularFileIcon *regular_file_icon;
g_return_val_if_fail(G_IS_FILE(file), NULL);
g_return_val_if_fail(G_IS_FILE_INFO(file_info), NULL);
g_return_val_if_fail(GDK_IS_SCREEN(screen), NULL);
regular_file_icon = g_object_new(XFDESKTOP_TYPE_REGULAR_FILE_ICON, NULL);
regular_file_icon->priv->file = g_object_ref(file);
regular_file_icon->priv->file_info = g_object_ref(file_info);
/* set the display name */
regular_file_icon->priv->display_name = xfdesktop_file_utils_get_display_name(file,
file_info);
/* query file system information from GIO */
regular_file_icon->priv->filesystem_info = g_file_query_filesystem_info(regular_file_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
/* query file information from GIO */
regular_file_icon->priv->file_info = g_file_query_info(regular_file_icon->priv->file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
regular_file_icon->priv->gscreen = screen;
regular_file_icon->priv->fmanager = fmanager;
g_signal_connect_swapped(G_OBJECT(gtk_icon_theme_get_for_screen(screen)),
"changed",
G_CALLBACK(xfdesktop_icon_invalidate_pixbuf),
regular_file_icon);
if(g_file_info_get_file_type(regular_file_icon->priv->file_info) == G_FILE_TYPE_DIRECTORY) {
regular_file_icon->priv->monitor = g_file_monitor(regular_file_icon->priv->file,
G_FILE_MONITOR_NONE,
NULL,
NULL);
g_signal_connect(regular_file_icon->priv->monitor, "changed",
G_CALLBACK(cb_folder_contents_changed),
regular_file_icon);
g_object_get(regular_file_icon->priv->fmanager,
"show-thumbnails", ®ular_file_icon->priv->show_thumbnails,
NULL);
/* Keep an eye on the show-thumbnails property for folder thumbnails */
g_signal_connect(G_OBJECT(fmanager), "notify::show-thumbnails",
G_CALLBACK(cb_show_thumbnails_notify), regular_file_icon);
}
return regular_file_icon;
}
static void
impl_constructed (GObject *object)
{
RBGenericPlayerSource *source;
RBGenericPlayerSourcePrivate *priv;
RhythmDBEntryType *entry_type;
char **playlist_formats;
char **output_formats;
char *mount_name;
RBShell *shell;
GFile *root;
GFileInfo *info;
GError *error = NULL;
RB_CHAIN_GOBJECT_METHOD (rb_generic_player_source_parent_class, constructed, object);
source = RB_GENERIC_PLAYER_SOURCE (object);
priv = GET_PRIVATE (source);
rb_device_source_set_display_details (RB_DEVICE_SOURCE (source));
g_object_get (source,
"shell", &shell,
"entry-type", &entry_type,
NULL);
g_object_get (shell, "db", &priv->db, NULL);
priv->import_errors = rb_import_errors_source_new (shell,
priv->error_type,
entry_type,
priv->ignore_type);
g_object_unref (shell);
root = g_mount_get_root (priv->mount);
mount_name = g_mount_get_name (priv->mount);
info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, NULL, &error);
if (error != NULL) {
rb_debug ("error querying filesystem info for %s: %s", mount_name, error->message);
g_error_free (error);
priv->read_only = FALSE;
} else {
priv->read_only = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY);
g_object_unref (info);
}
g_free (mount_name);
g_object_unref (root);
g_object_get (priv->device_info, "playlist-formats", &playlist_formats, NULL);
if (playlist_formats != NULL && g_strv_length (playlist_formats) > 0) {
g_object_set (entry_type, "has-playlists", TRUE, NULL);
}
g_strfreev (playlist_formats);
g_object_unref (entry_type);
g_object_get (priv->device_info, "output-formats", &output_formats, NULL);
if (output_formats != NULL) {
GstEncodingTarget *target;
int i;
target = gst_encoding_target_new ("generic-player", "device", "", NULL);
for (i = 0; output_formats[i] != NULL; i++) {
const char *media_type = rb_gst_mime_type_to_media_type (output_formats[i]);
if (media_type != NULL) {
GstEncodingProfile *profile;
profile = rb_gst_get_encoding_profile (media_type);
if (profile != NULL) {
gst_encoding_target_add_profile (target, profile);
}
}
}
g_object_set (source, "encoding-target", target, NULL);
}
g_strfreev (output_formats);
}
/**
* mcm_profile_store_add_profiles_from_mounted_volume:
**/
static gboolean
mcm_profile_store_add_profiles_from_mounted_volume (McmProfileStore *profile_store, GMount *mount)
{
GFile *root;
gchar *path;
gchar *path_root;
const gchar *type;
GFileInfo *info;
GError *error = NULL;
gboolean ret;
gboolean success = FALSE;
/* get the mount root */
root = g_mount_get_root (mount);
path_root = g_file_get_path (root);
if (path_root == NULL)
goto out;
/* get the filesystem type */
info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE, NULL, &error);
if (info == NULL) {
egg_warning ("failed to get filesystem type: %s", error->message);
g_error_free (error);
goto out;
}
type = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE);
egg_debug ("filesystem mounted on %s has type %s", path_root, type);
/* only scan hfs volumes for OSX */
if (g_strcmp0 (type, "hfs") == 0) {
path = g_build_filename (path_root, "Library", "ColorSync", "Profiles", "Displays", NULL);
ret = mcm_profile_store_search_by_path (profile_store, path);
if (ret)
success = TRUE;
g_free (path);
/* no more matching */
goto out;
}
/* and fat32 and ntfs for windows */
if (g_strcmp0 (type, "ntfs") == 0 || g_strcmp0 (type, "msdos") == 0) {
/* Windows XP */
path = g_build_filename (path_root, "Windows", "system32", "spool", "drivers", "color", NULL);
ret = mcm_profile_store_search_by_path (profile_store, path);
if (ret)
success = TRUE;
g_free (path);
/* Windows 2000 */
path = g_build_filename (path_root, "Winnt", "system32", "spool", "drivers", "color", NULL);
ret = mcm_profile_store_search_by_path (profile_store, path);
if (ret)
success = TRUE;
g_free (path);
/* Windows 98 and ME */
path = g_build_filename (path_root, "Windows", "System", "Color", NULL);
ret = mcm_profile_store_search_by_path (profile_store, path);
if (ret)
success = TRUE;
g_free (path);
/* no more matching */
goto out;
}
out:
g_free (path_root);
g_object_unref (root);
return success;
}
static void
file_manager_receive_file_response_cb (GtkDialog *dialog,
GtkResponseType response,
EmpathyFTHandler *handler)
{
EmpathyFTFactory *factory;
GFile *file;
if (response == GTK_RESPONSE_OK)
{
GFile *parent;
GFileInfo *info;
guint64 free_space, file_size;
GError *error = NULL;
file = gtk_file_chooser_get_file (GTK_FILE_CHOOSER (dialog));
parent = g_file_get_parent (file);
info = g_file_query_filesystem_info (parent,
G_FILE_ATTRIBUTE_FILESYSTEM_FREE, NULL, &error);
g_object_unref (parent);
if (error != NULL)
{
g_warning ("Error: %s", error->message);
g_object_unref (file);
return;
}
free_space = g_file_info_get_attribute_uint64 (info,
G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
file_size = empathy_ft_handler_get_total_bytes (handler);
g_object_unref (info);
if (file_size > free_space)
{
GtkWidget *message = gtk_message_dialog_new (GTK_WINDOW (dialog),
GTK_DIALOG_MODAL, GTK_MESSAGE_ERROR,
GTK_BUTTONS_CLOSE,
_("Insufficient free space to save file"));
char *file_size_str, *free_space_str;
file_size_str = g_format_size (file_size);
free_space_str = g_format_size (free_space);
gtk_message_dialog_format_secondary_text (
GTK_MESSAGE_DIALOG (message),
_("%s of free space are required to save this "
"file, but only %s is available. Please "
"choose another location."),
file_size_str, free_space_str);
gtk_dialog_run (GTK_DIALOG (message));
g_free (file_size_str);
g_free (free_space_str);
gtk_widget_destroy (message);
g_object_unref (file);
return;
}
factory = empathy_ft_factory_dup_singleton ();
empathy_ft_factory_set_destination_for_incoming_handler (
factory, handler, file);
g_object_unref (factory);
g_object_unref (file);
}
else
{
/* unref the handler, as we dismissed the file chooser,
* and refused the transfer.
*/
g_object_unref (handler);
}
gtk_widget_destroy (GTK_WIDGET (dialog));
}
static gboolean
volume_icon_changed_timeout(XfdesktopVolumeIcon *volume_icon)
{
GMount *mount;
gboolean mounted_before = FALSE;
gboolean mounted_after = FALSE;
g_return_val_if_fail(XFDESKTOP_IS_VOLUME_ICON(volume_icon), FALSE);
DBG("TIMEOUT");
/* reset the icon's mount point information */
if(volume_icon->priv->file) {
g_object_unref(volume_icon->priv->file);
volume_icon->priv->file = NULL;
/* apparently the volume was mounted before, otherwise
* we wouldn't have had a mount point for it */
mounted_before = TRUE;
}
if(volume_icon->priv->file_info) {
g_object_unref(volume_icon->priv->file_info);
volume_icon->priv->file_info = NULL;
}
if(volume_icon->priv->filesystem_info) {
g_object_unref(volume_icon->priv->filesystem_info);
volume_icon->priv->filesystem_info = NULL;
}
/* check if we have a valid mount now */
mount = g_volume_get_mount(volume_icon->priv->volume);
if(mount) {
/* load mount point information */
volume_icon->priv->file = g_mount_get_root(mount);
volume_icon->priv->file_info =
g_file_query_info(volume_icon->priv->file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
volume_icon->priv->filesystem_info =
g_file_query_filesystem_info(volume_icon->priv->file,
XFDESKTOP_FILESYSTEM_INFO_NAMESPACE,
NULL, NULL);
/* release the mount itself */
g_object_unref(mount);
/* the device is mounted now (we have a mount point for it) */
mounted_after = TRUE;
}
DBG("MOUNTED BEFORE: %d, MOUNTED AFTER: %d", mounted_before, mounted_after);
if(mounted_before != mounted_after) {
/* invalidate the tooltip */
if(volume_icon->priv->tooltip) {
g_free(volume_icon->priv->tooltip);
volume_icon->priv->tooltip = NULL;
}
/* not really easy to check if this changed or not, so just invalidate it */
xfdesktop_icon_invalidate_pixbuf(XFDESKTOP_ICON(volume_icon));
xfdesktop_icon_pixbuf_changed(XFDESKTOP_ICON(volume_icon));
/* finalize the timeout source */
volume_icon->priv->changed_timeout_id = 0;
return FALSE;
} else {
/* increment the timeout counter */
volume_icon->priv->changed_timeout_count += 1;
if(volume_icon->priv->changed_timeout_count >= 5) {
/* finalize the timeout source */
volume_icon->priv->changed_timeout_id = 0;
return FALSE;
} else {
DBG("TRY AGAIN");
return TRUE;
}
}
}
static void
impl_constructed (GObject *object)
{
RBGenericPlayerSource *source;
RBGenericPlayerSourcePrivate *priv;
RhythmDBEntryType *entry_type;
char **playlist_formats;
char **output_formats;
char *mount_name;
RBShell *shell;
GFile *root;
GFileInfo *info;
GError *error = NULL;
char *label;
char *fullname;
char *name;
RB_CHAIN_GOBJECT_METHOD (rb_generic_player_source_parent_class, constructed, object);
source = RB_GENERIC_PLAYER_SOURCE (object);
priv = GET_PRIVATE (source);
rb_device_source_set_display_details (RB_DEVICE_SOURCE (source));
g_object_get (source,
"shell", &shell,
"entry-type", &entry_type,
"name", &name,
NULL);
g_object_get (shell, "db", &priv->db, NULL);
priv->import_errors = rb_import_errors_source_new (shell,
priv->error_type,
entry_type,
priv->ignore_type);
priv->new_playlist_action_name = g_strdup_printf ("generic-player-%p-playlist-new", source);
fullname = g_strdup_printf ("app.%s", priv->new_playlist_action_name);
label = g_strdup_printf (_("New Playlist on %s"), name);
rb_application_add_plugin_menu_item (RB_APPLICATION (g_application_get_default ()),
"display-page-add-playlist",
priv->new_playlist_action_name,
g_menu_item_new (label, fullname));
g_free (fullname);
g_free (label);
g_free (name);
root = g_mount_get_root (priv->mount);
mount_name = g_mount_get_name (priv->mount);
info = g_file_query_filesystem_info (root, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY, NULL, &error);
if (error != NULL) {
rb_debug ("error querying filesystem info for %s: %s", mount_name, error->message);
g_error_free (error);
priv->read_only = FALSE;
} else {
priv->read_only = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY);
g_object_unref (info);
}
g_free (mount_name);
g_object_unref (root);
g_object_get (priv->device_info, "playlist-formats", &playlist_formats, NULL);
if ((priv->read_only == FALSE) && playlist_formats != NULL && g_strv_length (playlist_formats) > 0) {
RBDisplayPageModel *model;
GMenu *playlist_menu;
GMenuModel *playlists;
priv->new_playlist_action = g_simple_action_new (priv->new_playlist_action_name, NULL);
g_signal_connect (priv->new_playlist_action, "activate", G_CALLBACK (new_playlist_action_cb), source);
g_action_map_add_action (G_ACTION_MAP (g_application_get_default ()), G_ACTION (priv->new_playlist_action));
g_object_get (shell, "display-page-model", &model, NULL);
playlists = rb_display_page_menu_new (model,
RB_DISPLAY_PAGE (source),
RB_TYPE_GENERIC_PLAYER_PLAYLIST_SOURCE,
"app.playlist-add-to");
g_object_unref (model);
playlist_menu = g_menu_new ();
g_menu_append (playlist_menu, _("Add to New Playlist"), priv->new_playlist_action_name);
g_menu_append_section (playlist_menu, NULL, playlists);
g_object_set (source, "playlist-menu", playlist_menu, NULL);
}
g_strfreev (playlist_formats);
g_object_unref (entry_type);
g_object_get (priv->device_info, "output-formats", &output_formats, NULL);
if (output_formats != NULL) {
GstEncodingTarget *target;
int i;
target = gst_encoding_target_new ("generic-player", "device", "", NULL);
for (i = 0; output_formats[i] != NULL; i++) {
const char *media_type = rb_gst_mime_type_to_media_type (output_formats[i]);
if (media_type != NULL) {
GstEncodingProfile *profile;
profile = rb_gst_get_encoding_profile (media_type);
if (profile != NULL) {
gst_encoding_target_add_profile (target, profile);
}
}
}
g_object_set (source, "encoding-target", target, NULL);
}
g_strfreev (output_formats);
g_object_unref (shell);
}
