gboolean gd_queue_thumbnail_job_for_file_finish (GAsyncResult *res) { GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); return g_simple_async_result_get_op_res_gboolean (simple); }
static gboolean app_chooser_online_pk_init_finish (GAsyncInitable *init, GAsyncResult *res, GError **error) { return g_simple_async_result_get_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (res)); }
static gboolean modem_time_check_support_finish (MMIfaceModemTime *self, GAsyncResult *res, GError **error) { return g_simple_async_result_get_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (res)); }
/** * ovirt_collection_fetch_finish: * @collection: a #OvirtCollection * @result: async method result * * Return value: TRUE if successful, FALSE otherwise, with @error set. */ gboolean ovirt_collection_fetch_finish(OvirtCollection *collection, GAsyncResult *result, GError **err) { g_return_val_if_fail(OVIRT_IS_COLLECTION(collection), FALSE); g_return_val_if_fail(g_simple_async_result_is_valid(result, G_OBJECT(collection), ovirt_collection_fetch_async), FALSE); if (g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(result), err)) return FALSE; return g_simple_async_result_get_op_res_gboolean(G_SIMPLE_ASYNC_RESULT(result)); }
gboolean goa_http_client_check_finish (GoaHttpClient *self, GAsyncResult *res, GError **error) { GSimpleAsyncResult *simple; g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (self), goa_http_client_check), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); simple = G_SIMPLE_ASYNC_RESULT (res); if (g_simple_async_result_propagate_error (simple, error)) return FALSE; return g_simple_async_result_get_op_res_gboolean (simple); }
/** * pk_package_sack_merge_generic_finish: * @sack: a valid #PkPackageSack instance * @res: the #GAsyncResult * @error: A #GError or %NULL * * Gets the result from the asynchronous function. * * Return value: %TRUE for success * * Since: 0.5.2 **/ gboolean pk_package_sack_merge_generic_finish (PkPackageSack *sack, GAsyncResult *res, GError **error) { GSimpleAsyncResult *simple; g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE); g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (res), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); simple = G_SIMPLE_ASYNC_RESULT (res); if (g_simple_async_result_propagate_error (simple, error)) return FALSE; return g_simple_async_result_get_op_res_gboolean (simple); }
static gboolean tf_call_channel_init_finish (GAsyncInitable *initable, GAsyncResult *res, GError **error) { GSimpleAsyncResult *simple_res; g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (initable), tf_call_channel_init_async), FALSE); simple_res = G_SIMPLE_ASYNC_RESULT (res); if (g_simple_async_result_propagate_error (simple_res, error)) return FALSE; return g_simple_async_result_get_op_res_gboolean (simple_res); }
gboolean pp_maintenance_command_execute_finish (PpMaintenanceCommand *command, GAsyncResult *res, GError **error) { GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == pp_maintenance_command_execute_async); if (g_simple_async_result_propagate_error (simple, error)) { return FALSE; } return g_simple_async_result_get_op_res_gboolean (simple); }
/** * soup_input_stream_send_finish: * @stream: a #SoupInputStream * @result: a #GAsyncResult. * @error: a #GError location to store the error occuring, or %NULL to * ignore. * * Finishes a soup_input_stream_send_async() operation. * * Return value: %TRUE if the message was sent successfully and * received a successful status code, %FALSE if not. **/ gboolean soup_input_stream_send_finish (GInputStream *stream, GAsyncResult *result, GError **error) { GSimpleAsyncResult *simple; g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE); simple = G_SIMPLE_ASYNC_RESULT (result); g_return_val_if_fail (g_simple_async_result_get_source_tag (simple) == soup_input_stream_send_async, FALSE); if (g_simple_async_result_propagate_error (simple, error)) return FALSE; return g_simple_async_result_get_op_res_gboolean (simple); }
gboolean hd_imageset_background_init_finish (HDImagesetBackground *background, GAsyncResult *result, GError **error) { g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (background), hd_imageset_background_init_async), FALSE); if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) return FALSE; return g_simple_async_result_get_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (result)); }
/** * gom_resource_save_sync: * @resource: (in): A #GomResource. * @error: (out): A location for a #GError, or %NULL. * * Returns: %TRUE if successful; otherwise %FALSE. */ gboolean gom_resource_save_sync (GomResource *resource, GError **error) { GomResourcePrivate *priv; GomAdapter *adapter; GAsyncQueue *queue; GSimpleAsyncResult *simple; gboolean ret; g_return_val_if_fail(GOM_IS_RESOURCE(resource), FALSE); priv = resource->priv; if (!priv->repository) { g_set_error(error, GOM_ERROR, GOM_ERROR_COMMAND_NO_REPOSITORY, _("Cannot save resource, no repository set")); return FALSE; } queue = g_async_queue_new(); simple = g_simple_async_result_new(G_OBJECT(resource), NULL, NULL, gom_resource_save_sync); adapter = gom_repository_get_adapter(priv->repository); g_object_set_data(G_OBJECT(simple), "queue", queue); g_assert(GOM_IS_ADAPTER(adapter)); gom_resource_build_save_cmd(resource, adapter); gom_adapter_queue_write(adapter, gom_resource_save_cb, simple); g_async_queue_pop(queue); g_async_queue_unref(queue); if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) { g_simple_async_result_propagate_error(simple, error); } if (ret) set_post_save_properties(resource); g_object_unref(simple); return ret; }
static void on_screenshot_written (GObject *source, GAsyncResult *result, gpointer user_data) { _screenshot_data *screenshot_data = (_screenshot_data*) user_data; if (screenshot_data->callback) screenshot_data->callback (screenshot_data->screenshot, g_simple_async_result_get_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (result)), &screenshot_data->screenshot_area, screenshot_data->filename_used); cairo_surface_destroy (screenshot_data->image); g_object_unref (screenshot_data->screenshot); g_free (screenshot_data->filename); g_free (screenshot_data->filename_used); g_free (screenshot_data); }
gboolean gom_repository_migrate_finish (GomRepository *repository, GAsyncResult *result, GError **error) { GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result; gboolean ret; g_return_val_if_fail(GOM_IS_REPOSITORY(repository), FALSE); g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(result), FALSE); if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) { g_simple_async_result_propagate_error(simple, error); } g_object_unref(simple); return ret; }
gboolean gom_resource_delete_finish (GomResource *resource, GAsyncResult *result, GError **error) { GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result; gboolean ret; g_return_val_if_fail(GOM_IS_RESOURCE(resource), FALSE); g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), FALSE); if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) { g_simple_async_result_propagate_error(simple, error); } g_object_unref(simple); return ret; }
/** * catch_resource_group_fetch_finish: * @group: (in): A #CatchResourceGroup. * @result: (in): A #GAsyncResult. * @error: (out): A locationf or a #GError, or %NULL. * * Completes an asynchronous request to catch_resource_group_fetch_async(). * %TRUE is returned if the resources were loaded, otherwise %FALSE and * @error is set. * * Returns: %TRUE if successful; otherwise %FALSE and @error is set. */ gboolean catch_resource_group_fetch_finish (CatchResourceGroup *group, GAsyncResult *result, GError **error) { GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result; gboolean ret; ENTRY; g_return_val_if_fail(CATCH_IS_RESOURCE_GROUP(group), FALSE); g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), FALSE); if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) { g_simple_async_result_propagate_error(simple, error); } RETURN(ret); }
gboolean push_gcm_client_deliver_finish (PushGcmClient *client, GAsyncResult *result, GError **error) { GSimpleAsyncResult *simple = (GSimpleAsyncResult *)result; gboolean ret; ENTRY; g_return_val_if_fail(PUSH_IS_GCM_CLIENT(client), FALSE); g_return_val_if_fail(G_IS_SIMPLE_ASYNC_RESULT(simple), FALSE); if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) { g_simple_async_result_propagate_error(simple, error); } RETURN(ret); }
gboolean hev_serial_port_config_finish(HevSerialPort *self, GAsyncResult *res, GError **error) { HevSerialPortPrivate *priv = NULL; g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); g_return_val_if_fail(HEV_IS_SERIAL_PORT(self), FALSE); priv = HEV_SERIAL_PORT_GET_PRIVATE(self); g_return_val_if_fail(g_simple_async_result_is_valid(res, G_OBJECT(self), hev_serial_port_config_async), FALSE); if(g_simple_async_result_propagate_error(G_SIMPLE_ASYNC_RESULT(res), error)) return FALSE; return g_simple_async_result_get_op_res_gboolean(G_SIMPLE_ASYNC_RESULT(res)); }
static gboolean polkit_system_bus_name_exists_finish (PolkitSubject *subject, GAsyncResult *res, GError **error) { GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); gboolean ret; g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == polkit_system_bus_name_exists); ret = FALSE; if (g_simple_async_result_propagate_error (simple, error)) goto out; ret = g_simple_async_result_get_op_res_gboolean (simple); out: return ret; }
/** * gom_repository_migrate_sync: * @repository: (in): A #GomRepository. * @version: (in): The version to migrate to. * @migrator: (in) (scope call): A function to perform the migrations. * @migrator_data: (in): User data for @migrator. * @error: a #GError * * Performs a migration on the underlying database. This will * call @migrator from the SQLite thread for each migration to perform. * * Returns: #TRUE in case of success. */ gboolean gom_repository_migrate_sync (GomRepository *repository, guint version, GomRepositoryMigrator migrator, gpointer migrator_data, GError **error) { GomRepositoryPrivate *priv; GSimpleAsyncResult *simple; GAsyncQueue *queue; gboolean ret; g_return_val_if_fail(GOM_IS_REPOSITORY(repository), FALSE); g_return_val_if_fail(migrator != NULL, FALSE); g_return_val_if_fail(version >= 1, FALSE); priv = repository->priv; queue = g_async_queue_new(); simple = g_simple_async_result_new(G_OBJECT(repository), NULL, NULL, gom_repository_migrate_sync); g_object_set_data(G_OBJECT(simple), "version", GINT_TO_POINTER(version)); g_object_set_data(G_OBJECT(simple), "migrator", migrator); g_object_set_data(G_OBJECT(simple), "migrator_data", migrator_data); g_object_set_data(G_OBJECT(simple), "queue", queue); gom_adapter_queue_write(priv->adapter, gom_repository_migrate_cb, simple); g_async_queue_pop(queue); g_async_queue_unref(queue); if (!(ret = g_simple_async_result_get_op_res_gboolean(simple))) { g_simple_async_result_propagate_error(simple, error); } g_object_unref(simple); return ret; }
/** * picasaweb_upload_async_cb: * * Handles completion of the image's asynchronous upload to PicasaWeb. * * If the #GAsyncResults indicates success, we'll update the * treeview's row for the given upload indicating this. Elsewise, if * it wasn't cancelled, then we report an error. * * NOTE: we also clean up the #PicasaWebUploadFileAsyncData here. * * TODO: we don't yet make the progress bar throb, how do we do that? * **/ static void picasaweb_upload_async_cb (XviewerPostasaPlugin *plugin, GAsyncResult *res, PicasaWebUploadFileAsyncData *data) { GCancellable* cancellable; GError *error = NULL; /* TODO: make sure to clear all set errors */ if (g_simple_async_result_get_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (res)) == TRUE) { gtk_list_store_set (plugin->priv->uploads_store, data->iter, 3, G_MAXINT, 5, _("Uploaded"), -1); } else { gtk_tree_model_get (GTK_TREE_MODEL (plugin->priv->uploads_store), data->iter, 4, &cancellable, -1); if (g_cancellable_is_cancelled (cancellable) == TRUE) { gtk_list_store_set (plugin->priv->uploads_store, data->iter, 3, -1, 5, _("Cancelled"), -1); } else { g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), &error); gtk_list_store_set (plugin->priv->uploads_store, data->iter, 3, -1, 5, error ? error->message : _("Failed"), -1); g_clear_error (&error); } } free_picasaweb_upload_file_async_data (data); }
gboolean _sw_client_service_upload_finish (SwClientService *service, GAsyncResult *res, GError **error) { GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); gboolean ret; g_return_val_if_fail (g_simple_async_result_is_valid (res, G_OBJECT (service), NULL), FALSE); ret = FALSE; if (g_simple_async_result_propagate_error (simple, error)) goto out; ret = g_simple_async_result_get_op_res_gboolean (simple); out: return ret; }
/** * e_webdav_discover_content_refresh_finish: * @content: a WebDAV discovery content, created by e_webdav_discover_content_new() * @result: a #GAsyncResult * @error: (allow-none): return location for a #GError, or %NULL * * Finishes the operation started with e_webdav_discover_content_refresh(). If an * error occurred, the function will set @error and return %FALSE. There is * available e_webdav_discover_content_show_error() for convenience, which * shows the error within @content and takes care of it when refreshing * the content. * * Returns: %TRUE on success, %FALSE on failure * * Since: 3.18 **/ gboolean e_webdav_discover_content_refresh_finish (GtkWidget *content, GAsyncResult *result, GError **error) { EWebDAVDiscoverContentData *data; GSimpleAsyncResult *simple; g_return_val_if_fail (GTK_IS_GRID (content), FALSE); data = g_object_get_data (G_OBJECT (content), WEBDAV_DISCOVER_CONTENT_DATA_KEY); g_return_val_if_fail (data != NULL, FALSE); g_return_val_if_fail (g_simple_async_result_is_valid ( result, G_OBJECT (content), e_webdav_discover_content_refresh), FALSE); simple = G_SIMPLE_ASYNC_RESULT (result); if (g_simple_async_result_propagate_error (simple, error)) return FALSE; return g_simple_async_result_get_op_res_gboolean (simple); }
gboolean mm_port_probe_run_finish (MMPortProbe *self, GAsyncResult *result, GError **error) { gboolean res; g_return_val_if_fail (MM_IS_PORT_PROBE (self), FALSE); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); /* Propagate error, if any */ if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result), error)) res = FALSE; else res = g_simple_async_result_get_op_res_gboolean (G_SIMPLE_ASYNC_RESULT (result)); /* Cleanup probing task */ if (self->priv->task) { port_probe_run_task_free (self->priv->task); self->priv->task = NULL; } return res; }
static VALUE rg_op_res_gboolean(VALUE self) { return CBOOL2RVAL(g_simple_async_result_get_op_res_gboolean(_SELF(self))); }