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