static void
resolve_album_art (ResolveData *resolve_data,
resolution_flags_t flags)
{
const gchar *artist, *album;
GCancellable *cancellable = NULL;
GFile *cache_file = NULL;
resolve_data_start_operation (resolve_data, "album-art");
artist = grl_media_audio_get_artist (GRL_MEDIA_AUDIO (resolve_data->rs->media));
album = grl_media_audio_get_album (GRL_MEDIA_AUDIO (resolve_data->rs->media));
if (!artist || !album)
goto done;
cancellable = resolve_data_ensure_cancellable (resolve_data);
media_art_get_file (artist, album, "album", &cache_file);
if (cache_file) {
/* Check whether the cache file exists. */
resolve_data_start_operation (resolve_data, "album-art");
g_file_query_info_async (cache_file, G_FILE_ATTRIBUTE_ACCESS_CAN_READ,
G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
cancellable, resolve_album_art_cb, resolve_data);
} else {
GRL_DEBUG ("Found no thumbnail for artist %s and album %s", artist, album);
}
done:
resolve_data_finish_operation (resolve_data, "album-art", NULL);
g_clear_object (&cache_file);
}
static void
resolve_image (ResolveData *resolve_data,
resolution_flags_t flags)
{
GFile *file;
GCancellable *cancellable;
GRL_DEBUG ("resolve_image");
resolve_data_start_operation (resolve_data, "image");
if (flags & FLAG_THUMBNAIL) {
const gchar *attributes;
file = g_file_new_for_uri (grl_media_get_url (resolve_data->rs->media));
cancellable = resolve_data_ensure_cancellable (resolve_data);
#if GLIB_CHECK_VERSION (2, 39, 0)
attributes = G_FILE_ATTRIBUTE_THUMBNAIL_PATH "," \
G_FILE_ATTRIBUTE_THUMBNAIL_IS_VALID;
#else
attributes = G_FILE_ATTRIBUTE_THUMBNAIL_PATH;
#endif
g_file_query_info_async (file, attributes,
G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, cancellable,
(GAsyncReadyCallback)got_file_info, resolve_data);
g_object_unref (file);
} else {
resolve_data_finish_operation (resolve_data, "image", NULL);
}
}
/**
* empathy_ft_handler_new_outgoing:
* @contact: the #EmpathyContact to send @source to
* @source: the #GFile to send
* @callback: callback to be called when the handler has been created
* @user_data: user data to be passed to @callback
*
* Triggers the creation of a new #EmpathyFTHandler for an outgoing transfer.
*/
void
empathy_ft_handler_new_outgoing (EmpathyContact *contact,
GFile *source,
EmpathyFTHandlerReadyCallback callback,
gpointer user_data)
{
EmpathyFTHandler *handler;
CallbacksData *data;
EmpathyFTHandlerPriv *priv;
DEBUG ("New handler outgoing");
g_return_if_fail (EMPATHY_IS_CONTACT (contact));
g_return_if_fail (G_IS_FILE (source));
handler = g_object_new (EMPATHY_TYPE_FT_HANDLER,
"contact", contact, "gfile", source, NULL);
priv = GET_PRIV (handler);
data = g_slice_new0 (CallbacksData);
data->callback = callback;
data->user_data = user_data;
data->handler = g_object_ref (handler);
/* start collecting info about the file */
g_file_query_info_async (priv->gfile,
G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME ","
G_FILE_ATTRIBUTE_STANDARD_SIZE ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
NULL, (GAsyncReadyCallback) ft_handler_gfile_ready_cb, data);
}
static void
pdf_load_job_from_google_documents (PdfLoadJob *job)
{
gchar *tmp_name;
gchar *tmp_path, *pdf_path;
GFile *pdf_file;
job->original_file_mtime = gdata_entry_get_updated (job->gdata_entry);
tmp_name = g_strdup_printf ("gnome-documents-%u.pdf",
g_str_hash (gdata_documents_entry_get_resource_id (GDATA_DOCUMENTS_ENTRY (job->gdata_entry))));
tmp_path = g_build_filename (g_get_user_cache_dir (), "gnome-documents", NULL);
job->pdf_path = pdf_path =
g_build_filename (tmp_path, tmp_name, NULL);
g_mkdir_with_parents (tmp_path, 0700);
pdf_file = g_file_new_for_path (pdf_path);
g_file_query_info_async (pdf_file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
job->cancellable,
gdata_cache_query_info_ready_cb,
job);
g_free (tmp_name);
g_free (tmp_path);
g_object_unref (pdf_file);
}
static void
pdf_load_job_from_skydrive (PdfLoadJob *job)
{
gchar *tmp_name;
gchar *tmp_path, *pdf_path;
GDateTime *updated_time;
GFile *pdf_file;
updated_time = zpj_skydrive_entry_get_updated_time (job->zpj_entry);
job->original_file_mtime = (guint64) g_date_time_to_unix (updated_time);
tmp_name = g_strdup_printf ("gnome-documents-%u.pdf",
g_str_hash (zpj_skydrive_entry_get_id (job->zpj_entry)));
tmp_path = g_build_filename (g_get_user_cache_dir (), "gnome-documents", NULL);
job->pdf_path = pdf_path =
g_build_filename (tmp_path, tmp_name, NULL);
g_mkdir_with_parents (tmp_path, 0700);
pdf_file = g_file_new_for_path (pdf_path);
g_file_query_info_async (pdf_file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
job->cancellable,
zpj_cache_query_info_ready_cb,
job);
g_free (tmp_name);
g_free (tmp_path);
g_object_unref (pdf_file);
}
static void
amazon_cover_uri_async_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
NemoPreviewCoverArtFetcher *self = NEMO_PREVIEW_COVER_ART_FETCHER (source);
GError *error = NULL;
GFile *file;
self->priv->asin = nemo_preview_cover_art_fetcher_get_uri_for_track_finish
(self, res, &error);
if (error != NULL) {
g_print ("Unable to fetch the Amazon cover art uri from MusicBrainz: %s\n",
error->message);
g_error_free (error);
return;
}
file = get_gfile_for_cache (self);
g_file_query_info_async (file, G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT, NULL,
cache_file_query_info_cb,
self);
g_object_unref (file);
}
static void
photos_base_item_create_thumbnail_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
{
PhotosBaseItem *self = PHOTOS_BASE_ITEM (source_object);
PhotosBaseItemPrivate *priv = self->priv;
GError *error;
GFile *file = G_FILE (user_data);
error = NULL;
photos_base_item_create_thumbnail_finish (self, res, &error);
if (error != NULL)
{
priv->failed_thumbnailing = TRUE;
g_warning ("Unable to create thumbnail: %s", error->message);
photos_base_item_set_failed_icon (self);
g_error_free (error);
goto out;
}
g_file_query_info_async (file,
G_FILE_ATTRIBUTE_THUMBNAIL_PATH,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
NULL,
photos_base_item_thumbnail_path_info,
g_object_ref (self));
out:
g_object_unref (file);
}
static void
photos_base_item_refresh_icon (PhotosBaseItem *self)
{
PhotosBaseItemPrivate *priv = self->priv;
GFile *file;
if (priv->thumb_path != NULL)
{
photos_base_item_refresh_thumb_path (self);
return;
}
photos_base_item_set_thumbnailing_icon (self);
if (priv->collection)
{
photos_base_item_refresh_collection_icon (self);
return;
}
if (priv->failed_thumbnailing)
return;
file = g_file_new_for_uri (priv->uri);
g_file_query_info_async (file,
G_FILE_ATTRIBUTE_THUMBNAIL_PATH,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
NULL,
photos_base_item_file_query_info,
g_object_ref (self));
g_object_unref (file);
}
/**
* shell_doc_system_queue_existence_check:
* @system: A #ShellDocSystem
* @n_items: Count of items to check for existence, starting from most recent
*
* Asynchronously start a check of a number of recent file for existence;
* any deleted files will be emitted from the #ShellDocSystem::deleted
* signal. Note that this function ignores non-local files; they
* will simply always appear to exist (until they are removed from
* the recent file list manually).
*
* The intent of this function is to be called after a #ShellDocSystem::changed
* signal has been emitted, and a display has shown a subset of those files.
*/
void
shell_doc_system_queue_existence_check (ShellDocSystem *self,
guint n_items)
{
GSList *iter;
guint i;
for (i = 0, iter = self->priv->infos_by_timestamp; i < n_items && iter; i++, iter = iter->next)
{
GtkRecentInfo *info = iter->data;
const char *uri;
GFile *file;
ShellDocSystemRecentQueryData *data;
if (!gtk_recent_info_is_local (info))
continue;
data = g_new0 (ShellDocSystemRecentQueryData, 1);
data->self = self;
data->info = gtk_recent_info_ref (info);
uri = gtk_recent_info_get_uri (info);
file = g_file_new_for_uri (uri);
g_file_query_info_async (file, "standard::type", G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT, NULL, on_recent_file_query_result, data);
g_object_unref (file);
}
}
static gboolean
miner_applications_process_file (TrackerMinerFS *fs,
GFile *file,
TrackerSparqlBuilder *sparql,
GCancellable *cancellable)
{
ProcessApplicationData *data;
const gchar *attrs;
data = g_slice_new0 (ProcessApplicationData);
data->miner = g_object_ref (fs);
data->sparql = g_object_ref (sparql);
data->file = g_object_ref (file);
data->cancellable = g_object_ref (cancellable);
attrs = G_FILE_ATTRIBUTE_TIME_MODIFIED ","
G_FILE_ATTRIBUTE_STANDARD_TYPE;
g_file_query_info_async (file,
attrs,
G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,
G_PRIORITY_DEFAULT,
cancellable,
process_file_cb,
data);
return TRUE;
}
static void
pdf_load_job_from_regular_file (PdfLoadJob *job)
{
GFile *file;
const gchar *zpj_prefix = "windows-live:skydrive:";
if (g_str_has_prefix (job->uri, "https://docs.google.com")) {
job->document_id = document_id_from_entry_id (job->uri);
pdf_load_job_from_gdata_cache (job);
return;
}
if (g_str_has_prefix (job->uri, zpj_prefix)) {
job->document_id = g_strdup (job->uri + strlen (zpj_prefix));
pdf_load_job_from_zpj_cache (job);
return;
}
file = g_file_new_for_uri (job->uri);
g_file_query_info_async (file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
job->cancellable,
query_info_ready_cb,
job);
g_object_unref (file);
}
static void
set_metadata_callback (GObject *source_object,
GAsyncResult *result,
gpointer callback_data)
{
NautilusFile *file;
GError *error;
gboolean res;
file = callback_data;
error = NULL;
res = g_file_set_attributes_finish (G_FILE (source_object),
result,
NULL,
&error);
if (res)
{
g_file_query_info_async (G_FILE (source_object),
NAUTILUS_FILE_DEFAULT_ATTRIBUTES,
0,
G_PRIORITY_DEFAULT,
NULL,
set_metadata_get_info_callback, file);
}
else
{
nautilus_file_unref (file);
g_error_free (error);
}
}
void TrashLauncherIcon::UpdateTrashIcon()
{
glib::Object<GFile> location(g_file_new_for_uri(TRASH_URI.c_str()));
g_file_query_info_async(location,
G_FILE_ATTRIBUTE_STANDARD_ICON,
G_FILE_QUERY_INFO_NONE,
0,
cancellable_,
&TrashLauncherIcon::UpdateTrashIconCb,
this);
}
static void after_mount_enclosing_volume (GDownloadable * download)
{
//g_message ("get size and read after mounting ...\n");
if (download->priv->size == 0)
g_file_query_info_async (download->priv->remote_file,
G_FILE_ATTRIBUTE_STANDARD_SIZE,
0, G_PRIORITY_DEFAULT, NULL,
on_size_query_ready, download);
g_file_read_async (download->priv->remote_file, G_PRIORITY_DEFAULT, NULL,
on_file_read_ready, download);
}
static void
start_loading_document (NemoPreviewPdfLoader *self)
{
GFile *file;
file = g_file_new_for_uri (self->priv->uri);
g_file_query_info_async (file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
NULL,
query_info_ready_cb,
self);
g_object_unref (file);
}
static GtkWidget *
create_child_for_place (Place *place)
{
GtkWidget *child;
child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
g_object_set (child, "margin-left", 16, "margin-right", 16, NULL);
g_object_set_data_full (G_OBJECT (child), "place", place, (GDestroyNotify) place_free);
place->cancellable = g_cancellable_new ();
g_file_query_info_async (place->location, "standard::symbolic-icon",
G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
place->cancellable, place_query_info_ready, child);
return child;
}
static void
pdf_load_job_from_regular_file (PdfLoadJob *job)
{
GFile *file;
file = g_file_new_for_uri (job->uri);
g_file_query_info_async (file,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
job->cancellable,
query_info_ready_cb,
job);
g_object_unref (file);
}
static void
pdf_load_job_from_openoffice (PdfLoadJob *job)
{
GFile *original_file;
original_file = g_file_new_for_uri (job->uri);
g_file_query_info_async (original_file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
job->cancellable,
openoffice_cache_query_info_original_ready_cb,
job);
g_object_unref (original_file);
}
static void
gb_rename_file_popover__entry_changed (GbRenameFilePopover *self,
GtkEntry *entry)
{
g_autoptr(GFile) parent = NULL;
g_autoptr(GFile) file = NULL;
const gchar *text;
g_assert (GB_IS_RENAME_FILE_POPOVER (self));
g_assert (GTK_IS_ENTRY (entry));
g_assert (self->file != NULL);
g_assert (G_IS_FILE (self->file));
gtk_widget_set_sensitive (GTK_WIDGET (self->button), FALSE);
gtk_label_set_label (self->message, NULL);
text = gtk_entry_get_text (entry);
if (ide_str_empty0 (text))
return;
if (strchr (text, G_DIR_SEPARATOR) != NULL)
{
gtk_label_set_label (self->message,
_("File name must not contain subdirectories."));
return;
}
if (self->cancellable)
{
g_cancellable_cancel (self->cancellable);
g_clear_object (&self->cancellable);
}
self->cancellable = g_cancellable_new ();
parent = g_file_get_parent (self->file);
file = g_file_get_child (parent, text);
g_file_query_info_async (file,
G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
self->cancellable,
gb_rename_file_popover__file_query_info,
g_object_ref (self));
}
static void
gedit_document_saved_real (GeditDocument *doc)
{
GFile *location = gtk_source_file_get_location (doc->priv->file);
/* Keep the doc alive during the async operation. */
g_object_ref (doc);
g_file_query_info_async (location,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
NULL,
(GAsyncReadyCallback) saved_query_info_cb,
doc);
}
gboolean
_sw_client_service_upload (SwClientService *service,
SwServiceIface iface,
const char *filename,
const GHashTable *fields,
GCancellable *cancellable,
GFileProgressCallback progress_callback,
gpointer progress_callback_data,
GAsyncReadyCallback callback,
gpointer userdata)
{
SwClientServicePrivate *priv = GET_PRIVATE (service);
SwClientServiceCallClosure *closure;
GFile *file;
if (!_sw_client_service_setup_proxy_for_iface (service,
priv->name,
iface,
NULL)) {
return FALSE;
}
closure = g_slice_new0 (SwClientServiceCallClosure);
closure->progress_cb = progress_callback;
closure->progress_cb_data = progress_callback_data;
closure->service = g_object_ref (service);
closure->userdata = userdata;
closure->cb = G_CALLBACK (callback);
closure->iface = iface;
if (fields)
closure->fields = g_hash_table_ref ((GHashTable *) fields);
else
closure->fields = g_hash_table_new (g_str_hash, g_str_equal);
file = g_file_new_for_path (filename);
g_file_query_info_async (file,
G_FILE_ATTRIBUTE_STANDARD_SIZE","G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE,
0,
NULL,
got_file_size_cb,
closure);
g_object_unref (file);
return TRUE;
}
static GtkWidget *
create_row_for_place (Place *place)
{
GtkWidget *child, *row;
row = gtk_list_box_row_new ();
child = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_container_add (GTK_CONTAINER (row), child);
g_object_set (row, "margin-start", 16, "margin-end", 16, NULL);
g_object_set_data_full (G_OBJECT (row), "place", place, (GDestroyNotify) place_free);
place->cancellable = g_cancellable_new ();
g_file_query_info_async (place->location, "standard::symbolic-icon",
G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
place->cancellable, place_query_info_ready, row);
return row;
}
static void
gedit_document_loaded_real (GeditDocument *doc)
{
GFile *location;
if (!doc->priv->language_set_by_user)
{
GtkSourceLanguage *language = guess_language (doc);
gedit_debug_message (DEBUG_DOCUMENT, "Language: %s",
language != NULL ? gtk_source_language_get_name (language) : "None");
set_language (doc, language, FALSE);
}
doc->priv->mtime_set = FALSE;
doc->priv->externally_modified = FALSE;
doc->priv->deleted = FALSE;
g_get_current_time (&doc->priv->time_of_last_save_or_load);
set_readonly (doc, FALSE);
gedit_document_set_content_type (doc, NULL);
location = gtk_source_file_get_location (doc->priv->file);
if (location != NULL)
{
/* Keep the doc alive during the async operation. */
g_object_ref (doc);
g_file_query_info_async (location,
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE ","
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
NULL,
(GAsyncReadyCallback) loaded_query_info_cb,
doc);
}
}
static void
file_added (GFile *file,
BgPicturesSource *self)
{
char *uri;
uri = g_file_get_uri (file);
if (!bg_pictures_source_is_known (self, uri))
{
g_file_query_info_async (file,
ATTRIBUTES,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_LOW,
NULL,
file_info_ready,
self);
}
g_free (uri);
}
static void
nautilus_bookmark_update_exists (NautilusBookmark *bookmark)
{
/* Convert to a path, returning FALSE if not local. */
if (!g_file_is_native (bookmark->details->location) &&
bookmark->details->exists_id == 0) {
bookmark->details->exists_id =
g_idle_add (exists_non_native_idle_cb, bookmark);
return;
}
if (bookmark->details->cancellable != NULL) {
return;
}
bookmark->details->cancellable = g_cancellable_new ();
g_file_query_info_async (bookmark->details->location,
G_FILE_ATTRIBUTE_STANDARD_TYPE,
0, G_PRIORITY_DEFAULT,
bookmark->details->cancellable,
exists_query_info_ready_cb, bookmark);
}
static void
_g_find_file_insensitive_async (GFile *parent,
const gchar *name,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
InsensitiveFileSearchData *data;
GFile *direct_file = g_file_get_child (parent, name);
data = g_new0 (InsensitiveFileSearchData, 1);
data->cancellable = cancellable;
data->callback = callback;
data->user_data = user_data;
data->root = g_object_ref (parent);
data->original_path = g_strdup (name);
g_file_query_info_async (direct_file, G_FILE_ATTRIBUTE_STANDARD_TYPE,
G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT,
cancellable,
find_file_insensitive_exists_callback, data);
}
bool ResourceHandle::startGio(String urlString)
{
if (request().httpMethod() != "GET") {
ResourceError error("webkit-network-error", ERROR_BAD_NON_HTTP_METHOD, urlString, request().httpMethod());
d->client()->didFail(this, error);
return false;
}
// Remove the fragment part of the URL since the file backend doesn't deal with it
int fragPos;
if ((fragPos = urlString.find("#")) != -1)
urlString = urlString.left(fragPos);
d->m_gfile = g_file_new_for_uri(urlString.utf8().data());
d->m_cancellable = g_cancellable_new();
g_file_query_info_async(d->m_gfile,
G_FILE_ATTRIBUTE_STANDARD_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE ","
G_FILE_ATTRIBUTE_STANDARD_SIZE,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT, d->m_cancellable,
queryInfoCallback, this);
return true;
}
static void
openoffice_cache_query_info_original_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
PdfLoadJob *job = user_data;
GError *error = NULL;
GFileInfo *info;
guint64 mtime;
gchar *pdf_path, *tmp_name, *tmp_path;
GFile *cache_file;
info = g_file_query_info_finish (G_FILE (source), res, &error);
if (error != NULL) {
/* try to create the cache anyway - if the source file
* is really not readable we'll fail again soon.
*/
pdf_load_job_openoffice_refresh_cache (job);
g_error_free (error);
return;
}
/* If we are converting a downloaded file then we already know its
* mtime. Moreover, we we don't want to find the mtime of the
* temporary file.
*/
if (job->original_file_mtime == 0)
job->original_file_mtime = mtime =
g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
g_object_unref (info);
tmp_path = g_build_filename (g_get_user_cache_dir (), "gnome-documents", NULL);
g_mkdir_with_parents (tmp_path, 0700);
/* If we are converting a downloaded file then we already know its
* location in the cache. Moreover, we we don't want to hash the
* temporary file.
*/
if (job->pdf_path == NULL)
{
tmp_name = g_strdup_printf ("gnome-documents-%u.pdf", g_str_hash (job->uri));
job->pdf_path = pdf_path =
g_build_filename (tmp_path, tmp_name, NULL);
g_free (tmp_name);
}
g_free (tmp_path);
cache_file = g_file_new_for_path (pdf_path);
g_file_query_info_async (cache_file,
G_FILE_ATTRIBUTE_TIME_MODIFIED,
G_FILE_QUERY_INFO_NONE,
G_PRIORITY_DEFAULT,
job->cancellable,
openoffice_cache_query_info_ready_cb,
job);
g_object_unref (cache_file);
}
static gboolean rotation_plugin_store_state_co (RotationPluginStoreStateData* _data_) {
switch (_data_->_state_) {
case 0:
goto _state_0;
case 1:
goto _state_1;
case 2:
goto _state_2;
default:
g_assert_not_reached ();
}
_state_0:
_data_->_tmp0_ = NULL;
g_object_get ((PeasActivatable*) _data_->self, "object", &_data_->_tmp0_, NULL);
_data_->_tmp1_ = NULL;
_data_->_tmp1_ = _data_->_tmp0_;
_data_->t = G_TYPE_CHECK_INSTANCE_CAST (_data_->_tmp1_, totem_object_get_type (), TotemObject);
_data_->_tmp2_ = NULL;
_data_->_tmp2_ = _data_->t;
_data_->_tmp3_ = NULL;
_data_->_tmp3_ = totem_object_get_current_mrl (_data_->_tmp2_);
_data_->mrl = _data_->_tmp3_;
_data_->_tmp4_ = NULL;
_data_->_tmp4_ = _data_->mrl;
if (_data_->_tmp4_ == NULL) {
_g_free0 (_data_->mrl);
_g_object_unref0 (_data_->t);
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_->_tmp5_ = NULL;
_data_->_tmp5_ = _data_->mrl;
_data_->_tmp6_ = NULL;
_data_->_tmp6_ = g_file_new_for_uri (_data_->_tmp5_);
_data_->file = _data_->_tmp6_;
{
_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_store_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 __catch0_g_io_error_not_supported;
}
goto __catch0_g_error;
}
_data_->_tmp9_ = NULL;
_data_->_tmp9_ = g_strdup ("");
_data_->state_str = _data_->_tmp9_;
_data_->_tmp10_ = NULL;
_data_->_tmp10_ = _data_->self->priv->bvw;
_data_->_tmp11_ = 0;
_data_->_tmp11_ = bacon_video_widget_get_rotation (_data_->_tmp10_);
_data_->rotation = _data_->_tmp11_;
_data_->_tmp12_ = 0;
_data_->_tmp12_ = _data_->rotation;
if (_data_->_tmp12_ != BVW_ROTATION_R_ZERO) {
_data_->_tmp13_ = 0;
_data_->_tmp13_ = _data_->rotation;
_data_->_tmp14_ = NULL;
_data_->_tmp14_ = g_strdup_printf ("%u", (guint) _data_->_tmp13_);
_g_free0 (_data_->state_str);
_data_->state_str = _data_->_tmp14_;
}
_data_->_tmp15_ = NULL;
_data_->_tmp15_ = _data_->file_info;
_data_->_tmp16_ = NULL;
_data_->_tmp16_ = _data_->state_str;
g_file_info_set_attribute_string (_data_->_tmp15_, GIO_ROTATION_FILE_ATTRIBUTE, _data_->_tmp16_);
_data_->_tmp17_ = NULL;
_data_->_tmp17_ = _data_->file;
_data_->_tmp18_ = NULL;
_data_->_tmp18_ = _data_->file_info;
_data_->_state_ = 2;
g_file_set_attributes_async (_data_->_tmp17_, _data_->_tmp18_, G_FILE_QUERY_INFO_NONE, G_PRIORITY_DEFAULT, NULL, rotation_plugin_store_state_ready, _data_);
return FALSE;
_state_2:
g_file_set_attributes_finish (_data_->_tmp17_, _data_->_res_, NULL, &_data_->_inner_error_);
if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
_g_free0 (_data_->state_str);
_g_object_unref0 (_data_->file_info);
if (g_error_matches (_data_->_inner_error_, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED)) {
goto __catch0_g_io_error_not_supported;
}
goto __catch0_g_error;
}
_g_free0 (_data_->state_str);
_g_object_unref0 (_data_->file_info);
}
goto __finally0;
__catch0_g_io_error_not_supported:
{
_data_->e = _data_->_inner_error_;
_data_->_inner_error_ = NULL;
_g_error_free0 (_data_->e);
}
goto __finally0;
__catch0_g_error:
{
_data_->_vala1_e = _data_->_inner_error_;
_data_->_inner_error_ = NULL;
_data_->_tmp19_ = NULL;
_data_->_tmp19_ = _data_->_vala1_e;
_data_->_tmp20_ = NULL;
_data_->_tmp20_ = _data_->_tmp19_->message;
g_warning ("totem-rotation-plugin.vala:156: Could not store file attribute: %s", _data_->_tmp20_);
_g_error_free0 (_data_->_vala1_e);
}
__finally0:
if (G_UNLIKELY (_data_->_inner_error_ != NULL)) {
_g_object_unref0 (_data_->file);
_g_free0 (_data_->mrl);
_g_object_unref0 (_data_->t);
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);
_g_free0 (_data_->mrl);
_g_object_unref0 (_data_->t);
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;
}
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;
}
