static void
ide_async_helper_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = user_data;
GPtrArray *funcs;
GError *error = NULL;
g_return_if_fail (G_IS_TASK (task));
g_return_if_fail (G_IS_TASK (result));
funcs = g_task_get_task_data (task);
if (!g_task_propagate_boolean (G_TASK (result), &error))
{
g_task_return_error (task, error);
return;
}
g_ptr_array_remove_index (funcs, 0);
if (funcs->len)
{
IdeAsyncStep step;
step = g_ptr_array_index (funcs, 0);
step (g_task_get_source_object (task),
g_task_get_cancellable (task),
ide_async_helper_cb,
g_object_ref (task));
}
else
g_task_return_boolean (task, TRUE);
}
/**
* egg_task_cache_get_finish:
*
* Finish a call to egg_task_cache_get_async().
*
* Returns: (transfer full): The result from the cache.
*/
gpointer
egg_task_cache_get_finish (EggTaskCache *self,
GAsyncResult *result,
GError **error)
{
GTask *task = (GTask *)result;
g_return_val_if_fail (EGG_IS_TASK_CACHE (self), NULL);
g_return_val_if_fail (G_IS_TASK (result), NULL);
g_return_val_if_fail (G_IS_TASK (task), NULL);
return g_task_propagate_pointer (task, error);
}
static void
ide_run_manager_do_install_before_run (IdeRunManager *self,
GTask *task)
{
IdeBuildManager *build_manager;
IdeContext *context;
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (G_IS_TASK (task));
context = ide_object_get_context (IDE_OBJECT (self));
build_manager = ide_context_get_build_manager (context);
/*
* First we need to make sure the target is up to date and installed
* so that all the dependent resources are available.
*/
self->busy = TRUE;
g_signal_connect_object (task,
"notify::completed",
G_CALLBACK (ide_run_manager_task_completed),
self,
G_CONNECT_SWAPPED);
ide_build_manager_install_async (build_manager,
g_task_get_cancellable (task),
ide_run_manager_install_cb,
g_object_ref (task));
ide_run_manager_notify_busy (self);
}
static void
ide_run_manager_run_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeRunner *runner = (IdeRunner *)object;
g_autoptr(GTask) task = user_data;
IdeRunManager *self;
GError *error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_RUNNER (runner));
g_assert (G_IS_TASK (task));
self = g_task_get_source_object (task);
if (!ide_runner_run_finish (runner, result, &error))
{
g_task_return_error (task, error);
IDE_GOTO (failure);
}
g_task_return_boolean (task, TRUE);
failure:
g_signal_emit (self, signals [STOPPED], 0);
IDE_EXIT;
}
static void
load_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeMingwDeviceProvider *self = (IdeMingwDeviceProvider *)object;
GTask *task = (GTask *)result;
GPtrArray *devices;
gsize i;
g_assert (IDE_IS_MINGW_DEVICE_PROVIDER (self));
g_assert (G_IS_TASK (task));
devices = g_task_propagate_pointer (task, NULL);
if (devices)
{
g_clear_pointer (&self->devices, g_ptr_array_unref);
self->devices = devices;
for (i = 0; i < devices->len; i++)
{
IdeDevice *device;
device = g_ptr_array_index (devices, i);
ide_device_provider_emit_device_added (IDE_DEVICE_PROVIDER (self), device);
}
}
self->settled = TRUE;
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SETTLED]);
}
static void
ide_autotools_build_system_get_build_targets_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeAutotoolsBuildSystem *self = (IdeAutotoolsBuildSystem *)object;
g_autoptr(IdeMakecache) makecache = NULL;
g_autoptr(GTask) task = user_data;
GError *error = NULL;
g_assert (IDE_IS_AUTOTOOLS_BUILD_SYSTEM (self));
g_assert (G_IS_TASK (task));
makecache = ide_autotools_build_system_get_makecache_finish (self, result, &error);
if (makecache == NULL)
{
g_task_return_error (task, error);
return;
}
ide_makecache_get_build_targets_async (makecache,
g_task_get_cancellable (task),
ide_autotools_build_system_get_build_targets_cb2,
g_object_ref (task));
}
static gboolean
finish_animation_in_idle (gpointer data)
{
g_autoptr(GTask) task = data;
IdeGitCloneWidget *self;
IDE_ENTRY;
g_assert (G_IS_TASK (task));
self = g_task_get_source_object (task);
g_assert (IDE_IS_GIT_CLONE_WIDGET (self));
egg_object_animate_full (self->clone_progress,
EGG_ANIMATION_EASE_IN_OUT_QUAD,
ANIMATION_DURATION_MSEC,
NULL,
(GDestroyNotify)ide_widget_hide_with_fade,
self->clone_progress,
"fraction", 1.0,
NULL);
/*
* Wait for a second so animations can complete before opening
* the project. Otherwise, it's pretty jarring to the user.
*/
g_timeout_add (ANIMATION_DURATION_MSEC, open_after_timeout, g_object_ref (task));
IDE_RETURN (G_SOURCE_REMOVE);
}
static void
populate_cache__get_local_makefile_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeAutotoolsBuildSystem *self = (IdeAutotoolsBuildSystem *)object;
g_autoptr(GTask) task = user_data;
g_autoptr(GFile) makefile = NULL;
IdeContext *context;
GError *error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_AUTOTOOLS_BUILD_SYSTEM (self));
g_assert (G_IS_TASK (task));
makefile = ide_autotools_build_system_get_local_makefile_finish (self, result, &error);
if (makefile == NULL)
{
g_task_return_error (task, error);
IDE_EXIT;
}
context = ide_object_get_context (IDE_OBJECT (self));
ide_makecache_new_for_makefile_async (context,
makefile,
g_task_get_cancellable (task),
populate_cache__new_makecache_cb,
g_object_ref (task));
IDE_EXIT;
}
static void
ide_subprocess_wait_check_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeSubprocess *self = (IdeSubprocess *)object;
g_autoptr(GTask) task = user_data;
g_autoptr(GError) error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_SUBPROCESS (self));
g_assert (G_IS_TASK (task));
if (!ide_subprocess_wait_finish (self, result, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
if (!ide_subprocess_check_exit_status (self, &error))
{
g_task_return_error (task, g_steal_pointer (&error));
IDE_EXIT;
}
g_task_return_boolean (task, TRUE);
IDE_EXIT;
}
static void
egg_task_cache_fetch_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
EggTaskCache *self = (EggTaskCache *)object;
GTask *task = (GTask *)result;
GError *error = NULL;
gpointer key = user_data;
gpointer ret;
g_assert (EGG_IS_TASK_CACHE (self));
g_assert (G_IS_TASK (task));
g_hash_table_remove (self->in_flight, key);
ret = g_task_propagate_pointer (task, &error);
if (ret != NULL)
{
egg_task_cache_populate (self, key, ret);
egg_task_cache_propagate_pointer (self, key, ret);
self->value_destroy_func (ret);
}
else
{
egg_task_cache_propagate_error (self, key, error);
g_clear_error (&error);
}
self->key_destroy_func (key);
EGG_COUNTER_DEC (in_flight);
}
static void
aws_s3_client_read_got_chunk (SoupMessage *message,
SoupBuffer *buffer,
GTask *task)
{
AwsS3Client *client;
ReadState *state;
g_assert (SOUP_IS_MESSAGE (message));
g_assert (buffer != NULL);
g_assert (G_IS_TASK (task));
client = g_task_get_source_object (task);
g_assert (AWS_IS_S3_CLIENT (client));
state = g_task_get_task_data (task);
g_assert (state != NULL);
g_assert (state->handler != NULL);
if (!state->handler (client, message, buffer, state->handler_data))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_CANCELLED,
"The request was cancelled");
soup_session_cancel_message (SOUP_SESSION (client), message, SOUP_STATUS_CANCELLED);
}
}
static void
discover_file_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeAutotoolsBuildSystem *self;
g_autoptr(GTask) task = user_data;
g_autoptr(GFile) file = NULL;
GError *error = NULL;
g_return_if_fail (G_IS_TASK (task));
self = g_task_get_source_object (task);
file = ide_autotools_build_system_discover_file_finish (self, result, &error);
if (!file)
{
g_task_return_error (task, error);
return;
}
g_object_set (self, "project-file", file, NULL);
ide_autotools_build_system_parse_async (self,
file,
g_task_get_cancellable (task),
parse_cb,
g_object_ref (task));
}
static void
ide_git_vcs_reload_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
IdeGitVcs *self = source_object;
g_autoptr(GgitRepository) repository1 = NULL;
g_autoptr(GgitRepository) repository2 = NULL;
GError *error = NULL;
g_assert (G_IS_TASK (task));
g_assert (IDE_IS_GIT_VCS (self));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
if (!(repository1 = ide_git_vcs_load (self, &error)) ||
!(repository2 = ide_git_vcs_load (self, &error)))
{
g_task_return_error (task, error);
return;
}
g_set_object (&self->repository, repository1);
g_set_object (&self->change_monitor_repository, repository2);
if (!ide_git_vcs_load_monitor (self, &error))
{
g_task_return_error (task, error);
return;
}
g_task_return_boolean (task, TRUE);
}
static void
parse_xml_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
DspyIntrospectionModel *self = source_object;
GBytes *bytes = task_data;
g_autoptr(GError) error = NULL;
DspyNodeInfo *info;
const gchar *xml;
g_assert (G_IS_TASK (task));
g_assert (DSPY_IS_INTROSPECTION_MODEL (source_object));
g_assert (bytes != NULL);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
xml = (const gchar *)g_bytes_get_data (bytes, NULL);
g_mutex_lock (&self->chunks_mutex);
info = _dspy_node_parse (xml, self->chunks, &error);
g_mutex_unlock (&self->chunks_mutex);
if (info != NULL)
g_task_return_pointer (task, info, (GDestroyNotify) _dspy_node_free);
else
g_task_return_error (task, g_steal_pointer (&error));
}
static void
ide_git_vcs_list_status_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
ListStatus *state = task_data;
g_autoptr(GListStore) store = NULL;
g_autoptr(GFile) workdir = NULL;
g_autoptr(GgitRepository) repository = NULL;
g_autoptr(GgitStatusOptions) options = NULL;
g_autoptr(GString) pathspec = NULL;
g_autoptr(GError) error = NULL;
g_autofree gchar *relative = NULL;
gchar *strv[] = { NULL, NULL };
g_assert (G_IS_TASK (task));
g_assert (IDE_IS_GIT_VCS (source_object));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
g_assert (state != NULL);
g_assert (G_IS_FILE (state->repository_location));
if (!(repository = ggit_repository_open (state->repository_location, &error)))
{
g_task_return_error (task, g_steal_pointer (&error));
return;
}
if (!(workdir = ggit_repository_get_workdir (repository)))
{
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_FAILED,
"Failed to locate working directory");
return;
}
g_set_object (&state->workdir, workdir);
if (state->directory_or_file != NULL)
relative = g_file_get_relative_path (workdir, state->directory_or_file);
strv[0] = relative;
options = ggit_status_options_new (GGIT_STATUS_OPTION_DEFAULT,
GGIT_STATUS_SHOW_INDEX_AND_WORKDIR,
(const gchar **)strv);
store = g_list_store_new (IDE_TYPE_VCS_FILE_INFO);
g_set_object (&state->store, store);
if (!ggit_repository_file_status_foreach (repository,
options,
ide_git_vcs_list_status_cb,
state,
&error))
g_task_return_error (task, g_steal_pointer (&error));
else
g_task_return_pointer (task, g_steal_pointer (&store), g_object_unref);
}
static void
fetch_items(GTask* task, gpointer source, gpointer task_data, GCancellable* cancel)
{
g_assert(GT_IS_SEARCH_GAME_CONTAINER(source));
GtSearchGameContainer* self = GT_SEARCH_GAME_CONTAINER(source);
GtSearchGameContainerPrivate* priv = gt_search_game_container_get_instance_private(self);
g_assert(G_IS_CANCELLABLE(cancel));
g_assert(G_IS_TASK(task));
if (g_task_return_error_if_cancelled(task))
return;
if (utils_str_empty(priv->query))
{
g_task_return_pointer(task, NULL, NULL);
return;
}
g_assert_nonnull(task_data);
FetchItemsData* data = task_data;
g_mutex_lock(&priv->mutex);
gint64 end_time = g_get_monotonic_time() + SEARCH_DELAY;
g_cancellable_connect(cancel, G_CALLBACK(cancelled_cb), self, NULL);
while (!g_cancellable_is_cancelled(cancel))
{
if (!g_cond_wait_until(&priv->cond, &priv->mutex, end_time))
{
/* We weren't cancelled */
g_assert(!utils_str_empty(priv->query));
GError* err = NULL;
GList* items = data->offset == 0 ? gt_twitch_search_games(main_app->twitch,
priv->query, data->amount, data->offset, &err) : NULL;
if (err)
g_task_return_error(task, err);
else
g_task_return_pointer(task, items, (GDestroyNotify) gt_game_list_free);
g_mutex_unlock(&priv->mutex);
return;
}
}
/* We were cancelled */
g_assert(g_task_return_error_if_cancelled(task));
g_mutex_unlock(&priv->mutex);
}
static gboolean
ide_application_task_completion (GAsyncResult *result,
GError **error)
{
g_assert (G_IS_TASK (result));
return g_task_propagate_boolean (G_TASK (result), error);
}
static void
ide_autotools_build_system_discover_file_worker (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
GFile *file = task_data;
GFile *parent;
g_assert (G_IS_TASK (task));
g_assert (G_IS_FILE (file));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
if (is_configure (file) && g_file_query_exists (file, cancellable))
{
g_task_return_pointer (task, g_object_ref (file), g_object_unref);
return;
}
parent = g_object_ref (file);
while (parent != NULL)
{
GFile *child;
GFile *tmp;
child = g_file_get_child (parent, "configure.ac");
if (g_file_query_exists (child, cancellable))
{
g_task_return_pointer (task, g_object_ref (child), g_object_unref);
g_clear_object (&child);
g_clear_object (&parent);
return;
}
child = g_file_get_child (parent, "configure.in");
if (g_file_query_exists (child, cancellable))
{
g_task_return_pointer (task, g_object_ref (child), g_object_unref);
g_clear_object (&child);
g_clear_object (&parent);
return;
}
g_clear_object (&child);
tmp = parent;
parent = g_file_get_parent (parent);
g_clear_object (&tmp);
}
g_clear_object (&parent);
g_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_FOUND,
_("Failed to locate configure.ac"));
}
static void
ide_clang_service_unit_completed_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(GTask) task = user_data;
gpointer ret;
GError *error = NULL;
g_assert (IDE_IS_CLANG_SERVICE (object));
g_assert (G_IS_TASK (result));
g_assert (G_IS_TASK (task));
if (!(ret = g_task_propagate_pointer (G_TASK (result), &error)))
g_task_return_error (task, error);
else
g_task_return_pointer (task, ret, g_object_unref);
}
static void
do_run_async (IdeRunManager *self,
GTask *task)
{
IdeBuildTarget *build_target;
IdeContext *context;
IdeConfigurationManager *config_manager;
IdeConfiguration *config;
IdeRuntime *runtime;
g_autoptr(IdeRunner) runner = NULL;
GCancellable *cancellable;
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (G_IS_TASK (task));
build_target = g_task_get_task_data (task);
context = ide_object_get_context (IDE_OBJECT (self));
g_assert (IDE_IS_BUILD_TARGET (build_target));
g_assert (IDE_IS_CONTEXT (context));
config_manager = ide_context_get_configuration_manager (context);
config = ide_configuration_manager_get_current (config_manager);
runtime = ide_configuration_get_runtime (config);
if (runtime == NULL)
{
g_task_return_new_error (task,
IDE_RUNTIME_ERROR,
IDE_RUNTIME_ERROR_NO_SUCH_RUNTIME,
"%s “%s”",
_("Failed to locate runtime"),
ide_configuration_get_runtime_id (config));
IDE_EXIT;
}
runner = ide_runtime_create_runner (runtime, build_target);
cancellable = g_task_get_cancellable (task);
g_assert (IDE_IS_RUNNER (runner));
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
/*
* If the current handler has a callback specified (our default "run" handler
* does not), then we need to allow that handler to prepare the runner.
*/
if (self->handler != NULL && self->handler->handler != NULL)
self->handler->handler (self, runner, self->handler->handler_data);
g_signal_emit (self, signals [RUN], 0, runner);
ide_runner_run_async (runner,
cancellable,
ide_run_manager_run_cb,
g_object_ref (task));
}
static gboolean
dummy_finish (IdeRunnerAddin *self,
GAsyncResult *result,
GError **error)
{
g_assert (IDE_IS_RUNNER_ADDIN (self));
g_assert (G_IS_TASK (result));
return g_task_propagate_boolean (G_TASK (result), error);
}
static gboolean
ide_git_vcs_initializer_initialize_finish (IdeVcsInitializer *initializer,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (IDE_IS_GIT_VCS_INITIALIZER (initializer), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
return g_task_propagate_boolean (G_TASK (result), error);
}
gboolean
_ide_back_forward_list_load_finish (IdeBackForwardList *self,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (IDE_IS_BACK_FORWARD_LIST (self), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
return g_task_propagate_boolean (G_TASK (result), error);
}
static IdeBuildResult *
ide_builder_real_build_finish (IdeBuilder *self,
GAsyncResult *result,
GError **error)
{
g_assert (IDE_IS_BUILDER (self));
g_assert (G_IS_TASK (result));
return g_task_propagate_pointer (G_TASK (result), error);
}
static IdeSymbolTree *
ide_symbol_resolver_real_get_symbol_tree_finish (IdeSymbolResolver *self,
GAsyncResult *result,
GError **error)
{
g_assert (IDE_IS_SYMBOL_RESOLVER (self));
g_assert (G_IS_TASK (result));
return g_task_propagate_pointer (G_TASK (result), error);
}
static gboolean
ide_runtime_real_postbuild_finish (IdeRuntime *self,
GAsyncResult *result,
GError **error)
{
g_assert (IDE_IS_RUNTIME (self));
g_assert (G_IS_TASK (result));
return g_task_propagate_boolean (G_TASK (result), error);
}
gboolean
aws_s3_client_write_finish (AwsS3Client *client,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (AWS_IS_S3_CLIENT (client), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
return g_task_propagate_boolean (G_TASK (result), error);
}
static GListModel *
ide_git_vcs_list_status_finish (IdeVcs *vcs,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (IDE_IS_GIT_VCS (vcs), NULL);
g_return_val_if_fail (G_IS_TASK (result), NULL);
return g_task_propagate_pointer (G_TASK (result), error);
}
static gboolean
ide_rename_provider_real_rename_finish (IdeRenameProvider *self,
GAsyncResult *result,
GPtrArray **edits,
GError **error)
{
g_assert (G_IS_TASK (result));
return g_task_propagate_boolean (G_TASK (result), error);
}
/**
* ide_file_find_other_finish:
*
* Completes an asynchronous call to ide_file_find_other_async(). This function
* will try to find a matching file for languages where this exists. Such cases
* include C and C++ where a .c or .cpp file may have a .h or .hh header. Additional
* suffixes are implemented including (.c, .cc, .cpp, .cxx, .h, .hh, .hpp, and .hxx).
*
* Returns an #IdeFile if successful, otherwise %NULL and @error is set.
*
* Returns: (transfer full) (nullable): An #IdeFIle or %NULL.
*/
IdeFile *
ide_file_find_other_finish (IdeFile *self,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (IDE_IS_FILE (self), NULL);
g_return_val_if_fail (G_IS_TASK (result), NULL);
return g_task_propagate_pointer (G_TASK (result), error);
}
