static void
debugger_run_handler (IdeRunManager *run_manager,
IdeRunner *runner,
gpointer user_data)
{
IdeDebuggerEditorAddin *self = user_data;
IdeDebugManager *debug_manager;
IdeContext *context;
g_autoptr(GError) error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_RUN_MANAGER (run_manager));
g_assert (IDE_IS_RUNNER (runner));
g_assert (IDE_IS_DEBUGGER_EDITOR_ADDIN (self));
/*
* Get the currently configured debugger and attach it to our runner.
* It might need to prepend arguments like `gdb', `pdb', `mdb', etc.
*/
context = ide_object_get_context (IDE_OBJECT (run_manager));
debug_manager = ide_debug_manager_from_context (context);
if (!ide_debug_manager_start (debug_manager, runner, &error))
send_notification (self,
_("Failed to start the debugger"),
error->message,
"computer-fail-symbolic",
TRUE);
IDE_EXIT;
}
gboolean
ide_run_manager_get_busy (IdeRunManager *self)
{
g_return_val_if_fail (IDE_IS_RUN_MANAGER (self), FALSE);
return self->busy;
}
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);
}
/**
* ide_run_manager_get_build_target:
*
* Gets the build target that will be executed by the run manager which
* was either specified to ide_run_manager_run_async() or determined by
* the build system.
*
* Returns: (transfer none): An #IdeBuildTarget or %NULL if no build target
* has been set.
*/
IdeBuildTarget *
ide_run_manager_get_build_target (IdeRunManager *self)
{
g_return_val_if_fail (IDE_IS_RUN_MANAGER (self), NULL);
return self->build_target;
}
void
ide_run_manager_discover_default_target_async (IdeRunManager *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
IdeBuildSystem *build_system;
IdeContext *context;
IDE_ENTRY;
g_return_if_fail (IDE_IS_RUN_MANAGER (self));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, ide_run_manager_discover_default_target_async);
context = ide_object_get_context (IDE_OBJECT (self));
build_system = ide_context_get_build_system (context);
ide_build_system_get_build_targets_async (build_system,
cancellable,
ide_run_manager_discover_default_target_cb,
g_object_ref (task));
IDE_EXIT;
}
const GList *
_ide_run_manager_get_handlers (IdeRunManager *self)
{
g_return_val_if_fail (IDE_IS_RUN_MANAGER (self), NULL);
return self->handlers;
}
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);
}
void
ide_run_manager_remove_handler (IdeRunManager *self,
const gchar *id)
{
g_return_if_fail (IDE_IS_RUN_MANAGER (self));
g_return_if_fail (id != NULL);
for (GList *iter = self->handlers; iter; iter = iter->next)
{
IdeRunHandlerInfo *info = iter->data;
if (g_strcmp0 (info->id, id) == 0)
{
self->handlers = g_list_remove_link (self->handlers, iter);
if (self->handler == info && self->handlers != NULL)
self->handler = self->handlers->data;
else
self->handler = NULL;
ide_run_handler_info_free (info);
break;
}
}
}
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 void
ide_run_manager_notify_busy (IdeRunManager *self)
{
g_assert (IDE_IS_RUN_MANAGER (self));
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_BUSY]);
g_action_group_action_enabled_changed (G_ACTION_GROUP (self), "run", self->busy == FALSE);
g_action_group_action_enabled_changed (G_ACTION_GROUP (self), "run-with-handler", self->busy == FALSE);
g_action_group_action_enabled_changed (G_ACTION_GROUP (self), "stop", self->busy == TRUE);
}
const gchar *
ide_run_manager_get_handler (IdeRunManager *self)
{
g_return_val_if_fail (IDE_IS_RUN_MANAGER (self), NULL);
if (self->handler != NULL)
return self->handler->id;
return NULL;
}
void
ide_run_manager_set_build_target (IdeRunManager *self,
IdeBuildTarget *build_target)
{
g_return_if_fail (IDE_IS_RUN_MANAGER (self));
g_return_if_fail (IDE_IS_BUILD_TARGET (build_target));
if (g_set_object (&self->build_target, build_target))
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_BUILD_TARGET]);
}
static gboolean
ide_run_manager_query_action (GActionGroup *group,
const gchar *action_name,
gboolean *enabled,
const GVariantType **parameter_type,
const GVariantType **state_type,
GVariant **state_hint,
GVariant **state)
{
IdeRunManager *self = (IdeRunManager *)group;
const GVariantType *real_parameter_type = NULL;
gboolean real_enabled = FALSE;
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (action_name != NULL);
if (g_strcmp0 (action_name, "run-with-handler") == 0)
{
real_enabled = self->busy == FALSE;
real_parameter_type = G_VARIANT_TYPE_STRING;
goto finish;
}
if (g_strcmp0 (action_name, "run") == 0)
{
real_enabled = self->busy == FALSE;
goto finish;
}
if (g_strcmp0 (action_name, "stop") == 0)
{
real_enabled = self->busy == TRUE;
goto finish;
}
finish:
if (state_type)
*state_type = NULL;
if (state_hint)
*state_hint = NULL;
if (state)
*state = NULL;
if (enabled)
*enabled = real_enabled;
if (parameter_type)
*parameter_type = real_parameter_type;
return TRUE;
}
void
ide_run_manager_cancel (IdeRunManager *self)
{
IDE_ENTRY;
g_return_if_fail (IDE_IS_RUN_MANAGER (self));
if (self->cancellable != NULL)
g_timeout_add (0, do_cancel_in_timeout, g_object_ref (self->cancellable));
IDE_EXIT;
}
/**
* ide_run_manager_discover_default_target_finish:
*
* Returns: (transfer full): An #IdeBuildTarget if successful; otherwise %NULL
* and @error is set.
*/
IdeBuildTarget *
ide_run_manager_discover_default_target_finish (IdeRunManager *self,
GAsyncResult *result,
GError **error)
{
IdeBuildTarget *ret;
IDE_ENTRY;
g_return_val_if_fail (IDE_IS_RUN_MANAGER (self), NULL);
g_return_val_if_fail (G_IS_TASK (result), NULL);
ret = g_task_propagate_pointer (G_TASK (result), error);
IDE_RETURN (ret);
}
gboolean
ide_run_manager_run_finish (IdeRunManager *self,
GAsyncResult *result,
GError **error)
{
gboolean ret;
IDE_ENTRY;
g_return_val_if_fail (IDE_IS_RUN_MANAGER (self), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
ret = g_task_propagate_boolean (G_TASK (result), error);
IDE_RETURN (ret);
}
static void
ide_run_manager_task_completed (IdeRunManager *self,
GParamSpec *pspec,
GTask *task)
{
IDE_ENTRY;
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (pspec != NULL);
g_assert (G_IS_TASK (task));
self->busy = FALSE;
ide_run_manager_notify_busy (self);
IDE_EXIT;
}
static void
ide_run_manager_activate_action (GActionGroup *group,
const gchar *action_name,
GVariant *parameter)
{
IdeRunManager *self = (IdeRunManager *)group;
g_autoptr(GVariant) sunk = NULL;
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (action_name != NULL);
if (parameter != NULL && g_variant_is_floating (parameter))
sunk = g_variant_ref_sink (parameter);
if (FALSE) {}
else if (g_strcmp0 (action_name, "run-with-handler") == 0)
{
const gchar *handler = NULL;
if (parameter != NULL)
handler = g_variant_get_string (parameter, NULL);
/* "" translates to current handler */
if (handler && *handler)
ide_run_manager_set_handler (self, handler);
ide_run_manager_run_async (self,
NULL,
NULL,
ide_run_manager_run_action_cb,
NULL);
}
else if (g_strcmp0 (action_name, "run") == 0)
{
ide_run_manager_run_async (self,
NULL,
NULL,
ide_run_manager_run_action_cb,
NULL);
}
else if (g_strcmp0 (action_name, "stop") == 0)
{
ide_run_manager_cancel (self);
}
}
static void
ide_run_manager_run_action_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeRunManager *self = (IdeRunManager *)object;
IdeContext *context;
g_autoptr(GError) error = NULL;
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (G_IS_ASYNC_RESULT (result));
context = ide_object_get_context (IDE_OBJECT (self));
/* Propagate the error to the context */
if (!ide_run_manager_run_finish (self, result, &error))
ide_context_warning (context, "%s", error->message);
}
static void
ide_run_manager_install_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeBuildManager *build_manager = (IdeBuildManager *)object;
g_autoptr(GTask) task = user_data;
IdeRunManager *self;
IdeBuildTarget *build_target;
GCancellable *cancellable;
GError *error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_BUILD_MANAGER (build_manager));
g_assert (G_IS_TASK (task));
if (!ide_build_manager_build_finish (build_manager, result, &error))
{
g_task_return_error (task, error);
IDE_EXIT;
}
self = g_task_get_source_object (task);
g_assert (IDE_IS_RUN_MANAGER (self));
build_target = ide_run_manager_get_build_target (self);
if (build_target == NULL)
{
cancellable = g_task_get_cancellable (task);
g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
ide_run_manager_discover_default_target_async (self,
cancellable,
ide_run_manager_run_discover_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
g_task_set_task_data (task, g_object_ref (build_target), g_object_unref);
do_run_async (self, g_steal_pointer (&task));
}
static gboolean
ide_run_manager_check_busy (IdeRunManager *self,
GError **error)
{
g_assert (IDE_IS_RUN_MANAGER (self));
g_assert (error != NULL);
if (ide_run_manager_get_busy (self))
{
g_set_error (error,
G_IO_ERROR,
G_IO_ERROR_BUSY,
"%s",
_("Cannot run target, another target is running"));
return TRUE;
}
return FALSE;
}
void
ide_run_manager_set_handler (IdeRunManager *self,
const gchar *id)
{
g_return_if_fail (IDE_IS_RUN_MANAGER (self));
self->handler = NULL;
for (GList *iter = self->handlers; iter; iter = iter->next)
{
const IdeRunHandlerInfo *info = iter->data;
if (g_strcmp0 (info->id, id) == 0)
{
self->handler = info;
IDE_TRACE_MSG ("run handler set to %s", info->title);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_HANDLER]);
break;
}
}
}
void
ide_run_manager_add_handler (IdeRunManager *self,
const gchar *id,
const gchar *title,
const gchar *icon_name,
const gchar *accel,
IdeRunHandler run_handler,
gpointer user_data,
GDestroyNotify user_data_destroy)
{
IdeRunHandlerInfo *info;
g_autofree gchar *action_name = NULL;
const gchar *accels[] = { accel, NULL };
GApplication *app;
g_return_if_fail (IDE_IS_RUN_MANAGER (self));
g_return_if_fail (id != NULL);
g_return_if_fail (title != NULL);
info = g_slice_new (IdeRunHandlerInfo);
info->id = g_strdup (id);
info->title = g_strdup (title);
info->icon_name = g_strdup (icon_name);
info->accel = g_strdup (accel);
info->handler = run_handler;
info->handler_data = user_data;
info->handler_data_destroy = user_data_destroy;
app = g_application_get_default ();
action_name = g_strdup_printf ("run-manager.run-with-handler('%s')", id);
if (accel != NULL && app != NULL)
gtk_application_set_accels_for_action (GTK_APPLICATION (app), action_name, accels);
self->handlers = g_list_append (self->handlers, info);
if (self->handler == NULL)
self->handler = info;
}
void
ide_run_manager_run_async (IdeRunManager *self,
IdeBuildTarget *build_target,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
g_autoptr(GTask) task = NULL;
g_autoptr(GCancellable) local_cancellable = NULL;
GError *error = NULL;
IDE_ENTRY;
g_return_if_fail (IDE_IS_RUN_MANAGER (self));
g_return_if_fail (!build_target || IDE_IS_BUILD_TARGET (build_target));
g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
if (cancellable == NULL)
cancellable = local_cancellable = g_cancellable_new ();
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_source_tag (task, ide_run_manager_run_async);
g_set_object (&self->cancellable, cancellable);
if (ide_run_manager_check_busy (self, &error))
{
g_task_return_error (task, error);
IDE_EXIT;
}
if (build_target != NULL)
ide_run_manager_set_build_target (self, build_target);
ide_run_manager_do_install_before_run (self, task);
IDE_EXIT;
}