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