/** * g_dbus_address_get_stream_finish: * @res: A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream(). * @out_guid: %NULL or return location to store the GUID extracted from @address, if any. * @error: Return location for error or %NULL. * * Finishes an operation started with g_dbus_address_get_stream(). * * Returns: (transfer full): A #GIOStream or %NULL if @error is set. * * Since: 2.26 */ GIOStream * g_dbus_address_get_stream_finish (GAsyncResult *res, gchar **out_guid, GError **error) { GSimpleAsyncResult *simple = G_SIMPLE_ASYNC_RESULT (res); GetStreamData *data; GIOStream *ret; g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); g_warn_if_fail (g_simple_async_result_get_source_tag (simple) == g_dbus_address_get_stream); ret = NULL; data = g_simple_async_result_get_op_res_gpointer (simple); if (g_simple_async_result_propagate_error (simple, error)) goto out; ret = g_object_ref (data->stream); if (out_guid != NULL) *out_guid = g_strdup (data->guid); out: return ret; }
static void la_handler_service_handle_register_finish (GObject *object, GAsyncResult *res, gpointer user_data) { GDBusMethodInvocation *invocation = G_DBUS_METHOD_INVOCATION (user_data); LAHandlerService *service; NSMConsumer *nsm_consumer = NSM_CONSUMER (object); GError *error = NULL; gint error_code; g_return_if_fail (IS_NSM_CONSUMER (nsm_consumer)); g_return_if_fail (G_IS_ASYNC_RESULT (res)); g_return_if_fail (G_IS_DBUS_METHOD_INVOCATION (invocation)); /* finish registering the shutdown client */ nsm_consumer_call_register_shutdown_client_finish (nsm_consumer, &error_code, res, &error); if (error != NULL) { DLT_LOG (la_handler_context, DLT_LOG_ERROR, DLT_STRING ("Failed to register a shutdown consumer:"), DLT_STRING (error->message)); g_error_free (error); } /* retrieve the LAHandlerService from the invocation object */ service = g_object_get_data (G_OBJECT (invocation), "la-handler-service"); /* notify the caller that we have handled the registration request */ la_handler_complete_register (service->interface, invocation); }
static void update_dependencies_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeDependencyUpdater *updater = (IdeDependencyUpdater *)object; g_autoptr(IdeTask) task = user_data; g_autoptr(GError) error = NULL; IdePrimaryWorkspace *self; UpdateDependencies *ud; IdeContext *context; g_assert (IDE_IS_DEPENDENCY_UPDATER (updater)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (IDE_IS_TASK (task)); self = ide_task_get_source_object (task); context = ide_widget_get_context (GTK_WIDGET (self)); if (!ide_dependency_updater_update_finish (updater, result, &error)) ide_context_warning (context, "%s", error->message); ide_object_destroy (IDE_OBJECT (updater)); ud = ide_task_get_task_data (task); ud->n_active--; if (ud->n_active == 0) ide_task_return_boolean (task, TRUE); }
/** * news_parser_buffered_fill_cb: * @object: (in): A #GBufferedInputStream. * @result: (in): A #GAsyncResult. * @user_data: (in): A #NewsParser. * * Completes an asynchronous request to fill the buffer of a * #GBufferedInputStream. If the buffer was successfully filled, then * the feed format will be discovered and the stream parsed. * * Returns: None. */ static void news_parser_buffered_fill_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GBufferedInputStream *buffered = (GBufferedInputStream *)object; NewsParserPrivate *priv; NewsParser *parser = user_data; NewsFormat *format; guint8 buffer[BUFFER_FILL_SIZE]; gsize length = 0; GType format_type = G_TYPE_INVALID; ENTRY; g_assert(G_IS_BUFFERED_INPUT_STREAM(buffered)); g_assert(G_IS_ASYNC_RESULT(result)); g_assert(NEWS_IS_PARSER(parser)); priv = parser->priv; length = g_buffered_input_stream_peek(buffered, buffer, 0, sizeof buffer); if (length <= 0) { g_simple_async_result_set_error(priv->simple, NEWS_PARSER_ERROR, NEWS_PARSER_ERROR_NO_DATA, _("No data was available to parse.")); g_simple_async_result_complete_in_idle(priv->simple); } else { format_type = news_parser_discover_format(parser, buffer, length); if (format_type) { format = g_object_new(format_type, "adapter", priv->adapter, "source", priv->source, NULL); news_format_read_async(format, G_INPUT_STREAM(buffered), priv->cancellable, news_parser_format_read_cb, g_object_ref(parser)); g_object_unref(format); } else { g_simple_async_result_set_error(priv->simple, NEWS_PARSER_ERROR, NEWS_PARSER_ERROR_NO_FORMAT, _("Failed to discover format.")); g_simple_async_result_complete_in_idle(priv->simple); #if 0 { gchar *uri; g_object_get(priv->source, "uri", &uri, NULL); g_printerr("%s\n", uri); g_free(uri); } #endif } } g_object_unref(parser); EXIT; }
static void ide_run_manager_run_discover_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeRunManager *self = (IdeRunManager *)object; g_autoptr(IdeBuildTarget) build_target = NULL; g_autoptr(GTask) task = user_data; GError *error = NULL; g_assert (IDE_IS_RUN_MANAGER (self)); g_assert (G_IS_ASYNC_RESULT (result)); build_target = ide_run_manager_discover_default_target_finish (self, result, &error); if (build_target == NULL) { g_task_return_error (task, error); return; } ide_run_manager_set_build_target (self, build_target); g_task_set_task_data (task, g_steal_pointer (&build_target), g_object_unref); do_run_async (self, task); }
/** * ide_build_system_get_build_flags_for_files_finish: * @self: an #IdeBuildSystem * @result: a #GAsyncResult * @error: a location for a #GError or %NULL * * Returns: (element-type Ide.File GStrv) (transfer full): a #GHashTable or #GFile to #GStrv * * Since: 3.32 */ GHashTable * ide_build_system_get_build_flags_for_files_finish (IdeBuildSystem *self, GAsyncResult *result, GError **error) { GHashTable *ret; IDE_ENTRY; g_return_val_if_fail (IDE_IS_BUILD_SYSTEM (self), NULL); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL); ret = IDE_BUILD_SYSTEM_GET_IFACE (self)->get_build_flags_for_files_finish (self, result, error); if (ret != NULL) { GHashTableIter iter; gchar **flags; g_hash_table_iter_init (&iter, ret); while (g_hash_table_iter_next (&iter, NULL, (gpointer *)&flags)) ide_build_system_post_process_build_flags (self, flags); } IDE_RETURN (ret); }
/** * news_parser_format_read_cb: * @object: (in): A #NewsFormat. * @result: (in): A #GAsyncResult. * @user_data: (in): A #NewsParser. * * Handles the asynchronous completion of a call to news_format_read_async(). * If the reading of the buffer was successful; then the resulting feed * is stored for use by news_parser_parse_finish(). Otherwise, a proper * error is set. * * Returns: None. */ static void news_parser_format_read_cb (GObject *object, GAsyncResult *result, gpointer user_data) { NewsParserPrivate *priv; NewsParser *parser = user_data; NewsFormat *format = (NewsFormat *)object; GError *error = NULL; ENTRY; g_return_if_fail(NEWS_IS_FORMAT(format)); g_return_if_fail(G_IS_ASYNC_RESULT(result)); g_return_if_fail(NEWS_IS_PARSER(parser)); priv = parser->priv; if (!(priv->feed = news_format_read_finish(format, result, &error))) { g_simple_async_result_take_error(priv->simple, error); } g_simple_async_result_complete_in_idle(priv->simple); g_object_unref(parser); EXIT; }
/** * g_tls_interaction_ask_password_finish: * @interaction: a #GTlsInteraction object * @result: the result passed to the callback * @error: an optional location to place an error on failure * * Complete an ask password user interaction request. This should be once * the g_tls_interaction_ask_password_async() completion callback is called. * * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed * to g_tls_interaction_ask_password() will have its password filled in. * * If the interaction is cancelled by the cancellation object, or by the * user then %G_TLS_INTERACTION_FAILED will be returned with an error that * contains a %G_IO_ERROR_CANCELLED error code. * * Returns: The status of the ask password interaction. * * Since: 2.30 */ GTlsInteractionResult g_tls_interaction_ask_password_finish (GTlsInteraction *interaction, GAsyncResult *result, GError **error) { GTlsInteractionClass *klass; g_return_val_if_fail (G_IS_TLS_INTERACTION (interaction), G_TLS_INTERACTION_UNHANDLED); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), G_TLS_INTERACTION_UNHANDLED); /* If it's one of our simple unhandled async results, handle here */ if (g_simple_async_result_is_valid (result, G_OBJECT (interaction), g_tls_interaction_ask_password_async)) { return G_TLS_INTERACTION_UNHANDLED; } /* Invoke finish of derived class */ else { klass = G_TLS_INTERACTION_GET_CLASS (interaction); g_return_val_if_fail (klass->ask_password_finish, G_TLS_INTERACTION_UNHANDLED); return (klass->ask_password_finish) (interaction, result, error); } }
static void ide_lsp_formatter_format_call_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeLspClient *client = (IdeLspClient *)object; g_autoptr(IdeTask) task = user_data; g_autoptr(GError) error = NULL; g_autoptr(GVariant) reply = NULL; IdeLspFormatter *self; IdeBuffer *buffer; g_return_if_fail (IDE_IS_LSP_CLIENT (client)); g_return_if_fail (G_IS_ASYNC_RESULT (result)); if (!ide_lsp_client_call_finish (client, result, &reply, &error)) { ide_task_return_error (task, g_steal_pointer (&error)); return; } self = ide_task_get_source_object (task); buffer = ide_task_get_task_data (task); g_assert (IDE_IS_LSP_FORMATTER (self)); g_assert (IDE_IS_BUFFER (buffer)); ide_lsp_formatter_apply_changes (self, buffer, reply); ide_task_return_boolean (task, TRUE); }
static void ide_lsp_completion_provider_complete_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeLspCompletionProviderPrivate *priv; IdeLspCompletionProvider *self; IdeLspClient *client = (IdeLspClient *)object; g_autoptr(GVariant) return_value = NULL; g_autoptr(IdeTask) task = user_data; g_autoptr(GError) error = NULL; IdeLspCompletionResults *ret; IDE_ENTRY; g_assert (IDE_IS_LSP_CLIENT (client)); g_assert (G_IS_ASYNC_RESULT (result)); if (!ide_lsp_client_call_finish (client, result, &return_value, &error)) { ide_task_return_error (task, g_steal_pointer (&error)); return; } self = ide_task_get_source_object (task); priv = ide_lsp_completion_provider_get_instance_private (self); ret = ide_lsp_completion_results_new (return_value); if (priv->word != NULL && *priv->word != 0) ide_lsp_completion_results_refilter (ret, priv->word); ide_task_return_object (task, g_steal_pointer (&ret)); IDE_EXIT; }
static void load_find_files_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GFile *file = (GFile *)object; g_autoptr(IdeTask) task = user_data; g_autoptr(GError) error = NULL; g_autoptr(GPtrArray) ret = NULL; g_assert (G_IS_FILE (file)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (IDE_IS_TASK (task)); ret = ide_g_file_find_finish (file, result, &error); IDE_PTR_ARRAY_SET_FREE_FUNC (ret, g_object_unref); if (ret == NULL) { ide_task_return_error (task, g_steal_pointer (&error)); return; } ide_task_set_task_data (task, g_steal_pointer (&ret), g_ptr_array_unref); ide_task_run_in_thread (task, gbp_cmake_toolchain_provider_load_worker); }
static void pkg_channels_page_add_channel_cb (PkConnection *connection, GAsyncResult *result, PkgChannelsPage *page) { PkgChannelsPagePrivate *priv; GError *error = NULL; gint channel; g_return_if_fail(PK_IS_CONNECTION(connection)); g_return_if_fail(G_IS_ASYNC_RESULT(result)); g_return_if_fail(PKG_IS_CHANNELS_PAGE(page)); ENTRY; priv = page->priv; if (!pk_connection_manager_add_channel_finish(priv->connection, result, &channel, &error)) { WARNING(Channels, "Failed to add new channel: %s", error->message); pkg_util_dialog_warning(gtk_widget_get_toplevel(GTK_WIDGET(page)), "", _("There was an error adding the channel."), error->message, TRUE); g_error_free(error); GOTO(fail); } DEBUG(Channels, "Added channel %d to system.", channel); fail: EXIT; }
static void ide_build_system_get_build_flags_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeBuildSystem *self = (IdeBuildSystem *)object; g_autoptr(IdeTask) task = user_data; g_autoptr(GError) error = NULL; g_auto(GStrv) flags = NULL; GetBuildFlagsData *data; GFile *file; g_assert (IDE_IS_BUILD_SYSTEM (self)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (IDE_IS_TASK (task)); data = ide_task_get_task_data (task); g_assert (data != NULL); g_assert (data->files != NULL); g_assert (data->files->len > 0); g_assert (data->index < data->files->len); g_assert (data->flags != NULL); file = g_ptr_array_index (data->files, data->index); g_assert (G_IS_FILE (file)); data->index++; flags = ide_build_system_get_build_flags_finish (self, result, &error); if (error != NULL) g_debug ("Failed to load build flags for \"%s\": %s", g_file_peek_path (file), error->message); else g_hash_table_insert (data->flags, g_object_ref (file), g_steal_pointer (&flags)); if (ide_task_return_error_if_cancelled (task)) return; if (data->index < data->files->len) { GCancellable *cancellable = ide_task_get_cancellable (task); file = g_ptr_array_index (data->files, data->index); g_assert (G_IS_FILE (file)); ide_build_system_get_build_flags_async (self, file, cancellable, ide_build_system_get_build_flags_cb, g_steal_pointer (&task)); return; } ide_task_return_pointer (task, g_steal_pointer (&data->flags), g_hash_table_unref); }
static void ide_terminal_page_spawn_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeTerminalLauncher *launcher = (IdeTerminalLauncher *)object; g_autoptr(IdeTerminalPage) self = user_data; g_autoptr(GError) error = NULL; gint64 now; g_assert (IDE_IS_TERMINAL_LAUNCHER (launcher)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (IDE_IS_TERMINAL_PAGE (self)); if (!ide_terminal_launcher_spawn_finish (launcher, result, &error)) { g_autofree gchar *format = NULL; format = g_strdup_printf ("%s: %s", _("Subprocess launcher failed"), error->message); ide_terminal_page_feed (self, format); } if (gtk_widget_in_destruction (GTK_WIDGET (self))) return; now = g_get_monotonic_time (); if (ABS (now - self->last_respawn) < FLAPPING_DURATION_USEC) { ide_terminal_page_feed (self, _("Subprocess launcher failed too quickly, will not respawn.")); return; } if (!self->respawn_on_exit) { if (self->close_on_exit) gdk_threads_add_idle_full (G_PRIORITY_LOW + 1000, (GSourceFunc) destroy_widget_in_idle, g_object_ref (self), g_object_unref); return; } g_clear_object (&self->pty); vte_terminal_reset (VTE_TERMINAL (self->terminal_top), TRUE, TRUE); self->pty = vte_pty_new_sync (VTE_PTY_DEFAULT, NULL, NULL); vte_terminal_set_pty (VTE_TERMINAL (self->terminal_top), self->pty); /* Spawn our terminal and wait for it to exit */ self->last_respawn = now; ide_terminal_launcher_spawn_async (self->launcher, self->pty, NULL, ide_terminal_page_spawn_cb, g_object_ref (self)); }
gint ide_application_tool_run_finish (IdeApplicationTool *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_APPLICATION_TOOL (self), 0); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), 0); return IDE_APPLICATION_TOOL_GET_IFACE (self)->run_finish (self, result, error); }
/** * ide_device_provider_load_finish: * @self: an #IdeDeviceProvider * @result: a #GAsyncResult provided to callback * @error: a location for a #GError, or %NULL * * Completes an asynchronous request to load known devices via * ide_device_provider_load_async(). * * Returns: %TRUE if successful; otherwise %FALSE and @error is set. * * Since: 3.32 */ gboolean ide_device_provider_load_finish (IdeDeviceProvider *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_DEVICE_PROVIDER (self), FALSE); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); return IDE_DEVICE_PROVIDER_GET_CLASS (self)->load_finish (self, result, error); }
/** * ide_build_system_get_build_flags_for_dir_finish: * @self: an #IdeBuildSystem * @result: a #GAsyncResult * @error: a location for a #GError or %NULL * * Returns: (element-type Ide.File GStrv) (transfer full): a #GHashTable of #GFile to #GStrv * * Since: 3.32 */ GHashTable * ide_build_system_get_build_flags_for_dir_finish (IdeBuildSystem *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_BUILD_SYSTEM (self), NULL); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL); return ide_task_propagate_pointer (IDE_TASK (result), error); }
/** * ide_search_provider_search_finish: * @self: a #IdeSearchProvider * @result: a #GAsyncResult * @error: a location for a #GError, or %NULL * * Completes a request to a search provider. * * Returns: (transfer full) (element-type IdeSearchResult): a #GPtrArray * of #IdeSearchResult elements. * * Since: 3.32 */ GPtrArray * ide_search_provider_search_finish (IdeSearchProvider *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_SEARCH_PROVIDER (self), NULL); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL); return IDE_SEARCH_PROVIDER_GET_IFACE (self)->search_finish (self, result, error); }
/** * ide_context_addin_load_project_finish: * @self: an #IdeContextAddin * @result: a #GAsyncResult * @error: a location for a #GError, or %NULL * * Completes a request to load a project with the #IdeContextAddin. * * This function will be called from the callback provided to * ide_context_addin_load_project_async(). * * Returns: %TRUE if successful; otherwise %FALSE and @error is set. * * Since: 3.32 */ gboolean ide_context_addin_load_project_finish (IdeContextAddin *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_CONTEXT_ADDIN (self), FALSE); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); return IDE_CONTEXT_ADDIN_GET_IFACE (self)->load_project_finish (self, result, error); }
gboolean photos_share_point_share_finish (PhotosSharePoint *self, GAsyncResult *res, gchar **out_uri, GError **error) { g_return_val_if_fail (PHOTOS_IS_SHARE_POINT (self), FALSE); g_return_val_if_fail (G_IS_ASYNC_RESULT (res), FALSE); g_return_val_if_fail (out_uri == NULL || *out_uri == NULL, FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); return PHOTOS_SHARE_POINT_GET_CLASS (self)->share_finish (self, res, out_uri, error); }
/** * ide_diagnostic_provider_diagnose_finish: * * Completes an asynchronous call to ide_diagnostic_provider_diagnose_async(). * * Returns: (transfer full): #IdeDiagnostics or %NULL and @error is set. */ IdeDiagnostics * ide_diagnostic_provider_diagnose_finish (IdeDiagnosticProvider *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_DIAGNOSTIC_PROVIDER (self), NULL); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), NULL); return IDE_DIAGNOSTIC_PROVIDER_GET_IFACE (self)->diagnose_finish (self, result, error); }
gboolean ide_project_miner_mine_finish (IdeProjectMiner *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_PROJECT_MINER (self), FALSE); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); return IDE_PROJECT_MINER_GET_IFACE (self)->mine_finish (self, result, error); }
gboolean ide_vcs_initializer_initialize_finish (IdeVcsInitializer *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_VCS_INITIALIZER (self), FALSE); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); return IDE_VCS_INITIALIZER_GET_IFACE (self)->initialize_finish (self, result, error); }
gboolean ide_runner_addin_posthook_finish (IdeRunnerAddin *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_RUNNER_ADDIN (self), FALSE); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); return IDE_RUNNER_ADDIN_GET_IFACE (self)->posthook_finish (self, result, error); }
gboolean ide_frame_agree_to_close_finish (IdeFrame *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_FRAME (self), FALSE); g_return_val_if_fail (G_IS_ASYNC_RESULT (result), FALSE); return IDE_FRAME_GET_CLASS (self)->agree_to_close_finish (self, result, error); }
/** * ide_symbol_resolver_get_symbol_tree_finish: * * Completes an asynchronous request to get the symbol tree for the requested file. * * Returns: (nullable) (transfer full): An #IdeSymbolTree; otherwise %NULL and @error is set. */ IdeSymbolTree * ide_symbol_resolver_get_symbol_tree_finish (IdeSymbolResolver *self, GAsyncResult *result, GError **error) { g_return_val_if_fail (IDE_IS_SYMBOL_RESOLVER (self), NULL); g_return_val_if_fail (!result || G_IS_ASYNC_RESULT (result), NULL); return IDE_SYMBOL_RESOLVER_GET_IFACE (self)->get_symbol_tree_finish (self, result, error); }
static void ide_build_system_get_build_flags_for_dir_cb (GObject *object, GAsyncResult *result, gpointer user_data) { GFile *dir = (GFile *)object; g_autoptr(IdeTask) task = user_data; g_autoptr(GError) error = NULL; g_autoptr(GPtrArray) infos = NULL; g_autoptr(GPtrArray) files = NULL; IdeBuildSystem *self; GCancellable *cancellable; IdeContext *context; IdeVcs *vcs; g_assert (G_IS_FILE (dir)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (IDE_IS_TASK (task)); infos = ide_g_file_get_children_finish (dir, result, &error); IDE_PTR_ARRAY_SET_FREE_FUNC (infos, g_object_unref); if (infos == NULL) { ide_task_return_error (task, g_steal_pointer (&error)); return; } self = ide_task_get_source_object (task); context = ide_object_get_context (IDE_OBJECT (self)); vcs = ide_vcs_from_context (context); cancellable = ide_task_get_cancellable (task); files = g_ptr_array_new_with_free_func (g_object_unref); for (guint i = 0; i < infos->len; i++) { GFileInfo *file_info = g_ptr_array_index (infos, i); GFileType file_type = g_file_info_get_file_type (file_info); if (file_type == G_FILE_TYPE_REGULAR) { const gchar *name = g_file_info_get_name (file_info); g_autoptr(GFile) child = g_file_get_child (dir, name); if (!ide_vcs_is_ignored (vcs, child, NULL)) g_ptr_array_add (files, g_steal_pointer (&child)); } } ide_build_system_get_build_flags_for_files_async (self, files, cancellable, ide_build_system_get_build_flags_for_dir_cb2, g_steal_pointer (&task)); }
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; }
static void ide_debugger_editor_addin_disassemble_cb (GObject *object, GAsyncResult *result, gpointer user_data) { IdeDebugger *debugger = (IdeDebugger *)object; g_autoptr(IdeDebuggerEditorAddin) self = user_data; g_autoptr(GPtrArray) instructions = NULL; g_autoptr(GError) error = NULL; GtkWidget *stack; IDE_ENTRY; g_assert (IDE_IS_DEBUGGER (debugger)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (IDE_IS_DEBUGGER_EDITOR_ADDIN (self)); instructions = ide_debugger_disassemble_finish (debugger, result, &error); if (instructions == NULL) { g_warning ("%s", error->message); IDE_EXIT; } if (self->editor == NULL) IDE_EXIT; if (self->disassembly_view == NULL) { IdeGrid *grid = ide_editor_surface_get_grid (self->editor); self->disassembly_view = g_object_new (IDE_TYPE_DEBUGGER_DISASSEMBLY_VIEW, "visible", TRUE, NULL); g_signal_connect (self->disassembly_view, "destroy", G_CALLBACK (gtk_widget_destroyed), &self->disassembly_view); gtk_container_add (GTK_CONTAINER (grid), GTK_WIDGET (self->disassembly_view)); } ide_debugger_disassembly_view_set_instructions (self->disassembly_view, instructions); /* TODO: Set current instruction */ /* FIXME: It would be nice if we had a nicer API for this */ stack = gtk_widget_get_ancestor (GTK_WIDGET (self->disassembly_view), IDE_TYPE_FRAME); if (stack != NULL) ide_frame_set_visible_child (IDE_FRAME (stack), IDE_PAGE (self->disassembly_view)); IDE_EXIT; }
/** * g_async_result_get_source_object: * @res: a #GAsyncResult * * Gets the source object from a #GAsyncResult. * * Returns: (transfer full): a new reference to the source object for the @res, * or %NULL if there is none. */ GObject * g_async_result_get_source_object (GAsyncResult *res) { GAsyncResultIface *iface; g_return_val_if_fail (G_IS_ASYNC_RESULT (res), NULL); iface = G_ASYNC_RESULT_GET_IFACE (res); return (* iface->get_source_object) (res); }