static void
gb_editor_view_actions_reload_buffer (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
GbEditorView *self = user_data;
IdeContext *context;
IdeBufferManager *buffer_manager;
IdeFile *file;
g_autoptr(IdeProgress) progress = NULL;
g_assert (GB_IS_EDITOR_VIEW (self));
context = ide_buffer_get_context (IDE_BUFFER (self->document));
file = ide_buffer_get_file (IDE_BUFFER (self->document));
buffer_manager = ide_context_get_buffer_manager (context);
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (self->progress_bar), 0.0);
gtk_widget_show (GTK_WIDGET (self->progress_bar));
ide_buffer_manager_load_file_async (buffer_manager,
file,
TRUE,
&progress,
NULL,
gb_editor_view_actions_reload_buffer_cb,
g_object_ref (self));
g_object_bind_property (progress, "fraction", self->progress_bar, "fraction",
G_BINDING_SYNC_CREATE);
}
static gboolean
gb_color_picker_document_monitor_queue_oper_cb (gpointer data)
{
QueuedColorize *qc = data;
g_assert (qc != NULL);
g_assert (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (qc->self));
g_assert (GTK_IS_TEXT_MARK (qc->begin));
g_assert (GTK_IS_TEXT_MARK (qc->end));
g_assert (GTK_TEXT_BUFFER (qc->buffer));
block_signals (qc->self, IDE_BUFFER (qc->buffer));
if (qc->buffer != NULL)
{
GtkTextIter begin;
GtkTextIter end;
gtk_text_buffer_get_iter_at_mark (qc->buffer, &begin, qc->begin);
gtk_text_buffer_get_iter_at_mark (qc->buffer, &end, qc->end);
if (qc->uncolorize)
gb_color_picker_document_monitor_uncolorize (qc->self, qc->buffer, &begin, &end);
else
gb_color_picker_document_monitor_colorize (qc->self, qc->buffer, &begin, &end);
gtk_text_buffer_delete_mark (qc->buffer, qc->begin);
gtk_text_buffer_delete_mark (qc->buffer, qc->end);
}
unblock_signals (qc->self, IDE_BUFFER (qc->buffer));
return G_SOURCE_REMOVE;
}
/**
* ide_editor_frame_get_document:
*
* Gets the #IdeEditorFrame:document property.
*
* Returns: (transfer none) (nullable): An #IdeBuffer or %NULL.
*/
IdeBuffer *
ide_editor_frame_get_document (IdeEditorFrame *self)
{
GtkTextBuffer *buffer;
g_return_val_if_fail (IDE_IS_EDITOR_FRAME (self), NULL);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->source_view));
return IDE_IS_BUFFER (buffer) ? IDE_BUFFER (buffer) : NULL;
}
static void
ide_editor_view_actions_find_other_file (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeEditorView *self = user_data;
IdeFile *file;
g_assert (IDE_IS_EDITOR_VIEW (self));
file = ide_buffer_get_file (IDE_BUFFER (self->document));
ide_file_find_other_async (file, NULL, find_other_file_cb, g_object_ref (self));
}
static void
save_temp_response (GtkWidget *widget,
gint response,
gpointer user_data)
{
g_autoptr(IdeEditorView) self = user_data;
g_autoptr(GFile) target = NULL;
g_autoptr(IdeProgress) progress = NULL;
GtkFileChooser *chooser = (GtkFileChooser *)widget;
g_assert (GTK_IS_FILE_CHOOSER (chooser));
g_assert (IDE_IS_EDITOR_VIEW (self));
switch (response)
{
case GTK_RESPONSE_OK:
target = gtk_file_chooser_get_file (chooser);
break;
case GTK_RESPONSE_CANCEL:
default:
break;
}
if (target != NULL)
{
IdeBufferManager *buffer_manager;
IdeContext *context;
IdeProject *project;
IdeBuffer *buffer = IDE_BUFFER (self->document);
g_autoptr(IdeFile) file = NULL;
context = ide_buffer_get_context (buffer);
project = ide_context_get_project (context);
buffer_manager = ide_context_get_buffer_manager (context);
file = ide_project_get_project_file (project, target);
ide_buffer_set_file (buffer, file);
ide_buffer_manager_save_file_async (buffer_manager,
buffer,
file,
&progress,
NULL,
ide_editor_view_actions__save_temp_cb,
g_object_ref (self));
}
gtk_widget_destroy (widget);
}
static GtkTextTag *
get_misspelled_tag (GbpSpellNavigator *self)
{
IdeBufferAddin *buffer_addin;
g_assert (GBP_IS_SPELL_NAVIGATOR (self));
g_assert (self->buffer != NULL);
g_assert (IDE_IS_BUFFER (self->buffer));
buffer_addin = ide_buffer_addin_find_by_module_name (IDE_BUFFER (self->buffer), "spellcheck-plugin");
if (buffer_addin != NULL)
return gbp_spell_buffer_addin_get_misspelled_tag (GBP_SPELL_BUFFER_ADDIN (buffer_addin));
return NULL;
}
static void
ide_editor_view_actions_save_as (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeEditorView *self = user_data;
IdeBuffer *buffer;
GtkWidget *suggested;
GtkWidget *toplevel;
GtkWidget *dialog;
IdeFile *file;
GFile *gfile;
g_assert (IDE_IS_EDITOR_VIEW (self));
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self));
dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
"action", GTK_FILE_CHOOSER_ACTION_SAVE,
"do-overwrite-confirmation", TRUE,
"local-only", FALSE,
"modal", TRUE,
"select-multiple", FALSE,
"show-hidden", FALSE,
"transient-for", toplevel,
"title", _("Save Document As"),
NULL);
buffer = IDE_BUFFER (self->document);
file = ide_buffer_get_file (buffer);
gfile = ide_file_get_file (file);
if (gfile != NULL)
gtk_file_chooser_set_file (GTK_FILE_CHOOSER (dialog), gfile, NULL);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Cancel"), GTK_RESPONSE_CANCEL,
_("Save"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
suggested = gtk_dialog_get_widget_for_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_style_context_add_class (gtk_widget_get_style_context (suggested),
GTK_STYLE_CLASS_SUGGESTED_ACTION);
g_signal_connect (dialog, "response", G_CALLBACK (save_as_response), g_object_ref (self));
gtk_window_present (GTK_WINDOW (dialog));
}
static void
ide_line_change_gutter_renderer_begin (GtkSourceGutterRenderer *renderer,
cairo_t *cr,
GdkRectangle *bg_area,
GdkRectangle *cell_area,
GtkTextIter *begin,
GtkTextIter *end)
{
IdeLineChangeGutterRenderer *self = (IdeLineChangeGutterRenderer *)renderer;
IdeBufferChangeMonitor *monitor;
GtkTextBuffer *buffer;
GtkTextView *view;
struct {
GArray *lines;
guint begin_line;
guint end_line;
} state;
g_assert (IDE_IS_LINE_CHANGE_GUTTER_RENDERER (self));
g_assert (cr != NULL);
g_assert (bg_area != NULL);
g_assert (cell_area != NULL);
g_assert (begin != NULL);
g_assert (end != NULL);
if (!(view = gtk_source_gutter_renderer_get_view (renderer)) ||
!(buffer = gtk_text_view_get_buffer (view)) ||
!IDE_IS_BUFFER (buffer) ||
!(monitor = ide_buffer_get_change_monitor (IDE_BUFFER (buffer))))
return;
self->begin_line = state.begin_line = gtk_text_iter_get_line (begin);
state.end_line = gtk_text_iter_get_line (end);
state.lines = g_array_new (FALSE, TRUE, sizeof (LineInfo));
g_array_set_size (state.lines, state.end_line - state.begin_line + 1);
ide_buffer_change_monitor_foreach_change (monitor,
state.begin_line,
state.end_line,
populate_changes_cb,
&state);
g_clear_pointer (&self->lines, g_array_unref);
self->lines = g_steal_pointer (&state.lines);
}
static void
gb_editor_view_actions_reveal (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
GbEditorView *self = user_data;
GbWorkbench *workbench;
IdeFile *file;
GFile *gfile;
g_assert (G_IS_SIMPLE_ACTION (action));
g_assert (GB_IS_EDITOR_VIEW (self));
file = ide_buffer_get_file (IDE_BUFFER (self->document));
gfile = ide_file_get_file (file);
workbench = gb_widget_get_workbench (GTK_WIDGET (self));
gb_workbench_reveal_file (workbench, gfile);
}
static gboolean
ide_editor_frame__source_view_focus_in_event (IdeEditorFrame *self,
GdkEventKey *event,
IdeSourceView *source_view)
{
GtkTextBuffer *buffer;
g_assert (IDE_IS_EDITOR_FRAME (self));
g_assert (IDE_IS_SOURCE_VIEW (source_view));
gtk_revealer_set_reveal_child (self->search_revealer, FALSE);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view));
if (IDE_IS_BUFFER (buffer))
ide_buffer_check_for_volume_change (IDE_BUFFER (buffer));
return FALSE;
}
static void
ide_editor_view_request_documentation (IdeEditorView *self,
IdeSourceView *source_view)
{
g_autofree gchar *word = NULL;
IdeBuffer *buffer;
GtkTextMark *mark;
GtkTextIter iter;
g_assert (IDE_IS_EDITOR_VIEW (self));
g_assert (IDE_IS_SOURCE_VIEW (source_view));
buffer = IDE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)));
mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (buffer), &iter, mark);
word = ide_buffer_get_word_at_iter (buffer, &iter);
g_signal_emit (self, signals [REQUEST_DOCUMENTATION], 0, word);
}
static void
ide_editor_spell_widget_finalize (GObject *object)
{
IdeEditorSpellWidget *self = (IdeEditorSpellWidget *)object;
GspellTextView *spell_text_view;
const GspellLanguage *spell_language;
GtkTextBuffer *buffer;
if (self->check_word_timeout_id > 0)
g_source_remove (self->check_word_timeout_id);
/* Set back the view spellchecking previous state */
if (self->view != NULL)
{
spell_text_view = gspell_text_view_get_from_gtk_text_view (GTK_TEXT_VIEW (self->view));
if (self->view_spellchecker_set)
{
gspell_text_view_set_inline_spell_checking (spell_text_view, TRUE);
spell_language = gspell_checker_get_language (self->checker);
if (gspell_language_compare (self->spellchecker_language, spell_language) != 0)
gspell_checker_set_language (self->checker, self->spellchecker_language);
}
else
{
gspell_text_view_set_inline_spell_checking (spell_text_view, FALSE);
gspell_text_view_set_enable_language_menu (spell_text_view, FALSE);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->view));
ide_buffer_set_spell_checking (IDE_BUFFER (buffer), FALSE);
}
}
g_clear_object (&self->navigator);
ide_clear_weak_pointer (&self->view);
G_OBJECT_CLASS (ide_editor_spell_widget_parent_class)->finalize (object);
}
static void
ide_editor_view_actions_save (GSimpleAction *action,
GVariant *param,
gpointer user_data)
{
IdeEditorView *self = user_data;
IdeContext *context;
IdeBufferManager *buffer_manager;
IdeFile *file;
IdeProgress *progress = NULL;
IdeVcs *vcs;
GFile *workdir;
g_assert (IDE_IS_EDITOR_VIEW (self));
file = ide_buffer_get_file (IDE_BUFFER (self->document));
context = ide_buffer_get_context (IDE_BUFFER (self->document));
buffer_manager = ide_context_get_buffer_manager (context);
vcs = ide_context_get_vcs (context);
workdir = ide_vcs_get_working_directory (vcs);
if (ide_file_get_is_temporary (file))
{
GtkDialog *dialog;
GtkWidget *toplevel;
GtkWidget *suggested;
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (self));
dialog = g_object_new (GTK_TYPE_FILE_CHOOSER_DIALOG,
"action", GTK_FILE_CHOOSER_ACTION_SAVE,
"do-overwrite-confirmation", TRUE,
"local-only", FALSE,
"modal", TRUE,
"select-multiple", FALSE,
"show-hidden", FALSE,
"transient-for", toplevel,
"title", _("Save Document"),
NULL);
gtk_file_chooser_set_current_folder_file (GTK_FILE_CHOOSER (dialog), workdir, NULL);
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_("Cancel"), GTK_RESPONSE_CANCEL,
_("Save"), GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
suggested = gtk_dialog_get_widget_for_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_style_context_add_class (gtk_widget_get_style_context (suggested),
GTK_STYLE_CLASS_SUGGESTED_ACTION);
g_signal_connect (dialog, "response", G_CALLBACK (save_temp_response), g_object_ref (self));
gtk_window_present (GTK_WINDOW (dialog));
return;
}
ide_buffer_manager_save_file_async (buffer_manager,
IDE_BUFFER (self->document),
file,
&progress,
NULL,
save_file_cb,
g_object_ref (self));
g_object_bind_property (progress, "fraction", self->progress_bar, "fraction",
G_BINDING_SYNC_CREATE);
gtk_widget_show (GTK_WIDGET (self->progress_bar));
g_clear_object (&progress);
}
static void
ide_editor_spell_widget_constructed (GObject *object)
{
IdeEditorSpellWidget *self = (IdeEditorSpellWidget *)object;
GspellTextBuffer *spell_buffer;
g_assert (IDE_IS_SOURCE_VIEW (self->view));
self->buffer = IDE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->view)));
ide_buffer_set_spell_checking (self->buffer, TRUE);
self->spellchecking_status = TRUE;
spell_buffer = gspell_text_buffer_get_from_gtk_text_buffer (GTK_TEXT_BUFFER (self->buffer));
self->checker = gspell_text_buffer_get_spell_checker (spell_buffer);
ide_editor_spell_dict_set_checker (self->dict, self->checker);
self->spellchecker_language = gspell_checker_get_language (self->checker);
gspell_language_chooser_set_language (GSPELL_LANGUAGE_CHOOSER (self->language_chooser_button),
self->spellchecker_language);
g_signal_connect_swapped (self->navigator,
"notify::words-counted",
G_CALLBACK (ide_editor_spell_widget__words_counted_cb),
self);
g_signal_connect_swapped (self->word_entry,
"changed",
G_CALLBACK (ide_editor_spell_widget__word_entry_changed_cb),
self);
g_signal_connect_swapped (self->word_entry,
"populate-popup",
G_CALLBACK (ide_editor_spell_widget__populate_popup_cb),
self);
g_signal_connect_swapped (self->ignore_button,
"clicked",
G_CALLBACK (ide_editor_spell_widget__ignore_button_clicked_cb),
self);
g_signal_connect_swapped (self->ignore_all_button,
"clicked",
G_CALLBACK (ide_editor_spell_widget__ignore_all_button_clicked_cb),
self);
g_signal_connect_swapped (self->change_button,
"clicked",
G_CALLBACK (ide_editor_spell_widget__change_button_clicked_cb),
self);
g_signal_connect_swapped (self->change_all_button,
"clicked",
G_CALLBACK (ide_editor_spell_widget__change_all_button_clicked_cb),
self);
g_signal_connect_swapped (self->suggestions_box,
"row-selected",
G_CALLBACK (ide_editor_spell_widget__row_selected_cb),
self);
g_signal_connect_swapped (self->suggestions_box,
"row-activated",
G_CALLBACK (ide_editor_spell_widget__row_activated_cb),
self);
g_signal_connect_swapped (self,
"key-press-event",
G_CALLBACK (ide_editor_spell_widget__key_press_event_cb),
self);
g_signal_connect_swapped (self->highlight_switch,
"state-set",
G_CALLBACK (ide_editor_spell_widget__highlight_switch_toggled_cb),
self);
g_signal_connect_object (self->language_chooser_button,
"notify::language",
G_CALLBACK (ide_editor_spell_widget__language_notify_cb),
self,
G_CONNECT_SWAPPED);
g_signal_connect_swapped (self->dict_add_button,
"clicked",
G_CALLBACK (ide_editor_spell_widget__add_button_clicked_cb),
self);
g_signal_connect_swapped (self->dict_word_entry,
"changed",
G_CALLBACK (ide_editor_spell_widget__dict_word_entry_changed_cb),
self);
self->placeholder = gtk_label_new (NULL);
gtk_widget_set_visible (self->placeholder, TRUE);
gtk_list_box_set_placeholder (self->suggestions_box, self->placeholder);
/* Due to the change of focus between the view and the spellchecker widget,
* we need to start checking only when the widget is mapped,
* so the view can keep the selection on the first word.
*/
g_signal_connect_object (self,
"map",
G_CALLBACK (ide_editor_spell__widget_mapped_cb),
NULL,
G_CONNECT_AFTER);
g_signal_connect_swapped (self->dict,
"loaded",
G_CALLBACK (ide_editor_spell_widget__dict__loaded_cb),
self);
g_signal_connect_object (self->word_label,
"notify::label",
G_CALLBACK (ide_editor_spell_widget__word_label_notify_cb),
self,
G_CONNECT_SWAPPED);
}
static void
ide_editor_view_set_document (IdeEditorView *self,
IdeBuffer *document)
{
g_return_if_fail (IDE_IS_EDITOR_VIEW (self));
g_return_if_fail (IDE_IS_BUFFER (document));
if (g_set_object (&self->document, document))
{
if (self->frame1)
ide_editor_frame_set_document (self->frame1, document);
if (self->frame2)
ide_editor_frame_set_document (self->frame2, document);
g_settings_bind (self->settings, "style-scheme-name",
document, "style-scheme-name",
G_SETTINGS_BIND_GET);
g_settings_bind (self->settings, "highlight-matching-brackets",
document, "highlight-matching-brackets",
G_SETTINGS_BIND_GET);
g_signal_connect_object (document,
"cursor-moved",
G_CALLBACK (ide_editor_view__buffer_cursor_moved),
self,
G_CONNECT_SWAPPED);
g_object_bind_property_full (document, "language", self->tweak_button,
"label", G_BINDING_SYNC_CREATE,
language_to_string, NULL, NULL, NULL);
g_signal_connect_object (document,
"modified-changed",
G_CALLBACK (ide_editor_view__buffer_modified_changed),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (document,
"notify::title",
G_CALLBACK (ide_editor_view__buffer_notify_title),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (document,
"notify::language",
G_CALLBACK (ide_editor_view__buffer_notify_language),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (document,
"notify::changed-on-volume",
G_CALLBACK (ide_editor_view__buffer_changed_on_volume),
self,
G_CONNECT_SWAPPED);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_DOCUMENT]);
g_object_bind_property (document, "has-diagnostics",
self->warning_button, "visible",
G_BINDING_SYNC_CREATE);
ide_editor_view__buffer_notify_language (self, NULL, document);
ide_editor_view__buffer_notify_title (self, NULL, IDE_BUFFER (document));
ide_editor_view_actions_update (self);
}
}
static void
ide_editor_frame_update_ruler (IdeEditorFrame *self)
{
const gchar *mode_display_name;
const gchar *mode_name;
GtkTextBuffer *buffer;
gboolean visible = FALSE;
g_assert (IDE_IS_EDITOR_FRAME (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self->source_view));
if (!IDE_IS_BUFFER (buffer))
return;
/* update line/column text */
if (self->show_ruler)
{
g_autofree gchar *text = NULL;
guint ln = 0;
guint col = 0;
ide_source_view_get_visual_position (self->source_view, &ln, &col);
text = g_strdup_printf (_("Line %u, Column %u"), ln + 1, col + 1);
nautilus_floating_bar_set_primary_label (self->floating_bar, text);
visible = TRUE;
}
else
{
nautilus_floating_bar_set_primary_label (self->floating_bar, NULL);
}
/* update current mode */
mode_display_name = ide_source_view_get_mode_display_name (self->source_view);
gtk_label_set_label (self->mode_name_label, mode_display_name);
gtk_widget_set_visible (GTK_WIDGET (self->mode_name_label), !!mode_display_name);
if (mode_display_name != NULL)
visible = TRUE;
/*
* Update overwrite label.
*
* XXX: Hack for 3.18 to ensure we don't have "OVR Replace" in vim mode.
*/
mode_name = ide_source_view_get_mode_name (self->source_view);
if (ide_source_view_get_overwrite (self->source_view) &&
!ide_str_equal0 (mode_name, "vim-replace"))
{
gtk_widget_set_visible (GTK_WIDGET (self->overwrite_label), TRUE);
visible = TRUE;
}
else
{
gtk_widget_set_visible (GTK_WIDGET (self->overwrite_label), FALSE);
}
if (gtk_widget_get_visible (GTK_WIDGET (self->mode_name_label)))
visible = TRUE;
if (ide_buffer_get_busy (IDE_BUFFER (buffer)))
{
nautilus_floating_bar_set_show_spinner (self->floating_bar, TRUE);
visible = TRUE;
}
else
{
nautilus_floating_bar_set_show_spinner (self->floating_bar, FALSE);
}
/* we don't fade while hiding because we likely won't have
* any text labels set anyway.
*/
if (!visible && gtk_widget_get_visible (GTK_WIDGET (self->floating_bar)))
gtk_widget_hide (GTK_WIDGET (self->floating_bar));
else if (visible && !gtk_widget_get_visible (GTK_WIDGET (self->floating_bar)))
gtk_widget_show (GTK_WIDGET (self->floating_bar));
}
static void
ide_lsp_completion_provider_populate_async (IdeCompletionProvider *provider,
IdeCompletionContext *context,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
IdeLspCompletionProvider *self = (IdeLspCompletionProvider *)provider;
IdeLspCompletionProviderPrivate *priv = ide_lsp_completion_provider_get_instance_private (self);
g_autoptr(IdeTask) task = NULL;
g_autoptr(GVariant) params = NULL;
g_autofree gchar *uri = NULL;
GtkTextIter iter, end;
GtkTextBuffer *buffer;
gint line;
gint column;
IDE_ENTRY;
g_assert (IDE_IS_LSP_COMPLETION_PROVIDER (self));
g_assert (IDE_IS_COMPLETION_CONTEXT (context));
task = ide_task_new (self, cancellable, callback, user_data);
ide_task_set_source_tag (task, ide_lsp_completion_provider_populate_async);
if (priv->client == NULL)
{
ide_task_return_new_error (task,
G_IO_ERROR,
G_IO_ERROR_NOT_SUPPORTED,
"No client for completion");
IDE_EXIT;
}
ide_completion_context_get_bounds (context, &iter, &end);
g_clear_pointer (&priv->word, g_free);
priv->word = ide_completion_context_get_word (context);
buffer = ide_completion_context_get_buffer (context);
uri = ide_buffer_dup_uri (IDE_BUFFER (buffer));
line = gtk_text_iter_get_line (&iter);
column = gtk_text_iter_get_line_offset (&iter);
params = JSONRPC_MESSAGE_NEW (
"textDocument", "{",
"uri", JSONRPC_MESSAGE_PUT_STRING (uri),
"}",
"position", "{",
"line", JSONRPC_MESSAGE_PUT_INT32 (line),
"character", JSONRPC_MESSAGE_PUT_INT32 (column),
"}"
);
ide_lsp_client_call_async (priv->client,
"textDocument/completion",
params,
cancellable,
ide_lsp_completion_provider_complete_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
static void
ide_langserv_completion_provider_populate (GtkSourceCompletionProvider *provider,
GtkSourceCompletionContext *context)
{
IdeLangservCompletionProvider *self = (IdeLangservCompletionProvider *)provider;
IdeLangservCompletionProviderPrivate *priv = ide_langserv_completion_provider_get_instance_private (self);
g_autoptr(GVariant) params = NULL;
g_autoptr(GCancellable) cancellable = NULL;
g_autoptr(CompletionState) state = NULL;
g_autofree gchar *uri = NULL;
GtkTextIter iter;
IdeBuffer *buffer;
gint line;
gint column;
IDE_ENTRY;
g_assert (IDE_IS_LANGSERV_COMPLETION_PROVIDER (self));
g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context));
if (priv->client == NULL)
{
IDE_TRACE_MSG ("No client set, cannot provide proposals");
gtk_source_completion_context_add_proposals (context, provider, NULL, TRUE);
IDE_EXIT;
}
gtk_source_completion_context_get_iter (context, &iter);
buffer = IDE_BUFFER (gtk_text_iter_get_buffer (&iter));
uri = ide_buffer_get_uri (buffer);
line = gtk_text_iter_get_line (&iter);
column = gtk_text_iter_get_line_offset (&iter);
params = JSONRPC_MESSAGE_NEW (
"textDocument", "{",
"uri", JSONRPC_MESSAGE_PUT_STRING (uri),
"}",
"position", "{",
"line", JSONRPC_MESSAGE_PUT_INT32 (line),
"character", JSONRPC_MESSAGE_PUT_INT32 (column),
"}"
);
cancellable = g_cancellable_new ();
g_signal_connect_data (context,
"cancelled",
G_CALLBACK (g_cancellable_cancel),
g_object_ref (cancellable),
(GClosureNotify)g_object_unref,
G_CONNECT_SWAPPED);
state = completion_state_new (self, context);
ide_langserv_client_call_async (priv->client,
"textDocument/completion",
g_steal_pointer (¶ms),
g_steal_pointer (&cancellable),
ide_langserv_completion_provider_complete_cb,
g_steal_pointer (&state));
IDE_EXIT;
}
