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