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);
}
static void
ide_primary_workspace_actions_update_dependencies_cb (PeasExtensionSet *set,
PeasPluginInfo *plugin_info,
PeasExtension *exten,
gpointer user_data)
{
IdeDependencyUpdater *updater = (IdeDependencyUpdater *)exten;
IdePrimaryWorkspace *self;
UpdateDependencies *ud;
IdeContext *context;
IdeTask *task = user_data;
g_assert (PEAS_IS_EXTENSION_SET (set));
g_assert (plugin_info != NULL);
g_assert (IDE_IS_DEPENDENCY_UPDATER (updater));
g_assert (IDE_IS_TASK (task));
self = ide_task_get_source_object (task);
context = ide_widget_get_context (GTK_WIDGET (self));
ide_object_append (IDE_OBJECT (context), IDE_OBJECT (updater));
ud = ide_task_get_task_data (task);
ud->n_active++;
ide_dependency_updater_update_async (updater,
NULL,
update_dependencies_cb,
g_object_ref (task));
}
static void
ide_omni_bar_update (IdeOmniBar *self)
{
g_autofree gchar *branch_name = NULL;
const gchar *project_name = NULL;
IdeContext *context;
g_assert (IDE_IS_OMNI_BAR (self));
context = ide_widget_get_context (GTK_WIDGET (self));
if (IDE_IS_CONTEXT (context))
{
IdeProject *project;
IdeVcs *vcs;
project = ide_context_get_project (context);
project_name = ide_project_get_name (project);
vcs = ide_context_get_vcs (context);
branch_name = ide_vcs_get_branch_name (vcs);
}
gtk_label_set_label (self->project_label, project_name);
gtk_label_set_label (self->branch_label, branch_name);
gtk_label_set_label (self->popover_branch_label, branch_name);
}
static IdeLayoutView *
ide_editor_perspective_create_view (IdeEditorPerspective *self,
const gchar *uri,
IdeLayoutGrid *grid)
{
g_autoptr(GFile) file = NULL;
g_autoptr(IdeFile) ifile = NULL;
IdeBufferManager *bufmgr;
IdeContext *context;
IdeBuffer *buffer;
g_assert (IDE_IS_EDITOR_PERSPECTIVE (self));
g_assert (uri != NULL);
g_assert (IDE_IS_LAYOUT_GRID (grid));
g_debug ("Creating view for %s", uri);
context = ide_widget_get_context (GTK_WIDGET (self));
file = g_file_new_for_uri (uri);
ifile = ide_file_new (context, file);
bufmgr = ide_context_get_buffer_manager (context);
buffer = ide_buffer_manager_find_buffer (bufmgr, file);
/*
* If we failed to locate an already loaded buffer, we need to start
* loading the buffer. But that could take some time. Either way, after
* we start the loading process, we can access the buffer and we'll
* display it while it loads.
*/
if (buffer == NULL)
{
/* TODO: We probably need a generic "Open" API that allows
* us to handle any sort of API and redirect it to a
* given view provider.
*/
ide_buffer_manager_load_file_async (bufmgr,
ifile,
FALSE,
IDE_WORKBENCH_OPEN_FLAGS_NO_VIEW,
NULL,
NULL,
ide_editor_perspective_load_file_cb,
g_object_ref (self));
buffer = ide_buffer_manager_find_buffer (bufmgr, file);
}
return g_object_new (IDE_TYPE_EDITOR_VIEW,
"buffer", buffer,
"visible", TRUE,
NULL);
}
static void
on_frame_activated (IdeDebuggerEditorAddin *self,
IdeDebuggerThread *thread,
IdeDebuggerFrame *frame,
IdeDebuggerThreadsView *threads_view)
{
IdeDebuggerAddress addr;
const gchar *path;
guint line;
IDE_ENTRY;
g_assert (IDE_IS_DEBUGGER_EDITOR_ADDIN (self));
g_assert (IDE_IS_DEBUGGER_THREAD (thread));
g_assert (IDE_IS_DEBUGGER_FRAME (frame));
g_assert (IDE_IS_DEBUGGER_THREADS_VIEW (threads_view));
ide_debugger_locals_view_load_async (self->locals_view, thread, frame, NULL, NULL, NULL);
path = ide_debugger_frame_get_file (frame);
line = ide_debugger_frame_get_line (frame);
if (line > 0)
line--;
if (path != NULL)
{
IdeContext *context = ide_widget_get_context (GTK_WIDGET (threads_view));
g_autoptr(IdeLocation) location = NULL;
g_autofree gchar *project_path = ide_context_build_filename (context, path, NULL);
g_autoptr(GFile) file = g_file_new_for_path (project_path);
location = ide_location_new (file, line, -1);
ide_editor_surface_focus_location (self->editor, location);
IDE_EXIT;
}
addr = ide_debugger_frame_get_address (frame);
if (addr != IDE_DEBUGGER_ADDRESS_INVALID)
{
ide_debugger_editor_addin_navigate_to_address (self, addr);
IDE_EXIT;
}
g_warning ("Failed to locate source or memory address for frame");
IDE_EXIT;
}
static void
gbp_editor_workspace_addin_load (IdeWorkspaceAddin *addin,
IdeWorkspace *workspace)
{
GbpEditorWorkspaceAddin *self = (GbpEditorWorkspaceAddin *)addin;
IdeBufferManager *buffer_manager;
IdeHeaderBar *header_bar;
IdeContext *context;
g_assert (GBP_IS_EDITOR_WORKSPACE_ADDIN (self));
g_assert (IDE_IS_WORKSPACE (workspace));
g_assert (IDE_IS_PRIMARY_WORKSPACE (workspace) ||
IDE_IS_EDITOR_WORKSPACE (workspace));
self->workspace = workspace;
/* Get our buffer manager for future use */
context = ide_widget_get_context (GTK_WIDGET (workspace));
buffer_manager = ide_buffer_manager_from_context (context);
/* Monitor buffer manager for new buffers */
self->buffer_manager_signals = dzl_signal_group_new (IDE_TYPE_BUFFER_MANAGER);
g_signal_connect_swapped (self->buffer_manager_signals,
"bind",
G_CALLBACK (bind_buffer_manager),
self);
dzl_signal_group_connect_swapped (self->buffer_manager_signals,
"load-buffer",
G_CALLBACK (on_load_buffer),
self);
dzl_signal_group_set_target (self->buffer_manager_signals, buffer_manager);
/* Add buttons to the header bar */
header_bar = ide_workspace_get_header_bar (workspace);
add_buttons (self, header_bar);
/* Add the editor surface to the workspace */
self->surface = g_object_new (IDE_TYPE_EDITOR_SURFACE,
"name", "editor",
"restore-panel", IDE_IS_PRIMARY_WORKSPACE (workspace),
"visible", TRUE,
NULL);
g_signal_connect (self->surface,
"destroy",
G_CALLBACK (gtk_widget_destroyed),
&self->surface);
ide_workspace_add_surface (IDE_WORKSPACE (workspace), IDE_SURFACE (self->surface));
ide_workspace_set_visible_surface_name (IDE_WORKSPACE (workspace), "editor");
}
static void
ide_primary_workspace_actions_update_dependencies (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdePrimaryWorkspace *self = user_data;
g_autoptr(PeasExtensionSet) set = NULL;
g_autoptr(IdeNotification) notif = NULL;
g_autoptr(IdeTask) task = NULL;
UpdateDependencies *state;
IdeContext *context;
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (G_IS_SIMPLE_ACTION (action));
g_assert (IDE_IS_PRIMARY_WORKSPACE (self));
context = ide_widget_get_context (GTK_WIDGET (self));
notif = ide_notification_new ();
ide_notification_set_title (notif, _("Updating Dependencies…"));
ide_notification_set_body (notif, _("Builder is updating your projects configured dependencies."));
ide_notification_set_icon_name (notif, "software-update-available-symbolic");
ide_notification_set_has_progress (notif, TRUE);
ide_notification_set_progress_is_imprecise (notif, TRUE);
ide_notification_attach (notif, IDE_OBJECT (context));
state = g_slice_new0 (UpdateDependencies);
state->n_active = 0;
state->notif = g_object_ref (notif);
task = ide_task_new (self, NULL, NULL, NULL);
ide_task_set_source_tag (task, ide_primary_workspace_actions_update_dependencies);
ide_task_set_task_data (task, state, update_dependencies_free);
set = peas_extension_set_new (peas_engine_get_default (),
IDE_TYPE_DEPENDENCY_UPDATER,
NULL);
peas_extension_set_foreach (set,
ide_primary_workspace_actions_update_dependencies_cb,
task);
if (state->n_active == 0)
ide_task_return_boolean (task, TRUE);
}
static void
ide_editor_surface_actions_new_file (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
IdeEditorSurface *self = user_data;
IdeBufferManager *bufmgr;
IdeContext *context;
g_assert (G_IS_SIMPLE_ACTION (action));
g_assert (IDE_IS_EDITOR_SURFACE (self));
context = ide_widget_get_context (GTK_WIDGET (self));
bufmgr = ide_buffer_manager_from_context (context);
ide_buffer_manager_load_file_async (bufmgr,
NULL,
IDE_BUFFER_OPEN_FLAGS_NONE,
NULL,
NULL,
NULL,
NULL);
}
static void
ide_omni_bar_next_message (IdeOmniBar *self)
{
IdeBuildManager *build_manager;
const gchar *name;
IdeContext *context;
g_assert (IDE_IS_OMNI_BAR (self));
if (NULL == (context = ide_widget_get_context (GTK_WIDGET (self))))
return;
build_manager = ide_context_get_build_manager (context);
name = gtk_stack_get_visible_child_name (self->message_stack);
/*
* TODO: This isn't the cleanest way to do this.
* We need to come up with a strategy for moving between these
* in a way that has a "check" function to determine if we can
* toggle to the next child.
*/
if (g_strcmp0 (name, "config") == 0)
{
/* Only rotate to build result if we have one and we haven't
* flapped too many times.
*/
if (self->did_build && self->seen_count < 2)
gtk_stack_set_visible_child_name (self->message_stack, "build");
}
else if (!ide_build_manager_get_busy (build_manager))
{
self->seen_count++;
gtk_stack_set_visible_child_name (self->message_stack, "config");
}
}
static void
ide_debugger_editor_addin_load (IdeEditorAddin *addin,
IdeEditorSurface *editor)
{
IdeDebuggerEditorAddin *self = (IdeDebuggerEditorAddin *)addin;
IdeContext *context;
IdeRunManager *run_manager;
IdeDebugManager *debug_manager;
IDE_ENTRY;
g_assert (IDE_IS_DEBUGGER_EDITOR_ADDIN (self));
g_assert (IDE_IS_EDITOR_SURFACE (editor));
self->editor = editor;
self->workbench = ide_widget_get_workbench (GTK_WIDGET (editor));
if (!ide_workbench_has_project (self->workbench))
return;
context = ide_widget_get_context (GTK_WIDGET (editor));
run_manager = ide_run_manager_from_context (context);
debug_manager = ide_debug_manager_from_context (context);
ide_debugger_editor_addin_add_ui (self);
ide_run_manager_add_handler (run_manager,
"debugger",
_("Run with Debugger"),
"builder-debugger-symbolic",
"F5",
debugger_run_handler,
g_object_ref (self),
g_object_unref);
self->debugger_signals = dzl_signal_group_new (IDE_TYPE_DEBUGGER);
dzl_signal_group_connect_swapped (self->debugger_signals,
"log",
G_CALLBACK (debugger_log),
self);
dzl_signal_group_connect_swapped (self->debugger_signals,
"stopped",
G_CALLBACK (debugger_stopped),
self);
self->debug_manager_signals = dzl_signal_group_new (IDE_TYPE_DEBUG_MANAGER);
dzl_signal_group_connect_swapped (self->debug_manager_signals,
"notify::active",
G_CALLBACK (debug_manager_notify_active),
self);
dzl_signal_group_connect_swapped (self->debug_manager_signals,
"notify::debugger",
G_CALLBACK (debug_manager_notify_debugger),
self);
dzl_signal_group_set_target (self->debug_manager_signals, debug_manager);
IDE_EXIT;
}
