static GList * realm_samba_provider_discover_finish (RealmProvider *provider, GAsyncResult *result, gint *relevance, GError **error) { RealmKerberos *realm = NULL; RealmDisco *disco; disco = g_task_propagate_pointer (G_TASK (result), error); if (disco == NULL) return NULL; if (g_strcmp0 (disco->server_software, REALM_DBUS_IDENTIFIER_ACTIVE_DIRECTORY) == 0) { realm = realm_provider_lookup_or_register_realm (provider, REALM_TYPE_SAMBA, disco->domain_name, disco); } realm_disco_unref (disco); if (realm == NULL) return NULL; /* Return a higher priority if we're the default */ *relevance = realm_provider_is_default (REALM_DBUS_IDENTIFIER_ACTIVE_DIRECTORY, REALM_DBUS_IDENTIFIER_WINBIND) ? 100 : 50; return g_list_append (NULL, g_object_ref (realm)); }
static void on_sliced_image_loaded (GObject *source_object, GAsyncResult *res, gpointer user_data) { GObject *cache = source_object; AsyncImageData *data = (AsyncImageData *)user_data; GTask *task = G_TASK (res); GList *list, *pixbufs; if (g_task_had_error (task)) return; pixbufs = g_task_propagate_pointer (task, NULL); for (list = pixbufs; list; list = list->next) { ClutterActor *actor = load_from_pixbuf (GDK_PIXBUF (list->data)); clutter_actor_hide (actor); clutter_actor_add_child (data->actor, actor); } g_list_free_full (pixbufs, g_object_unref); if (data->load_callback != NULL) data->load_callback (cache, data->load_callback_data); }
static gboolean get_providers_finish_default (GoaProviderFactory *factory, GList **out_providers, GAsyncResult *result, GError **error) { GTask *task; GList *providers; gboolean had_error; g_return_val_if_fail (g_task_is_valid (result, factory), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); task = G_TASK (result); /* Workaround for bgo#764163 */ had_error = g_task_had_error (task); providers = g_task_propagate_pointer (task, error); if (had_error) return FALSE; if (out_providers != NULL) { *out_providers = providers; providers = NULL; } g_list_free_full (providers, g_object_unref); return TRUE; }
static void egg_task_cache_fetch_cb (GObject *object, GAsyncResult *result, gpointer user_data) { EggTaskCache *self = (EggTaskCache *)object; GTask *task = (GTask *)result; GError *error = NULL; gpointer key = user_data; gpointer ret; g_assert (EGG_IS_TASK_CACHE (self)); g_assert (G_IS_TASK (task)); g_hash_table_remove (self->in_flight, key); ret = g_task_propagate_pointer (task, &error); if (ret != NULL) { egg_task_cache_populate (self, key, ret); egg_task_cache_propagate_pointer (self, key, ret); self->value_destroy_func (ret); } else { egg_task_cache_propagate_error (self, key, error); g_clear_error (&error); } self->key_destroy_func (key); EGG_COUNTER_DEC (in_flight); }
static void load_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeMingwDeviceProvider *self = (IdeMingwDeviceProvider *)object; GTask *task = (GTask *)result; GPtrArray *devices; gsize i; g_assert (IDE_IS_MINGW_DEVICE_PROVIDER (self)); g_assert (G_IS_TASK (task)); devices = g_task_propagate_pointer (task, NULL); if (devices) { g_clear_pointer (&self->devices, g_ptr_array_unref); self->devices = devices; for (i = 0; i < devices->len; i++) { IdeDevice *device; device = g_ptr_array_index (devices, i); ide_device_provider_emit_device_added (IDE_DEVICE_PROVIDER (self), device); } } self->settled = TRUE; g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SETTLED]); }
static GSocketAddress * soup_address_address_enumerator_next_finish (GSocketAddressEnumerator *enumerator, GAsyncResult *result, GError **error) { return g_task_propagate_pointer (G_TASK (result), error); }
static GList * lookup_records (GResolver *resolver, const gchar *rrname, GResolverRecordType record_type, GCancellable *cancellable, GError **error) { GTask *task; GList *records; LookupRecordsData *lrd; task = g_task_new (resolver, cancellable, NULL, NULL); g_task_set_source_tag (task, lookup_records); lrd = g_slice_new (LookupRecordsData); lrd->rrname = g_strdup (rrname); lrd->record_type = record_type; g_task_set_task_data (task, lrd, (GDestroyNotify) free_lookup_records_data); g_task_set_return_on_cancel (task, TRUE); g_task_run_in_thread_sync (task, do_lookup_records); records = g_task_propagate_pointer (task, error); g_object_unref (task); return records; }
static void download_preview_cb(GObject* source, GAsyncResult* res, gpointer udata) { GError* error = NULL; GdkPixbuf* pic = g_task_propagate_pointer(G_TASK(res), &error); if (error) { g_error_free(error); return; } GtChannel* self = GT_CHANNEL(udata); GtChannelPrivate* priv = gt_channel_get_instance_private(self); if (pic) { g_clear_object(&priv->preview); priv->preview_timestamp = utils_timestamp_now(); priv->preview = pic; utils_pixbuf_scale_simple(&priv->preview, 320, 180, GDK_INTERP_BILINEAR); g_object_notify_by_pspec(G_OBJECT(self), props[PROP_PREVIEW]); } priv->updating = FALSE; g_object_notify_by_pspec(G_OBJECT(self), props[PROP_UPDATING]); }
static GIOStream * g_socks4a_proxy_connect_finish (GProxy *proxy, GAsyncResult *result, GError **error) { return g_task_propagate_pointer (G_TASK (result), error); }
static GInputStream * soup_request_default_send_finish (SoupRequest *request, GAsyncResult *result, GError **error) { return g_task_propagate_pointer (G_TASK (result), error); }
GDavMultiStatus * gdav_propfind_finish (SoupSession *session, GAsyncResult *result, SoupMessage **out_message, GError **error) { AsyncContext *async_context; g_return_val_if_fail ( g_task_is_valid (result, session), NULL); g_return_val_if_fail ( g_async_result_is_tagged (result, gdav_propfind), FALSE); async_context = g_task_get_task_data (G_TASK (result)); /* SoupMessage is set even in case of error for uses * like calling soup_message_get_https_status() when * SSL/TLS negotiation fails, though SoupMessage may * be NULL if the Request-URI was invalid. */ if (out_message != NULL) { *out_message = async_context->message; async_context->message = NULL; } return g_task_propagate_pointer (G_TASK (result), error); }
GFileOutputStream * photos_glib_file_create_finish (GFile *file, GAsyncResult *res, GFile **out_unique_file, GError **error) { GTask *task = G_TASK (res); GFileOutputStream *ret_val = NULL; PhotosGLibFileCreateData *data; g_return_val_if_fail (G_IS_FILE (file), NULL); g_return_val_if_fail (g_task_is_valid (res, file), NULL); g_return_val_if_fail (g_task_get_source_tag (task) == photos_glib_file_create_async, NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); data = (PhotosGLibFileCreateData *) g_task_get_task_data (task); g_return_val_if_fail (data != NULL, NULL); ret_val = g_task_propagate_pointer (task, error); if (ret_val == NULL) goto out; if (out_unique_file != NULL) { GFile *unique_file; g_autofree gchar *filename = NULL; filename = photos_glib_file_create_data_get_filename (data); unique_file = g_file_get_child (data->dir, filename); *out_unique_file = unique_file; } out: return ret_val; }
static void chat_badges_cb(GObject* source, GAsyncResult* res, gpointer udata) { GtTwitchChatView* self = GT_TWITCH_CHAT_VIEW(udata); GtTwitchChatViewPrivate* priv = gt_twitch_chat_view_get_instance_private(self); GtTwitchChatBadges* badges; badges = g_task_propagate_pointer(G_TASK(res), NULL); //TODO: Error handling if (priv->chat_badges) { gt_twitch_chat_badges_free(priv->chat_badges); priv->chat_badges = NULL; } if (!badges) return; priv->chat_badges = badges; if (gt_twitch_chat_client_is_connected(priv->chat)) gt_twitch_chat_client_join(priv->chat, priv->cur_chan); }
static gchar * load_sim_identifier_finish (MMBaseSim *self, GAsyncResult *res, GError **error) { return g_task_propagate_pointer (G_TASK (res), error); }
static gchar * load_operator_name_finish (MMBaseSim *self, GAsyncResult *res, GError **error) { return g_task_propagate_pointer (G_TASK (res), error); }
static void file_loaded (GObject *source_object, GAsyncResult *result, gpointer user_data) { MetaBackgroundImage *image = META_BACKGROUND_IMAGE (source_object); GError *error = NULL; CoglError *catch_error = NULL; GTask *task; CoglTexture *texture; GdkPixbuf *pixbuf; int width, height, row_stride; guchar *pixels; gboolean has_alpha; task = G_TASK (result); pixbuf = g_task_propagate_pointer (task, &error); if (pixbuf == NULL) { char *uri = g_file_get_uri (image->file); g_warning ("Failed to load background '%s': %s", uri, error->message); g_clear_error (&error); g_free (uri); goto out; } width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); row_stride = gdk_pixbuf_get_rowstride (pixbuf); pixels = gdk_pixbuf_get_pixels (pixbuf); has_alpha = gdk_pixbuf_get_has_alpha (pixbuf); texture = meta_create_texture (width, height, has_alpha ? COGL_TEXTURE_COMPONENTS_RGBA : COGL_TEXTURE_COMPONENTS_RGB, META_TEXTURE_ALLOW_SLICING); if (!cogl_texture_set_data (texture, has_alpha ? COGL_PIXEL_FORMAT_RGBA_8888 : COGL_PIXEL_FORMAT_RGB_888, row_stride, pixels, 0, &catch_error)) { g_warning ("Failed to create texture for background"); cogl_error_free (catch_error); cogl_object_unref (texture); } image->texture = texture; out: if (pixbuf != NULL) g_object_unref (pixbuf); image->loaded = TRUE; g_signal_emit (image, signals[LOADED], 0); }
static GList * lookup_records_finish (GResolver *resolver, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, resolver), NULL); return g_task_propagate_pointer (G_TASK (result), error); }
PpDevicesList * pp_host_get_lpd_devices_finish (PpHost *host, GAsyncResult *res, GError **error) { g_return_val_if_fail (g_task_is_valid (res, host), NULL); return g_task_propagate_pointer (G_TASK (res), error); }
static GSocketAddress * g_proxy_address_enumerator_next_finish (GSocketAddressEnumerator *enumerator, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, enumerator), NULL); return g_task_propagate_pointer (G_TASK (result), error); }
static GList * seahorse_hkp_source_import_finish (SeahorseServerSource *source, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, source), NULL); return g_task_propagate_pointer (G_TASK (result), error); }
PpCupsDests * pp_cups_get_dests_finish (PpCups *cups, GAsyncResult *res, GError **error) { g_return_val_if_fail (g_task_is_valid (res, cups), NULL); return g_task_propagate_pointer (G_TASK (res), error); }
static GInputStream * soup_request_file_send_finish (SoupRequest *request, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_task_is_valid (result, request), NULL); return g_task_propagate_pointer (G_TASK (result), error); }
static void onTaskReadyCallback(GObject * source, GAsyncResult * res, gpointer userData) { GError *err = NULL; //WlDictQuery *query=WL_DICT_QUERY(source); TaskData *td = g_task_get_task_data(G_TASK(res)); gchar *responseBody = g_task_propagate_pointer(G_TASK(res), &err); if (err) { /* Error */ if (td->cb) td->cb(td->from, td->to, td->src, NULL, td->cbData, err); return; } JsonParser *parser = json_parser_new(); if (!json_parser_load_from_data(parser, responseBody, -1, &err)) { if (td->cb) td->cb(td->from, td->to, td->src, NULL, td->cbData, err); g_message("%s", responseBody); return; } JsonNode *rootNode = json_parser_get_root(parser); JsonObject *rootObj = json_node_get_object(rootNode); const gchar *from = json_object_get_string_member(rootObj, "from"); const gchar *to = json_object_get_string_member(rootObj, "to"); if (json_object_has_member(rootObj, "error_code")) { /* 查询出错 */ const gchar *error_msg = json_object_get_string_member(rootObj, "error_msg"); const gchar *error_code = json_object_get_string_member(rootObj, "error_code"); if (td->cb) { GError *error = g_error_new(G_IO_ERROR, atoi(error_code), "%s", error_msg); td->cb(wl_dict_lang_get_enum(from), wl_dict_lang_get_enum(to), json_object_get_string_member(rootObj, "query"), NULL, td->cbData, error); g_error_free(error); } g_object_unref(parser); return; } JsonArray *results = json_object_get_array_member(rootObj, "trans_result"); gint i, len = json_array_get_length(results); for (i = 0; i < len; i++) { JsonObject *resEle = json_array_get_object_element(results, i); const gchar *src = json_object_get_string_member(resEle, "src"); const gchar *dst = json_object_get_string_member(resEle, "dst"); if (td->cb) td->cb(wl_dict_lang_get_enum(from), wl_dict_lang_get_enum(to), src, dst, td->cbData, NULL); } g_object_unref(parser); }
/** * gnlp_get_available_languages_finish: * @result: a #GAsyncResult * @error: (nullable): return location for a #GError, or %NULL * * Finishes the operation started by @gnlp_get_available_languages. * * Returns: (transfer full)(nullable)(element-type #GnlpLanguage): a #GPtrArray, or %NULL * * Since: 0.1.0 */ GPtrArray* gnlp_get_available_languages_finish (GAsyncResult *result, GError **error) { g_return_val_if_fail (G_IS_TASK (result), NULL); g_return_val_if_fail (g_task_is_valid (result, NULL), NULL); g_return_val_if_fail (!error || !*error, NULL); return g_task_propagate_pointer (G_TASK (result), error); }
static IdeSymbolTree * ide_symbol_resolver_real_get_symbol_tree_finish (IdeSymbolResolver *self, GAsyncResult *result, GError **error) { g_assert (IDE_IS_SYMBOL_RESOLVER (self)); g_assert (G_IS_TASK (result)); return g_task_propagate_pointer (G_TASK (result), error); }
static DspyNodeInfo * parse_xml_finish (DspyIntrospectionModel *self, GAsyncResult *result, GError **error) { g_assert (DSPY_IS_INTROSPECTION_MODEL (self)); g_assert (G_IS_TASK (result)); return g_task_propagate_pointer (G_TASK (result), error); }
static IdeBuildResult * ide_builder_real_build_finish (IdeBuilder *self, GAsyncResult *result, GError **error) { g_assert (IDE_IS_BUILDER (self)); g_assert (G_IS_TASK (result)); return g_task_propagate_pointer (G_TASK (result), error); }
/** * ide_file_find_other_finish: * * Completes an asynchronous call to ide_file_find_other_async(). This function * will try to find a matching file for languages where this exists. Such cases * include C and C++ where a .c or .cpp file may have a .h or .hh header. Additional * suffixes are implemented including (.c, .cc, .cpp, .cxx, .h, .hh, .hpp, and .hxx). * * Returns an #IdeFile if successful, otherwise %NULL and @error is set. * * Returns: (transfer full) (nullable): An #IdeFIle or %NULL. */ IdeFile * ide_file_find_other_finish (IdeFile *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_FILE (self), NULL); g_return_val_if_fail (G_IS_TASK (result), NULL); return g_task_propagate_pointer (G_TASK (result), error); }
static GListModel * ide_git_vcs_list_status_finish (IdeVcs *vcs, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_GIT_VCS (vcs), NULL); g_return_val_if_fail (G_IS_TASK (result), NULL); return g_task_propagate_pointer (G_TASK (result), error); }
GdkPixbuf* gt_resource_donwloader_download_image_finish(GtResourceDownloader* self, GAsyncResult* result, GError** error) { RETURN_VAL_IF_FAIL(GT_IS_RESOURCE_DOWNLOADER(self), NULL); RETURN_VAL_IF_FAIL(G_IS_ASYNC_RESULT(result), NULL); GdkPixbuf* ret = g_task_propagate_pointer(G_TASK(result), error); return ret; }