static gboolean
ignore_mount (GMount *mount)
{
GFile *root;
GVolume *volume;
gboolean ret = TRUE;
root = g_mount_get_root (mount);
if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) {
/* We don't add Audio CDs, or blank media */
g_object_unref (root);
GRL_DEBUG ("%s: Not adding mount %s as is burn or cdda", __FUNCTION__,
g_mount_get_name (mount));
return TRUE;
}
g_object_unref (root);
volume = g_mount_get_volume (mount);
if (volume == NULL)
return ret;
ret = ignore_volume (volume);
g_object_unref (volume);
return ret;
}
/**
* gs_file_get_path_cached:
*
* Like g_file_get_path(), but returns a constant copy so callers
* don't need to free the result.
*/
const char *
gs_file_get_path_cached (GFile *file)
{
const char *path;
static GQuark _file_path_quark = 0;
if (G_UNLIKELY (_file_path_quark) == 0)
_file_path_quark = g_quark_from_static_string ("gsystem-file-path");
G_LOCK (pathname_cache);
path = g_object_get_qdata ((GObject*)file, _file_path_quark);
if (!path)
{
if (g_file_has_uri_scheme (file, "trash") ||
g_file_has_uri_scheme (file, "recent"))
path = gs_file_get_target_path (file);
else
path = g_file_get_path (file);
if (path == NULL)
{
G_UNLOCK (pathname_cache);
return NULL;
}
g_object_set_qdata_full ((GObject*)file, _file_path_quark, (char*)path, (GDestroyNotify)g_free);
}
G_UNLOCK (pathname_cache);
return path;
}
static GList *
add_volume (GList *media_list,
GVolume *volume,
GDrive *drive,
GrlOpticalMediaSource *source)
{
char *name, *icon_uri;
GIcon *icon;
char *device_path, *id;
GrlMedia * media;
GMount *mount;
device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
if (device_path == NULL)
return media_list;
/* Is it an audio CD or a blank media */
mount = g_volume_get_mount (volume);
if (mount != NULL) {
GFile *root;
root = g_mount_get_root (mount);
g_object_unref (mount);
if (g_file_has_uri_scheme (root, "burn") != FALSE || g_file_has_uri_scheme (root, "cdda") != FALSE) {
/* We don't add Audio CDs, or blank media */
g_object_unref (root);
g_free (device_path);
return media_list;
}
g_object_unref (root);
}
media = grl_media_video_new ();
id = g_filename_to_uri (device_path, NULL, NULL);
g_free (device_path);
grl_media_set_id (media, id);
g_free (id);
/* Work out an icon to display */
icon = g_volume_get_icon (volume);
icon_uri = get_uri_for_gicon (icon);
g_object_unref (icon);
grl_media_set_thumbnail (media, icon_uri);
g_free (icon_uri);
/* Get the volume's pretty name for the menu label */
name = g_volume_get_name (volume);
g_strstrip (name);
grl_media_set_title (media, name);
g_free (name);
grl_media_set_mime (media, "x-special/device-block");
return g_list_prepend (media_list, media);
}
static void append_file_to_cmd(GFile* gf, GString* cmd)
{
char* file = g_file_get_path(gf);
char* quote;
if(file == NULL) /* trash:// gvfs is incomplete in resolving it */
{
/* we can retrieve real path from GVFS >= 1.13.3 */
if(g_file_has_uri_scheme(gf, "trash"))
{
GFileInfo *inf;
const char *orig_path;
inf = g_file_query_info(gf, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
if(inf == NULL) /* failed */
return;
orig_path = g_file_info_get_attribute_string(inf, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
if(orig_path != NULL) /* success */
file = g_filename_from_uri(orig_path, NULL, NULL);
g_object_unref(inf);
}
if(file == NULL)
return;
}
quote = g_shell_quote(file);
g_string_append(cmd, quote);
g_string_append_c(cmd, ' ');
g_free(quote);
g_free(file);
}
static void
unmount_all_with_scheme (const char *scheme)
{
GVolumeMonitor *volume_monitor;
GList *mounts;
GList *l;
volume_monitor = g_volume_monitor_get();
/* populate gvfs network mounts */
iterate_gmain();
mounts = g_volume_monitor_get_mounts (volume_monitor);
for (l = mounts; l != NULL; l = l->next) {
GMount *mount = G_MOUNT (l->data);
GFile *root;
root = g_mount_get_root (mount);
if (g_file_has_uri_scheme (root, scheme)) {
unmount (root);
}
g_object_unref (root);
}
g_list_foreach (mounts, (GFunc)g_object_unref, NULL);
g_list_free (mounts);
g_object_unref (volume_monitor);
}
GBytes *
gtk_file_load_bytes (GFile *file,
GCancellable *cancellable,
GError **error)
{
gchar *contents;
gsize len;
g_return_val_if_fail (G_IS_FILE (file), NULL);
g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), NULL);
if (g_file_has_uri_scheme (file, "resource"))
{
gchar *uri, *unescaped;
GBytes *bytes;
uri = g_file_get_uri (file);
unescaped = g_uri_unescape_string (uri + strlen ("resource://"), NULL);
g_free (uri);
bytes = g_resources_lookup_data (unescaped, 0, error);
g_free (unescaped);
return bytes;
}
/* contents is always \0 terminated, but we don't include that in the bytes */
if (g_file_load_contents (file, cancellable, &contents, &len, NULL, error))
return g_bytes_new_take (contents, len);
return NULL;
}
static guint
impl_want_uri (RBSource *source, const char *uri)
{
GVolume *volume;
GMount *mount;
GFile *file;
int retval;
retval = 0;
file = g_file_new_for_uri (uri);
if (g_file_has_uri_scheme (file, "cdda") == FALSE) {
g_object_unref (file);
return 0;
}
g_object_get (G_OBJECT (source),
"volume", &volume,
NULL);
if (volume == NULL)
return 0;
mount = g_volume_get_mount (volume);
if (mount) {
GFile *root;
root = g_mount_get_root (mount);
retval = g_file_equal (root, file) ? 100 : 0;
g_object_unref (mount);
g_object_unref (root);
}
g_object_unref (file);
return retval;
}
gchar *
clean_uri (gchar * input_arg)
{
GFile *gfile;
gchar *fileuri;
if (gst_uri_is_valid (input_arg))
fileuri = g_strdup (input_arg);
else {
gfile = g_file_new_for_commandline_arg (input_arg);
if (g_file_has_uri_scheme (gfile, "archive") != FALSE) {
g_print ("ERROR: %s isn't a file\n", input_arg);
}
fileuri = g_file_get_path (gfile);
if (g_str_has_suffix (fileuri, ".iso")) {
fileuri = g_strdup_printf ("dvd://%s", fileuri);
} else {
fileuri = g_strdup_printf ("file://%s", fileuri);
}
}
return fileuri;
}
static gboolean
gtk_css_image_url_parse (GtkCssImage *image,
GtkCssParser *parser)
{
GtkCssImageUrl *url = GTK_CSS_IMAGE_URL (image);
GdkPixbuf *pixbuf;
GFile *file;
cairo_t *cr;
GError *error = NULL;
GFileInputStream *input;
file = _gtk_css_parser_read_url (parser);
if (file == NULL)
return FALSE;
/* We special case resources here so we can use
gdk_pixbuf_new_from_resource, which in turn has some special casing
for GdkPixdata files to avoid duplicating the memory for the pixbufs */
if (g_file_has_uri_scheme (file, "resource"))
{
char *uri = g_file_get_uri (file);
char *resource_path = g_uri_unescape_string (uri + strlen ("resource://"), NULL);
pixbuf = gdk_pixbuf_new_from_resource (resource_path, &error);
g_free (resource_path);
g_free (uri);
}
else
{
input = g_file_read (file, NULL, &error);
if (input == NULL)
{
_gtk_css_parser_take_error (parser, error);
return FALSE;
}
pixbuf = gdk_pixbuf_new_from_stream (G_INPUT_STREAM (input), NULL, &error);
g_object_unref (input);
}
g_object_unref (file);
if (pixbuf == NULL)
{
_gtk_css_parser_take_error (parser, error);
return FALSE;
}
url->surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
cr = cairo_create (url->surface);
gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
g_object_unref (pixbuf);
return TRUE;
}
gboolean
rb_ipod_helpers_is_ipod (GMount *mount, MPIDDevice *device_info)
{
GFile *root;
gboolean result = FALSE;
char **protocols;
/* if we have specific information about the device, use it.
* otherwise, check if the device has an ipod device directory on it.
*/
g_object_get (device_info, "access-protocols", &protocols, NULL);
if (protocols != NULL && g_strv_length (protocols) > 0) {
int i;
for (i = 0; protocols[i] != NULL; i++) {
if (g_str_equal (protocols[i], "ipod")) {
result = TRUE;
break;
}
}
} else {
root = g_mount_get_root (mount);
if (root != NULL) {
gchar *device_dir;
if (g_file_has_uri_scheme (root, "afc") != FALSE) {
gchar *uri;
uri = g_file_get_uri (root);
/* afc://<40 chars>:stuff */
g_assert (strlen (uri) >= 46);
if (uri[6 + 40] == ':' &&
uri[6 + 40 + 1] != '1') {
result = FALSE;
} else {
result = TRUE;
}
g_free (uri);
} else {
gchar *mount_point;
mount_point = g_file_get_path (root);
if (mount_point != NULL) {
device_dir = itdb_get_device_dir (mount_point);
if (device_dir != NULL) {
result = g_file_test (device_dir,
G_FILE_TEST_IS_DIR);
g_free (device_dir);
}
}
g_free (mount_point);
}
g_object_unref (root);
}
}
g_strfreev (protocols);
return result;
}
static GtkCssImage *
gtk_css_image_url_load_image (GtkCssImageUrl *url)
{
GdkPixbuf *pixbuf;
GError *error = NULL;
GFileInputStream *input;
if (url->loaded_image)
return url->loaded_image;
/* We special case resources here so we can use
gdk_pixbuf_new_from_resource, which in turn has some special casing
for GdkPixdata files to avoid duplicating the memory for the pixbufs */
if (g_file_has_uri_scheme (url->file, "resource"))
{
char *uri = g_file_get_uri (url->file);
char *resource_path = g_uri_unescape_string (uri + strlen ("resource://"), NULL);
pixbuf = gdk_pixbuf_new_from_resource (resource_path, &error);
g_free (resource_path);
g_free (uri);
}
else
{
input = g_file_read (url->file, NULL, &error);
if (input != NULL)
{
pixbuf = gdk_pixbuf_new_from_stream (G_INPUT_STREAM (input), NULL, &error);
g_object_unref (input);
}
else
{
pixbuf = NULL;
}
}
if (pixbuf == NULL)
{
cairo_surface_t *empty = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 0, 0);
/* XXX: Can we get the error somehow sent to the CssProvider?
* I don't like just dumping it to stderr or losing it completely. */
g_warning ("Error loading image: %s", error->message);
g_error_free (error);
url->loaded_image = _gtk_css_image_surface_new (empty);
cairo_surface_destroy (empty);
return url->loaded_image;
}
url->loaded_image = _gtk_css_image_surface_new_for_pixbuf (pixbuf);
g_object_unref (pixbuf);
return url->loaded_image;
}
static GtkCssImage *
gtk_css_image_url_load_image (GtkCssImageUrl *url,
GError **error)
{
GdkTexture *texture;
GError *local_error = NULL;
if (url->loaded_image)
return url->loaded_image;
/* We special case resources here so we can use
gdk_pixbuf_new_from_resource, which in turn has some special casing
for GdkPixdata files to avoid duplicating the memory for the pixbufs */
if (g_file_has_uri_scheme (url->file, "resource"))
{
char *uri = g_file_get_uri (url->file);
char *resource_path = g_uri_unescape_string (uri + strlen ("resource://"), NULL);
texture = gdk_texture_new_from_resource (resource_path);
g_free (resource_path);
g_free (uri);
}
else
{
texture = gdk_texture_new_from_file (url->file, &local_error);
}
if (texture == NULL)
{
if (error)
{
char *uri;
uri = g_file_get_uri (url->file);
g_set_error (error,
GTK_CSS_PARSER_ERROR,
GTK_CSS_PARSER_ERROR_FAILED,
"Error loading image '%s': %s", uri, local_error->message);
g_free (uri);
}
url->loaded_image = gtk_css_image_invalid_new ();
}
else
{
url->loaded_image = gtk_css_image_paintable_new (GDK_PAINTABLE (texture), GDK_PAINTABLE (texture));
g_object_unref (texture);
}
g_clear_error (&local_error);
return url->loaded_image;
}
gboolean
nemo_directory_is_in_recent (NemoDirectory *directory)
{
g_assert (NEMO_IS_DIRECTORY (directory));
if (directory->details->location == NULL) {
return FALSE;
}
return g_file_has_uri_scheme (directory->details->location, "recent");
}
gboolean
nautilus_directory_is_in_trash (NautilusDirectory *directory)
{
g_assert (NAUTILUS_IS_DIRECTORY (directory));
if (directory->details->location == NULL) {
return FALSE;
}
return g_file_has_uri_scheme (directory->details->location, "trash");
}
IdolPlParserResult
idol_pl_parser_add_itms (IdolPlParser *parser,
GFile *file,
GFile *base_file,
IdolPlParseData *parse_data,
gpointer data)
{
#ifndef HAVE_GMIME
WARN_NO_GMIME;
#else
GByteArray *content;
char *itms_uri;
GFile *feed_file;
IdolPlParserResult ret;
if (g_file_has_uri_scheme (file, "itms") != FALSE) {
itms_uri= g_file_get_uri (file);
memcpy (itms_uri, "http", 4);
} else if (g_file_has_uri_scheme (file, "http") != FALSE) {
itms_uri = g_file_get_uri (file);
} else {
return IDOL_PL_PARSER_RESULT_ERROR;
}
/* Load the file using iTunes user-agent */
content = idol_pl_parser_load_http_itunes (itms_uri);
/* And look in the file for the feedURL */
feed_file = idol_pl_parser_get_feed_uri ((char *) content->data, content->len);
g_byte_array_free (content, TRUE);
if (feed_file == NULL)
return IDOL_PL_PARSER_RESULT_ERROR;
DEBUG(feed_file, g_print ("Found feed URI: %s\n", uri));
ret = idol_pl_parser_add_rss (parser, feed_file, NULL, parse_data, NULL);
g_object_unref (feed_file);
return ret;
#endif /* !HAVE_GMIME */
}
/* Returns true if uri is a file: uri and is not a chained uri */
gboolean
gedit_utils_uri_has_file_scheme (const gchar *uri)
{
GFile *gfile;
gboolean res;
gfile = g_file_new_for_uri (uri);
res = g_file_has_uri_scheme (gfile, "file");
g_object_unref (gfile);
return res;
}
/**
* gtk_source_file_is_local:
* @file: a #GtkSourceFile.
*
* Returns whether the file is local. If the #GtkSourceFile:location is %NULL,
* returns %FALSE.
*
* Returns: whether the file is local.
* Since: 3.18
*/
gboolean
gtk_source_file_is_local (GtkSourceFile *file)
{
g_return_val_if_fail (GTK_SOURCE_IS_FILE (file), FALSE);
if (file->priv->location == NULL)
{
return FALSE;
}
return g_file_has_uri_scheme (file->priv->location, "file");
}
gboolean
idol_pl_parser_is_itms_feed (GFile *file)
{
char *uri;
g_return_val_if_fail (file != NULL, FALSE);
uri = g_file_get_uri (file);
if (g_file_has_uri_scheme (file, "itms") != FALSE ||
(g_file_has_uri_scheme (file, "http") != FALSE &&
strstr (uri, ".apple.com/") != FALSE)) {
if (strstr (uri, "/podcast/") != NULL ||
strstr (uri, "viewPodcast") != NULL) {
g_free (uri);
return TRUE;
}
}
g_free (uri);
return FALSE;
}
static void
link_button_uri_hook (GtkLinkButton *button,
gchar const *link_,
GitgWindow *window)
{
GFile *file;
GitgRepository *repository;
file = g_file_new_for_uri (link_);
repository = gitg_window_get_repository (window);
if (!g_file_has_uri_scheme (file, "gitg"))
{
original_link_button_hook (button, link_, NULL);
}
else if (repository)
{
gchar *work_tree_path;
gchar *selection;
gchar *activatable;
gchar *action;
if (gitg_uri_parse (link_, &work_tree_path, &selection, &activatable, &action))
{
GFile *wt;
GFile *work_tree;
gboolean equal;
wt = gitg_repository_get_work_tree (repository);
work_tree = g_file_new_for_path (work_tree_path);
equal = g_file_equal (wt, work_tree);
g_object_unref (wt);
g_object_unref (work_tree);
if (equal)
{
gitg_window_select (window, selection);
gitg_window_activate (window, activatable, action);
}
g_free (work_tree_path);
g_free (selection);
g_free (activatable);
g_free (action);
}
}
g_object_unref (file);
}
gchar *
clean_uri (gchar * input_arg)
{
GFile *gfile;
gchar *filepath;
gfile = g_file_new_for_commandline_arg (input_arg);
if (g_file_has_uri_scheme (gfile, "archive") != FALSE) {
g_print ("ERROR: %s isn't a file\n", input_arg);
}
filepath = g_file_get_path (gfile);
return filepath;
}
static GIcon *
xfdesktop_special_file_icon_load_icon(XfdesktopIcon *icon)
{
XfdesktopSpecialFileIcon *special_icon = XFDESKTOP_SPECIAL_FILE_ICON(icon);
XfdesktopFileIcon *file_icon = XFDESKTOP_FILE_ICON(icon);
gchar *icon_name = NULL;
GFile *parent = NULL;
GIcon *gicon = NULL;
TRACE("entering");
/* use a custom icon name for the local filesystem root */
parent = g_file_get_parent(special_icon->priv->file);
if(!parent && g_file_has_uri_scheme(special_icon->priv->file, "file"))
icon_name = g_strdup("drive-harddisk");
if(parent)
g_object_unref(parent);
/* use a custom icon for the trash, based on it having files
* the user can delete */
if(special_icon->priv->type == XFDESKTOP_SPECIAL_FILE_ICON_TRASH) {
if(special_icon->priv->trash_item_count == 0)
icon_name = g_strdup("user-trash");
else
icon_name = g_strdup("user-trash-full");
}
/* Create the themed icon for it */
if(icon_name) {
gicon = g_themed_icon_new(icon_name);
g_free(icon_name);
}
/* If we still don't have an icon, use the default */
if(!G_IS_ICON(gicon)) {
gicon = g_file_info_get_icon(special_icon->priv->file_info);
if(G_IS_ICON(gicon))
g_object_ref(gicon);
}
g_object_set(file_icon, "gicon", gicon, NULL);
/* Add any user set emblems */
gicon = xfdesktop_file_icon_add_emblems(file_icon);
return gicon;
}
gboolean
gedit_document_is_local (GeditDocument *doc)
{
GFile *location;
g_return_val_if_fail (GEDIT_IS_DOCUMENT (doc), FALSE);
location = gtk_source_file_get_location (doc->priv->file);
if (location == NULL)
{
return FALSE;
}
return g_file_has_uri_scheme (location, "file");
}
static void
ensure_monitor_for_file (StTextureCache *cache,
GFile *file)
{
StTextureCachePrivate *priv = cache->priv;
/* No point in trying to monitor files that are part of a
* GResource, since it does not support file monitoring.
*/
if (g_file_has_uri_scheme (file, "resource"))
return;
if (g_hash_table_lookup (priv->file_monitors, file) == NULL)
{
GFileMonitor *monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE,
NULL, NULL);
g_signal_connect (monitor, "changed",
G_CALLBACK (file_changed_cb), cache);
g_hash_table_insert (priv->file_monitors, g_object_ref (file), monitor);
}
}
void
gedit_recent_remove_if_local (GFile *location)
{
g_return_if_fail (G_IS_FILE (location));
/* If a file is local chances are that if load/save fails the file has
* beed removed and the failure is permanent so we remove it from the
* list of recent files. For remote files the failure may be just
* transitory and we keep the file in the list.
*/
if (g_file_has_uri_scheme (location, "file"))
{
GtkRecentManager *recent_manager;
gchar *uri;
recent_manager = gtk_recent_manager_get_default ();
uri = g_file_get_uri (location);
gtk_recent_manager_remove_item (recent_manager, uri, NULL);
g_free (uri);
}
}
static void
folder_changed_cb (GthMonitor *monitor,
GFile *parent,
GList *list /* GFile list */,
int position,
GthMonitorEvent event,
gpointer user_data)
{
BrowserData *data = user_data;
int n_selection;
if (event == GTH_MONITOR_EVENT_CHANGED)
return;
if (! g_file_has_uri_scheme (parent, "selection"))
return;
n_selection = _g_file_get_n_selection (parent);
if (n_selection <= 0)
return;
gtk_widget_set_sensitive (data->selection_buttons[n_selection - 1], ! gth_selections_manager_get_is_empty (n_selection));
}
static GList*
twp_provider_get_file_actions (ThunarxMenuProvider *menu_provider,
GtkWidget *window,
GList *files)
{
GtkWidget *action = NULL;
GFile *location;
GList *actions = NULL;
gchar selection_name[100];
Atom xfce_selection_atom;
Atom nautilus_selection_atom;
GdkScreen *gdk_screen = gdk_screen_get_default();
gint xscreen = gdk_screen_get_number(gdk_screen);
desktop_type = DESKTOP_TYPE_NONE;
/* we can only set a single wallpaper */
if (files->next == NULL)
{
/* get the location of the file */
location = thunarx_file_info_get_location (files->data);
/* unable to handle non-local files */
if (G_UNLIKELY (!g_file_has_uri_scheme (location, "file")))
{
g_object_unref (location);
return NULL;
}
/* release the location */
g_object_unref (location);
if (!thunarx_file_info_is_directory (files->data))
{
if (thunarx_file_info_has_mime_type (files->data, "image/jpeg")
||thunarx_file_info_has_mime_type (files->data, "image/png")
||thunarx_file_info_has_mime_type (files->data, "image/svg+xml")
||thunarx_file_info_has_mime_type (files->data, "image/svg+xml-compressed"))
{
action = g_object_new (GTK_TYPE_ACTION,
"name", "Twp::setwallpaper",
"icon-name", "background",
"label", _("Set as wallpaper"),
NULL);
g_signal_connect (action, "activate", G_CALLBACK (twp_action_set_wallpaper), files->data);
actions = g_list_append (actions, action);
}
}
}
g_snprintf(selection_name, 100, XFDESKTOP_SELECTION_FMT, xscreen);
xfce_selection_atom = XInternAtom (gdk_display, selection_name, False);
if ((XGetSelectionOwner(GDK_DISPLAY(), xfce_selection_atom)))
{
if (_has_xfconf_query)
desktop_type = DESKTOP_TYPE_XFCE;
}
else
{
/* FIXME: This is wrong, nautilus WINDOW_ID is not a selection */
g_snprintf(selection_name, 100, NAUTILUS_SELECTION_FMT);
nautilus_selection_atom = XInternAtom (gdk_display, selection_name, False);
if((XGetSelectionOwner(GDK_DISPLAY(), nautilus_selection_atom)))
{
if (_has_gconftool)
desktop_type = DESKTOP_TYPE_NAUTILUS;
}
}
if ((desktop_type == DESKTOP_TYPE_NONE) && (action != NULL))
{
/* gtk_widget_set_sensitive (action, FALSE); */
}
return actions;
}
/**
* rb_device_source_want_uri:
* @source: a #RBDeviceSource
* @uri: a URI to consider
*
* Checks whether @uri identifies a path underneath the
* device's mount point. Should be used to implement
* the #RBSource impl_want_uri method.
*
* Return value: URI match strength
*/
int
rb_device_source_want_uri (RBDeviceSource *source, const char *uri)
{
GMount *mount = NULL;
GVolume *volume = NULL;
GFile *file;
char *device_path, *uri_path;
int retval;
int len;
retval = 0;
/* ignore anything that isn't a local file */
file = g_file_new_for_uri (uri);
if (g_file_has_uri_scheme (file, "file") == FALSE) {
g_object_unref (file);
return 0;
}
/* Deal with the mount root being passed, eg. file:///media/IPODNAME */
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "mount")) {
g_object_get (source, "mount", &volume, NULL);
}
if (mount != NULL) {
GFile *root;
root = g_mount_get_root (mount);
retval = g_file_equal (root, file) ? 100 : 0;
g_object_unref (root);
if (retval) {
g_object_unref (file);
g_object_unref (mount);
return retval;
}
volume = g_mount_get_volume (mount);
g_object_unref (mount);
} else {
if (g_object_class_find_property (G_OBJECT_GET_CLASS (source), "volume")) {
g_object_get (source, "volume", &volume, NULL);
}
}
if (volume == NULL) {
g_object_unref (file);
return 0;
}
/* Deal with the path to the device node being passed */
device_path = g_volume_get_identifier (volume, G_VOLUME_IDENTIFIER_KIND_UNIX_DEVICE);
g_object_unref (volume);
if (device_path == NULL) {
g_object_unref (file);
return 0;
}
uri_path = g_file_get_path (file);
g_object_unref (file);
if (uri_path == NULL)
return 0;
len = strlen (uri_path);
if (uri_path[len - 1] == '/') {
if (strncmp (uri_path, device_path, len - 1) == 0) {
retval = 100;
}
} else if (strcmp (uri_path, device_path) == 0) {
retval = 100;
}
g_free (device_path);
g_free (uri_path);
return retval;
}
static gboolean rotation_plugin_try_restore_state_co (RotationPluginTryRestoreStateData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
case 1:
goto _state_1;
default:
g_assert_not_reached ();
}
_state_0:
_data_->_tmp0_ = NULL;
_data_->_tmp0_ = _data_->mrl;
_data_->_tmp1_ = NULL;
_data_->_tmp1_ = g_file_new_for_uri (_data_->_tmp0_);
_data_->file = _data_->_tmp1_;
_data_->_tmp3_ = NULL;
_data_->_tmp3_ = _data_->file;
_data_->_tmp4_ = FALSE;
_data_->_tmp4_ = g_file_has_uri_scheme (_data_->_tmp3_, "http");
if (_data_->_tmp4_) {
_data_->_tmp2_ = TRUE;
} else {
_data_->_tmp5_ = NULL;
_data_->_tmp5_ = _data_->file;
_data_->_tmp6_ = FALSE;
_data_->_tmp6_ = g_file_has_uri_scheme (_data_->_tmp5_, "dvd");
_data_->_tmp2_ = _data_->_tmp6_;
}
if (_data_->_tmp2_) {
_g_object_unref0 (_data_->file);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}
{
_data_->_tmp7_ = NULL;
_data_->_tmp7_ = _data_->file;
_data_->_state_ = 1;
g_file_query_info_async (_data_->_tmp7_, GIO_ROTATION_FILE_ATTRIBUTE, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, NULL, rotation_plugin_try_restore_state_ready, _data_);
return FALSE;
_state_1:
_data_->_tmp8_ = NULL;
_data_->_tmp8_ = g_file_query_info_finish (_data_->_tmp7_, _data_->_res_, &_data_->_inner_error_);
_data_->file_info = _data_->_tmp8_;
if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
if (g_error_matches (_data_->_inner_error_, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED)) {
goto __catch1_g_io_error_not_supported;
}
goto __catch1_g_error;
}
_data_->_tmp9_ = NULL;
_data_->_tmp9_ = _data_->file_info;
_data_->_tmp10_ = NULL;
_data_->_tmp10_ = g_file_info_get_attribute_string (_data_->_tmp9_, GIO_ROTATION_FILE_ATTRIBUTE);
_data_->_tmp11_ = NULL;
_data_->_tmp11_ = g_strdup (_data_->_tmp10_);
_data_->state_str = _data_->_tmp11_;
_data_->_tmp12_ = NULL;
_data_->_tmp12_ = _data_->state_str;
if (_data_->_tmp12_ != NULL) {
_data_->_tmp13_ = NULL;
_data_->_tmp13_ = _data_->state_str;
_data_->_tmp14_ = 0ULL;
_data_->_tmp14_ = uint64_parse (_data_->_tmp13_);
_data_->state = (gint) ((BvwRotation) _data_->_tmp14_);
_data_->_tmp15_ = NULL;
_data_->_tmp15_ = _data_->self->priv->bvw;
_data_->_tmp16_ = 0;
_data_->_tmp16_ = _data_->state;
bacon_video_widget_set_rotation (_data_->_tmp15_, (BvwRotation) _data_->_tmp16_);
}
_g_free0 (_data_->state_str);
_g_object_unref0 (_data_->file_info);
}
goto __finally1;
__catch1_g_io_error_not_supported:
{
_data_->e = _data_->_inner_error_;
_data_->_inner_error_ = NULL;
_g_error_free0 (_data_->e);
}
goto __finally1;
__catch1_g_error:
{
_data_->_vala1_e = _data_->_inner_error_;
_data_->_inner_error_ = NULL;
_data_->_tmp17_ = NULL;
_data_->_tmp17_ = _data_->_vala1_e;
_data_->_tmp18_ = NULL;
_data_->_tmp18_ = _data_->_tmp17_->message;
g_warning ("totem-rotation-plugin.vala:175: Could not query file attribute: %s", _data_->_tmp18_);
_g_error_free0 (_data_->_vala1_e);
}
__finally1:
if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
_g_object_unref0 (_data_->file);
g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _data_->_inner_error_->message, g_quark_to_string (_data_->_inner_error_->domain), _data_->_inner_error_->code);
g_clear_error (&_data_->_inner_error_);
return FALSE;
}
_g_object_unref0 (_data_->file);
if (_data_->_state_ == 0) {
g_simple_async_result_complete_in_idle (_data_->_async_result);
} else {
g_simple_async_result_complete (_data_->_async_result);
}
g_object_unref (_data_->_async_result);
return FALSE;
}
void
nautilus_drag_default_drop_action_for_icons (GdkDragContext *context,
const char *target_uri_string, const GList *items,
int *action)
{
gboolean same_fs;
gboolean target_is_source_parent;
const char *dropped_uri;
GFile *target, *dropped;
GdkDragAction actions;
NautilusFile *target_file;
if (target_uri_string == NULL) {
*action = 0;
return;
}
actions = context->actions & (GDK_ACTION_MOVE | GDK_ACTION_COPY);
if (actions == 0) {
/* We can't use copy or move, just go with the suggested action. */
*action = context->suggested_action;
return;
}
if (context->suggested_action == GDK_ACTION_ASK) {
/* Don't override ask */
*action = context->suggested_action;
return;
}
dropped_uri = ((NautilusDragSelectionItem *)items->data)->uri;
target_file = nautilus_file_get_existing_by_uri (dropped_uri);
/*
* Check for trash URI. We do a find_directory for any Trash directory.
* Passing 0 permissions as gnome-vfs would override the permissions
* passed with 700 while creating .Trash directory
*/
if (eel_uri_is_trash (target_uri_string)) {
/* Only move to Trash */
if (actions & GDK_ACTION_MOVE) {
*action = GDK_ACTION_MOVE;
}
nautilus_file_unref (target_file);
return;
} else if (target_file != NULL && nautilus_file_is_launcher (target_file)) {
if (actions & GDK_ACTION_MOVE) {
*action = GDK_ACTION_MOVE;
}
nautilus_file_unref (target_file);
return;
} else if (eel_uri_is_desktop (target_uri_string)) {
target = nautilus_get_desktop_location ();
if (eel_uri_is_desktop (dropped_uri)) {
/* Only move to Desktop icons */
if (actions & GDK_ACTION_MOVE) {
*action = GDK_ACTION_MOVE;
}
nautilus_file_unref (target_file);
return;
}
} else {
target = g_file_new_for_uri (target_uri_string);
}
nautilus_file_unref (target_file);
/* Compare the first dropped uri with the target uri for same fs match. */
dropped = g_file_new_for_uri (dropped_uri);
same_fs = check_same_fs (target, dropped);
target_is_source_parent = g_file_has_prefix (dropped, target);
if (same_fs || target_is_source_parent ||
g_file_has_uri_scheme (dropped, "trash")) {
if (actions & GDK_ACTION_MOVE) {
*action = GDK_ACTION_MOVE;
} else {
*action = context->suggested_action;
}
} else {
if (actions & GDK_ACTION_COPY) {
*action = GDK_ACTION_COPY;
} else {
*action = context->suggested_action;
}
}
g_object_unref (target);
g_object_unref (dropped);
}
/**
* gedit_utils_basename_for_display:
* @location: location for which the basename should be displayed
*
* Returns: (transfer full): the basename of a file suitable for display to users.
*/
gchar *
gedit_utils_basename_for_display (GFile *location)
{
gchar *name;
gchar *hn;
gchar *uri;
g_return_val_if_fail (G_IS_FILE (location), NULL);
uri = g_file_get_uri (location);
/* First, try to query the display name, but only on local files */
if (g_file_has_uri_scheme (location, "file"))
{
GFileInfo *info;
info = g_file_query_info (location,
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
G_FILE_QUERY_INFO_NONE,
NULL,
NULL);
if (info)
{
/* Simply get the display name to use as the basename */
name = g_strdup (g_file_info_get_display_name (info));
g_object_unref (info);
}
else
{
/* This is a local file, and therefore we will use
* g_filename_display_basename on the local path */
gchar *local_path;
local_path = g_file_get_path (location);
name = g_filename_display_basename (local_path);
g_free (local_path);
}
}
else if (g_file_has_parent (location, NULL) ||
!gedit_utils_decode_uri (uri, NULL, NULL, &hn, NULL, NULL))
{
/* For remote files with a parent (so not just http://foo.com)
or remote file for which the decoding of the host name fails,
use the _parse_name and take basename of that */
gchar *parse_name;
gchar *base;
parse_name = g_file_get_parse_name (location);
base = g_filename_display_basename (parse_name);
name = g_uri_unescape_string (base, NULL);
g_free (base);
g_free (parse_name);
}
else
{
/* display '/ on <host>' using the decoded host */
gchar *hn_utf8;
if (hn != NULL)
{
hn_utf8 = gedit_utils_make_valid_utf8 (hn);
}
else
{
/* we should never get here */
hn_utf8 = g_strdup ("?");
}
/* Translators: '/ on <remote-share>' */
name = g_strdup_printf (_("/ on %s"), hn_utf8);
g_free (hn_utf8);
g_free (hn);
}
g_free (uri);
return name;
}
