void
ss__gth_catalog_read_metadata (GthCatalog *catalog,
GthFileData *file_data)
{
if (g_file_info_get_attribute_status (file_data->info, "slideshow::personalize") == G_FILE_ATTRIBUTE_STATUS_SET)
g_value_hash_set_boolean (catalog->attributes,
"slideshow::personalize",
g_file_info_get_attribute_boolean (file_data->info, "slideshow::personalize"));
if (g_file_info_get_attribute_status (file_data->info, "slideshow::automatic") == G_FILE_ATTRIBUTE_STATUS_SET)
g_value_hash_set_boolean (catalog->attributes,
"slideshow::automatic",
g_file_info_get_attribute_boolean (file_data->info, "slideshow::automatic"));
if (g_file_info_get_attribute_status (file_data->info, "slideshow::wrap-around") == G_FILE_ATTRIBUTE_STATUS_SET)
g_value_hash_set_boolean (catalog->attributes,
"slideshow::wrap-around",
g_file_info_get_attribute_boolean (file_data->info, "slideshow::wrap-around"));
if (g_file_info_get_attribute_status (file_data->info, "slideshow::random-order") == G_FILE_ATTRIBUTE_STATUS_SET)
g_value_hash_set_boolean (catalog->attributes,
"slideshow::random-order",
g_file_info_get_attribute_boolean (file_data->info, "slideshow::random-order"));
if (g_file_info_get_attribute_status (file_data->info, "slideshow::delay") == G_FILE_ATTRIBUTE_STATUS_SET)
g_value_hash_set_int (catalog->attributes,
"slideshow::delay",
g_file_info_get_attribute_int32 (file_data->info, "slideshow::delay"));
if (g_file_info_get_attribute_status (file_data->info, "slideshow::transition") == G_FILE_ATTRIBUTE_STATUS_SET)
g_value_hash_set_string (catalog->attributes,
"slideshow::transition",
g_file_info_get_attribute_string (file_data->info, "slideshow::transition"));
if (g_file_info_get_attribute_status (file_data->info, "slideshow::playlist") == G_FILE_ATTRIBUTE_STATUS_SET)
g_value_hash_set_stringv (catalog->attributes,
"slideshow::playlist",
g_file_info_get_attribute_stringv (file_data->info, "slideshow::playlist"));
}
//TODO:
JS_EXPORT_API
JSObjectRef dentry_get_flags (Entry* e)
{
JSObjectRef json = json_array_create();
GFile* f;
if (!G_IS_FILE(e)) {
return json;
}
f = e;
GFileInfo* info = g_file_query_info (f,
"standard::*,access::*",
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL,
NULL);
if (info != NULL)
{
gboolean is_read_only = FALSE;
gboolean is_symlink = FALSE;
gboolean is_unreadable = FALSE;
is_unreadable = !g_file_info_get_attribute_boolean(info, "access::can-read");
is_read_only = !g_file_info_get_attribute_boolean(info, "access::can-write");
is_symlink = g_file_info_get_is_symlink(info);
g_object_unref(info);
json_append_number(json, "read_only", is_read_only);
json_append_number(json, "symbolic_link", is_symlink);
json_append_number(json, "unreadable", is_unreadable);
}
return json;
}
static EogThumbData*
eog_thumb_data_new (GFile *file, GError **error)
{
EogThumbData *data;
GFileInfo *file_info;
GError *ioerror = NULL;
g_return_val_if_fail (file != NULL, NULL);
g_return_val_if_fail (error != NULL && *error == NULL, NULL);
data = g_slice_new0 (EogThumbData);
data->uri_str = g_file_get_uri (file);
data->thumb_path = gnome_desktop_thumbnail_path_for_uri (data->uri_str, GNOME_DESKTOP_THUMBNAIL_SIZE_NORMAL);
file_info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED ","
G_FILE_ATTRIBUTE_THUMBNAIL_PATH ","
G_FILE_ATTRIBUTE_THUMBNAILING_FAILED ","
G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
0, NULL, &ioerror);
if (file_info == NULL)
{
set_vfs_error (error, ioerror);
g_clear_error (&ioerror);
}
if (*error == NULL) {
/* if available, copy data */
data->mtime = g_file_info_get_attribute_uint64 (file_info,
G_FILE_ATTRIBUTE_TIME_MODIFIED);
data->mime_type = g_strdup (g_file_info_get_content_type (file_info));
data->thumb_exists = (g_file_info_get_attribute_byte_string (file_info,
G_FILE_ATTRIBUTE_THUMBNAIL_PATH) != NULL);
data->failed_thumb_exists = g_file_info_get_attribute_boolean (file_info,
G_FILE_ATTRIBUTE_THUMBNAILING_FAILED);
data->can_read = TRUE;
if (g_file_info_has_attribute (file_info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ)) {
data->can_read = g_file_info_get_attribute_boolean (file_info,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
}
}
else {
eog_thumb_data_free (data);
data = NULL;
g_clear_error (&ioerror);
}
g_object_unref (file_info);
return data;
}
void
catalogs__gth_browser_folder_tree_popup_before_cb (GthBrowser *browser,
GthFileSource *file_source,
GthFileData *folder)
{
BrowserData *data;
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
g_return_if_fail (data != NULL);
if (GTH_IS_FILE_SOURCE_CATALOGS (file_source)) {
gboolean sensitive;
if (data->folder_popup_create_merge_id == 0)
data->folder_popup_create_merge_id =
gth_menu_manager_append_entries (gth_browser_get_menu_manager (browser, GTH_BROWSER_MENU_MANAGER_FOLDER_CREATE_ACTIONS),
folder_popup_create_entries,
G_N_ELEMENTS (folder_popup_create_entries));
if (data->folder_popup_edit_merge_id == 0)
data->folder_popup_edit_merge_id =
gth_menu_manager_append_entries (gth_browser_get_menu_manager (browser, GTH_BROWSER_MENU_MANAGER_FOLDER_EDIT_ACTIONS),
folder_popup_edit_entries,
G_N_ELEMENTS (folder_popup_edit_entries));
if (data->folder_popup_other_merge_id == 0)
data->folder_popup_other_merge_id =
gth_menu_manager_append_entries (gth_browser_get_menu_manager (browser, GTH_BROWSER_MENU_MANAGER_FOLDER_OTHER_ACTIONS),
folder_popup_other_entries,
G_N_ELEMENTS (folder_popup_other_entries));
sensitive = (folder != NULL) && g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE);
gth_window_enable_action (GTH_WINDOW (browser), "remove-catalog", sensitive);
sensitive = ((folder != NULL)
&& (_g_content_type_is_a (g_file_info_get_content_type (folder->info), "gthumb/library") || _g_content_type_is_a (g_file_info_get_content_type (folder->info), "gthumb/catalog"))
&& g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME));
gth_window_enable_action (GTH_WINDOW (browser), "rename-catalog", sensitive);
sensitive = (folder != NULL) && (! _g_content_type_is_a (g_file_info_get_content_type (folder->info), "gthumb/library"));
gth_window_enable_action (GTH_WINDOW (browser), "catalog-properties", sensitive);
}
else {
gth_menu_manager_remove_entries (gth_browser_get_menu_manager (browser, GTH_BROWSER_MENU_MANAGER_FOLDER_CREATE_ACTIONS), data->folder_popup_create_merge_id);
data->folder_popup_create_merge_id = 0;
gth_menu_manager_remove_entries (gth_browser_get_menu_manager (browser, GTH_BROWSER_MENU_MANAGER_FOLDER_EDIT_ACTIONS), data->folder_popup_edit_merge_id);
data->folder_popup_edit_merge_id = 0;
gth_menu_manager_remove_entries (gth_browser_get_menu_manager (browser, GTH_BROWSER_MENU_MANAGER_FOLDER_CREATE_ACTIONS), data->folder_popup_other_merge_id);
data->folder_popup_other_merge_id = 0;
}
}
static gboolean
_check_file (GFile *mount_root, const char *file_path, gboolean must_be_executable)
{
GFile *file;
GFileInfo *file_info;
gboolean ret;
ret = FALSE;
file = g_file_get_child (mount_root, file_path);
file_info = g_file_query_info (file,
G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE,
G_FILE_QUERY_INFO_NONE,
NULL,
NULL);
if (file_info != NULL)
{
if (must_be_executable)
{
if (g_file_info_get_attribute_boolean (file_info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE))
{
ret = TRUE;
}
}
else
{
ret = TRUE;
}
g_object_unref (file_info);
}
g_object_unref (file);
return ret;
}
static GdkDragAction
xfdesktop_special_file_icon_get_allowed_drop_actions(XfdesktopIcon *icon,
GdkDragAction *suggested_action)
{
XfdesktopSpecialFileIcon *special_file_icon = XFDESKTOP_SPECIAL_FILE_ICON(icon);
GFileInfo *info;
GdkDragAction actions = 0;
if(special_file_icon->priv->type != XFDESKTOP_SPECIAL_FILE_ICON_TRASH) {
info = xfdesktop_file_icon_peek_file_info(XFDESKTOP_FILE_ICON(icon));
if(info) {
if(g_file_info_get_attribute_boolean(info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
XF_DEBUG("can move, copy, link and ask");
actions = GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK;
if(suggested_action)
*suggested_action = GDK_ACTION_MOVE;
}
}
} else {
XF_DEBUG("can move");
actions = GDK_ACTION_MOVE; /* everything else is just silly */
if(suggested_action)
*suggested_action = GDK_ACTION_MOVE;
}
if(suggested_action)
*suggested_action = 0;
return actions;
}
static gboolean
xfdesktop_regular_file_can_write_parent(XfdesktopFileIcon *icon)
{
XfdesktopRegularFileIcon *file_icon = XFDESKTOP_REGULAR_FILE_ICON(icon);
GFile *parent_file;
GFileInfo *parent_info;
gboolean writable;
g_return_val_if_fail(file_icon, FALSE);
parent_file = g_file_get_parent(file_icon->priv->file);
if(!parent_file)
return FALSE;
parent_info = g_file_query_info(parent_file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if(!parent_info) {
g_object_unref(parent_file);
return FALSE;
}
writable = g_file_info_get_attribute_boolean(parent_info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
g_object_unref(parent_info);
g_object_unref(parent_file);
return writable;
}
static GdkDragAction
xfdesktop_volume_icon_get_allowed_drop_actions(XfdesktopIcon *icon,
GdkDragAction *suggested_action)
{
/* if not mounted, it doesn't really make sense to allow any operations
* here. if mounted, we should allow everything if it's writable. */
/* FIXME: should i allow all actions if not mounted as well, and try to
* mount and resolve on drop? */
if(xfdesktop_volume_icon_is_mounted(icon)) {
GFileInfo *info = xfdesktop_file_icon_peek_file_info(XFDESKTOP_FILE_ICON(icon));
if(info) {
if(g_file_info_get_attribute_boolean(info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) {
if(suggested_action)
*suggested_action = GDK_ACTION_COPY;
return GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK;
}
}
}
if(suggested_action)
*suggested_action = 0;
return 0;
}
static gboolean
_check_file (GFile *mount_root,
const char *file_path,
gboolean must_be_executable)
{
g_autoptr (GFile) file = NULL;
g_autoptr (GFileInfo) file_info = NULL;
file = g_file_get_child (mount_root, file_path);
file_info = g_file_query_info (file,
G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE,
G_FILE_QUERY_INFO_NONE,
NULL,
NULL);
if (file_info == NULL)
{
return FALSE;
}
if (must_be_executable &&
!g_file_info_get_attribute_boolean (file_info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE))
{
return FALSE;
}
return TRUE;
}
static gboolean
is_read_only (GFile *location)
{
gboolean ret = TRUE; /* default to read only */
GFileInfo *info;
cedit_debug (DEBUG_COMMANDS);
info = g_file_query_info (location,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE,
NULL,
NULL);
if (info != NULL)
{
if (g_file_info_has_attribute (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
ret = !g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
}
g_object_unref (info);
}
return ret;
}
gboolean theme_is_writable (const gpointer theme)
{
MateThemeCommonInfo *info = theme;
GFile *file;
GFileInfo *file_info;
gboolean writable;
if (info == NULL || info->path == NULL)
return FALSE;
file = g_file_new_for_path (info->path);
file_info = g_file_query_info (file,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
g_object_unref (file);
if (file_info == NULL)
return FALSE;
writable = g_file_info_get_attribute_boolean (file_info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
g_object_unref (file_info);
return writable;
}
static gboolean
gth_file_list_drag_motion (GtkWidget *file_view,
GdkDragContext *context,
gint x,
gint y,
guint time,
gpointer extra_data)
{
GthBrowser *browser = extra_data;
BrowserData *data;
GthFileData *location_data;
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
data->drop_pos = -1;
if ((gtk_drag_get_source_widget (context) == file_view) && ! gth_file_source_is_reorderable (gth_browser_get_location_source (browser))) {
gdk_drag_status (context, 0, time);
return FALSE;
}
location_data = gth_browser_get_location_data (browser);
if (! g_file_info_get_attribute_boolean (location_data->info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) {
gdk_drag_status (context, 0, time);
return FALSE;
}
if (gth_file_source_is_reorderable (gth_browser_get_location_source (browser))) {
GtkAllocation allocation;
if (gtk_drag_get_source_widget (context) == file_view)
gdk_drag_status (context, GDK_ACTION_MOVE, time);
else
gdk_drag_status (context, GDK_ACTION_COPY, time);
gth_file_view_set_drag_dest_pos (GTH_FILE_VIEW (file_view), context, x, y, time, &data->drop_pos);
gtk_widget_get_allocation (file_view, &allocation);
if (y < 10)
data->scroll_diff = - (10 - y);
else if (y > allocation.height - 10)
data->scroll_diff = (10 - (allocation.height - y));
else
data->scroll_diff = 0;
if (data->scroll_diff != 0) {
if (data->scroll_event == 0)
data->scroll_event = gdk_threads_add_timeout (SCROLL_TIMEOUT, drag_motion_autoscroll_cb, browser);
}
else if (data->scroll_event != 0) {
g_source_remove (data->scroll_event);
data->scroll_event = 0;
}
}
else if (gdk_drag_context_get_suggested_action (context) == GDK_ACTION_ASK)
gdk_drag_status (context, GDK_ACTION_ASK, time);
else
gdk_drag_status (context, GDK_ACTION_COPY, time);
return TRUE;
}
void
gth_browser_activate_rename (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GthBrowser *browser = GTH_BROWSER (user_data);
GtkWidget *folder_tree;
GtkWidget *file_list;
folder_tree = gth_browser_get_folder_tree (browser);
if (gtk_widget_has_focus (folder_tree)) {
GthFileData *file_data;
file_data = gth_folder_tree_get_selected (GTH_FOLDER_TREE (folder_tree));
if (file_data == NULL)
return;
if (! g_file_info_get_attribute_boolean (file_data->info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME))
return;
gth_folder_tree_start_editing (GTH_FOLDER_TREE (gth_browser_get_folder_tree (browser)), file_data->file);
g_object_unref (file_data);
return;
}
file_list = gth_browser_get_file_list_view (browser);
if (gtk_widget_has_focus (file_list)) {
gth_hook_invoke ("gth-browser-file-list-rename", browser);
return;
}
if (gth_window_get_current_page (GTH_WINDOW (browser)) == GTH_BROWSER_PAGE_VIEWER) {
gth_hook_invoke ("gth-browser-file-list-rename", browser);
return;
}
}
static gboolean
_should_process (GFileInfo *info)
{
/* check that the file is non-hidden and readable */
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ)) {
if (g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ) == FALSE) {
return FALSE;
}
}
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN)) {
if (g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN)) {
return FALSE;
}
}
return TRUE;
}
static void
clipboard_targets_received_cb (GtkClipboard *clipboard,
GdkAtom *atoms,
int n_atoms,
gpointer user_data)
{
GthBrowser *browser = user_data;
BrowserData *data;
int i;
GthFileData *folder;
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
data->can_paste = FALSE;
for (i = 0; ! data->can_paste && (i < n_atoms); i++)
if (atoms[i] == GNOME_COPIED_FILES)
data->can_paste = TRUE;
set_action_sensitive (data, "Edit_PasteInFolder", data->can_paste);
folder = gth_browser_get_folder_popup_file_data (browser);
set_action_sensitive (data, "Folder_Paste", (folder != NULL) && data->can_paste && g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE));
_g_object_unref (folder);
g_object_unref (browser);
}
static GdkDragAction
xfdesktop_regular_file_icon_get_allowed_drop_actions(XfdesktopIcon *icon,
GdkDragAction *suggested_action)
{
GFileInfo *info = xfdesktop_file_icon_peek_file_info(XFDESKTOP_FILE_ICON(icon));
if(!info) {
if(suggested_action)
*suggested_action = 0;
return 0;
}
/* if it's executable we can 'copy'. if it's a folder we can do anything
* if it's writable. */
if(g_file_info_get_file_type(info) == G_FILE_TYPE_DIRECTORY) {
if(g_file_info_get_attribute_boolean(info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) {
if(suggested_action)
*suggested_action = GDK_ACTION_MOVE;
return GDK_ACTION_MOVE | GDK_ACTION_COPY | GDK_ACTION_LINK | GDK_ACTION_ASK;
}
} else {
if(xfdesktop_file_utils_file_is_executable(info)) {
if(suggested_action)
*suggested_action = GDK_ACTION_COPY;
return GDK_ACTION_COPY;
}
}
if(suggested_action)
*suggested_action = 0;
return 0;
}
static bool gui_can_add_uri(char *uri, char **error_str)
{
g_assert(uri);
bool can_add = false;
GFile *file = g_file_new_for_uri(uri);
GError *error = NULL;
GFileInfo *info = g_file_query_info(file,
G_FILE_ATTRIBUTE_STANDARD_TYPE "," G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
G_FILE_QUERY_INFO_NONE, NULL, &error);
if (info) {
bool can_read = g_file_info_get_attribute_boolean(info,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
GFileType type = g_file_info_get_file_type(info);
g_object_unref(info);
if (!can_read)
*error_str = g_strdup(g_strerror(EACCES));
else if (type == G_FILE_TYPE_DIRECTORY)
*error_str = g_strdup(g_strerror(EISDIR));
else if (type != G_FILE_TYPE_REGULAR)
*error_str = g_strdup(_("Not a regular file"));
else
can_add = true;
} else {
*error_str = g_strdup(error->message);
g_error_free(error);
}
g_object_unref(file);
return can_add;
}
/**
* is_read_only:
* @location: a GFile Object that represents the file to check
*
* This method is copied from gedit, file gedit-commands-file.c
*
* Returns: False if file is writeable. True if file doesn't exists, is read-only or read-only attribute can't be check
*/
static gboolean
is_read_only (const gchar * filename)
{
gboolean ret = TRUE; /* default to read only */
GFileInfo *info;
GFile *location;
location = g_file_new_for_path (filename);
if (!g_file_query_exists (location, NULL))
return FALSE;
info = g_file_query_info (location,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
g_object_unref (location);
if (info != NULL)
{
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
ret = !g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
}
g_object_unref (info);
}
return ret;
}
static gboolean
uri_recurse_func (GFile *file, GFileInfo *info, RhythmDBImportJob *job)
{
RhythmDBEntry *entry;
char *uri;
if (g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_STANDARD_TYPE) == G_FILE_TYPE_DIRECTORY) {
return TRUE;
}
if (g_cancellable_is_cancelled (job->priv->cancel))
return FALSE;
if (g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK)) {
GFile *r;
r = rb_file_resolve_symlink (file, NULL);
if (r != NULL) {
uri = g_file_get_uri (r);
g_object_unref (r);
} else {
return FALSE;
}
} else {
uri = g_file_get_uri (file);
}
/* if it's not already in the db, add it to the list of things to process */
entry = rhythmdb_entry_lookup_by_location (job->priv->db, uri);
if (entry == NULL) {
rb_debug ("waiting for entry %s", uri);
g_mutex_lock (&job->priv->lock);
job->priv->total++;
g_queue_push_tail (job->priv->outstanding, g_strdup (uri));
if (job->priv->status_changed_id == 0) {
job->priv->status_changed_id = g_idle_add ((GSourceFunc) emit_status_changed, job);
}
maybe_start_more (job);
g_mutex_unlock (&job->priv->lock);
} else {
/* skip it if it's a different entry type */
RhythmDBEntryType *et;
et = rhythmdb_entry_get_entry_type (entry);
if (et == job->priv->entry_type ||
et == job->priv->ignore_type ||
et == job->priv->error_type) {
rhythmdb_add_uri_with_types (job->priv->db,
uri,
job->priv->entry_type,
job->priv->ignore_type,
job->priv->error_type);
}
}
g_free (uri);
return TRUE;
}
static void
nautilus_sendto_init (NautilusSendto *nst)
{
int i;
/* Clean up the URIs passed, and collect whether we have directories */
for (i = 0; filenames != NULL && filenames[i] != NULL; i++) {
GFile *file;
char *filename, *escaped, *uri;
GFileInfo *info;
const char *mimetype;
/* We need a filename */
file = g_file_new_for_commandline_arg (filenames[i]);
filename = g_file_get_path (file);
if (filename == NULL) {
filename = get_target_filename (file);
if (filename == NULL) {
g_object_unref (file);
continue;
}
}
/* Get the mime-type, and whether the file is readable */
info = g_file_query_info (file,
G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE","G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
G_FILE_QUERY_INFO_NONE,
NULL,
NULL);
g_object_unref (file);
if (info == NULL)
continue;
if (g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ) == FALSE) {
g_debug ("'%s' is not readable", filenames[i]);
g_object_unref (info);
continue;
}
mimetype = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE);
if (g_str_equal (mimetype, "inode/directory"))
nst->num_dirs++;
g_object_unref (info);
uri = g_filename_to_uri (filename, NULL, NULL);
g_free (filename);
escaped = escape_ampersands_and_commas (uri);
if (escaped == NULL) {
nst->file_list = g_list_prepend (nst->file_list, uri);
} else {
nst->file_list = g_list_prepend (nst->file_list, escaped);
g_free (uri);
}
}
nst->file_list = g_list_reverse (nst->file_list);
}
gboolean
gl_util_can_read_user_journal (void)
{
GFile *file;
GFileInfo *info;
gint ret;
gchar *path;
gchar ids[33];
gchar *filename;
gchar *uid;
uid_t user_id;
sd_id128_t machine;
GError *error = NULL;
GCredentials *credentials;
credentials = g_credentials_new ();
user_id = g_credentials_get_unix_user (credentials, &error);
if (error != NULL)
{
g_debug ("Unable to get uid: %s", error->message);
g_error_free (error);
}
uid = g_strdup_printf ("%d", user_id);
filename = g_strconcat ("/user-", uid, ".journal", NULL);
ret = sd_id128_get_machine (&machine);
if (ret < 0)
{
g_critical ("Error getting machine id: %s", g_strerror (-ret));
}
sd_id128_to_string (machine, ids);
path = g_build_filename ("/var/log/journal", ids, filename, NULL);
file = g_file_new_for_path (path);
info = g_file_query_info (file, G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
g_free (uid);
g_free (path);
g_free (filename);
g_object_unref (file);
g_object_unref (credentials);
if (g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
{
g_object_unref (info);
return TRUE;
}
else
{
g_object_unref (info);
return FALSE;
}
}
static void
comments__read_metadata_ready_cb (GList *file_list,
const char *attributes)
{
GSettings *settings;
gboolean store_metadata_in_files;
GList *scan;
gboolean synchronize;
settings = g_settings_new (GTHUMB_GENERAL_SCHEMA);
store_metadata_in_files = g_settings_get_boolean (settings, PREF_GENERAL_STORE_METADATA_IN_FILES);
g_object_unref (settings);
if (! store_metadata_in_files) {
/* if PREF_GENERAL_STORE_METADATA_IN_FILES is false, avoid to
* synchronize the .comment metadata because the embedded
* metadata is likely to be out-of-date.
* Give priority to the .comment metadata which, if present,
* is the most up-to-date. */
gboolean can_read_embedded_attributes;
can_read_embedded_attributes = gth_main_extension_is_active ("exiv2_tools");
for (scan = file_list; scan; scan = scan->next) {
GthFileData *file_data = scan->data;
/* If PREF_GENERAL_STORE_METADATA_IN_FILES is false and
* there is no comment file then we are reading
* the image metadata for the first time, in this
* case update the .comment metadata with the
* embedded metadata. */
if (g_file_info_get_attribute_boolean (file_data->info, "comment::no-comment-file")) {
if (can_read_embedded_attributes) {
exiv2_update_general_attributes (file_data->info);
gth_comment_update_from_general_attributes (file_data);
}
}
else
gth_comment_update_general_attributes ((GthFileData *) scan->data);
}
}
else {
/* if PREF_GENERAL_STORE_METADATA_IN_FILES is true, update the .comment
* metadata with the embedded metadata.
*/
settings = g_settings_new (GTHUMB_COMMENTS_SCHEMA);
synchronize = g_settings_get_boolean (settings, PREF_COMMENTS_SYNCHRONIZE);
g_object_unref (settings);
if (! synchronize)
return;
for (scan = file_list; scan; scan = scan->next)
gth_comment_update_from_general_attributes ((GthFileData *) scan->data);
}
}
static void
loaded_query_info_cb (GFile *location,
GAsyncResult *result,
GeditDocument *doc)
{
GFileInfo *info;
GError *error = NULL;
info = g_file_query_info_finish (location, result, &error);
if (error != NULL)
{
/* Ignore not found error as it can happen when opening a
* non-existent file from the command line.
*/
if (error->domain != G_IO_ERROR ||
error->code != G_IO_ERROR_NOT_FOUND)
{
g_warning ("Document loading: query info error: %s", error->message);
}
g_error_free (error);
error = NULL;
}
if (info != NULL)
{
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE))
{
const gchar *content_type;
content_type = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
gedit_document_set_content_type (doc, content_type);
}
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
gboolean read_only;
read_only = !g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
set_readonly (doc, read_only);
}
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
{
g_file_info_get_modification_time (info, &doc->priv->mtime);
doc->priv->mtime_set = TRUE;
}
g_object_unref (info);
}
/* Async operation finished. */
g_object_unref (doc);
}
void
fm__gth_browser_update_sensitivity_cb (GthBrowser *browser)
{
BrowserData *data;
GthFileSource *file_source;
int n_selected;
GthFileData *location_data;
gboolean sensitive;
GthFileData *folder;
data = g_object_get_data (G_OBJECT (browser), BROWSER_DATA_KEY);
g_return_if_fail (data != NULL);
file_source = gth_browser_get_location_source (browser);
n_selected = gth_file_selection_get_n_selected (GTH_FILE_SELECTION (gth_browser_get_file_list_view (browser)));
location_data = gth_browser_get_location_data (browser);
sensitive = (n_selected > 0) && (file_source != NULL) && (location_data != NULL) && gth_file_source_can_cut (file_source, location_data->file);
set_action_sensitive (data, "Edit_CutFiles", sensitive);
sensitive = (n_selected > 0) && (file_source != NULL);
set_action_sensitive (data, "Edit_CopyFiles", sensitive);
set_action_sensitive (data, "Edit_Trash", sensitive);
set_action_sensitive (data, "Edit_Delete", sensitive);
set_action_sensitive (data, "Edit_Duplicate", sensitive);
set_action_sensitive (data, "Tool_MoveToFolder", sensitive);
set_action_sensitive (data, "Tool_CopyToFolder", sensitive);
folder = gth_browser_get_folder_popup_file_data (browser);
set_action_sensitive (data, "Folder_Create", (folder != NULL) && g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE));
set_action_sensitive (data, "Folder_Rename", (folder != NULL) && g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME));
set_action_sensitive (data, "Folder_Delete", (folder != NULL) && g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE));
set_action_sensitive (data, "Folder_Trash", (folder != NULL) && g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH));
set_action_sensitive (data, "Folder_Cut", (folder != NULL) && g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE));
/*
folder = gth_browser_get_location_data (browser);
set_action_sensitive (data, "File_NewFolder", (folder != NULL) && g_file_info_get_attribute_boolean (folder->info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE));
*/
_g_object_unref (folder);
_gth_browser_update_paste_command_sensitivity (browser, NULL);
}
static void
check_file_on_disk (GeditDocument *doc)
{
GFile *location;
GFileInfo *info;
location = gtk_source_file_get_location (doc->priv->file);
if (location == NULL)
{
return;
}
info = g_file_query_info (location,
G_FILE_ATTRIBUTE_TIME_MODIFIED "," \
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if (info != NULL)
{
/* While at it also check if permissions changed */
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
gboolean read_only;
read_only = !g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
set_readonly (doc, read_only);
}
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED) &&
doc->priv->mtime_set)
{
GTimeVal timeval;
g_file_info_get_modification_time (info, &timeval);
/* Note that mtime can even go backwards if the
* user is copying over a file with an old mtime
*/
if (timeval.tv_sec != doc->priv->mtime.tv_sec ||
timeval.tv_usec != doc->priv->mtime.tv_usec)
{
doc->priv->externally_modified = TRUE;
}
}
g_object_unref (info);
}
else
{
doc->priv->deleted = TRUE;
}
}
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
mark_desktop_files_trusted (void)
{
char *do_once_file;
GFile *f, *c;
GFileEnumerator *e;
GFileInfo *info;
const char *name;
int fd;
do_once_file = g_build_filename (g_get_user_data_dir (),
".converted-launchers", NULL);
if (g_file_test (do_once_file, G_FILE_TEST_EXISTS)) {
goto out;
}
f = nautilus_get_desktop_location ();
e = g_file_enumerate_children (f,
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_NAME ","
G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE
,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
NULL, NULL);
if (e == NULL) {
goto out2;
}
while ((info = g_file_enumerator_next_file (e, NULL, NULL)) != NULL) {
name = g_file_info_get_name (info);
if (g_str_has_suffix (name, ".desktop") &&
!g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE)) {
c = g_file_get_child (f, name);
nautilus_file_mark_desktop_file_trusted (c,
NULL, FALSE,
NULL, NULL);
g_object_unref (c);
}
g_object_unref (info);
}
g_object_unref (e);
out2:
fd = g_creat (do_once_file, 0666);
close (fd);
g_object_unref (f);
out:
g_free (do_once_file);
}
gboolean
gl_util_can_read_system_journal (GlJournalStorage storage_type)
{
GFile *file;
GFileInfo *info;
gint ret;
gchar *path;
gchar ids[33];
sd_id128_t machine;
ret = sd_id128_get_machine (&machine);
if (ret < 0)
{
g_critical ("Error getting machine id: %s", g_strerror (-ret));
}
sd_id128_to_string (machine, ids);
if (storage_type == GL_JOURNAL_STORAGE_PERSISTENT)
{
path = g_build_filename ("/var/log/journal", ids, "system.journal", NULL);
}
else if (storage_type == GL_JOURNAL_STORAGE_VOLATILE)
{
path = g_build_filename ("/run/log/journal", ids, "system.journal", NULL);
}
else
{
path = "/dev/null";
}
file = g_file_new_for_path (path);
info = g_file_query_info (file, G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
g_free (path);
g_object_unref (file);
if (g_file_info_get_attribute_boolean (info,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
{
g_object_unref (info);
return TRUE;
}
else
{
g_object_unref (info);
return FALSE;
}
}
/**
* gtk_source_file_check_file_on_disk:
* @file: a #GtkSourceFile.
*
* Checks synchronously the file on disk, to know whether the file is externally
* modified, or has been deleted, and whether the file is read-only.
*
* #GtkSourceFile doesn't create a #GFileMonitor to track those properties, so
* this function needs to be called instead. Creating lots of #GFileMonitor's
* would take lots of resources.
*
* Since this function is synchronous, it is advised to call it only on local
* files. See gtk_source_file_is_local().
*
* Since: 3.18
*/
void
gtk_source_file_check_file_on_disk (GtkSourceFile *file)
{
GFileInfo *info;
if (file->priv->location == NULL)
{
return;
}
info = g_file_query_info (file->priv->location,
G_FILE_ATTRIBUTE_TIME_MODIFIED ","
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE,
G_FILE_QUERY_INFO_NONE,
NULL,
NULL);
if (info == NULL)
{
file->priv->deleted = TRUE;
return;
}
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED) &&
file->priv->modification_time_set)
{
GTimeVal timeval;
g_file_info_get_modification_time (info, &timeval);
/* Note that the modification time can even go backwards if the
* user is copying over an old file.
*/
if (timeval.tv_sec != file->priv->modification_time.tv_sec ||
timeval.tv_usec != file->priv->modification_time.tv_usec)
{
file->priv->externally_modified = TRUE;
}
}
if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
gboolean readonly;
readonly = !g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
_gtk_source_file_set_readonly (file, readonly);
}
g_object_unref (info);
}
static GdkDragAction
xfdesktop_regular_file_icon_get_allowed_drag_actions(XfdesktopIcon *icon)
{
GFileInfo *info = xfdesktop_file_icon_peek_file_info(XFDESKTOP_FILE_ICON(icon));
GFile *file = xfdesktop_file_icon_peek_file(XFDESKTOP_FILE_ICON(icon));
GdkDragAction actions = GDK_ACTION_LINK; /* we can always link */
if(!info)
return 0;
if(g_file_info_get_attribute_boolean(info,
G_FILE_ATTRIBUTE_ACCESS_CAN_READ))
{
GFileInfo *parent_info;
GFile *parent_file;
actions |= GDK_ACTION_COPY;
/* we can only move if the parent is writable */
parent_file = g_file_get_parent(file);
parent_info = g_file_query_info(parent_file,
XFDESKTOP_FILE_INFO_NAMESPACE,
G_FILE_QUERY_INFO_NONE,
NULL, NULL);
if(parent_info) {
if(g_file_info_get_attribute_boolean(parent_info,
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE))
{
actions |= GDK_ACTION_MOVE;
}
g_object_unref(parent_info);
}
g_object_unref(parent_file);
}
return actions;
}
