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