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