static void load_uri_pixbuf_async (StTextureCache *cache, const char *uri, guint width, guint height, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; AsyncIconLookupData *data; data = g_new0 (AsyncIconLookupData, 1); data->cache = cache; data->uri = g_strdup (uri); data->width = width; data->height = height; data->user_data = user_data; result = g_simple_async_result_new (G_OBJECT (cache), callback, user_data, load_uri_pixbuf_async); g_object_set_data_full (G_OBJECT (result), "load_pixbuf_async", data, icon_lookup_data_destroy); g_simple_async_result_run_in_thread (result, load_pixbuf_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (result); }
static void load_recent_thumbnail_async (StTextureCache *cache, GtkRecentInfo *info, guint size, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; AsyncIconLookupData *data; data = g_new0 (AsyncIconLookupData, 1); data->cache = cache; data->thumbnail = TRUE; data->recent_info = gtk_recent_info_ref (info); data->width = size; data->height = size; data->user_data = user_data; result = g_simple_async_result_new (G_OBJECT (cache), callback, user_data, load_recent_thumbnail_async); g_object_set_data_full (G_OBJECT (result), "load_pixbuf_async", data, icon_lookup_data_destroy); g_simple_async_result_run_in_thread (result, load_pixbuf_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (result); }
/** * gdata_access_handler_get_rules_async: * @self: a #GDataAccessHandler * @service: a #GDataService * @cancellable: (allow-none): optional #GCancellable object, or %NULL * @progress_callback: (allow-none) (closure progress_user_data): a #GDataQueryProgressCallback to call when a rule is loaded, or %NULL * @progress_user_data: (closure): data to pass to the @progress_callback function * @destroy_progress_user_data: (allow-none): the function to call when @progress_callback will not be called any more, or %NULL. This function will be * called with @progress_user_data as a parameter and can be used to free any memory allocated for it. * @callback: a #GAsyncReadyCallback to call when the query is finished * @user_data: (closure): data to pass to the @callback function * * Retrieves a #GDataFeed containing all the access rules which apply to the given #GDataAccessHandler. Only the owner of a #GDataAccessHandler may * view its rule feed. @self and @service are both reffed when this function is called, so can safely be unreffed after this function returns. * * For more details, see gdata_access_handler_get_rules(), which is the synchronous version of this function, and gdata_service_query_async(), which * is the base asynchronous query function. * * When the operation is finished, @callback will be called. You can then call gdata_service_query_finish() * to get the results of the operation. * * Since: 0.9.1 **/ void gdata_access_handler_get_rules_async (GDataAccessHandler *self, GDataService *service, GCancellable *cancellable, GDataQueryProgressCallback progress_callback, gpointer progress_user_data, GDestroyNotify destroy_progress_user_data, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; GetRulesAsyncData *data; g_return_if_fail (GDATA_IS_ACCESS_HANDLER (self)); g_return_if_fail (GDATA_IS_SERVICE (service)); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); g_return_if_fail (callback != NULL); data = g_slice_new (GetRulesAsyncData); data->service = g_object_ref (service); data->progress_callback = progress_callback; data->progress_user_data = progress_user_data; data->destroy_progress_user_data = destroy_progress_user_data; result = g_simple_async_result_new (G_OBJECT (self), callback, user_data, gdata_service_query_async); g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify) get_rules_async_data_free); g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) get_rules_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (result); }
void pp_samba_get_devices_async (PpSamba *samba, gboolean auth_if_needed, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; SMBData *data; gchar *hostname = NULL; g_object_get (G_OBJECT (samba), "hostname", &hostname, NULL); res = g_simple_async_result_new (G_OBJECT (samba), callback, user_data, pp_samba_get_devices_async); data = g_new0 (SMBData, 1); data->devices = NULL; data->context = g_main_context_default (); data->hostname_set = hostname != NULL; data->auth_if_needed = auth_if_needed; g_simple_async_result_set_check_cancellable (res, cancellable); g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify) smb_data_free); g_simple_async_result_run_in_thread (res, _pp_samba_get_devices_thread, 0, cancellable); g_free (hostname); g_object_unref (res); }
static void g_tls_database_real_lookup_certificates_issued_by_async (GTlsDatabase *self, GByteArray *issuer, GTlsInteraction *interaction, GTlsDatabaseLookupFlags flags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; AsyncLookupCertificatesIssuedBy *args; g_return_if_fail (callback); args = g_slice_new0 (AsyncLookupCertificatesIssuedBy); args->issuer = g_byte_array_ref (issuer); args->flags = flags; args->interaction = interaction ? g_object_ref (interaction) : NULL; res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, g_tls_database_real_lookup_certificates_issued_by_async); g_simple_async_result_set_op_res_gpointer (res, args, async_lookup_certificates_issued_by_free); g_simple_async_result_run_in_thread (res, async_lookup_certificates_issued_by_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (res); }
static void g_tls_database_real_lookup_certificate_issuer_async (GTlsDatabase *self, GTlsCertificate *certificate, GTlsInteraction *interaction, GTlsDatabaseLookupFlags flags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; AsyncLookupCertificateIssuer *args; g_return_if_fail (G_IS_TLS_CERTIFICATE (certificate)); g_return_if_fail (callback != NULL); args = g_slice_new0 (AsyncLookupCertificateIssuer); args->certificate = g_object_ref (certificate); args->flags = flags; args->interaction = interaction ? g_object_ref (interaction) : NULL; res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, g_tls_database_real_lookup_certificate_issuer_async); g_simple_async_result_set_op_res_gpointer (res, args, async_lookup_certificate_issuer_free); g_simple_async_result_run_in_thread (res, async_lookup_certificate_issuer_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (res); }
static void g_tls_database_real_lookup_certificate_for_handle_async (GTlsDatabase *self, const gchar *handle, GTlsInteraction *interaction, GTlsDatabaseLookupFlags flags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; AsyncLookupCertificateForHandle *args; g_return_if_fail (callback != NULL); args = g_slice_new0 (AsyncLookupCertificateForHandle); args->handle = g_strdup (handle); args->interaction = interaction ? g_object_ref (interaction) : NULL; res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, g_tls_database_real_lookup_certificate_for_handle_async); g_simple_async_result_set_op_res_gpointer (res, args, async_lookup_certificate_for_handle_free); g_simple_async_result_run_in_thread (res, async_lookup_certificate_for_handle_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (res); }
/** * gdk_pixbuf_new_from_stream_at_scale_async: * @stream: a #GInputStream from which to load the pixbuf * @width: the width the image should have or -1 to not constrain the width * @height: the height the image should have or -1 to not constrain the height * @preserve_aspect_ratio: %TRUE to preserve the image's aspect ratio * @cancellable: optional #GCancellable object, %NULL to ignore * @callback: a #GAsyncReadyCallback to call when the the pixbuf is loaded * @user_data: the data to pass to the callback function * * Creates a new pixbuf by asynchronously loading an image from an input stream. * * For more details see gdk_pixbuf_new_from_stream_at_scale(), which is the synchronous * version of this function. * * When the operation is finished, @callback will be called in the main thread. * You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation. * * Since: 2.18 **/ static void totem_gdk_pixbuf_new_from_stream_at_scale_async (GInputStream *stream, gint width, gint height, gboolean preserve_aspect_ratio, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; AtScaleData *data; g_return_if_fail (G_IS_INPUT_STREAM (stream)); g_return_if_fail (callback != NULL); data = g_new (AtScaleData, 1); data->width = width; data->height = height; data->preserve_aspect_ratio = preserve_aspect_ratio; result = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, totem_gdk_pixbuf_new_from_stream_at_scale_async); g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify) g_free); g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) new_from_stream_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (result); }
void e_mail_store_go_offline (CamelStore *store, gint io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; g_return_if_fail (CAMEL_IS_STORE (store)); /* Cancel any pending connect first so the set_offline_op * thread won't get queued behind a hung connect op. */ camel_service_cancel_connect (CAMEL_SERVICE (store)); simple = g_simple_async_result_new ( G_OBJECT (store), callback, user_data, e_mail_store_go_offline); g_simple_async_result_run_in_thread ( simple, (GSimpleAsyncThreadFunc) mail_store_go_offline_thread, io_priority, cancellable); g_object_unref (simple); }
static void gth_image_save_to_buffer_async (GthImage *image, const char *mime_type, GthFileData *file_data, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; SaveArguments *arguments; g_return_if_fail (image != NULL); g_return_if_fail (file_data != NULL); arguments = g_new0 (SaveArguments, 1); arguments->image = g_object_ref (image); arguments->mime_type = g_strdup (mime_type); arguments->file_data = g_object_ref (file_data); result = g_simple_async_result_new (NULL, callback, user_data, gth_image_save_to_buffer_async); g_simple_async_result_set_op_res_gpointer (result, arguments, (GDestroyNotify) save_arguments_free); g_simple_async_result_run_in_thread (result, save_to_buffer_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (result); }
void e_mail_store_create_folder (CamelStore *store, const gchar *full_name, gint io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; AsyncContext *context; g_return_if_fail (CAMEL_IS_STORE (store)); g_return_if_fail (full_name != NULL); context = g_slice_new0 (AsyncContext); context->full_name = g_strdup (full_name); simple = g_simple_async_result_new ( G_OBJECT (store), callback, user_data, e_mail_store_create_folder); g_simple_async_result_set_op_res_gpointer ( simple, context, (GDestroyNotify) async_context_free); g_simple_async_result_run_in_thread ( simple, mail_store_create_folder_thread, io_priority, cancellable); g_object_unref (simple); }
static void metadata_get_coverart (GooWindow *window, AlbumInfo *album, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; GetCoverArtData *data; result = g_simple_async_result_new (NULL, callback, user_data, metadata_get_coverart); data = g_new0 (GetCoverArtData, 1); data->window = g_object_ref (window); data->album = album_info_ref (album); data->buffer = NULL; data->size = 0; g_simple_async_result_set_op_res_gpointer (result, data, (GDestroyNotify) get_cover_art_data_free); g_simple_async_result_run_in_thread (result, metadata_get_coverart_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (result); }
static void g_tls_database_real_verify_chain_async (GTlsDatabase *self, GTlsCertificate *chain, const gchar *purpose, GSocketConnectable *identity, GTlsInteraction *interaction, GTlsDatabaseVerifyFlags flags, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; AsyncVerifyChain *args; args = g_slice_new0 (AsyncVerifyChain); args->chain = g_object_ref (chain); args->purpose = g_strdup (purpose); args->identity = identity ? g_object_ref (identity) : NULL; args->interaction = interaction ? g_object_ref (interaction) : NULL; args->flags = flags; res = g_simple_async_result_new (G_OBJECT (self), callback, user_data, g_tls_database_real_verify_chain_async); g_simple_async_result_set_op_res_gpointer (res, args, async_verify_chain_free); g_simple_async_result_run_in_thread (res, async_verify_chain_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (res); }
void _gcr_subject_public_key_load_async (GckObject *key, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; LoadClosure *closure; g_return_if_fail (GCK_IS_OBJECT (key)); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); res = g_simple_async_result_new (NULL, callback, user_data, _gcr_subject_public_key_load_async); closure = g_slice_new0 (LoadClosure); closure->object = g_object_ref (key); lookup_attributes (key, &closure->builder); g_simple_async_result_set_op_res_gpointer (res, closure, load_closure_free); if (check_attributes (&closure->builder)) { g_simple_async_result_complete_in_idle (res); g_object_unref (res); return; } g_simple_async_result_run_in_thread (res, thread_key_attributes, G_PRIORITY_DEFAULT, cancellable); g_object_unref (res); }
/** * st_texture_cache_load_sliced_image: * @cache: A #StTextureCache * @path: Path to a filename * @grid_width: Width in pixels * @grid_height: Height in pixels * * This function reads a single image file which contains multiple images internally. * The image file will be divided using @grid_width and @grid_height; * note that the dimensions of the image loaded from @path * should be a multiple of the specified grid dimensions. * * Returns: (transfer none): A new #ClutterActor */ ClutterActor * st_texture_cache_load_sliced_image (StTextureCache *cache, const gchar *path, gint grid_width, gint grid_height) { AsyncImageData *data; GSimpleAsyncResult *result; ClutterActor *actor = clutter_actor_new (); data = g_new0 (AsyncImageData, 1); data->grid_width = grid_width; data->grid_height = grid_height; data->path = g_strdup (path); data->actor = actor; g_object_ref (G_OBJECT (actor)); result = g_simple_async_result_new (G_OBJECT (cache), on_sliced_image_loaded, data, st_texture_cache_load_sliced_image); g_object_set_data_full (G_OBJECT (result), "load_sliced_image", data, on_data_destroy); g_simple_async_result_run_in_thread (result, load_sliced_image, G_PRIORITY_DEFAULT, NULL); g_object_unref (result); return actor; }
void e_reap_trash_directory (GFile *trash_directory, gint expiry_in_days, gint io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; g_return_if_fail (G_IS_FILE (trash_directory)); g_return_if_fail (expiry_in_days > 0); simple = g_simple_async_result_new ( G_OBJECT (trash_directory), callback, user_data, e_reap_trash_directory); g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_set_op_res_gssize (simple, expiry_in_days); g_simple_async_result_run_in_thread ( simple, reap_trash_directory_thread, io_priority, cancellable); g_object_unref (simple); }
void hev_serial_port_config_async(HevSerialPort *self, struct termios *options, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { HevSerialPortPrivate *priv = NULL; GSimpleAsyncResult *simple = NULL; struct termios *opts = NULL; g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); g_return_if_fail(HEV_IS_SERIAL_PORT(self)); g_return_if_fail(NULL != options); priv = HEV_SERIAL_PORT_GET_PRIVATE(self); /* Simple async result */ simple = g_simple_async_result_new(G_OBJECT(self), callback, user_data, hev_serial_port_config_async); g_simple_async_result_set_check_cancellable(simple, cancellable); opts = g_malloc0(sizeof(struct termios)); g_memmove(opts, options, sizeof(struct termios)); g_simple_async_result_set_op_res_gpointer(simple, opts, NULL); g_simple_async_result_run_in_thread(simple, g_simple_async_config_thread_handler, G_PRIORITY_DEFAULT, cancellable); g_object_unref(simple); }
void e_mail_session_handle_source_headers (EMailSession *session, CamelMimeMessage *message, gint io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; AsyncContext *context; g_return_if_fail (E_IS_MAIL_SESSION (session)); g_return_if_fail (CAMEL_IS_MIME_MESSAGE (message)); context = g_slice_new0 (AsyncContext); context->message = g_object_ref (message); simple = g_simple_async_result_new ( G_OBJECT (session), callback, user_data, e_mail_session_handle_source_headers); g_simple_async_result_set_check_cancellable (simple, cancellable); g_simple_async_result_set_op_res_gpointer ( simple, context, (GDestroyNotify) async_context_free); g_simple_async_result_run_in_thread ( simple, (GSimpleAsyncThreadFunc) mail_session_handle_source_headers_thread, io_priority, cancellable); g_object_unref (simple); }
static void hev_serial_port_write_async(HevSerialPort *self, const gpointer buffer, gsize count, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { HevSerialPortPrivate *priv = NULL; GSimpleAsyncResult *simple = NULL; HevSerialPortReadWriteData *data = NULL; g_debug("%s:%d[%s]", __FILE__, __LINE__, __FUNCTION__); g_return_if_fail(HEV_IS_SERIAL_PORT(self)); priv = HEV_SERIAL_PORT_GET_PRIVATE(self); /* Simple async result */ simple = g_simple_async_result_new(G_OBJECT(self), callback, user_data, hev_serial_port_write_async); g_simple_async_result_set_check_cancellable(simple, cancellable); /* ReadWrite data */ data = g_malloc0(sizeof(HevSerialPortReadWriteData)); data->buffer = buffer; data->count = count; g_simple_async_result_set_op_res_gpointer(simple, data, NULL); g_simple_async_result_run_in_thread(simple, g_simple_async_write_thread_handler, G_PRIORITY_DEFAULT, cancellable); g_object_unref(simple); }
/** * st_texture_cache_load_sliced_image: * @cache: A #StTextureCache * @file: A #GFile * @grid_width: Width in pixels * @grid_height: Height in pixels * @scale: Scale factor of the display * @load_callback: (scope async) (nullable): Function called when the image is loaded, or %NULL * @user_data: Data to pass to the load callback * * This function reads a single image file which contains multiple images internally. * The image file will be divided using @grid_width and @grid_height; * note that the dimensions of the image loaded from @path * should be a multiple of the specified grid dimensions. * * Returns: (transfer none): A new #ClutterActor */ ClutterActor * st_texture_cache_load_sliced_image (StTextureCache *cache, GFile *file, gint grid_width, gint grid_height, gint scale, GFunc load_callback, gpointer user_data) { AsyncImageData *data; GSimpleAsyncResult *result; ClutterActor *actor = clutter_actor_new (); data = g_new0 (AsyncImageData, 1); data->grid_width = grid_width; data->grid_height = grid_height; data->scale_factor = scale; data->gfile = g_object_ref (file); data->actor = actor; data->load_callback = load_callback; data->load_callback_data = user_data; g_object_ref (G_OBJECT (actor)); result = g_simple_async_result_new (G_OBJECT (cache), on_sliced_image_loaded, data, st_texture_cache_load_sliced_image); g_object_set_data_full (G_OBJECT (result), "load_sliced_image", data, on_data_destroy); g_simple_async_result_run_in_thread (result, load_sliced_image, G_PRIORITY_DEFAULT, NULL); g_object_unref (result); return actor; }
void e_mail_session_unsubscribe_folder (EMailSession *session, const gchar *folder_uri, gint io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; AsyncContext *context; g_return_if_fail (E_IS_MAIL_SESSION (session)); g_return_if_fail (folder_uri != NULL); context = g_slice_new0 (AsyncContext); context->folder_uri = g_strdup (folder_uri); simple = g_simple_async_result_new ( G_OBJECT (session), callback, user_data, e_mail_session_unsubscribe_folder); g_simple_async_result_set_op_res_gpointer ( simple, context, (GDestroyNotify) async_context_free); g_simple_async_result_run_in_thread ( simple, (GSimpleAsyncThreadFunc) mail_session_unsubscribe_folder_thread, io_priority, cancellable); g_object_unref (simple); }
void _ostree_static_delta_part_execute_async (OstreeRepo *repo, GVariant *header, GVariant *part, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { StaticDeltaPartExecuteAsyncData *asyncdata; asyncdata = g_new0 (StaticDeltaPartExecuteAsyncData, 1); asyncdata->repo = g_object_ref (repo); asyncdata->header = g_variant_ref (header); asyncdata->part = g_variant_ref (part); asyncdata->cancellable = cancellable ? g_object_ref (cancellable) : NULL; asyncdata->result = g_simple_async_result_new ((GObject*) repo, callback, user_data, _ostree_static_delta_part_execute_async); g_simple_async_result_set_op_res_gpointer (asyncdata->result, asyncdata, static_delta_part_execute_async_data_free); g_simple_async_result_run_in_thread (asyncdata->result, static_delta_part_execute_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (asyncdata->result); }
/** * g_dbus_address_get_stream: * @address: A valid D-Bus address. * @cancellable: (allow-none): A #GCancellable or %NULL. * @callback: A #GAsyncReadyCallback to call when the request is satisfied. * @user_data: Data to pass to @callback. * * Asynchronously connects to an endpoint specified by @address and * sets up the connection so it is in a state to run the client-side * of the D-Bus authentication conversation. * * When the operation is finished, @callback will be invoked. You can * then call g_dbus_address_get_stream_finish() to get the result of * the operation. * * This is an asynchronous failable function. See * g_dbus_address_get_stream_sync() for the synchronous version. * * Since: 2.26 */ void g_dbus_address_get_stream (const gchar *address, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; GetStreamData *data; g_return_if_fail (address != NULL); res = g_simple_async_result_new (NULL, callback, user_data, g_dbus_address_get_stream); g_simple_async_result_set_check_cancellable (res, cancellable); data = g_new0 (GetStreamData, 1); data->address = g_strdup (address); g_simple_async_result_set_op_res_gpointer (res, data, (GDestroyNotify) get_stream_data_free); g_simple_async_result_run_in_thread (res, get_stream_thread_func, G_PRIORITY_DEFAULT, cancellable); g_object_unref (res); }
void _cairo_image_surface_scale_async (cairo_surface_t *image, int new_width, int new_height, scale_filter_t quality, GCancellable *cancellable, GAsyncReadyCallback ready_callback, gpointer user_data) { GSimpleAsyncResult *result; result = g_simple_async_result_new (NULL, ready_callback, user_data, _cairo_image_surface_scale_async); g_simple_async_result_set_op_res_gpointer (result, scale_data_new (image, new_width, new_height, quality, cancellable), (GDestroyNotify) scale_data_free); g_simple_async_result_run_in_thread (result, scale_image_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (result); }
static void data_wrapper_construct_from_stream (CamelDataWrapper *data_wrapper, CamelStream *stream, gint io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *simple; AsyncContext *async_context; async_context = g_slice_new0 (AsyncContext); async_context->stream = g_object_ref (stream); simple = g_simple_async_result_new ( G_OBJECT (data_wrapper), callback, user_data, data_wrapper_construct_from_stream); g_simple_async_result_set_op_res_gpointer ( simple, async_context, (GDestroyNotify) async_context_free); g_simple_async_result_run_in_thread ( simple, data_wrapper_construct_from_stream_thread, io_priority, cancellable); g_object_unref (simple); }
void g_vfs_mount_info_query_bdmv_volume_info (GFile *directory, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { #ifdef HAVE_BLURAY GSimpleAsyncResult *simple; simple = g_simple_async_result_new (G_OBJECT (directory), callback, user_data, g_vfs_mount_info_query_bdmv_volume_info); g_simple_async_result_run_in_thread (simple, (GSimpleAsyncThreadFunc) bdmv_metadata_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (simple); #else GSimpleAsyncResult *simple; simple = g_simple_async_result_new (G_OBJECT (directory), callback, user_data, g_vfs_mount_info_query_bdmv_volume_info); g_simple_async_result_set_error (simple, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, "gvfs built without Expat support, no BDMV support"); g_object_unref (simple); #endif /* HAVE_BLURAY */ }
static void load_texture_async (StTextureCache *cache, AsyncTextureLoadData *data) { GSimpleAsyncResult *result; result = g_simple_async_result_new (G_OBJECT (cache), on_pixbuf_loaded, data, load_texture_async); g_simple_async_result_run_in_thread (result, load_pixbuf_thread, G_PRIORITY_DEFAULT, NULL); g_object_unref (result); }
static void webkit_soup_request_file_send_async (WebKitSoupRequest *request, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; res = g_simple_async_result_new (G_OBJECT (request), callback, user_data, webkit_soup_request_file_send_async); g_simple_async_result_run_in_thread (res, webkit_soup_request_file_send_async_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (res); }
/** * gdk_pixbuf_new_from_stream_async: * @stream: a #GInputStream from which to load the pixbuf * @cancellable: optional #GCancellable object, %NULL to ignore * @callback: a #GAsyncReadyCallback to call when the the pixbuf is loaded * @user_data: the data to pass to the callback function * * Creates a new pixbuf by asynchronously loading an image from an input stream. * * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous * version of this function. * * When the operation is finished, @callback will be called in the main thread. * You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation. * * Since: 2.18 **/ static void totem_gdk_pixbuf_new_from_stream_async (GInputStream *stream, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *result; g_return_if_fail (G_IS_INPUT_STREAM (stream)); g_return_if_fail (callback != NULL); result = g_simple_async_result_new (G_OBJECT (stream), callback, user_data, totem_gdk_pixbuf_new_from_stream_async); g_simple_async_result_run_in_thread (result, (GSimpleAsyncThreadFunc) new_from_stream_thread, G_PRIORITY_DEFAULT, cancellable); g_object_unref (result); }
void pp_maintenance_command_execute_async (PpMaintenanceCommand *command, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GSimpleAsyncResult *res; res = g_simple_async_result_new (G_OBJECT (command), callback, user_data, pp_maintenance_command_execute_async); g_simple_async_result_set_check_cancellable (res, cancellable); g_simple_async_result_run_in_thread (res, _pp_maintenance_command_execute_thread, 0, cancellable); g_object_unref (res); }