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