gem-graph/gem-graph-client
gem-graph
/
gem-graph-client
3
0
Fork 0
Code Issues 14 Pull Requests Projects Releases Activity
gem-graph-client/libide/sourceview/ide-source-view.c

8182 lines
256 KiB
C
Raw Permalink Blame History

/* ide-source-view.c
*
* Copyright 2015-2019 Christian Hergert <christian@hergert.me>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
* SPDX-License-Identifier: GPL-3.0-or-later
*/
#define G_LOG_DOMAIN "ide-source-view"
#include "config.h"
#include <cairo-gobject.h>
#include <dazzle.h>
#include <glib/gi18n.h>
#include <libide-code.h>
#include <libide-plugins.h>
#include <libide-threading.h>
#include <stdlib.h>
#include <string.h>
#include "ide-buffer-private.h"
#include "ide-completion-private.h"
#include "ide-completion.h"
#include "ide-cursor.h"
#include "ide-hover-private.h"
#include "ide-indenter.h"
#include "ide-snippet-chunk.h"
#include "ide-snippet-context.h"
#include "ide-snippet-private.h"
#include "ide-snippet.h"
#include "ide-source-view-capture.h"
#include "ide-source-view-mode.h"
#include "ide-source-view-movements.h"
#include "ide-source-view-private.h"
#include "ide-source-view.h"
#include "ide-source-view-enums.h"
#include "ide-text-util.h"
#define INCLUDE_STATEMENTS "^#include[\\s]+[\\\"\\<][^\\s\\\"\\\'\\<\\>[:cntrl:]]+[\\\"\\>]"
#define DEFAULT_FONT_DESC "Monospace 11"
#define ANIMATION_X_GROW 50
#define ANIMATION_Y_GROW 30
#define SMALL_SCROLL_DURATION_MSEC 100
#define LARGE_SCROLL_DURATION_MSEC 250
#define FIXIT_LABEL_LEN_MAX 30
#define SCROLL_REPLAY_DELAY 1000
#define DEFAULT_OVERSCROLL_NUM_LINES 1
#define TAG_DEFINITION "action::hover-definition"
#define DEFINITION_HIGHLIGHT_MODIFIER GDK_CONTROL_MASK
#define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK)
#define _GDK_RECTANGLE_X2(rect) dzl_cairo_rectangle_x2(rect)
#define _GDK_RECTANGLE_Y2(rect) dzl_cairo_rectangle_y2(rect)
#define _GDK_RECTANGLE_CONTAINS(rect,other) dzl_cairo_rectangle_contains_rectangle(rect,other)
#define _GDK_RECTANGLE_CENTER_X(rect) dzl_cairo_rectangle_center(rect)
#define _GDK_RECTANGLE_CENTER_Y(rect) dzl_cairo_rectangle_middle(rect)
#define TRACE_RECTANGLE(name, rect) \
IDE_TRACE_MSG ("%s = Rectangle(x=%d, y=%d, width=%d, height=%d)", \
name, (rect)->x, (rect)->y, (rect)->width, (rect)->height)
#define SCROLL_X(align) \
(((align) == IDE_SOURCE_SCROLL_BOTH) || ((align) == IDE_SOURCE_SCROLL_X))
#define SCROLL_Y(align) \
(((align) == IDE_SOURCE_SCROLL_BOTH) || ((align) == IDE_SOURCE_SCROLL_Y))
typedef struct
{
IdeBuffer *buffer;
GtkCssProvider *css_provider;
PangoFontDescription *font_desc;
IdeExtensionAdapter *indenter_adapter;
IdeSourceViewCapture *capture;
gchar *display_name;
IdeSourceViewMode *mode;
GtkTextMark *scroll_mark;
GQueue *selections;
GQueue *snippets;
DzlAnimation *hadj_animation;
DzlAnimation *vadj_animation;
IdeGutter *gutter;
IdeCompletion *completion;
IdeHover *hover;
DzlBindingGroup *file_setting_bindings;
DzlSignalGroup *buffer_signals;
guint change_sequence;
guint target_line_column;
GString *command_str;
gunichar command;
gunichar modifier;
gunichar search_char;
gint count;
gunichar inner_left;
gunichar inner_right;
guint scroll_offset;
gint cached_char_height;
gint cached_char_width;
guint saved_line;
guint saved_line_column;
guint saved_selection_line;
guint saved_selection_line_column;
GdkRGBA snippet_area_background_rgba;
guint font_scale;
gint overscroll_num_lines;
guint delay_size_allocate_chainup;
GtkAllocation delay_size_allocation;
IdeLocation *definition_src_location;
GtkTextMark *definition_highlight_start_mark;
GtkTextMark *definition_highlight_end_mark;
GRegex *include_regex;
IdeCursor *cursor;
guint in_key_press;
guint auto_indent : 1;
guint completion_blocked : 1;
guint did_ctrl_opacity : 1;
guint highlight_current_line : 1;
guint in_replay_macro : 1;
guint insert_mark_cleared : 1;
guint insert_matching_brace : 1;
guint interactive_completion : 1;
guint overwrite_braces : 1;
guint recording_macro : 1;
guint scrolling_to_scroll_mark : 1;
guint show_grid_lines : 1;
guint snippet_completion : 1;
guint waiting_for_capture : 1;
guint waiting_for_symbol : 1;
guint show_line_changes : 1;
guint show_line_diagnostics : 1;
guint show_line_numbers : 1;
guint show_relative_line_numbers : 1;
} IdeSourceViewPrivate;
typedef struct
{
IdeSourceView *self;
GtkTextMark *word_start_mark;
GtkTextMark *word_end_mark;
} DefinitionHighlightData;
typedef struct
{
GPtrArray *resolvers;
IdeLocation *location;
} FindReferencesTaskData;
G_DEFINE_TYPE_WITH_PRIVATE (IdeSourceView, ide_source_view, GTK_SOURCE_TYPE_VIEW)
DZL_DEFINE_COUNTER (instances, "IdeSourceView", "Instances", "Number of IdeSourceView instances")
enum {
PROP_0,
PROP_COMPLETION_N_ROWS,
PROP_COUNT,
PROP_FILE_SETTINGS,
PROP_FONT_NAME,
PROP_FONT_DESC,
PROP_INDENTER,
PROP_INDENT_STYLE,
PROP_INSERT_MATCHING_BRACE,
PROP_INTERACTIVE_COMPLETION,
PROP_MODE_DISPLAY_NAME,
PROP_OVERWRITE_BRACES,
PROP_SCROLL_OFFSET,
PROP_SHOW_GRID_LINES,
PROP_SHOW_LINE_CHANGES,
PROP_SHOW_LINE_DIAGNOSTICS,
PROP_SHOW_RELATIVE_LINE_NUMBERS,
PROP_OVERSCROLL,
LAST_PROP,
/* These are overridden */
PROP_AUTO_INDENT,
PROP_HIGHLIGHT_CURRENT_LINE,
PROP_OVERWRITE,
PROP_SHOW_LINE_NUMBERS,
};
enum {
ACTION,
ADD_CURSOR,
APPEND_TO_COUNT,
AUTO_INDENT,
BEGIN_MACRO,
BEGIN_RENAME,
BEGIN_USER_ACTION,
CAPTURE_MODIFIER,
CLEAR_COUNT,
CLEAR_MODIFIER,
CLEAR_SEARCH,
CLEAR_SELECTION,
CLEAR_SNIPPETS,
COPY_CLIPBOARD_EXTENDED,
CYCLE_COMPLETION,
DECREASE_FONT_SIZE,
DELETE_SELECTION,
DRAW_BUBBLES,
DUPLICATE_ENTIRE_LINE,
END_MACRO,
END_USER_ACTION,
FOCUS_LOCATION,
FORMAT_SELECTION,
QUERY_CODE_ACTION,
FIND_REFERENCES,
GOTO_DEFINITION,
HIDE_COMPLETION,
INCREASE_FONT_SIZE,
INDENT_SELECTION,
INSERT_AT_CURSOR_AND_INDENT,
INSERT_MODIFIER,
JUMP,
MOVEMENT,
MOVE_ERROR,
MOVE_SEARCH,
PASTE_CLIPBOARD_EXTENDED,
POP_SELECTION,
POP_SNIPPET,
PUSH_SELECTION,
PUSH_SNIPPET,
REBUILD_HIGHLIGHT,
REINDENT,
REMOVE_CURSORS,
REPLAY_MACRO,
REQUEST_DOCUMENTATION,
RESET,
RESET_FONT_SIZE,
RESTORE_INSERT_MARK,
SAVE_COMMAND,
SAVE_INSERT_MARK,
SAVE_SEARCH_CHAR,
SELECT_INNER,
SELECT_TAG,
SELECTION_THEATRIC,
SET_MODE,
SET_OVERWRITE,
SET_SEARCH_TEXT,
SORT,
SWAP_SELECTION_BOUNDS,
LAST_SIGNAL
};
enum {
FONT_SCALE_XX_SMALL,
FONT_SCALE_X_SMALL,
FONT_SCALE_SMALL,
FONT_SCALE_NORMAL,
FONT_SCALE_LARGE,
FONT_SCALE_X_LARGE,
FONT_SCALE_XX_LARGE,
FONT_SCALE_XXX_LARGE,
LAST_FONT_SCALE
};
static GParamSpec *properties [LAST_PROP];
static guint signals [LAST_SIGNAL];
static gdouble fontScale [LAST_FONT_SCALE] = {
0.57870, 0.69444, 0.83333,
1.0,
1.2, 1.44, 1.728, 2.48832,
};
static gboolean ide_source_view_do_size_allocate_hack_cb (gpointer data);
static void ide_source_view_real_save_insert_mark (IdeSourceView *self);
static void ide_source_view_real_restore_insert_mark (IdeSourceView *self);
static void ide_source_view_real_set_mode (IdeSourceView *self,
const gchar *name,
IdeSourceViewModeType type);
static void ide_source_view_save_column (IdeSourceView *self);
static void ide_source_view_maybe_overwrite (IdeSourceView *self,
GtkTextIter *iter,
const gchar *text,
gint len);
static gpointer
get_selection_owner (IdeSourceView *self)
{
return g_object_get_data (G_OBJECT (gtk_widget_get_toplevel (GTK_WIDGET (self))),
"IDE_SOURCE_VIEW_SELECTION_OWNER");
}
static void
set_selection_owner (IdeSourceView *self,
gpointer tag)
{
g_object_set_data (G_OBJECT (gtk_widget_get_toplevel (GTK_WIDGET (self))),
"IDE_SOURCE_VIEW_SELECTION_OWNER", tag);
}
static void
find_references_task_data_free (FindReferencesTaskData *data)
{
g_clear_pointer (&data->resolvers, g_ptr_array_unref);
g_clear_object (&data->location);
g_slice_free (FindReferencesTaskData, data);
}
static void
block_interactive (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->completion)
ide_completion_block_interactive (priv->completion);
}
static void
unblock_interactive (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->completion != NULL)
ide_completion_unblock_interactive (priv->completion);
}
static void
ide_source_view_set_interactive_completion (IdeSourceView *self,
gboolean interactive_completion)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
interactive_completion = !!interactive_completion;
if (interactive_completion != priv->interactive_completion)
{
priv->interactive_completion = interactive_completion;
if (interactive_completion)
unblock_interactive (self);
else
block_interactive (self);
}
}
static void
definition_highlight_data_free (DefinitionHighlightData *data)
{
if (data != NULL)
{
GtkTextBuffer *buffer;
buffer = gtk_text_mark_get_buffer (data->word_start_mark);
gtk_text_buffer_delete_mark (buffer, data->word_start_mark);
gtk_text_buffer_delete_mark (buffer, data->word_end_mark);
g_clear_object (&data->self);
g_clear_object (&data->word_start_mark);
g_clear_object (&data->word_end_mark);
g_slice_free (DefinitionHighlightData, data);
}
}
G_DEFINE_AUTOPTR_CLEANUP_FUNC (DefinitionHighlightData, definition_highlight_data_free)
static gboolean
ide_source_view_can_animate (IdeSourceView *self)
{
GtkSettings *settings;
GdkScreen *screen;
gboolean can_animate = FALSE;
g_assert (IDE_IS_SOURCE_VIEW (self));
screen = gtk_widget_get_screen (GTK_WIDGET (self));
settings = gtk_settings_get_for_screen (screen);
g_object_get (settings, "gtk-enable-animations", &can_animate, NULL);
return can_animate;
}
void
_ide_source_view_set_count (IdeSourceView *self,
gint count)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
priv->count = count;
}
void
_ide_source_view_set_modifier (IdeSourceView *self,
gunichar modifier)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
priv->modifier = modifier;
if (priv->recording_macro && !priv->in_replay_macro)
ide_source_view_capture_record_modifier (priv->capture, modifier);
}
static IdeIndenter *
ide_source_view_get_indenter (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->indenter_adapter != NULL)
return ide_extension_adapter_get_extension (priv->indenter_adapter);
return NULL;
}
static void
ide_source_view_block_handlers (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
dzl_signal_group_block (priv->buffer_signals);
}
static void
ide_source_view_unblock_handlers (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
dzl_signal_group_unblock (priv->buffer_signals);
}
static void
get_rect_for_iters (GtkTextView *text_view,
const GtkTextIter *iter1,
const GtkTextIter *iter2,
GdkRectangle *rect,
GtkTextWindowType window_type)
{
GdkRectangle area;
GdkRectangle tmp;
GtkTextIter begin;
GtkTextIter end;
GtkTextIter iter;
g_assert (GTK_IS_TEXT_VIEW (text_view));
g_assert (iter1 != NULL);
g_assert (iter2 != NULL);
g_assert (rect != NULL);
g_assert (gtk_text_iter_get_buffer (iter1) == gtk_text_iter_get_buffer (iter2));
g_assert (gtk_text_view_get_buffer (text_view) == gtk_text_iter_get_buffer (iter1));
begin = *iter1;
end = *iter2;
if (gtk_text_iter_equal (&begin, &end))
{
gtk_text_view_get_iter_location (text_view, &begin, &area);
goto finish;
}
gtk_text_iter_order (&begin, &end);
if (gtk_text_iter_get_line (&begin) == gtk_text_iter_get_line (&end))
{
gtk_text_view_get_iter_location (text_view, &begin, &area);
gtk_text_view_get_iter_location (text_view, &end, &tmp);
gdk_rectangle_union (&area, &tmp, &area);
goto finish;
}
gtk_text_view_get_iter_location (text_view, &begin, &area);
iter = begin;
do
{
/* skip trailing newline */
if ((gtk_text_iter_starts_line (&iter) && gtk_text_iter_equal (&iter, &end)))
break;
gtk_text_view_get_iter_location (text_view, &iter, &tmp);
gdk_rectangle_union (&area, &tmp, &area);
gtk_text_iter_forward_to_line_end (&iter);
gtk_text_view_get_iter_location (text_view, &iter, &tmp);
gdk_rectangle_union (&area, &tmp, &area);
if (!gtk_text_iter_forward_char (&iter))
break;
}
while (gtk_text_iter_compare (&iter, &end) <= 0);
finish:
gtk_text_view_buffer_to_window_coords (text_view, window_type, area.x, area.y, &area.x, &area.y);
*rect = area;
}
static void
animate_expand (IdeSourceView *self,
const GtkTextIter *begin,
const GtkTextIter *end)
{
DzlBoxTheatric *theatric;
GtkAllocation alloc;
GdkRectangle rect = { 0 };
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (begin != NULL);
g_assert (end != NULL);
get_rect_for_iters (GTK_TEXT_VIEW (self), begin, end, &rect, GTK_TEXT_WINDOW_WIDGET);
gtk_widget_get_allocation (GTK_WIDGET (self), &alloc);
rect.height = MIN (rect.height, alloc.height - rect.y);
theatric = g_object_new (DZL_TYPE_BOX_THEATRIC,
"alpha", 0.3,
"background", "#729fcf",
"height", rect.height,
"target", self,
"width", rect.width,
"x", rect.x,
"y", rect.y,
NULL);
dzl_object_animate_full (theatric,
DZL_ANIMATION_EASE_IN_CUBIC,
250,
gtk_widget_get_frame_clock (GTK_WIDGET (self)),
g_object_unref,
theatric,
"x", rect.x - ANIMATION_X_GROW,
"width", rect.width + (ANIMATION_X_GROW * 2),
"y", rect.y - ANIMATION_Y_GROW,
"height", rect.height + (ANIMATION_Y_GROW * 2),
"alpha", 0.0,
NULL);
}
static void
animate_shrink (IdeSourceView *self,
const GtkTextIter *begin,
const GtkTextIter *end)
{
DzlBoxTheatric *theatric;
GtkAllocation alloc;
GdkRectangle rect = { 0 };
GdkRectangle char_rect = { 0 };
GtkTextIter copy_begin;
GtkTextIter copy_end;
gboolean is_whole_line;
gboolean is_single_line;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (begin);
g_assert (end);
get_rect_for_iters (GTK_TEXT_VIEW (self), begin, begin, &char_rect, GTK_TEXT_WINDOW_WIDGET);
get_rect_for_iters (GTK_TEXT_VIEW (self), begin, end, &rect, GTK_TEXT_WINDOW_WIDGET);
gtk_widget_get_allocation (GTK_WIDGET (self), &alloc);
rect.height = MIN (rect.height, alloc.height - rect.y);
copy_begin = *begin;
copy_end = *end;
gtk_text_iter_order (&copy_begin, &copy_end);
is_single_line = (gtk_text_iter_get_line (&copy_begin) == gtk_text_iter_get_line (&copy_end));
is_whole_line = ((gtk_text_iter_get_line (&copy_begin) + 1 ==
gtk_text_iter_get_line (&copy_end)) &&
(gtk_text_iter_starts_line (&copy_begin) &&
gtk_text_iter_starts_line (&copy_end)));
theatric = g_object_new (DZL_TYPE_BOX_THEATRIC,
"alpha", 0.3,
"background", "#729fcf",
"height", rect.height,
"target", self,
"width", rect.width,
"x", rect.x,
"y", rect.y,
NULL);
if (is_whole_line)
dzl_object_animate_full (theatric,
DZL_ANIMATION_EASE_OUT_QUAD,
150,
gtk_widget_get_frame_clock (GTK_WIDGET (self)),
g_object_unref,
theatric,
"x", rect.x,
"width", rect.width,
"y", rect.y,
"height", 0,
"alpha", 0.3,
NULL);
else if (is_single_line)
dzl_object_animate_full (theatric,
DZL_ANIMATION_EASE_OUT_QUAD,
150,
gtk_widget_get_frame_clock (GTK_WIDGET (self)),
g_object_unref,
theatric,
"x", rect.x,
"width", 0,
"y", rect.y,
"height", rect.height,
"alpha", 0.3,
NULL);
else
dzl_object_animate_full (theatric,
DZL_ANIMATION_EASE_OUT_QUAD,
150,
gtk_widget_get_frame_clock (GTK_WIDGET (self)),
g_object_unref,
theatric,
"x", rect.x,
"width", 0,
"y", rect.y,
"height", char_rect.height,
"alpha", 0.3,
NULL);
}
void
ide_source_view_scroll_to_insert (IdeSourceView *self)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
_ide_buffer_cancel_cursor_restore (IDE_BUFFER (buffer));
mark = gtk_text_buffer_get_insert (buffer);
ide_source_view_scroll_mark_onscreen (self, mark, TRUE, 0.5, 1.0);
IDE_EXIT;
}
static void
ide_source_view_invalidate_window (IdeSourceView *self)
{
GdkWindow *window;
g_assert (IDE_IS_SOURCE_VIEW (self));
if ((window = gtk_text_view_get_window (GTK_TEXT_VIEW (self), GTK_TEXT_WINDOW_WIDGET)))
{
gdk_window_invalidate_rect (window, NULL, TRUE);
gtk_widget_queue_draw (GTK_WIDGET (self));
}
}
static gchar *
text_iter_get_line_prefix (const GtkTextIter *iter)
{
GtkTextIter begin;
GString *str;
g_assert (iter);
gtk_text_iter_assign (&begin, iter);
gtk_text_iter_set_line_offset (&begin, 0);
str = g_string_new (NULL);
if (gtk_text_iter_compare (&begin, iter) != 0)
{
do
{
gunichar c;
c = gtk_text_iter_get_char (&begin);
switch (c)
{
case '\t':
case ' ':
g_string_append_unichar (str, c);
break;
default:
g_string_append_c (str, ' ');
break;
}
}
while (gtk_text_iter_forward_char (&begin) &&
(gtk_text_iter_compare (&begin, iter) < 0));
}
return g_string_free (str, FALSE);
}
static void
ide_source_view_update_auto_indent_override (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkSourceLanguage *language;
const gchar *lang_id = NULL;
IdeIndenter *indenter;
g_assert (IDE_IS_SOURCE_VIEW (self));
/* Update the indenter if necessary */
if (priv->auto_indent &&
priv->indenter_adapter != NULL &&
priv->buffer != NULL &&
NULL != (language = gtk_source_buffer_get_language (GTK_SOURCE_BUFFER (priv->buffer))))
lang_id = gtk_source_language_get_id (language);
if (priv->indenter_adapter != NULL)
ide_extension_adapter_set_value (priv->indenter_adapter, lang_id);
/* Fetch our indenter */
indenter = ide_source_view_get_indenter (self);
/*
* Updates our override of auto-indent from the GtkSourceView underneath us.
* Since we do our own mimicing of GtkSourceView, we always disable it. Also
* updates our mode which needs to know if we have an indenter to provide
* different CSS selectors.
*/
gtk_source_view_set_auto_indent (GTK_SOURCE_VIEW (self), FALSE);
if (priv->mode != NULL)
ide_source_view_mode_set_has_indenter (priv->mode, !!indenter);
}
static void
ide_source_view_set_file_settings (IdeSourceView *self,
IdeFileSettings *file_settings)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (!file_settings || IDE_IS_FILE_SETTINGS (file_settings));
if (file_settings != ide_source_view_get_file_settings (self))
{
dzl_binding_group_set_source (priv->file_setting_bindings, file_settings);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_FILE_SETTINGS]);
}
}
static void
ide_source_view__buffer_notify_file_settings_cb (IdeSourceView *self,
GParamSpec *pspec,
IdeBuffer *buffer)
{
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
ide_source_view_set_file_settings (self, ide_buffer_get_file_settings (buffer));
}
static void
ide_source_view__buffer_notify_language_cb (IdeSourceView *self,
GParamSpec *pspec,
IdeBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
const gchar *lang_id;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
lang_id = ide_buffer_get_language_id (buffer);
/* Update the indenter, which is provided by a plugin. */
if (priv->indenter_adapter != NULL)
ide_extension_adapter_set_value (priv->indenter_adapter, lang_id);
ide_source_view_update_auto_indent_override (self);
/* Reload hover providers by language */
_ide_hover_set_language (priv->hover, lang_id);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_INDENTER]);
}
static void
ide_source_view__buffer_notify_style_scheme_cb (IdeSourceView *self,
GParamSpec *pspec,
IdeBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkSourceStyleScheme *scheme = NULL;
GtkSourceStyle *snippet_area_style = NULL;
g_autofree gchar *snippet_background = NULL;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
scheme = gtk_source_buffer_get_style_scheme (GTK_SOURCE_BUFFER (buffer));
if (scheme != NULL)
snippet_area_style = gtk_source_style_scheme_get_style (scheme, "snippet::area");
if (snippet_area_style != NULL)
g_object_get (snippet_area_style, "background", &snippet_background, NULL);
if (snippet_background == NULL ||
!gdk_rgba_parse (&priv->snippet_area_background_rgba, snippet_background))
{
gdk_rgba_parse (&priv->snippet_area_background_rgba, "#204a87");
priv->snippet_area_background_rgba.alpha = 0.1;
}
}
static void
ide_source_view__buffer_request_scroll_to_insert_cb (IdeSourceView *self,
IdeBuffer *buffer)
{
GtkTextMark *mark;
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (buffer));
gtk_text_view_scroll_mark_onscreen (GTK_TEXT_VIEW (self), mark);
}
static void
ide_source_view__buffer_changed_cb (IdeSourceView *self,
IdeBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
priv->change_sequence++;
}
static void
ide_source_view_rebuild_css (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
if (!priv->css_provider)
{
GtkStyleContext *style_context;
priv->css_provider = gtk_css_provider_new ();
style_context = gtk_widget_get_style_context (GTK_WIDGET (self));
gtk_style_context_add_provider (style_context,
GTK_STYLE_PROVIDER (priv->css_provider),
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
}
if (priv->font_desc)
{
g_autofree gchar *str = NULL;
g_autofree gchar *css = NULL;
const PangoFontDescription *font_desc = priv->font_desc;
PangoFontDescription *copy = NULL;
if (priv->font_scale != FONT_SCALE_NORMAL)
font_desc = copy = ide_source_view_get_scaled_font_desc (self);
str = dzl_pango_font_description_to_css (font_desc);
css = g_strdup_printf ("textview { %s }", str ?: "");
gtk_css_provider_load_from_data (priv->css_provider, css, -1, NULL);
if (priv->gutter != NULL)
ide_gutter_style_changed (priv->gutter);
if (priv->completion != NULL)
_ide_completion_set_font_description (priv->completion, font_desc);
g_clear_pointer (&copy, pango_font_description_free);
}
}
static void
ide_source_view_invalidate_range_mark (IdeSourceView *self,
GtkTextMark *mark_begin,
GtkTextMark *mark_end)
{
GtkTextBuffer *buffer;
GdkRectangle rect;
GtkTextIter begin;
GtkTextIter end;
GdkWindow *window;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_TEXT_MARK (mark_begin));
g_assert (GTK_IS_TEXT_MARK (mark_end));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_get_iter_at_mark (buffer, &begin, mark_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &end, mark_end);
get_rect_for_iters (GTK_TEXT_VIEW (self), &begin, &end, &rect, GTK_TEXT_WINDOW_TEXT);
window = gtk_text_view_get_window (GTK_TEXT_VIEW (self), GTK_TEXT_WINDOW_TEXT);
gdk_window_invalidate_rect (window, &rect, FALSE);
}
static void
ide_source_view__buffer_insert_text_cb (IdeSourceView *self,
GtkTextIter *iter,
gchar *text,
gint len,
GtkTextBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSnippet *snippet;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (iter != NULL);
g_assert (text != NULL);
g_assert (IDE_IS_BUFFER (buffer));
if (ide_buffer_get_loading (IDE_BUFFER (buffer)))
return;
gtk_text_buffer_begin_user_action (buffer);
if (NULL != (snippet = g_queue_peek_head (priv->snippets)))
{
ide_source_view_block_handlers (self);
ide_snippet_before_insert_text (snippet, buffer, iter, text, len);
ide_source_view_unblock_handlers (self);
}
}
static void
ide_source_view__buffer_insert_text_after_cb (IdeSourceView *self,
GtkTextIter *iter,
gchar *text,
gint len,
GtkTextBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSnippet *snippet;
GtkTextIter insert;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (iter != NULL);
g_assert (text != NULL);
g_assert (IDE_IS_BUFFER (buffer));
if (ide_buffer_get_loading (IDE_BUFFER (buffer)))
return;
if (NULL != (snippet = g_queue_peek_head (priv->snippets)))
{
GtkTextMark *begin;
GtkTextMark *end;
ide_source_view_block_handlers (self);
ide_snippet_after_insert_text (snippet, buffer, iter, text, len);
ide_source_view_unblock_handlers (self);
begin = ide_snippet_get_mark_begin (snippet);
end = ide_snippet_get_mark_end (snippet);
ide_source_view_invalidate_range_mark (self, begin, end);
}
if (priv->in_key_press)
{
/*
* If we are handling the key-press-event, we might have just inserted
* a character that indicates we should overwrite the next character.
* However, due to GtkIMContext constraints, we need to allow it to be
* inserted and then handle it here.
*/
ide_source_view_maybe_overwrite (self, iter, text, len);
}
/* Ignore multiple cursors unless we have focus */
if (gtk_widget_has_focus (GTK_WIDGET (self)))
{
gtk_text_buffer_get_iter_at_mark (buffer, &insert, gtk_text_buffer_get_insert(buffer));
if (gtk_text_iter_equal (iter, &insert))
{
ide_source_view_block_handlers (self);
ide_cursor_insert_text (priv->cursor, text, len);
ide_source_view_unblock_handlers (self);
gtk_text_buffer_get_iter_at_mark (buffer, iter, gtk_text_buffer_get_insert (buffer));
}
}
gtk_text_buffer_end_user_action (buffer);
}
static void
ide_source_view__buffer_delete_range_cb (IdeSourceView *self,
GtkTextIter *begin,
GtkTextIter *end,
GtkTextBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSnippet *snippet;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_TEXT_BUFFER (buffer));
if (NULL != (snippet = g_queue_peek_head (priv->snippets)))
{
GtkTextMark *begin_mark;
GtkTextMark *end_mark;
ide_source_view_block_handlers (self);
ide_snippet_before_delete_range (snippet, buffer, begin, end);
ide_source_view_unblock_handlers (self);
begin_mark = ide_snippet_get_mark_begin (snippet);
end_mark = ide_snippet_get_mark_end (snippet);
ide_source_view_invalidate_range_mark (self, begin_mark, end_mark);
}
IDE_EXIT;
}
static void
ide_source_view__buffer_delete_range_after_cb (IdeSourceView *self,
GtkTextIter *begin,
GtkTextIter *end,
GtkTextBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSnippet *snippet;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_TEXT_BUFFER (buffer));
ide_source_view_block_handlers (self);
if (NULL != (snippet = g_queue_peek_head (priv->snippets)))
ide_snippet_after_delete_range (snippet, buffer, begin, end);
ide_source_view_unblock_handlers (self);
IDE_EXIT;
}
static void
ide_source_view__buffer_mark_set_cb (IdeSourceView *self,
GtkTextIter *iter,
GtkTextMark *mark,
GtkTextBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSnippet *snippet;
GtkTextMark *insert;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (iter != NULL);
g_assert (GTK_IS_TEXT_MARK (mark));
g_assert (GTK_IS_TEXT_BUFFER (buffer));
insert = gtk_text_buffer_get_insert (buffer);
if (mark == insert)
{
ide_source_view_block_handlers (self);
while (NULL != (snippet = g_queue_peek_head (priv->snippets)) &&
!ide_snippet_insert_set (snippet, mark))
ide_source_view_pop_snippet (self);
ide_source_view_unblock_handlers (self);
}
#ifdef IDE_ENABLE_TRACE
if (mark == insert || mark == gtk_text_buffer_get_selection_bound (buffer))
{
GtkTextIter begin;
GtkTextIter end;
if (gtk_text_buffer_get_selection_bounds (buffer, &begin, &end))
{
gtk_text_iter_order (&begin, &end);
IDE_TRACE_MSG ("Selection is now %d:%d to %d:%d",
gtk_text_iter_get_line (&begin),
gtk_text_iter_get_line_offset (&begin),
gtk_text_iter_get_line (&end),
gtk_text_iter_get_line_offset (&end));
}
}
#endif
}
static void
ide_source_view__buffer_notify_has_selection_cb (IdeSourceView *self,
GParamSpec *pspec,
IdeBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gboolean has_selection;
has_selection = gtk_text_buffer_get_has_selection (GTK_TEXT_BUFFER (buffer));
ide_source_view_mode_set_has_selection (priv->mode, has_selection);
if (has_selection)
set_selection_owner (self, G_OBJECT (self));
else if (get_selection_owner (self) == G_OBJECT (self))
set_selection_owner (self, NULL);
}
static void
ide_source_view__buffer_line_flags_changed_cb (IdeSourceView *self,
IdeBuffer *buffer)
{
GtkSourceGutter *gutter;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
gutter = gtk_source_view_get_gutter (GTK_SOURCE_VIEW (self), GTK_TEXT_WINDOW_LEFT);
gtk_source_gutter_queue_draw (gutter);
IDE_EXIT;
}
static void
ide_source_view__buffer_loaded_cb (IdeSourceView *self,
IdeBuffer *buffer)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextMark *insert;
GtkTextIter iter;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
if (priv->completion_blocked)
{
unblock_interactive (self);
priv->completion_blocked = FALSE;
}
/* Store the line column (visual offset) so movements are correct. */
insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (buffer), &iter, insert);
priv->target_line_column = gtk_source_view_get_visual_column (GTK_SOURCE_VIEW (self), &iter);
IDE_EXIT;
}
static void
ide_source_view_set_cursor_from_name (IdeSourceView *self,
const gchar *cursor_name)
{
GdkDisplay *display;
GdkCursor *cursor;
GdkWindow *window = gtk_text_view_get_window (GTK_TEXT_VIEW (self),
GTK_TEXT_WINDOW_TEXT);
if (!window)
return;
display = gdk_window_get_display (window);
cursor = gdk_cursor_new_from_name (display, cursor_name);
gdk_window_set_cursor (window, cursor);
}
static void
ide_source_view_reset_definition_highlight (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->definition_src_location)
g_clear_object (&priv->definition_src_location);
if (priv->buffer != NULL)
{
GtkTextIter begin;
GtkTextIter end;
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (priv->buffer), &begin, &end);
gtk_text_buffer_remove_tag_by_name (GTK_TEXT_BUFFER (priv->buffer), TAG_DEFINITION, &begin, &end);
}
ide_source_view_set_cursor_from_name (self, "text");
}
static void
ide_source_view__buffer__notify_can_redo (IdeSourceView *self,
GParamSpec *pspec,
IdeBuffer *buffer)
{
GActionGroup *group;
gboolean can_redo;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
g_object_get (buffer,
"can-redo", &can_redo,
NULL);
group = gtk_widget_get_action_group (GTK_WIDGET (self), "sourceview");
dzl_widget_action_group_set_action_enabled (DZL_WIDGET_ACTION_GROUP (group), "redo", can_redo);
}
static void
ide_source_view__buffer__notify_can_undo (IdeSourceView *self,
GParamSpec *pspec,
IdeBuffer *buffer)
{
GActionGroup *group;
gboolean can_undo;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
g_object_get (buffer,
"can-undo", &can_undo,
NULL);
group = gtk_widget_get_action_group (GTK_WIDGET (self), "sourceview");
dzl_widget_action_group_set_action_enabled (DZL_WIDGET_ACTION_GROUP (group), "undo", can_undo);
}
static void
ide_source_view_bind_buffer (IdeSourceView *self,
IdeBuffer *buffer,
DzlSignalGroup *group)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_autoptr(IdeContext) context = NULL;
GtkTextMark *insert;
IdeObjectBox *box;
GtkTextIter iter;
IDE_ENTRY;
g_assert (IDE_IS_MAIN_THREAD ());
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_BUFFER (buffer));
g_assert (DZL_IS_SIGNAL_GROUP (group));
priv->buffer = buffer;
ide_source_view_reset_definition_highlight (self);
ide_buffer_hold (buffer);
if (ide_buffer_get_loading (buffer))
{
block_interactive (self);
priv->completion_blocked = TRUE;
}
context = ide_buffer_ref_context (buffer);
_ide_hover_set_context (priv->hover, context);
box = ide_object_box_from_object (G_OBJECT (buffer));
priv->indenter_adapter = ide_extension_adapter_new (IDE_OBJECT (box),
peas_engine_get_default (),
IDE_TYPE_INDENTER,
"Indenter-Languages",
NULL);
priv->cursor = g_object_new (IDE_TYPE_CURSOR,
"ide-source-view", self,
NULL);
/* Create scroll mark used by movements and our scrolling helper */
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &iter);
priv->scroll_mark = gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (buffer), NULL, &iter, TRUE);
/* Marks used for definition highlights */
priv->definition_highlight_start_mark =
gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (buffer), NULL, &iter, TRUE);
priv->definition_highlight_end_mark =
gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (buffer), NULL, &iter, TRUE);
g_object_ref (priv->definition_highlight_start_mark);
g_object_ref (priv->definition_highlight_end_mark);
ide_source_view__buffer_notify_language_cb (self, NULL, buffer);
ide_source_view__buffer_notify_file_settings_cb (self, NULL, buffer);
ide_source_view__buffer_notify_style_scheme_cb (self, NULL, buffer);
ide_source_view__buffer__notify_can_redo (self, NULL, buffer);
ide_source_view__buffer__notify_can_undo (self, NULL, buffer);
ide_source_view_real_set_mode (self, NULL, IDE_SOURCE_VIEW_MODE_TYPE_PERMANENT);
insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (buffer));
ide_source_view_scroll_mark_onscreen (self, insert, TRUE, 0.5, 0.5);
IDE_EXIT;
}
static void
ide_source_view_unbind_buffer (IdeSourceView *self,
DzlSignalGroup *group)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (DZL_IS_SIGNAL_GROUP (group));
if (priv->buffer == NULL)
IDE_EXIT;
priv->scroll_mark = NULL;
if (priv->completion_blocked)
{
unblock_interactive (self);
priv->completion_blocked = FALSE;
}
if (priv->cursor != NULL)
{
g_object_run_dispose (G_OBJECT (priv->cursor));
g_clear_object (&priv->cursor);
}
ide_clear_and_destroy_object (&priv->indenter_adapter);
g_clear_object (&priv->definition_highlight_start_mark);
g_clear_object (&priv->definition_highlight_end_mark);
ide_buffer_release (priv->buffer);
IDE_EXIT;
}
static gboolean
is_opening_char (gunichar ch)
{
switch (ch)
{
case '{':
case '(':
case '"':
case '\'':
case '[':
return TRUE;
default:
return FALSE;
}
}
static guint
count_chars_on_line (IdeSourceView *view,
gunichar expected_char,
const GtkTextIter *iter)
{
GtkTextIter cur;
guint count = 0;
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (view), 0);
g_return_val_if_fail (iter, 0);
cur = *iter;
gtk_text_iter_set_line_offset (&cur, 0);
while (!gtk_text_iter_ends_line (&cur))
{
gunichar ch;
ch = gtk_text_iter_get_char (&cur);
if (ch == '\\')
{
gtk_text_iter_forward_chars (&cur, 2);
continue;
}
count += (ch == expected_char);
gtk_text_iter_forward_char (&cur);
}
return count;
}
static gboolean
is_xmlish (const gchar *lang_id)
{
return (g_strcmp0 (lang_id, "xml") == 0) ||
(g_strcmp0 (lang_id, "html") == 0);
}
static void
ide_source_view_maybe_overwrite (IdeSourceView *self,
GtkTextIter *iter,
const gchar *text,
gint len)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextIter insert;
GtkTextIter next;
gunichar ch;
gunichar next_ch;
gunichar match;
guint count_open;
guint count_close;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (iter != NULL);
g_assert (text != NULL);
g_assert (len > 0);
/*
* Some auto-indenters will perform triggers on certain key-press that we
* would hijack by otherwise "doing nothing" during this key-press. So to
* avoid that, we actually delete the previous value and then allow this
* key-press event to continue.
*/
if (!priv->overwrite_braces)
return;
/*
* WORKAROUND:
*
* If we are inside of a snippet, then let's not do anything. It really
* messes with the position tracking. Once we can better integrate these
* things, go ahead and remove this.
*/
if (priv->snippets->length)
return;
/*
* Ignore this if it wasn't a single character insertion.
*/
if (len != 1)
return;
/*
* Short circuit if there is already a selection.
*/
buffer = gtk_text_iter_get_buffer (iter);
if (gtk_text_buffer_get_has_selection (buffer))
return;
/*
* @iter is pointing at the location we just inserted text. Since we
* know we only inserted one character, lets move past it and compare
* to see if we want to overwrite.
*/
gtk_text_buffer_get_iter_at_mark (buffer, &insert, gtk_text_buffer_get_insert (buffer));
ch = g_utf8_get_char (text);
next_ch = gtk_text_iter_get_char (&insert);
switch (ch)
{
case ')': case ']': case '}': case '"': case '\'': case ';':
if (ch == next_ch)
{
if (ch == '"' || ch == '\'')
break;
switch (ch)
{
case ']': match = '['; break;
case '}': match = '{'; break;
case ')': match = '('; break;
case '>': match = '<'; break;
default: match = 0; break;
}
count_open = count_chars_on_line (self, match, iter);
count_close = count_chars_on_line (self, ch, iter);
if (count_close != count_open)
break;
}
/* fall through */
default:
return;
}
next = insert;
gtk_text_iter_forward_char (&next);
gtk_text_buffer_delete (buffer, &insert, &next);
*iter = insert;
}
static gboolean
ide_source_view_maybe_insert_match (IdeSourceView *self,
GdkEventKey *event)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkSourceBuffer *sbuf;
GtkTextBuffer *buffer;
GtkTextMark *insert;
const gchar *lang_id;
GtkTextIter iter;
GtkTextIter prev_iter;
gunichar next_ch = 0;
gchar ch[2] = { 0 };
/*
* TODO: I think we should put this into a base class for auto
* indenters. It would make some things a lot more convenient, like
* changing which characters we won't add matching characters for.
*/
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (event);
if (priv->cursor != NULL && ide_cursor_is_enabled (priv->cursor))
return FALSE;
/*
* If we are disabled, then do nothing.
*/
if (!priv->insert_matching_brace)
return FALSE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
sbuf = GTK_SOURCE_BUFFER (buffer);
insert = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
next_ch = gtk_text_iter_get_char (&iter);
prev_iter = iter;
gtk_text_iter_backward_chars (&prev_iter, 2);
/*
* If the source language has marked this region as a string or comment,
* then do nothing.
*/
if (gtk_source_buffer_iter_has_context_class (sbuf, &prev_iter, "string") ||
gtk_source_buffer_iter_has_context_class (sbuf, &prev_iter, "comment"))
return FALSE;
switch (event->keyval)
{
case GDK_KEY_braceleft:
ch[0] = '}';
break;
case GDK_KEY_parenleft:
ch[0] = ')';
break;
case GDK_KEY_bracketleft:
ch[0] = ']';
break;
case GDK_KEY_quotedbl:
ch[0] = '"';
break;
case GDK_KEY_apostrophe:
ch[0] = '\'';
break;
case GDK_KEY_less:
if (!(lang_id = ide_buffer_get_language_id (IDE_BUFFER (buffer))) || !is_xmlish (lang_id))
return FALSE;
ch[0] = '>';
break;
#if 0
/*
* TODO: We should avoid this when we are in comments, etc. That will
* require some communication with the syntax engine.
*/
case GDK_KEY_quoteleft:
case GDK_KEY_quoteright:
ch = '\'';
break;
#endif
default:
return FALSE;
}
/*
* Insert the match if one of the following is true:
*
* - We are at EOF
* - The next character is whitespace
* - The next character is punctuation
* - The next character is not a opening brace.
* - If the char is ", then there must be an even number already on
* the current line.
*/
if (!next_ch || g_unichar_isspace (next_ch) || (g_unichar_ispunct (next_ch) && !is_opening_char (next_ch)))
{
/*
* Special case for working with double quotes.
*
* Ignore double quote if we just added enough to make there be an
* even number on this line. However, if it was the first quote on
* the line, we still need to include a second.
*/
if (ch[0] == '"' || ch[0] == '\'')
{
guint count;
count = count_chars_on_line (self, ch[0], &iter);
if ((count > 1) && ((count % 2) == 0))
return FALSE;
}
gtk_text_buffer_insert_at_cursor (buffer, ch, 1);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
gtk_text_iter_backward_char (&iter);
gtk_text_buffer_select_range (buffer, &iter, &iter);
return TRUE;
}
return FALSE;
}
static gboolean
ide_source_view_maybe_delete_match (IdeSourceView *self,
GdkEventKey *event)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextIter iter;
GtkTextIter prev;
gunichar ch;
gunichar match;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (event);
g_assert (event->keyval == GDK_KEY_BackSpace);
if (!priv->insert_matching_brace)
return FALSE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
insert = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
prev = iter;
if (!gtk_text_iter_backward_char (&prev))
return FALSE;
ch = gtk_text_iter_get_char (&prev);
switch (ch)
{
case '[': match = ']'; break;
case '{': match = '}'; break;
case '(': match = ')'; break;
case '"': match = '"'; break;
case '\'': match = '\''; break;
case '<': match = '>'; break;
default: match = 0; break;
}
if (match && (gtk_text_iter_get_char (&iter) == match))
{
gtk_text_iter_forward_char (&iter);
gtk_text_buffer_delete (buffer, &prev, &iter);
return TRUE;
}
return FALSE;
}
static void
ide_source_view_do_indent (IdeSourceView *self,
GdkEventKey *event,
IdeIndenter *indenter)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkWidget *widget = (GtkWidget *)self;
GtkTextView *text_view = (GtkTextView *)self;
GtkTextBuffer *buffer;
GtkTextMark *insert;
g_autofree gchar *indent = NULL;
GtkTextIter begin;
GtkTextIter end;
gint cursor_offset = 0;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (priv->auto_indent == TRUE);
g_assert (event);
g_assert (!indenter || IDE_IS_INDENTER (indenter));
buffer = gtk_text_view_get_buffer (text_view);
/*
* Insert into the buffer so the auto-indenter can see it. If
* GtkSourceView:auto-indent is set, then we will end up with very
* unpredictable results.
*/
GTK_WIDGET_CLASS (ide_source_view_parent_class)->key_press_event (widget, event);
/*
* Set begin and end to the position of the new insertion point.
*/
insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (priv->buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer), &begin, insert);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer), &end, insert);
/*
* Let the formatter potentially set the replacement text. If we don't have a
* formatter, use our simple formatter which tries to mimic GtkSourceView.
*/
indent = ide_indenter_format (indenter, text_view, &begin, &end, &cursor_offset, event);
if (indent != NULL)
{
/*
* Insert the indention text.
*/
gtk_text_buffer_begin_user_action (buffer);
if (!gtk_text_iter_equal (&begin, &end))
gtk_text_buffer_delete (buffer, &begin, &end);
gtk_text_buffer_insert (buffer, &begin, indent, -1);
gtk_text_buffer_end_user_action (buffer);
/*
* Make sure we stay in the visible rect.
*/
ide_source_view_scroll_mark_onscreen (self, insert, FALSE, 0, 0);
/*
* Place the cursor, as it could be somewhere within our indent text.
*/
gtk_text_buffer_get_iter_at_mark (buffer, &begin, insert);
if (cursor_offset > 0)
gtk_text_iter_forward_chars (&begin, cursor_offset);
else if (cursor_offset < 0)
gtk_text_iter_backward_chars (&begin, ABS (cursor_offset));
gtk_text_buffer_select_range (buffer, &begin, &begin);
}
IDE_EXIT;
}
static inline gboolean
compare_keys (GdkKeymap *keymap,
GdkEventKey *event,
GtkBindingEntry *binding_entry,
guint *new_keyval,
GdkModifierType *state_consumed)
{
gdk_keymap_translate_keyboard_state (keymap,
event->hardware_keycode, event->state, event->group,
new_keyval, NULL, NULL, state_consumed);
if (g_ascii_isupper (*new_keyval))
{
*new_keyval = gdk_keyval_to_lower (*new_keyval);
*state_consumed &= ~GDK_SHIFT_MASK;
}
return (*new_keyval == binding_entry->keyval &&
(event->state & ~(*state_consumed) & ALL_ACCELS_MASK) == (binding_entry->modifiers & ALL_ACCELS_MASK));
}
static gboolean
is_key_vim_binded (GtkWidget *widget,
GdkEventKey *event,
guint *new_keyval,
GdkModifierType *state_consumed)
{
GdkKeymap *keymap;
GtkBindingSet *binding_set;
GtkBindingEntry *binding_entry;
GtkStyleContext *context;
GtkStateFlags state;
GPtrArray *binding_set_array;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (IDE_SOURCE_VIEW (widget));
context = gtk_widget_get_style_context (GTK_WIDGET (priv->mode));
keymap = gdk_keymap_get_for_display (gtk_widget_get_display (widget));
state = gtk_widget_get_state_flags (GTK_WIDGET (priv->mode));
gtk_style_context_get (context, state, "gtk-key-bindings", &binding_set_array, NULL);
if (binding_set_array)
{
for (guint i = 0; i < binding_set_array->len; i++)
{
binding_set = g_ptr_array_index (binding_set_array, i);
if (g_str_has_prefix (binding_set->set_name, "builder-vim"))
{
binding_entry = binding_set->entries;
while (binding_entry)
{
if (compare_keys (keymap, event, binding_entry, new_keyval, state_consumed))
{
g_ptr_array_unref (binding_set_array);
return TRUE;
}
binding_entry = binding_entry->set_next;
}
}
}
g_ptr_array_unref (binding_set_array);
}
return FALSE;
}
static void
command_string_append_to (GString *command_str,
guint keyval,
GdkModifierType state)
{
if (state & GDK_CONTROL_MASK)
g_string_append (command_str, "<ctrl>");
if (state & GDK_SHIFT_MASK)
g_string_append (command_str, "<shift>");
if (state & GDK_MOD1_MASK)
g_string_append (command_str, "<alt>");
if ((keyval >= '!' && keyval <= '~' ) && keyval != GDK_KEY_bracketleft && keyval != GDK_KEY_bracketright)
g_string_append_c (command_str, keyval);
else if (keyval >= GDK_KEY_KP_0 && keyval <= GDK_KEY_KP_9)
g_string_append_c (command_str, keyval - GDK_KEY_KP_0 + '0');
else
{
g_string_append_c (command_str, '[');
g_string_append (command_str, gdk_keyval_name (keyval));
g_string_append_c (command_str, ']');
}
}
static gboolean
ide_source_view_do_mode (IdeSourceView *self,
GdkEventKey *event)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_autofree gchar *suggested_default = NULL;
guint new_keyval;
GdkModifierType state;
GdkModifierType state_consumed;
gboolean ret = FALSE;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->mode)
{
IdeSourceViewMode *mode;
gboolean handled;
gboolean remove = FALSE;
#ifdef IDE_ENABLE_TRACE
{
gunichar ch = 0;
gchar *name = NULL;
g_object_get (priv->mode, "name", &name, NULL);
if (event->string)
ch = g_utf8_get_char (event->string);
IDE_TRACE_MSG ("dispatching to mode \"%s\": (%s)",
name, g_unichar_isprint (ch) ? event->string : "");
g_free (name);
}
#endif
/* hold a reference incase binding changes mode */
mode = g_object_ref (priv->mode);
if (is_key_vim_binded (GTK_WIDGET (self), event, &new_keyval, &state_consumed))
{
state = event->state & ~(state_consumed);
command_string_append_to (priv->command_str, new_keyval, state);
}
/* lookup what this mode thinks our next default should be */
suggested_default = g_strdup (ide_source_view_mode_get_default_mode (priv->mode));
handled = _ide_source_view_mode_do_event (priv->mode, event, &remove);
if (remove)
{
/* only remove mode if it is still active */
if (priv->mode == mode)
g_clear_object (&priv->mode);
}
g_object_unref (mode);
if (handled)
ret = TRUE;
}
if (priv->mode == NULL)
ide_source_view_real_set_mode (self, suggested_default, IDE_SOURCE_VIEW_MODE_TYPE_PERMANENT);
g_assert (priv->mode != NULL);
if (ide_source_view_mode_get_mode_type (priv->mode) == IDE_SOURCE_VIEW_MODE_TYPE_PERMANENT)
g_string_erase (priv->command_str, 0, -1);
if (ide_source_view_mode_get_keep_mark_on_char (priv->mode))
{
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextMark *selection;
GtkTextIter insert_iter;
GtkTextIter selection_iter;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
insert = gtk_text_buffer_get_insert (buffer);
selection = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter, insert);
gtk_text_buffer_get_iter_at_mark (buffer, &selection_iter, selection);
if (gtk_text_iter_ends_line (&insert_iter) && !gtk_text_iter_starts_line (&insert_iter))
{
gtk_text_iter_backward_char (&insert_iter);
if (gtk_text_buffer_get_has_selection (buffer))
gtk_text_buffer_select_range (buffer, &insert_iter, &selection_iter);
else
gtk_text_buffer_select_range (buffer, &insert_iter, &insert_iter);
}
}
gtk_text_view_reset_cursor_blink (GTK_TEXT_VIEW (self));
return ret;
}
static gboolean
is_modifier_key (GdkEventKey *event)
{
static const guint modifier_keyvals[] = {
GDK_KEY_Shift_L, GDK_KEY_Shift_R, GDK_KEY_Shift_Lock,
GDK_KEY_Caps_Lock, GDK_KEY_ISO_Lock, GDK_KEY_Control_L,
GDK_KEY_Control_R, GDK_KEY_Meta_L, GDK_KEY_Meta_R,
GDK_KEY_Alt_L, GDK_KEY_Alt_R, GDK_KEY_Super_L, GDK_KEY_Super_R,
GDK_KEY_Hyper_L, GDK_KEY_Hyper_R, GDK_KEY_ISO_Level3_Shift,
GDK_KEY_ISO_Next_Group, GDK_KEY_ISO_Prev_Group,
GDK_KEY_ISO_First_Group, GDK_KEY_ISO_Last_Group,
GDK_KEY_Mode_switch, GDK_KEY_Num_Lock, GDK_KEY_Multi_key,
GDK_KEY_Scroll_Lock,
0
};
const guint *ac_val;
ac_val = modifier_keyvals;
while (*ac_val)
{
if (event->keyval == *ac_val++)
return TRUE;
}
return FALSE;
}
static gboolean
ide_source_view_key_press_event (GtkWidget *widget,
GdkEventKey *event)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextMark *insert;
IdeSnippet *snippet;
gboolean ret = FALSE;
guint change_sequence;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
insert = gtk_text_buffer_get_insert (buffer);
/*
* If we are waiting for input for a modifier key, dispatch it now.
*/
if (priv->waiting_for_capture)
{
if (!is_modifier_key (event))
{
guint new_keyval;
GdkModifierType state_consumed;
GdkKeymap *keymap = gdk_keymap_get_for_display (gtk_widget_get_display (widget));
_ide_source_view_set_modifier (self, gdk_keyval_to_unicode (event->keyval));
gdk_keymap_translate_keyboard_state (keymap,
event->hardware_keycode, event->state, event->group,
&new_keyval, NULL, NULL, &state_consumed);
command_string_append_to (priv->command_str, new_keyval, event->state & ~(state_consumed));
}
return TRUE;
}
/*
* If we got Control alone, with no key, and the completion window is
* visible, then request that it make itself less visible.
*/
if (event->keyval == GDK_KEY_Control_L &&
event->state == 0 &&
ide_completion_is_visible (priv->completion))
{
priv->did_ctrl_opacity = TRUE;
return GDK_EVENT_STOP;
}
priv->did_ctrl_opacity = FALSE;
/*
* Are we currently recording a macro? If so lets stash the event for later.
*/
if (priv->recording_macro)
ide_source_view_capture_record_event (priv->capture, (GdkEvent *)event,
priv->count, priv->modifier);
/*
* Check our current change sequence. If the buffer has changed during the
* key-press handler, we'll refocus our selves at the insert caret.
*/
change_sequence = priv->change_sequence;
priv->in_key_press++;
/*
* If we are in a non-default mode, dispatch the event to the mode. This allows custom
* keybindings like Emacs and Vim to be implemented using gtk-bindings CSS.
*/
if (ide_source_view_do_mode (self, event))
{
ret = TRUE;
goto cleanup;
}
/*
* Handle movement through the tab stops of the current snippet if needed.
*/
if (NULL != (snippet = g_queue_peek_head (priv->snippets)))
{
switch ((gint) event->keyval)
{
case GDK_KEY_Escape:
ide_source_view_block_handlers (self);
ide_source_view_pop_snippet (self);
ide_source_view_scroll_to_insert (self);
ide_source_view_unblock_handlers (self);
ret = TRUE;
goto cleanup;
case GDK_KEY_KP_Tab:
case GDK_KEY_Tab:
if ((event->state & GDK_SHIFT_MASK) == 0)
{
ide_source_view_block_handlers (self);
if (!ide_snippet_move_next (snippet))
ide_source_view_pop_snippet (self);
ide_completion_cancel (priv->completion);
/* TODO: ask snippet if we should auto-display completion options? */
ide_source_view_scroll_to_insert (self);
ide_source_view_unblock_handlers (self);
ret = TRUE;
goto cleanup;
}
/* Fallthrough */
case GDK_KEY_ISO_Left_Tab:
ide_source_view_block_handlers (self);
ide_snippet_move_previous (snippet);
ide_source_view_scroll_to_insert (self);
ide_source_view_unblock_handlers (self);
ret = TRUE;
goto cleanup;
default:
break;
}
}
/*
* If we are backspacing, and the next character is the matching brace,
* then we might want to delete it too.
*/
if ((event->keyval == GDK_KEY_BackSpace) && !gtk_text_buffer_get_has_selection (buffer))
{
if (ide_source_view_maybe_delete_match (self, event))
{
ret = TRUE;
goto cleanup;
}
}
/*
* If we have an auto-indenter and the event is for a trigger key, then we
* chain up to the parent class to insert the character, and then let the
* auto-indenter fix things up.
*/
if (priv->buffer != NULL &&
priv->auto_indent &&
(priv->cursor == NULL || !ide_cursor_is_enabled (priv->cursor)))
{
IdeIndenter *indenter = ide_source_view_get_indenter (self);
/*
* Indenter may be NULL and that is okay, the IdeIdenter API
* knows how to deal with that situation by emulating GtkSourceView
* indentation style.
*/
if (ide_indenter_is_trigger (indenter, event))
{
ide_source_view_do_indent (self, event, indenter);
ret = TRUE;
goto cleanup;
}
}
/*
* If repeat-with-count is set, we need to repeat the insertion multiple times.
*/
if (priv->count &&
priv->mode &&
ide_source_view_mode_get_repeat_insert_with_count (priv->mode))
{
for (gint i = MAX (1, priv->count); i > 0; i--)
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->key_press_event (widget, event);
priv->count = 0;
}
else
{
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->key_press_event (widget, event);
}
/*
* If we just inserted ({["', we might want to insert a matching close.
*/
if (ret)
ide_source_view_maybe_insert_match (self, event);
/*
* Only scroll to the insert mark if we made a change.
*/
if (priv->change_sequence != change_sequence)
ide_source_view_scroll_mark_onscreen (self, insert, FALSE, 0, 0);
cleanup:
priv->in_key_press--;
return ret;
}
static gboolean
ide_source_view_key_release_event (GtkWidget *widget,
GdkEventKey *event)
{
IdeSourceView *self = (IdeSourceView *) widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gboolean ret;
g_assert (IDE_IS_SOURCE_VIEW (self));
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->key_release_event (widget, event);
if (priv->did_ctrl_opacity)
{
IdeCompletionDisplay *display = ide_completion_get_display (priv->completion);
if (event->keyval == GDK_KEY_Control_L &&
event->state == GDK_CONTROL_MASK &&
ide_completion_is_visible (priv->completion))
{
if (gtk_widget_get_opacity (GTK_WIDGET (display)) == 1.0)
dzl_object_animate (display, DZL_ANIMATION_LINEAR, 250, NULL, "opacity", 0.1, NULL);
else
dzl_object_animate (display, DZL_ANIMATION_LINEAR, 250, NULL, "opacity", 1.0, NULL);
}
priv->did_ctrl_opacity = FALSE;
}
if (priv->definition_src_location)
ide_source_view_reset_definition_highlight (self);
return ret;
}
static gboolean
ide_source_view_process_press_on_definition (IdeSourceView *self,
GdkEventButton *event)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextView *text_view = (GtkTextView *)self;
GtkTextIter iter;
GtkTextWindowType window_type;
gint buffer_x;
gint buffer_y;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (event != NULL);
window_type = gtk_text_view_get_window_type (text_view, event->window);
gtk_text_view_window_to_buffer_coords (text_view,
window_type,
event->x,
event->y,
&buffer_x,
&buffer_y);
gtk_text_view_get_iter_at_location (text_view,
&iter,
buffer_x,
buffer_y);
if (priv->definition_src_location != NULL)
{
GtkTextIter definition_highlight_start;
GtkTextIter definition_highlight_end;
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer),
&definition_highlight_start,
priv->definition_highlight_start_mark);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer),
&definition_highlight_end,
priv->definition_highlight_end_mark);
if (gtk_text_iter_in_range (&iter, &definition_highlight_start, &definition_highlight_end))
{
g_autoptr(IdeLocation) src_location = NULL;
src_location = g_object_ref (priv->definition_src_location);
ide_source_view_reset_definition_highlight (self);
g_signal_emit (self, signals [FOCUS_LOCATION], 0, src_location);
}
ide_source_view_reset_definition_highlight (self);
return TRUE;
}
return FALSE;
}
static gboolean
ide_source_view_real_button_press_event (GtkWidget *widget,
GdkEventButton *event)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextView *text_view = (GtkTextView *)widget;
gboolean ret;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_TEXT_VIEW (text_view));
if (ide_source_view_process_press_on_definition (self, event))
return TRUE;
if (event->button == GDK_BUTTON_PRIMARY)
{
if (event->state & GDK_CONTROL_MASK)
{
if (!ide_cursor_is_enabled (priv->cursor))
ide_cursor_add_cursor (priv->cursor, IDE_CURSOR_SELECT);
}
else if (ide_cursor_is_enabled (priv->cursor))
{
ide_cursor_remove_cursors (priv->cursor);
}
}
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->button_press_event (widget, event);
/*
* Keep mark on the last character if the sourceviewmode dictates such.
*/
if (gtk_widget_has_focus (widget) &&
priv->mode &&
ide_source_view_mode_get_keep_mark_on_char (priv->mode))
{
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextMark *selection;
GtkTextIter iter;
GtkTextIter iter2;
buffer = gtk_text_view_get_buffer (text_view);
insert = gtk_text_buffer_get_insert (buffer);
selection = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
gtk_text_buffer_get_iter_at_mark (buffer, &iter2, selection);
if (gtk_text_iter_ends_line (&iter) && !gtk_text_iter_starts_line (&iter))
{
GtkTextIter prev = iter;
gtk_text_iter_backward_char (&prev);
if (gtk_text_iter_equal (&iter, &iter2))
gtk_text_buffer_select_range (buffer, &prev, &prev);
}
}
/*
* Update our target column so movements don't cause us to revert
* to the previous column.
*/
ide_source_view_save_column (self);
return ret;
}
static gboolean
ide_source_view_real_button_release_event (GtkWidget *widget,
GdkEventButton *event)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gboolean ret;
g_assert (IDE_IS_SOURCE_VIEW (self));
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->button_release_event (widget, event);
if ((event->button == GDK_BUTTON_PRIMARY) && (event->state & GDK_CONTROL_MASK))
ide_cursor_add_cursor (priv->cursor, IDE_CURSOR_SELECT);
return ret;
}
static gboolean
ide_source_get_word_from_iter (const GtkTextIter *iter,
GtkTextIter *word_start,
GtkTextIter *word_end)
{
/* Just using forward/backward to word start/end is not enough
* because _ break words when using those functions while they
* are commonly used in the same word in code */
*word_start = *iter;
*word_end = *iter;
do
{
const gunichar c = gtk_text_iter_get_char (word_end);
if (!(g_unichar_isalnum (c) || c == '_'))
break;
}
while (gtk_text_iter_forward_char (word_end));
if (gtk_text_iter_equal (word_start, word_end))
{
/* Iter is not inside a word */
return FALSE;
}
while (gtk_text_iter_backward_char (word_start))
{
const gunichar c = gtk_text_iter_get_char (word_start);
if (!(g_unichar_isalnum (c) || c == '_'))
{
gtk_text_iter_forward_char (word_start);
break;
}
}
return (!gtk_text_iter_equal (word_start, word_end));
}
static void
ide_source_view_get_definition_on_mouse_over_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(DefinitionHighlightData) data = user_data;
IdeSourceViewPrivate *priv;
IdeBuffer *buffer = (IdeBuffer *)object;
g_autoptr(IdeSymbol) symbol = NULL;
g_autoptr(GError) error = NULL;
IdeLocation *srcloc;
IdeSymbolKind kind;
IDE_ENTRY;
g_assert (data != NULL);
g_assert (IDE_IS_BUFFER (buffer));
g_assert (IDE_IS_SOURCE_VIEW (data->self));
priv = ide_source_view_get_instance_private (data->self);
priv->waiting_for_symbol = FALSE;
symbol = ide_buffer_get_symbol_at_location_finish (buffer, result, &error);
if (symbol == NULL)
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
g_warning ("%s", error->message);
IDE_EXIT;
}
/* Short circuit if the async operation completed after we closed */
if (priv->buffer == NULL)
IDE_EXIT;
kind = ide_symbol_get_kind (symbol);
srcloc = ide_symbol_get_location (symbol);
if (srcloc == NULL)
srcloc = ide_symbol_get_header_location (symbol);
if (srcloc != NULL)
{
GtkTextIter word_start;
GtkTextIter word_end;
if (priv->definition_src_location != NULL && priv->definition_src_location != srcloc)
g_clear_object (&priv->definition_src_location);
if (priv->definition_src_location == NULL)
priv->definition_src_location = g_object_ref (srcloc);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (buffer),
&word_start, data->word_start_mark);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (buffer),
&word_end, data->word_end_mark);
if (kind == IDE_SYMBOL_KIND_HEADER)
{
GtkTextIter line_start = word_start;
GtkTextIter line_end = word_end;
g_autofree gchar *line_text = NULL;
g_autoptr (GMatchInfo) matchInfo = NULL;
gtk_text_iter_set_line_offset (&line_start, 0);
gtk_text_iter_forward_to_line_end (&line_end);
line_text = gtk_text_iter_get_visible_text (&line_start,&line_end);
g_regex_match (priv->include_regex, line_text, 0, &matchInfo);
if (g_match_info_matches (matchInfo))
{
gint start_pos;
gint end_pos;
g_match_info_fetch_pos (matchInfo,
0,
&start_pos,
&end_pos);
word_start = line_start;
word_end = line_start;
gtk_text_iter_set_line_index (&word_start, start_pos);
gtk_text_iter_set_line_index (&word_end, end_pos);
}
}
gtk_text_buffer_apply_tag_by_name (GTK_TEXT_BUFFER (priv->buffer),
TAG_DEFINITION, &word_start, &word_end);
if (priv->definition_highlight_start_mark != NULL)
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (priv->buffer),
priv->definition_highlight_start_mark,
&word_start);
if (priv->definition_highlight_end_mark != NULL)
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (priv->buffer),
priv->definition_highlight_end_mark,
&word_end);
ide_source_view_set_cursor_from_name (data->self, "pointer");
}
else
ide_source_view_reset_definition_highlight (data->self);
IDE_EXIT;
}
static gboolean
ide_source_view_real_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextIter iter;
GtkTextIter start_iter;
GtkTextIter line_start_iter;
GtkTextIter end_iter;
gunichar ch;
gint buffer_x;
gint buffer_y;
GtkTextWindowType window_type;
DefinitionHighlightData *data;
gboolean word_found = FALSE;
gboolean ret;
g_assert (IDE_IS_SOURCE_VIEW (self));
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->motion_notify_event (widget, event);
if ((event->state & ALL_ACCELS_MASK) != DEFINITION_HIGHLIGHT_MODIFIER)
{
if (priv->definition_src_location)
ide_source_view_reset_definition_highlight (self);
return ret;
}
window_type = gtk_text_view_get_window_type (GTK_TEXT_VIEW (self), event->window);
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (self),
window_type,
event->x,
event->y,
&buffer_x,
&buffer_y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (self),
&iter,
buffer_x,
buffer_y);
/* Workaround about a Clang bug where <> includes are not correctly reported */
line_start_iter = iter;
gtk_text_iter_set_line_offset (&line_start_iter, 0);
if (gtk_text_iter_ends_line (&line_start_iter))
goto cleanup;
while ((ch = gtk_text_iter_get_char (&line_start_iter)) &&
g_unichar_isspace (ch) &&
gtk_text_iter_forward_char (&line_start_iter))
;
if (ch == '#')
{
g_autofree gchar *str = NULL;
GtkTextIter sharp_iter = line_start_iter;
GtkTextIter line_end_iter = iter;
gtk_text_iter_forward_char (&line_start_iter);
gtk_text_iter_forward_to_line_end (&line_end_iter);
str = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (priv->buffer), &line_start_iter, &line_end_iter, FALSE);
g_strchug (str);
if (g_str_has_prefix (str, "include"))
{
iter = start_iter = sharp_iter;
end_iter = line_end_iter;
word_found = TRUE;
}
}
if (!word_found && !ide_source_get_word_from_iter (&iter, &start_iter, &end_iter))
goto cleanup;
if (priv->definition_src_location)
{
GtkTextIter definition_highlight_start;
GtkTextIter definition_highlight_end;
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer),
&definition_highlight_start,
priv->definition_highlight_start_mark);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer),
&definition_highlight_end,
priv->definition_highlight_end_mark);
if (gtk_text_iter_equal (&definition_highlight_start, &start_iter) &&
gtk_text_iter_equal (&definition_highlight_end, &end_iter))
return ret;
ide_source_view_reset_definition_highlight (self);
}
/* Skip work if we're already active */
if (priv->waiting_for_symbol)
return ret;
priv->waiting_for_symbol = TRUE;
data = g_slice_new0 (DefinitionHighlightData);
data->self = self;
data->word_start_mark = gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (priv->buffer),
NULL, &start_iter, TRUE);
data->word_end_mark = gtk_text_buffer_create_mark (GTK_TEXT_BUFFER (priv->buffer),
NULL, &end_iter, TRUE);
g_object_ref (data->self);
g_object_ref (data->word_start_mark);
g_object_ref (data->word_end_mark);
ide_buffer_get_symbol_at_location_async (priv->buffer,
&iter,
NULL,
ide_source_view_get_definition_on_mouse_over_cb,
data);
return ret;
cleanup:
ide_source_view_reset_definition_highlight (self);
return ret;
}
static void
ide_source_view_real_add_cursor (IdeSourceView *self,
IdeCursorType type)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
ide_cursor_add_cursor (priv->cursor, type);
IDE_EXIT;
}
static void
ide_source_view_real_remove_cursors (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
ide_cursor_remove_cursors (priv->cursor);
IDE_EXIT;
}
static void
ide_source_view_real_style_updated (GtkWidget *widget)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
PangoContext *context;
PangoLayout *layout;
g_assert (IDE_IS_SOURCE_VIEW (self));
GTK_WIDGET_CLASS (ide_source_view_parent_class)->style_updated (widget);
context = gtk_widget_get_pango_context (widget);
layout = pango_layout_new (context);
pango_layout_set_text (layout, "X", 1);
pango_layout_get_pixel_size (layout, &priv->cached_char_width, &priv->cached_char_height);
g_object_unref (layout);
}
static void
ide_source_view_real_append_to_count (IdeSourceView *self,
gint digit)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
g_return_if_fail (digit >= 0);
g_return_if_fail (digit <= 9);
priv->count = (priv->count * 10) + digit;
}
static void
ide_source_view_real_capture_modifier (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
priv->waiting_for_capture = TRUE;
while ((priv->modifier == 0) && gtk_widget_has_focus (GTK_WIDGET (self)))
gtk_main_iteration ();
priv->waiting_for_capture = FALSE;
}
static void
ide_source_view_real_change_case (IdeSourceView *self,
GtkSourceChangeCaseType type)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextIter begin;
GtkTextIter end;
g_assert (IDE_IS_SOURCE_VIEW (self));
ide_cursor_remove_cursors (priv->cursor);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
if (GTK_SOURCE_IS_BUFFER (buffer))
gtk_source_buffer_change_case (GTK_SOURCE_BUFFER (buffer), type, &begin, &end);
}
static void
ide_source_view_real_clear_count (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
priv->count = 0;
}
static void
ide_source_view_real_clear_modifier (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
priv->modifier = 0;
}
static void
ide_source_view_real_clear_selection (IdeSourceView *self)
{
GtkTextView *text_view = (GtkTextView *)self;
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextIter iter;
g_assert (GTK_IS_TEXT_VIEW (text_view));
buffer = gtk_text_view_get_buffer (text_view);
insert = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
gtk_text_buffer_select_range (buffer, &iter, &iter);
ide_source_view_scroll_mark_onscreen (self, insert, FALSE, 0, 0);
}
static void
ide_source_view_real_cycle_completion (IdeSourceView *self,
GtkDirectionType direction)
{
IdeCompletion *completion;
g_assert (IDE_IS_SOURCE_VIEW (self));
completion = ide_source_view_get_completion (self);
if (!ide_completion_is_visible (completion))
{
ide_completion_show (completion);
return;
}
switch (direction)
{
case GTK_DIR_TAB_FORWARD:
case GTK_DIR_DOWN:
ide_completion_move_cursor (completion, GTK_MOVEMENT_DISPLAY_LINES, 1);
break;
case GTK_DIR_TAB_BACKWARD:
case GTK_DIR_UP:
ide_completion_move_cursor (completion, GTK_MOVEMENT_DISPLAY_LINES, -1);
break;
case GTK_DIR_LEFT:
case GTK_DIR_RIGHT:
default:
break;
}
}
static void
ide_source_view_real_delete_selection (IdeSourceView *self)
{
GtkTextView *text_view = (GtkTextView *)self;
GtkTextBuffer *buffer;
GtkTextIter begin;
GtkTextIter end;
gboolean editable;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_TEXT_VIEW (text_view));
buffer = gtk_text_view_get_buffer (text_view);
editable = gtk_text_view_get_editable (text_view);
if (!editable)
return;
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
gtk_text_iter_order (&begin, &end);
if (gtk_text_iter_is_end (&end) && gtk_text_iter_starts_line (&begin))
{
gtk_text_buffer_begin_user_action (buffer);
gtk_text_iter_backward_char (&begin);
gtk_text_buffer_delete (buffer, &begin, &end);
gtk_text_buffer_end_user_action (buffer);
}
else
{
gtk_text_buffer_delete_selection (buffer, TRUE, editable);
}
ide_source_view_save_column (self);
}
static void
ide_source_view_real_indent_selection (IdeSourceView *self,
gint level)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkSourceView *source_view = (GtkSourceView *)self;
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter selection;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
/*
* Use count to increase direction.
*/
if (priv->count && level)
level *= (gint)priv->count;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
if (level < 0)
{
for (; level < 0; level++)
{
if (gtk_text_buffer_get_selection_bounds (buffer, &iter, &selection))
gtk_source_view_unindent_lines (source_view, &iter, &selection);
}
}
else
{
for (; level > 0; level--)
{
if (gtk_text_buffer_get_selection_bounds (buffer, &iter, &selection))
gtk_source_view_indent_lines (source_view, &iter, &selection);
}
}
}
static void
ide_source_view_real_insert_modifier (IdeSourceView *self,
gboolean use_count)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
gchar str[8] = { 0 };
gint count = 1;
gint len;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (!priv->modifier)
return;
if (use_count)
count = MAX (1, priv->count);
len = g_unichar_to_utf8 (priv->modifier, str);
str [len] = '\0';
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_begin_user_action (buffer);
for (gint i = 0; i < count; i++)
gtk_text_buffer_insert_at_cursor (buffer, str, len);
gtk_text_buffer_end_user_action (buffer);
}
static void
ide_source_view_real_duplicate_entire_line (IdeSourceView *self)
{
GtkTextView *text_view = (GtkTextView *)self;
GtkTextIter begin, end;
gboolean selected;
g_autofree gchar *text = NULL;
g_autofree gchar *duplicate_line = NULL;
GtkTextMark *cursor;
GtkTextBuffer *buffer;
g_assert (GTK_IS_TEXT_VIEW (text_view));
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (text_view);
cursor = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_begin_user_action (buffer);
selected = gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
if (selected)
{
duplicate_line = gtk_text_iter_get_text (&begin, &end);
gtk_text_buffer_insert (buffer, &begin, duplicate_line, -1);
}
else
{
gtk_text_buffer_get_iter_at_mark (buffer, &begin, cursor);
end = begin;
gtk_text_iter_set_line_offset (&begin, 0);
if (!gtk_text_iter_ends_line (&end))
gtk_text_iter_forward_to_line_end (&end);
if (gtk_text_iter_get_line (&begin) == gtk_text_iter_get_line (&end))
{
text = gtk_text_iter_get_text (&begin, &end);
duplicate_line = g_strconcat (text, "\n", NULL);
gtk_text_buffer_insert (buffer, &begin, duplicate_line, -1);
}
}
gtk_text_buffer_end_user_action (buffer);
}
static void
ide_source_view_real_join_lines (IdeSourceView *self)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
GtkTextIter begin;
GtkTextIter end;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
if (!GTK_SOURCE_IS_BUFFER (buffer))
return;
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
gtk_text_iter_order (&begin, &end);
/*
* We want to leave the cursor inbetween the joined lines, so lets create an
* insert mark and delete it later after we reposition the cursor.
*/
mark = gtk_text_buffer_create_mark (buffer, NULL, &end, TRUE);
/* join lines and restore the insert mark inbetween joined lines. */
gtk_text_buffer_begin_user_action (buffer);
gtk_source_buffer_join_lines (GTK_SOURCE_BUFFER (buffer), &begin, &end);
gtk_text_buffer_get_iter_at_mark (buffer, &end, mark);
gtk_text_buffer_select_range (buffer, &end, &end);
gtk_text_buffer_end_user_action (buffer);
/* Remove our temporary mark. */
gtk_text_buffer_delete_mark (buffer, mark);
}
static void
ide_source_view_real_copy_clipboard_extended (IdeSourceView *self)
{
GtkTextView *text_view = (GtkTextView *)self;
GtkClipboard *clipboard;
GtkTextBuffer *buffer;
GtkTextIter begin, end;
g_autofree gchar *text = NULL;
g_autofree gchar *new_text = NULL;
gsize len;
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (self), GDK_SELECTION_CLIPBOARD);
buffer = gtk_text_view_get_buffer (text_view);
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
if (gtk_text_iter_is_end (&end))
{
text = gtk_text_buffer_get_text (buffer, &begin, &end, FALSE);
len = strlen (text);
new_text = g_malloc (len + 1);
memcpy (new_text, text, len);
new_text[len] = '\n';
gtk_clipboard_set_text (clipboard, new_text, len + 1);
}
else
gtk_text_buffer_copy_clipboard (buffer, clipboard);
}
static void
ide_source_view_real_paste_clipboard_extended (IdeSourceView *self,
gboolean smart_lines,
gboolean after_cursor,
gboolean place_cursor_at_original)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextView *text_view = (GtkTextView *)self;
g_autofree gchar *text = NULL;
GtkClipboard *clipboard;
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextIter iter;
guint target_line;
guint target_line_column;
/*
* NOTE:
*
* In this function, we try to improve how pasting works in GtkTextView. There are some
* semantics that make things easier by tracking the paste of an entire line versus small
* snippets of text.
*
* Basically, we are implementing something close to Vim. However that is not a strict
* requirement, just what we are starting with. In fact, the rest of the handling to be like vim
* is handled within vim.css (for example, what character to leave the insert mark on).
*/
g_assert (GTK_IS_TEXT_VIEW (text_view));
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (text_view);
insert = gtk_text_buffer_get_insert (buffer);
clipboard = gtk_widget_get_clipboard (GTK_WIDGET (self), GDK_SELECTION_CLIPBOARD);
text = gtk_clipboard_wait_for_text (clipboard);
/* Possible mismatch between the clipboard content and the utf-8 converted text
* so we set back the utf-8 text in the clipboard to be sure.
*/
gtk_clipboard_set_text (clipboard, text, -1);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
target_line = gtk_text_iter_get_line (&iter);
target_line_column = gtk_source_view_get_visual_column (GTK_SOURCE_VIEW (self), &iter);
if (priv->count == 0)
priv->count = 1;
gtk_text_buffer_begin_user_action (buffer);
for (; priv->count > 0; priv->count--)
{
/*
* If we are pasting an entire line, we don't want to paste it at the current location. We want
* to insert a new line after the current line, and then paste it there (so move the insert mark
* first).
*/
if (smart_lines && text && g_str_has_suffix (text, "\n"))
{
g_autofree gchar *trimmed = NULL;
/*
* WORKAROUND:
*
* This is a hack so that we can continue to use the paste code from within GtkTextBuffer.
*
* We needed to keep the trailing \n in the text so that we know when we are selecting whole
* lines. We also need to insert a new line manually based on the context. Furthermore, we
* need to remove the trailing line since we already added one.
*
* Terribly annoying, but the result is something that feels very nice, similar to Vim.
*/
trimmed = g_strndup (text, strlen (text) - 1);
if (after_cursor)
{
if (!gtk_text_iter_ends_line (&iter))
gtk_text_iter_forward_to_line_end (&iter);
gtk_text_buffer_select_range (buffer, &iter, &iter);
g_signal_emit_by_name (self, "insert-at-cursor", "\n");
}
else
{
gtk_text_iter_set_line_offset (&iter, 0);
gtk_text_buffer_select_range (buffer, &iter, &iter);
g_signal_emit_by_name (self, "insert-at-cursor", "\n");
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
gtk_text_iter_backward_line (&iter);
gtk_text_buffer_select_range (buffer, &iter, &iter);
}
if (!place_cursor_at_original)
{
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
target_line = gtk_text_iter_get_line (&iter);
target_line_column = gtk_source_view_get_visual_column (GTK_SOURCE_VIEW (self),
&iter);
}
gtk_clipboard_set_text (clipboard, trimmed, -1);
GTK_TEXT_VIEW_CLASS (ide_source_view_parent_class)->paste_clipboard (text_view);
gtk_clipboard_set_text (clipboard, text, -1);
}
else
{
if (after_cursor)
{
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
if (!gtk_text_iter_ends_line (&iter))
gtk_text_iter_forward_char (&iter);
gtk_text_buffer_select_range (buffer, &iter, &iter);
}
GTK_TEXT_VIEW_CLASS (ide_source_view_parent_class)->paste_clipboard (text_view);
if (!place_cursor_at_original)
{
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
target_line = gtk_text_iter_get_line (&iter);
target_line_column = gtk_source_view_get_visual_column (GTK_SOURCE_VIEW (self),
&iter);
}
}
/* Revalidate the position on our next attempt through the paste */
gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, target_line, 0);
ide_source_view_get_iter_at_visual_column (self, target_line_column, &iter);
}
gtk_text_buffer_select_range (buffer, &iter, &iter);
gtk_text_buffer_end_user_action (buffer);
if (priv->cursor != NULL)
ide_cursor_clear_highlight (priv->cursor);
}
static void
ide_source_view_real_selection_theatric (IdeSourceView *self,
IdeSourceViewTheatric theatric)
{
GtkTextBuffer *buffer;
GtkTextIter begin;
GtkTextIter end;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert ((theatric == IDE_SOURCE_VIEW_THEATRIC_EXPAND) ||
(theatric == IDE_SOURCE_VIEW_THEATRIC_SHRINK));
if (!ide_source_view_can_animate (self))
return;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
gtk_text_iter_order (&begin, &end);
if (gtk_text_iter_equal (&begin, &end))
return;
if (gtk_text_iter_starts_line (&end))
gtk_text_iter_backward_char (&end);
switch (theatric)
{
case IDE_SOURCE_VIEW_THEATRIC_EXPAND:
animate_expand (self, &begin, &end);
break;
case IDE_SOURCE_VIEW_THEATRIC_SHRINK:
animate_shrink (self, &begin, &end);
break;
default:
break;
}
}
static void
ide_source_view_save_column (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextView *text_view = (GtkTextView *)self;
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextIter iter;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (text_view);
insert = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
priv->target_line_column = ide_source_view_get_visual_column (self, &iter);
}
static void
ide_source_view_update_display_name (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
const gchar *display_name = NULL;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->mode != NULL)
display_name = ide_source_view_mode_get_display_name (priv->mode);
if (g_strcmp0 (display_name, priv->display_name) != 0)
{
g_free (priv->display_name);
priv->display_name = g_strdup (display_name);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_MODE_DISPLAY_NAME]);
}
}
static void
ide_source_view_real_set_mode (IdeSourceView *self,
const gchar *mode,
IdeSourceViewModeType type)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_autofree gchar *suggested_default = NULL;
gboolean overwrite;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (!priv->buffer)
IDE_EXIT;
#ifdef IDE_ENABLE_TRACE
{
const gchar *old_mode = "null";
if (priv->mode)
old_mode = ide_source_view_mode_get_name (priv->mode);
IDE_TRACE_MSG ("transition from mode (%s) to (%s)", old_mode, mode ?: "<default>");
}
#endif
ide_source_view_save_column (self);
if (priv->mode)
{
IdeSourceViewMode *old_mode = g_object_ref (priv->mode);
const gchar *str;
/* see if this mode suggested a default next mode */
str = ide_source_view_mode_get_default_mode (old_mode);
suggested_default = g_strdup (str);
g_clear_object (&priv->mode);
g_object_unref (old_mode);
}
if (mode == NULL)
{
mode = suggested_default ?: "default";
type = IDE_SOURCE_VIEW_MODE_TYPE_PERMANENT;
}
/* reset the count when switching to permanent mode */
if (type == IDE_SOURCE_VIEW_MODE_TYPE_PERMANENT)
priv->count = 0;
priv->mode = _ide_source_view_mode_new (GTK_WIDGET (self), mode, type);
overwrite = ide_source_view_mode_get_block_cursor (priv->mode);
if (overwrite != gtk_text_view_get_overwrite (GTK_TEXT_VIEW (self)))
gtk_text_view_set_overwrite (GTK_TEXT_VIEW (self), overwrite);
g_object_notify (G_OBJECT (self), "overwrite");
ide_source_view_update_auto_indent_override (self);
ide_source_view_update_display_name (self);
IDE_EXIT;
}
static void
ide_source_view_real_set_overwrite (IdeSourceView *self,
gboolean overwrite)
{
g_assert (IDE_IS_SOURCE_VIEW (self));
IDE_TRACE_MSG ("Setting overwrite to %s", overwrite ? "TRUE" : "FALSE");
gtk_text_view_set_overwrite (GTK_TEXT_VIEW (self), overwrite);
}
static void
ide_source_view_real_swap_selection_bounds (IdeSourceView *self)
{
GtkTextBuffer *buffer;
GtkTextIter insert;
GtkTextIter selection_bound;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_get_selection_bounds (buffer, &insert, &selection_bound);
gtk_text_buffer_select_range (buffer, &selection_bound, &insert);
}
static void
ide_source_view_real_movement (IdeSourceView *self,
IdeSourceViewMovement movement,
gboolean extend_selection,
gboolean exclusive,
gboolean apply_count)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gint count = -1;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (apply_count)
count = priv->count;
if (priv->scrolling_to_scroll_mark)
priv->scrolling_to_scroll_mark = FALSE;
_ide_source_view_apply_movement (self,
movement,
extend_selection,
exclusive,
count,
priv->command_str,
priv->command,
priv->modifier,
priv->search_char,
&priv->target_line_column);
}
static void
ide_source_view_real_move_error (IdeSourceView *self,
GtkDirectionType dir)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeDiagnostics *diagnostics;
GtkTextBuffer *buffer;
GtkTextMark *insert;
GFile *file;
GtkTextIter iter;
gboolean wrap_around = TRUE;
gboolean (*movement) (GtkTextIter *) = NULL;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (!priv->buffer)
return;
if (!(diagnostics = ide_buffer_get_diagnostics (priv->buffer)))
return;
file = ide_buffer_get_file (priv->buffer);
if (dir == GTK_DIR_RIGHT)
dir = GTK_DIR_DOWN;
else if (dir == GTK_DIR_LEFT)
dir = GTK_DIR_UP;
/*
* TODO: This is not particularly very efficient. But I didn't feel like
* plumbing access to the diagnostics set and duplicating most of
* the code for getting a diagnostic at a line. Once the diagnostics
* get support for fast lookups (bloom filter or something) then
* we should change to that.
*/
if (dir == GTK_DIR_DOWN)
movement = gtk_text_iter_forward_line;
else
movement = gtk_text_iter_backward_line;
buffer = GTK_TEXT_BUFFER (priv->buffer);
insert = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
wrapped:
while (movement (&iter))
{
IdeDiagnostic *diag;
guint line = gtk_text_iter_get_line (&iter);
if ((diag = ide_diagnostics_get_diagnostic_at_line (diagnostics, file, line)))
{
IdeLocation *location;
location = ide_diagnostic_get_location (diag);
if (location)
{
guint line_offset;
line_offset = ide_location_get_line_offset (location);
gtk_text_iter_set_line_offset (&iter, 0);
for (; line_offset; line_offset--)
if (gtk_text_iter_ends_line (&iter) || !gtk_text_iter_forward_char (&iter))
break;
gtk_text_buffer_select_range (buffer, &iter, &iter);
ide_source_view_scroll_mark_onscreen (self, insert, TRUE, 0.5, 0.5);
return;
}
break;
}
}
if (wrap_around)
{
if (dir == GTK_DIR_DOWN)
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (priv->buffer), &iter);
else
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (priv->buffer), &iter);
wrap_around = FALSE;
goto wrapped;
}
}
static gboolean
is_same_range (GtkTextIter *new_start,
GtkTextIter *old_start,
GtkTextIter *new_sel,
GtkTextIter *old_sel)
{
if (gtk_text_iter_equal (new_start, old_start))
return gtk_text_iter_equal (old_sel, new_sel);
if (gtk_text_iter_equal (new_start, old_sel))
return gtk_text_iter_equal (old_start, new_sel);
return FALSE;
}
static void
ide_source_view_real_restore_insert_mark_full (IdeSourceView *self,
gboolean move_mark)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter selection;
GtkTextIter old_iter;
GtkTextIter old_selection;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->insert_mark_cleared)
{
priv->insert_mark_cleared = FALSE;
return;
}
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, priv->saved_line, 0);
ide_source_view_get_iter_at_visual_column (self, priv->saved_line_column, &iter);
gtk_text_buffer_get_iter_at_line_offset (buffer,
&selection,
priv->saved_selection_line,
0);
ide_source_view_get_iter_at_visual_column (self,
priv->saved_selection_line_column,
&selection);
gtk_text_buffer_get_selection_bounds (buffer, &old_iter, &old_selection);
if (!is_same_range (&iter, &old_iter, &selection, &old_selection))
gtk_text_buffer_select_range (buffer, &iter, &selection);
if (move_mark)
{
GtkTextMark *insert;
insert = gtk_text_buffer_get_insert (buffer);
ide_source_view_scroll_mark_onscreen (self, insert, FALSE, 0, 0);
}
}
static void
ide_source_view_real_restore_insert_mark (IdeSourceView *self)
{
ide_source_view_real_restore_insert_mark_full (self, TRUE);
}
void
_ide_source_view_clear_saved_mark (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
priv->insert_mark_cleared = TRUE;
}
static void
ide_source_view_real_save_insert_mark (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextMark *selection_bound;
GtkTextIter iter;
GtkTextIter selection;
g_assert (IDE_IS_SOURCE_VIEW (self));
priv->insert_mark_cleared = FALSE;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
insert = gtk_text_buffer_get_insert (buffer);
selection_bound = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
gtk_text_buffer_get_iter_at_mark (buffer, &selection, selection_bound);
priv->saved_line = gtk_text_iter_get_line (&iter);
priv->saved_line_column = ide_source_view_get_visual_column (self, &iter);
priv->saved_selection_line = gtk_text_iter_get_line (&selection);
priv->saved_selection_line_column = ide_source_view_get_visual_column (self, &selection);
priv->target_line_column = priv->saved_line_column;
}
static void
ide_source_view_real_save_command (IdeSourceView *self)
{
GdkEvent *event;
guint keyval;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
event = gtk_get_current_event ();
if (event && gdk_event_get_keyval (event, &keyval))
priv->command = (gunichar)keyval;
}
static void
ide_source_view_real_save_search_char (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->modifier)
priv->search_char = priv->modifier;
}
/* In string mode, the search act only on the current line,
* search a string to the right if we are not already in one,
* and only inner_left is used ( inner_right is set to it )
*/
static void
ide_source_view_real_select_inner (IdeSourceView *self,
const gchar *inner_left,
const gchar *inner_right,
gboolean exclusive,
gboolean string_mode)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gunichar unichar_inner_left;
gunichar unichar_inner_right;
g_assert (IDE_IS_SOURCE_VIEW (self));
unichar_inner_left = g_utf8_get_char (inner_left);
unichar_inner_right = g_utf8_get_char (inner_right);
_ide_source_view_select_inner (self,
unichar_inner_left,
unichar_inner_right,
priv->count,
exclusive,
string_mode);
}
static void
ide_source_view_real_select_tag (IdeSourceView *self,
gboolean exclusive)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
_ide_source_view_select_tag (self, priv->count, exclusive);
}
static void
ide_source_view_real_pop_selection (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextMark *selection_bound;
GtkTextIter insert_iter;
GtkTextIter selection_bound_iter;
gpointer *data;
g_assert (IDE_IS_SOURCE_VIEW (self));
data = g_queue_pop_head (priv->selections);
if (!data)
{
g_warning ("request to pop selection that does not exist!");
return;
}
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
insert = gtk_text_buffer_get_insert (buffer);
selection_bound = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter, data [0]);
gtk_text_buffer_get_iter_at_mark (buffer, &selection_bound_iter, data [1]);
gtk_text_buffer_move_mark (buffer, insert, &insert_iter);
gtk_text_buffer_move_mark (buffer, selection_bound, &selection_bound_iter);
gtk_text_buffer_delete_mark (buffer, data [0]);
gtk_text_buffer_delete_mark (buffer, data [1]);
g_object_unref (data [0]);
g_object_unref (data [1]);
g_free (data);
}
static void
ide_source_view_real_push_selection (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextMark *selection_bound;
GtkTextIter insert_iter;
GtkTextIter selection_bound_iter;
gpointer *data;
gboolean left_gravity;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
insert = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter, insert);
selection_bound = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &selection_bound_iter, selection_bound);
left_gravity = (gtk_text_iter_compare (&insert_iter, &selection_bound_iter) <= 0);
insert = gtk_text_buffer_create_mark (buffer, NULL, &insert_iter, left_gravity);
left_gravity = (gtk_text_iter_compare (&selection_bound_iter, &insert_iter) < 0);
selection_bound = gtk_text_buffer_create_mark (buffer, NULL, &selection_bound_iter, left_gravity);
data = g_new0 (gpointer, 2);
data [0] = g_object_ref (insert);
data [1] = g_object_ref (selection_bound);
g_queue_push_head (priv->selections, data);
}
static void
ide_source_view_real_push_snippet (IdeSourceView *self,
IdeSnippet *snippet,
const GtkTextIter *location)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_autoptr(GFile) gparentfile = NULL;
g_autoptr(IdeContext) ide_context = NULL;
IdeSnippetContext *context;
GFile *file = NULL;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (IDE_IS_SNIPPET (snippet));
g_assert (location != NULL);
context = ide_snippet_get_context (snippet);
if (priv->buffer != NULL)
{
if ((file = ide_buffer_get_file (priv->buffer)))
{
g_autofree gchar *name = NULL;
g_autofree gchar *path = NULL;
g_autofree gchar *dirname = NULL;
name = g_file_get_basename (file);
gparentfile = g_file_get_parent (file);
dirname = g_file_get_path (gparentfile);
path = g_file_get_path (file);
ide_snippet_context_add_variable (context, "filename", name);
ide_snippet_context_add_variable (context, "dirname", dirname);
ide_snippet_context_add_variable (context, "path", path);
}
if ((ide_context = ide_buffer_ref_context (priv->buffer)))
{
g_autoptr(GFile) workdir = NULL;
workdir = ide_context_ref_workdir (ide_context);
if (workdir && file)
{
g_autofree gchar *relative_path = NULL;
relative_path = g_file_get_relative_path (workdir, file);
ide_snippet_context_add_variable (context, "relative_path", relative_path);
}
if (workdir && gparentfile)
{
g_autofree gchar *relative_dirname = NULL;
relative_dirname = g_file_get_relative_path (workdir, gparentfile);
ide_snippet_context_add_variable (context, "relative_dirname", relative_dirname);
}
}
}
}
static void
ide_source_view_real_reindent (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
IdeIndenter *indenter;
GtkTextIter begin;
GtkTextIter end;
GdkWindow *window;
GtkTextIter iter;
guint i;
guint first_line;
g_autoptr(GPtrArray) lines = NULL;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->buffer == NULL)
return;
/* indenter may be NULL and that is okay */
indenter = ide_source_view_get_indenter (self);
buffer = GTK_TEXT_BUFFER (priv->buffer);
window = gtk_text_view_get_window (GTK_TEXT_VIEW (self), GTK_TEXT_WINDOW_TEXT);
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
gtk_text_iter_order (&begin, &end);
gtk_text_iter_set_line_offset (&begin, 0);
first_line = gtk_text_iter_get_line (&begin);
/* if the end position is at index 0 of the next line (common with
* line mode in vim), then move it back to the end of the previous
* line, since we don't really care about that next line.
*/
if (gtk_text_iter_starts_line (&end) &&
gtk_text_iter_get_line (&begin) != gtk_text_iter_get_line (&end))
gtk_text_iter_backward_char (&end);
if (!gtk_text_iter_ends_line (&end))
gtk_text_iter_forward_to_line_end (&end);
lines = g_ptr_array_new_with_free_func (g_free);
if (gtk_text_iter_compare (&begin, &end) == 0)
g_ptr_array_add (lines, g_strdup (""));
else
for (iter = begin;
gtk_text_iter_compare (&iter, &end) < 0;
gtk_text_iter_forward_line (&iter))
{
GtkTextIter line_end = iter;
gchar *line;
if (!gtk_text_iter_ends_line (&line_end))
gtk_text_iter_forward_to_line_end (&line_end);
line = gtk_text_iter_get_slice (&iter, &line_end);
g_ptr_array_add (lines, g_strstrip (line));
}
gtk_text_buffer_begin_user_action (buffer);
gtk_text_buffer_delete (buffer, &begin, &end);
for (i = 0; i < lines->len; i++)
{
g_autofree gchar *indent = NULL;
const gchar *line;
GdkEventKey *event;
gint cursor_offset;
line = g_ptr_array_index (lines, i);
event = dzl_gdk_synthesize_event_key (window, '\n');
indent = ide_indenter_format (indenter, GTK_TEXT_VIEW (self), &begin, &end, &cursor_offset, event);
gdk_event_free ((GdkEvent *)event);
if (indent != NULL)
{
if (!gtk_text_iter_equal (&begin, &end))
gtk_text_buffer_delete (buffer, &begin, &end);
gtk_text_buffer_insert (buffer, &begin, indent, -1);
gtk_text_buffer_insert (buffer, &begin, line, -1);
if (i != lines->len - 1)
gtk_text_buffer_insert (buffer, &begin, "\n", -1);
}
end = begin;
}
gtk_text_buffer_end_user_action (buffer);
/* Advance to first non-whitespace */
gtk_text_iter_set_line (&begin, first_line);
while (!gtk_text_iter_ends_line (&begin) &&
g_unichar_isspace (gtk_text_iter_get_char (&begin)))
gtk_text_iter_forward_char (&begin);
gtk_text_buffer_select_range (buffer, &begin, &begin);
}
static void
ide_source_view_set_overscroll_num_lines (IdeSourceView *self,
gint num_lines)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gint height;
gint new_margin;
g_assert (IDE_IS_SOURCE_VIEW (self));
priv->overscroll_num_lines = num_lines;
/* Do nothing if there is no height yet */
if (!(height = gtk_widget_get_allocated_height (GTK_WIDGET (self))))
return;
new_margin = priv->overscroll_num_lines * priv->cached_char_height;
if (new_margin < 0)
{
new_margin = height + new_margin;
if (new_margin < 0)
new_margin = height - priv->cached_char_height;
}
new_margin = CLAMP (new_margin, 0, MAX (height - priv->cached_char_height, 0));
/* ensure enough space for the overlay scrollbars and their interactive
* trough when scrolled to the end.
*/
if (new_margin < 16)
new_margin = 16;
g_object_set (self,
"bottom-margin", new_margin,
NULL);
}
static void
ide_source_view_constructed (GObject *object)
{
IdeSourceView *self = (IdeSourceView *)object;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
G_OBJECT_CLASS (ide_source_view_parent_class)->constructed (object);
_ide_source_view_init_shortcuts (self);
ide_source_view_real_set_mode (self, NULL, IDE_SOURCE_VIEW_MODE_TYPE_PERMANENT);
priv->definition_src_location = NULL;
ide_source_view_reset_definition_highlight (self);
priv->completion = _ide_completion_new (GTK_SOURCE_VIEW (self));
/* Disable sourceview completion always */
gtk_source_completion_block_interactive (gtk_source_view_get_completion (GTK_SOURCE_VIEW (self)));
/* Disable completion until focus-in-event */
block_interactive (self);
}
static void
ide_source_view_real_insert_at_cursor (GtkTextView *text_view,
const gchar *str)
{
IdeSourceView *self = (IdeSourceView *)text_view;
GtkTextBuffer *buffer;
GtkTextMark *insert;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_TEXT_VIEW (text_view));
g_assert (str);
GTK_TEXT_VIEW_CLASS (ide_source_view_parent_class)->insert_at_cursor (text_view, str);
buffer = gtk_text_view_get_buffer (text_view);
insert = gtk_text_buffer_get_insert (buffer);
ide_source_view_scroll_mark_onscreen (self, insert, FALSE, 0, 0);
}
static void
ide_source_view_real_sort (IdeSourceView *self,
gboolean ignore_case,
gboolean reverse)
{
GtkTextView *text_view = (GtkTextView *)self;
GtkTextBuffer *buffer;
GtkTextIter begin;
GtkTextIter end;
GtkSourceSortFlags sort_flags = GTK_SOURCE_SORT_FLAGS_NONE;
g_assert (GTK_TEXT_VIEW (self));
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (text_view);
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
if (gtk_text_iter_equal (&begin, &end))
gtk_text_buffer_get_bounds (buffer, &begin, &end);
if (!ignore_case)
sort_flags |= GTK_SOURCE_SORT_FLAGS_CASE_SENSITIVE;
if (reverse)
sort_flags |= GTK_SOURCE_SORT_FLAGS_REVERSE_ORDER;
gtk_source_buffer_sort_lines (GTK_SOURCE_BUFFER (buffer),
&begin,
&end,
sort_flags,
0);
}
static void
ide_source_view_draw_snippet_background (IdeSourceView *self,
cairo_t *cr,
IdeSnippet *snippet,
gint width)
{
GtkTextBuffer *buffer;
GtkTextView *text_view = (GtkTextView *)self;
GtkTextIter begin;
GtkTextIter end;
GtkTextMark *mark_begin;
GtkTextMark *mark_end;
GdkRectangle r;
g_assert (GTK_IS_TEXT_VIEW (text_view));
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (cr);
g_assert (IDE_IS_SNIPPET (snippet));
buffer = gtk_text_view_get_buffer (text_view);
mark_begin = ide_snippet_get_mark_begin (snippet);
mark_end = ide_snippet_get_mark_end (snippet);
if (!mark_begin || !mark_end)
return;
gtk_text_buffer_get_iter_at_mark (buffer, &begin, mark_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &end, mark_end);
get_rect_for_iters (text_view, &begin, &end, &r, GTK_TEXT_WINDOW_TEXT);
gtk_text_view_window_to_buffer_coords (text_view, GTK_TEXT_WINDOW_TEXT, r.x, r.y, &r.x, &r.y);
dzl_cairo_rounded_rectangle (cr, &r, 5, 5);
cairo_fill (cr);
}
static void
ide_source_view_draw_snippets_background (IdeSourceView *self,
cairo_t *cr)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextView *text_view = GTK_TEXT_VIEW (self);
GdkWindow *window;
gint width;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (cr);
window = gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT);
width = gdk_window_get_width (window);
cairo_save (cr);
gdk_cairo_set_source_rgba (cr, &priv->snippet_area_background_rgba);
for (guint i = 0; i < priv->snippets->length; i++)
{
IdeSnippet *snippet = g_queue_peek_nth (priv->snippets, i);
ide_source_view_draw_snippet_background (self,
cr,
snippet,
width - ((priv->snippets->length - i) * 10));
}
cairo_restore (cr);
}
static void
ide_source_view_real_draw_layer (GtkTextView *text_view,
GtkTextViewLayer layer,
cairo_t *cr)
{
IdeSourceView *self = (IdeSourceView *)text_view;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (GTK_IS_TEXT_VIEW (text_view));
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (cr);
GTK_TEXT_VIEW_CLASS (ide_source_view_parent_class)->draw_layer (text_view, layer, cr);
if (layer == GTK_TEXT_VIEW_LAYER_BELOW_TEXT)
{
if (priv->snippets->length)
ide_source_view_draw_snippets_background (self, cr);
if (g_signal_has_handler_pending (self, signals [DRAW_BUBBLES], 0, FALSE))
{
GdkRectangle rect;
gtk_text_view_get_visible_rect (text_view, &rect);
cairo_save (cr);
cairo_translate (cr, rect.x, rect.y);
g_signal_emit (self, signals [DRAW_BUBBLES], 0, cr);
cairo_restore (cr);
}
}
}
static gboolean
ide_source_view_focus_in_event (GtkWidget *widget,
GdkEventFocus *event)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gboolean ret;
g_assert (IDE_IS_SOURCE_VIEW (self));
/* Restore the completion window now that we have regained focus. */
unblock_interactive (self);
/* Force size allocation immediately if we have something queued. */
if (priv->delay_size_allocate_chainup)
{
g_clear_handle_id (&priv->delay_size_allocate_chainup, g_source_remove);
ide_source_view_do_size_allocate_hack_cb (self);
}
/*
* Restore the insert mark, but ignore selections (since we cant ensure they
* will stay looking selected, as the other frame could be a view into our
* own buffer).
*/
if (get_selection_owner (self) != self)
{
priv->saved_selection_line = priv->saved_line;
priv->saved_selection_line_column = priv->saved_line_column;
}
ide_source_view_real_restore_insert_mark_full (self, FALSE);
/* restore line highlight if enabled */
if (priv->highlight_current_line)
gtk_source_view_set_highlight_current_line (GTK_SOURCE_VIEW (self), TRUE);
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->focus_in_event (widget, event);
return ret;
}
static gboolean
ide_source_view_focus_out_event (GtkWidget *widget,
GdkEventFocus *event)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gboolean ret;
g_assert (IDE_IS_SOURCE_VIEW (self));
/* save our insert mark for when we focus back in. it could have moved if
* another view into the same buffer has caused the insert mark to jump.
*/
ide_source_view_real_save_insert_mark (self);
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->focus_out_event (widget, event);
/*
* Block the completion window while we are not focused. It confuses text
* insertion and such.
*/
block_interactive (self);
/* We don't want highlight-current-line unless the widget is in focus, so
* disable it until we get re-focused.
*/
gtk_source_view_set_highlight_current_line (GTK_SOURCE_VIEW (self), FALSE);
if (priv->cursor != NULL)
ide_cursor_remove_cursors (priv->cursor);
return ret;
}
static void
ide_source_view_real_begin_macro (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSourceViewModeType mode_type;
GdkEvent *event;
const gchar *mode_name;
gunichar modifier;
gint count;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->in_replay_macro)
IDE_GOTO (in_replay);
priv->recording_macro = TRUE;
mode_type = ide_source_view_mode_get_mode_type (priv->mode);
mode_name = ide_source_view_mode_get_name (priv->mode);
modifier = priv->modifier;
count = priv->count;
event = gtk_get_current_event ();
g_clear_object (&priv->capture);
priv->capture = ide_source_view_capture_new (self, mode_name, mode_type, count, modifier);
ide_source_view_capture_record_event (priv->capture, event, count, modifier);
gdk_event_free (event);
in_replay:
IDE_EXIT;
}
static void
ide_source_view_real_end_macro (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->in_replay_macro)
IDE_GOTO (in_replay);
priv->recording_macro = FALSE;
in_replay:
IDE_EXIT;
}
static void
ide_source_view_goto_definition_symbol_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(IdeSourceView) self = user_data;
g_autoptr(IdeSymbol) symbol = NULL;
IdeBuffer *buffer = (IdeBuffer *)object;
g_autoptr(GError) error = NULL;
IdeLocation *srcloc;
IDE_ENTRY;
g_assert (IDE_IS_BUFFER (buffer));
g_assert (IDE_IS_SOURCE_VIEW (self));
symbol = ide_buffer_get_symbol_at_location_finish (buffer, result, &error);
if (symbol == NULL)
{
g_warning ("%s", error->message);
IDE_EXIT;
}
srcloc = ide_symbol_get_location (symbol);
if (srcloc == NULL)
srcloc = ide_symbol_get_header_location (symbol);
if (srcloc != NULL)
{
guint line = ide_location_get_line (srcloc);
guint line_offset = ide_location_get_line_offset (srcloc);
GFile *file = ide_location_get_file (srcloc);
GFile *our_file = ide_buffer_get_file (buffer);
#ifdef IDE_ENABLE_TRACE
const gchar *filename = g_file_peek_path (file);
IDE_TRACE_MSG ("%s => %s +%u:%u",
ide_symbol_get_name (symbol),
filename, line+1, line_offset+1);
#endif
/* Stash our current position for jump-back */
ide_source_view_jump (self, NULL, NULL);
/*
* If we are navigating within this file, just stay captive instead of
* potentially allowing jumping to the file in another editor.
*/
if (g_file_equal (file, our_file))
{
GtkTextIter iter;
gtk_text_buffer_get_iter_at_line_offset (GTK_TEXT_BUFFER (buffer),
&iter, line, line_offset);
gtk_text_buffer_select_range (GTK_TEXT_BUFFER (buffer), &iter, &iter);
ide_source_view_scroll_to_insert (self);
IDE_EXIT;
}
g_signal_emit (self, signals [FOCUS_LOCATION], 0, srcloc);
}
IDE_EXIT;
}
static void
ide_source_view_real_goto_definition (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->buffer != NULL)
{
GtkTextMark *insert;
GtkTextIter iter;
insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (priv->buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer), &iter, insert);
ide_buffer_get_symbol_at_location_async (priv->buffer,
&iter,
NULL,
ide_source_view_goto_definition_symbol_cb,
g_object_ref (self));
}
}
static void
ide_source_view_real_hide_completion (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
ide_completion_hide (priv->completion);
}
static void
ide_source_view_real_replay_macro (IdeSourceView *self,
gboolean use_count)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSourceViewCapture *capture;
gint count = 1;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->recording_macro)
{
g_warning ("Cannot playback macro while recording.");
IDE_EXIT;
}
if (priv->in_replay_macro)
{
g_warning ("Cannot playback macro while playing back macro.");
IDE_EXIT;
}
if (priv->capture == NULL)
return;
if (use_count)
count = MAX (1, priv->count);
IDE_TRACE_MSG ("Replaying capture %d times.", count);
priv->in_replay_macro = TRUE;
capture = priv->capture, priv->capture = NULL;
for (gint i = 0; i < count; i++)
ide_source_view_capture_replay (capture);
g_clear_object (&priv->capture);
priv->capture = capture, capture = NULL;
priv->in_replay_macro = FALSE;
IDE_EXIT;
}
static void
ide_source_view_begin_user_action (IdeSourceView *self)
{
GtkTextBuffer *buffer;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_begin_user_action (buffer);
}
static void
ide_source_view_end_user_action (IdeSourceView *self)
{
GtkTextBuffer *buffer;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_end_user_action (buffer);
}
gboolean
ide_source_view_get_overwrite (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
if (gtk_text_view_get_overwrite (GTK_TEXT_VIEW (self)))
{
if (!priv->mode || !ide_source_view_mode_get_block_cursor (priv->mode))
return TRUE;
}
return FALSE;
}
static gchar *
ide_source_view_get_fixit_label (IdeSourceView *self,
IdeTextEdit *fixit)
{
IdeLocation *begin_loc;
IdeLocation *end_loc;
IdeRange *range;
GtkTextBuffer *buffer;
GtkTextIter begin;
GtkTextIter end;
gchar *old_text = NULL;
gchar *new_text = NULL;
gchar *tmp;
gchar *ret = NULL;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (fixit != NULL);
range = ide_text_edit_get_range (fixit);
if (range == NULL)
goto cleanup;
new_text = g_strdup (ide_text_edit_get_text (fixit));
if (new_text == NULL)
goto cleanup;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
if (!IDE_IS_BUFFER (buffer))
goto cleanup;
begin_loc = ide_range_get_begin (range);
end_loc = ide_range_get_end (range);
ide_buffer_get_iter_at_location (IDE_BUFFER (buffer), &begin, begin_loc);
ide_buffer_get_iter_at_location (IDE_BUFFER (buffer), &end, end_loc);
old_text = gtk_text_iter_get_slice (&begin, &end);
if (strlen (old_text) > FIXIT_LABEL_LEN_MAX)
{
tmp = old_text;
old_text = g_strndup (tmp, FIXIT_LABEL_LEN_MAX);
g_free (tmp);
}
if (strlen (new_text) > FIXIT_LABEL_LEN_MAX)
{
tmp = new_text;
new_text = g_strndup (tmp, FIXIT_LABEL_LEN_MAX);
g_free (tmp);
}
tmp = old_text;
old_text = g_markup_escape_text (old_text, -1);
g_free (tmp);
tmp = new_text;
new_text = g_markup_escape_text (new_text, -1);
g_free (tmp);
if (old_text [0] == '\0')
ret = g_strdup_printf (_("Insert “%s”"), new_text);
else
ret = g_strdup_printf (_("Replace “%s” with “%s”"), old_text, new_text);
cleanup:
g_free (old_text);
g_free (new_text);
return ret;
}
static void
ide_source_view__fixit_activate (IdeSourceView *self,
GtkMenuItem *menu_item)
{
IdeTextEdit *fixit;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_MENU_ITEM (menu_item));
fixit = g_object_get_data (G_OBJECT (menu_item), "IDE_FIXIT");
if (fixit != NULL)
{
IdeLocation *srcloc;
IdeRange *range;
GtkTextBuffer *buffer;
const gchar *text;
GtkTextIter begin;
GtkTextIter end;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
if (!IDE_IS_BUFFER (buffer))
return;
text = ide_text_edit_get_text (fixit);
range = ide_text_edit_get_range (fixit);
srcloc = ide_range_get_begin (range);
ide_buffer_get_iter_at_location (IDE_BUFFER (buffer), &begin, srcloc);
srcloc = ide_range_get_end (range);
ide_buffer_get_iter_at_location (IDE_BUFFER (buffer), &end, srcloc);
gtk_text_buffer_begin_user_action (buffer);
gtk_text_buffer_delete (buffer, &begin, &end);
gtk_text_buffer_insert (buffer, &begin, text, -1);
gtk_text_buffer_end_user_action (buffer);
}
}
static void
ide_source_view_real_populate_popup (GtkTextView *text_view,
GtkWidget *popup)
{
IdeSourceView *self = (IdeSourceView *)text_view;
g_autoptr(GPtrArray) line_diags = NULL;
GtkSeparatorMenuItem *sep;
IdeDiagnostics *diagnostics;
GtkTextBuffer *buffer;
GtkMenuItem *menu_item;
GtkTextMark *insert;
GtkTextIter iter;
GtkTextIter begin;
GtkTextIter end;
GMenu *model;
g_assert (GTK_IS_TEXT_VIEW (text_view));
g_assert (GTK_IS_WIDGET (popup));
GTK_TEXT_VIEW_CLASS (ide_source_view_parent_class)->populate_popup (text_view, popup);
if (!GTK_IS_MENU (popup))
return;
buffer = gtk_text_view_get_buffer (text_view);
if (!IDE_IS_BUFFER (buffer))
return;
model = dzl_application_get_menu_by_id (DZL_APPLICATION_DEFAULT, "ide-source-view-popup-menu");
gtk_menu_shell_bind_model (GTK_MENU_SHELL (popup), G_MENU_MODEL (model), NULL, TRUE);
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
/*
* TODO: I'm pretty sure we don't want to use the insert mark, but the
* location of the button-press-event (if there was one).
*/
insert = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
/*
* Check if we have a diagnostic at this position and if there are fixits associated with it.
* If so, display the "Apply TextEdit" menu item with available fixits.
*/
if ((diagnostics = ide_buffer_get_diagnostics (IDE_BUFFER (buffer))))
{
g_assert (IDE_IS_DIAGNOSTICS (diagnostics));
line_diags = ide_diagnostics_get_diagnostics_at_line (diagnostics,
ide_buffer_get_file (IDE_BUFFER (buffer)),
gtk_text_iter_get_line (&iter));
IDE_PTR_ARRAY_SET_FREE_FUNC (line_diags, g_object_unref);
}
if (line_diags != NULL)
{
for (guint j = 0; j < line_diags->len; j++)
{
IdeDiagnostic *diag = g_ptr_array_index (line_diags, j);
guint num_fixits;
num_fixits = ide_diagnostic_get_n_fixits (diag);
if (num_fixits > 0)
{
GtkWidget *parent;
GtkWidget *submenu;
guint i;
sep = g_object_new (GTK_TYPE_SEPARATOR_MENU_ITEM,
"visible", TRUE,
NULL);
gtk_menu_shell_prepend (GTK_MENU_SHELL (popup), GTK_WIDGET (sep));
submenu = gtk_menu_new ();
parent = g_object_new (GTK_TYPE_MENU_ITEM,
"label", _("Apply Fix-It"),
"submenu", submenu,
"visible", TRUE,
NULL);
gtk_menu_shell_prepend (GTK_MENU_SHELL (popup), parent);
for (i = 0; i < num_fixits; i++)
{
IdeTextEdit *fixit;
gchar *label;
fixit = ide_diagnostic_get_fixit (diag, i);
label = ide_source_view_get_fixit_label (self, fixit);
menu_item = g_object_new (GTK_TYPE_MENU_ITEM,
"label", label,
"visible", TRUE,
NULL);
gtk_menu_shell_append (GTK_MENU_SHELL (submenu), GTK_WIDGET (menu_item));
g_object_set_data_full (G_OBJECT (menu_item),
"IDE_FIXIT",
g_object_ref (fixit),
(GDestroyNotify)g_object_unref);
g_signal_connect_object (menu_item,
"activate",
G_CALLBACK (ide_source_view__fixit_activate),
self,
G_CONNECT_SWAPPED);
}
}
}
}
}
static void
ide_source_view_real_rebuild_highlight (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->buffer != NULL)
ide_buffer_rehighlight (priv->buffer);
IDE_EXIT;
}
static gboolean
ignore_invalid_buffers (GBinding *binding,
const GValue *from_value,
GValue *to_value,
gpointer user_data)
{
if (G_VALUE_HOLDS (from_value, GTK_TYPE_TEXT_BUFFER))
{
GtkTextBuffer *buffer;
buffer = g_value_get_object (from_value);
if (IDE_IS_BUFFER (buffer))
{
g_value_set_object (to_value, buffer);
return TRUE;
}
}
g_value_set_object (to_value, NULL);
return TRUE;
}
static void
ide_source_view_set_indent_style (IdeSourceView *self,
IdeIndentStyle indent_style)
{
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert ((indent_style == IDE_INDENT_STYLE_SPACES) ||
(indent_style == IDE_INDENT_STYLE_TABS));
if (indent_style == IDE_INDENT_STYLE_SPACES)
gtk_source_view_set_insert_spaces_instead_of_tabs (GTK_SOURCE_VIEW (self), TRUE);
else
gtk_source_view_set_insert_spaces_instead_of_tabs (GTK_SOURCE_VIEW (self), FALSE);
}
static gboolean
ide_source_view_do_size_allocate_hack_cb (gpointer data)
{
IdeSourceView *self = data;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkAllocation alloc = priv->delay_size_allocation;
g_assert (IDE_IS_SOURCE_VIEW (self));
priv->delay_size_allocate_chainup = 0;
GTK_WIDGET_CLASS (ide_source_view_parent_class)->size_allocate (GTK_WIDGET (self), &alloc);
ide_source_view_set_overscroll_num_lines (self, priv->overscroll_num_lines);
return G_SOURCE_REMOVE;
}
/*
* HACK:
*
* We really want the panels in Builder to be as smooth as possible when
* animating in and out of the scene. However, since these are not floating
* panels, we have the challenge of trying to go through the entire relayout,
* pixelcache, draw cycle many times per-second. Most systems are simply not
* up to the task.
*
* We can, however, take a shortcut when shrinking the allocation. We can
* simply defer the allocation request that would normally be chained up
* to GtkTextView and finish that work after the animation has completed.
* We use a simple heuristic to determine this, simply "missing" a size
* allocation from the typical frame clock cycle.
*/
static gboolean
ide_source_view_do_size_allocate_hack (IdeSourceView *self,
GtkAllocation *allocation)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkWidget *widget = (GtkWidget *)self;
GtkAllocation old;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (allocation != NULL);
/*
* If we are shrinking the allocation, we can go forward with the hack.
* If not, we will abort our request and do the normal chainup cycle.
*/
gtk_widget_get_allocation (widget, &old);
if ((old.width < allocation->width) || (old.height < allocation->height))
return FALSE;
/*
* Save the allocation for later. We'll need it to apply after our timeout
* which will occur just after the last frame (or sooner if we stall the
* drawing pipeline).
*/
priv->delay_size_allocation = *allocation;
/*
* Register our timeout to occur just after a normal frame interval.
* If we are animating at 60 FPS, we should get another size-allocate within
* the frame cycle, typically 17 msec.
*/
g_clear_handle_id (&priv->delay_size_allocate_chainup, g_source_remove);
priv->delay_size_allocate_chainup = g_timeout_add (30,
ide_source_view_do_size_allocate_hack_cb,
self);
return TRUE;
}
static void
ide_source_view_size_allocate (GtkWidget *widget,
GtkAllocation *allocation)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (GTK_IS_WIDGET (widget));
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (allocation != NULL);
if (!ide_source_view_do_size_allocate_hack (self, allocation))
{
GTK_WIDGET_CLASS (ide_source_view_parent_class)->size_allocate (GTK_WIDGET (self), allocation);
ide_source_view_set_overscroll_num_lines (self, priv->overscroll_num_lines);
}
}
static gboolean
ide_source_view_scroll_event (GtkWidget *widget,
GdkEventScroll *event)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
gboolean ret = GDK_EVENT_PROPAGATE;
g_assert (IDE_IS_SOURCE_VIEW (self));
/*
* If the user started a manual scroll while we were attempting to scroll to
* the target position, just abort our delayed scroll.
*/
priv->scrolling_to_scroll_mark = FALSE;
/*
* Be forward-portable against changes underneath us.
*/
if (GTK_WIDGET_CLASS (ide_source_view_parent_class)->scroll_event)
ret = GTK_WIDGET_CLASS (ide_source_view_parent_class)->scroll_event (widget, event);
return ret;
}
static void
ide_source_view_real_reset_font_size (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->font_scale != FONT_SCALE_NORMAL)
{
priv->font_scale = FONT_SCALE_NORMAL;
ide_source_view_rebuild_css (self);
}
}
static void
ide_source_view_real_increase_font_size (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->font_scale < LAST_FONT_SCALE - 1)
{
priv->font_scale++;
ide_source_view_rebuild_css (self);
}
}
static void
ide_source_view_real_decrease_font_size (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->font_scale > 0)
{
priv->font_scale--;
ide_source_view_rebuild_css (self);
}
}
static void
ide_source_view_real_delete_from_cursor (GtkTextView *text_view,
GtkDeleteType delete_type,
gint count)
{
if (delete_type == GTK_DELETE_PARAGRAPHS)
ide_text_util_delete_line (text_view, count);
else
GTK_TEXT_VIEW_CLASS (ide_source_view_parent_class)->delete_from_cursor (text_view,
delete_type,
count);
}
static void
ide_source_view_real_select_all (IdeSourceView *self,
gboolean select_)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
g_signal_chain_from_overridden_handler (self, select_);
priv->insert_mark_cleared = TRUE;
}
static void
ide_source_view_rename_changed (IdeSourceView *self,
DzlSimplePopover *popover)
{
const gchar *text;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (DZL_IS_SIMPLE_POPOVER (popover));
text = dzl_simple_popover_get_text (popover);
dzl_simple_popover_set_ready (popover, text != NULL);
IDE_EXIT;
}
static void
ide_source_view_rename_edits_applied (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
g_autoptr(IdeSourceView) self = user_data;
IDE_ENTRY;
g_assert (IDE_IS_BUFFER_MANAGER (object));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (IDE_IS_SOURCE_VIEW (self));
/*
* The completion window can sometimes popup when performing the replacements
* so we manually hide that window here.
*/
ide_source_view_real_hide_completion (self);
IDE_EXIT;
}
static void
ide_source_view_rename_edits_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeRenameProvider *provider = (IdeRenameProvider *)object;
g_autoptr(IdeSourceView) self = user_data;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_autoptr(GPtrArray) edits = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(IdeContext) context = NULL;
IdeBufferManager *buffer_manager;
IDE_ENTRY;
g_assert (IDE_IS_RENAME_PROVIDER (provider));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (IDE_IS_SOURCE_VIEW (self));
if (!ide_rename_provider_rename_finish (provider, result, &edits, &error))
{
/* TODO: Propagate error to UI */
g_warning ("%s", error->message);
IDE_EXIT;
}
g_assert (edits != NULL);
IDE_PTR_ARRAY_SET_FREE_FUNC (edits, g_object_unref);
context = ide_buffer_ref_context (priv->buffer);
buffer_manager = ide_buffer_manager_from_context (context);
ide_buffer_manager_apply_edits_async (buffer_manager,
IDE_PTR_ARRAY_STEAL_FULL (&edits),
NULL,
ide_source_view_rename_edits_applied,
g_steal_pointer (&self));
IDE_EXIT;
}
static void
ide_source_view_rename_activate (IdeSourceView *self,
const gchar *text,
DzlSimplePopover *popover)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_autoptr(IdeLocation) location = NULL;
IdeRenameProvider *provider;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (text != NULL);
g_assert (DZL_IS_SIMPLE_POPOVER (popover));
if (NULL == (provider = ide_buffer_get_rename_provider (priv->buffer)))
IDE_EXIT;
location = ide_buffer_get_insert_location (priv->buffer);
ide_rename_provider_rename_async (provider,
location,
text,
NULL,
ide_source_view_rename_edits_cb,
g_object_ref (self));
/*
* TODO: We should probably lock all buffers so that we can ensure
* that our edit points are correct by time we get called back.
*/
gtk_popover_popdown (GTK_POPOVER (popover));
IDE_EXIT;
}
static void
ide_source_view_real_begin_rename (IdeSourceView *self)
{
IdeRenameProvider *provider;
DzlSimplePopover *popover;
g_autofree gchar *title = NULL;
GtkTextBuffer *buffer;
GtkTextMark *insert;
GtkTextIter iter;
GtkTextIter word_start;
GtkTextIter word_end;
g_autofree gchar *symbol = NULL;
GdkRectangle loc;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
provider = ide_buffer_get_rename_provider (IDE_BUFFER (buffer));
if (provider == NULL)
{
g_message ("Cannot rename, operation requires an IdeRenameProvider");
return;
}
insert = gtk_text_buffer_get_insert (buffer);
title = ide_buffer_dup_title (IDE_BUFFER (buffer));
gtk_text_buffer_get_iter_at_mark (buffer, &iter, insert);
g_debug ("Renaming symbol from %s +%d:%d",
title,
gtk_text_iter_get_line (&iter) + 1,
gtk_text_iter_get_line_offset (&iter) + 1);
gtk_text_buffer_select_range (buffer, &iter, &iter);
gtk_text_view_get_iter_location (GTK_TEXT_VIEW (self), &iter, &loc);
gtk_text_view_buffer_to_window_coords (GTK_TEXT_VIEW (self),
GTK_TEXT_WINDOW_WIDGET,
loc.x, loc.y, &loc.x, &loc.y);
// get symbol to rename (for the popup)
if (gtk_text_iter_inside_word (&iter) && !gtk_text_iter_starts_word (&iter))
{
word_start = iter;
word_end = iter;
gtk_text_iter_backward_word_start (&word_start);
gtk_text_iter_forward_word_end (&word_end);
}
else if (gtk_text_iter_starts_word (&iter))
{
word_start = iter;
word_end = iter;
gtk_text_iter_forward_word_end (&word_end);
}
else if (gtk_text_iter_ends_word (&iter))
{
word_start = iter;
word_end = iter;
gtk_text_iter_backward_word_start (&word_start);
}
symbol = gtk_text_iter_get_text (&word_start, &word_end);
popover = g_object_new (DZL_TYPE_SIMPLE_POPOVER,
"title", _("Rename symbol"),
"button-text", _("Rename"),
"text", symbol,
"relative-to", self,
"pointing-to", &loc,
NULL);
g_signal_connect_object (popover,
"changed",
G_CALLBACK (ide_source_view_rename_changed),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (popover,
"activate",
G_CALLBACK (ide_source_view_rename_activate),
self,
G_CONNECT_SWAPPED);
gtk_popover_popup (GTK_POPOVER (popover));
IDE_EXIT;
}
static void
ide_source_view_format_selection_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeBuffer *buffer = (IdeBuffer *)object;
g_autoptr(IdeSourceView) self = user_data;
g_autoptr(GError) error = NULL;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (G_IS_ASYNC_RESULT (result));
if (!ide_buffer_format_selection_finish (buffer, result, &error))
{
if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
g_warning ("%s", error->message);
}
gtk_text_view_set_editable (GTK_TEXT_VIEW (self), TRUE);
IDE_EXIT;
}
static void
ide_source_view_real_format_selection (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_autoptr(IdeFormatterOptions) options = NULL;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
options = ide_formatter_options_new ();
ide_formatter_options_set_tab_width (options,
gtk_source_view_get_tab_width (GTK_SOURCE_VIEW (self)));
ide_formatter_options_set_insert_spaces (options,
gtk_source_view_get_insert_spaces_instead_of_tabs (GTK_SOURCE_VIEW (self)));
gtk_text_view_set_editable (GTK_TEXT_VIEW (self), FALSE);
ide_buffer_format_selection_async (priv->buffer,
options,
NULL,
ide_source_view_format_selection_cb,
g_object_ref (self));
IDE_EXIT;
}
static void
ide_source_view_code_action_execute_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IDE_TRACE_MSG ("ide_source_view_code_action_execute_cb done");
}
static void
execute_code_action_cb (IdeCodeAction *code_action)
{
ide_code_action_execute_async(code_action,
NULL,
ide_source_view_code_action_execute_cb,
g_object_ref (code_action));
}
static void
popup_menu_detach (GtkWidget *attach_widget,
GtkMenu *menu)
{
}
static void
ide_source_view_code_action_query_cb(GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeBuffer *buffer = (IdeBuffer *)object;
g_autoptr(IdeSourceView) self = user_data;
g_autoptr(GError) error = NULL;
g_autoptr(GPtrArray) code_actions = NULL;
IDE_ENTRY;
g_assert(IDE_IS_SOURCE_VIEW(self));
g_assert(G_IS_ASYNC_RESULT(result));
code_actions = ide_buffer_code_action_query_finish(buffer, result, &error);
if (!code_actions)
{
if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED))
g_warning("%s", error->message);
IDE_EXIT;
}
if (code_actions->len)
{
IdeContext* context;
GtkTextView* text_view;
GtkTextIter iter;
GdkRectangle iter_location;
GdkRectangle visible_rect;
gboolean is_visible;
GtkWidget* popup_menu;
context = ide_buffer_ref_context(buffer);
popup_menu = gtk_menu_new();
gtk_style_context_add_class(gtk_widget_get_style_context(popup_menu),
GTK_STYLE_CLASS_CONTEXT_MENU);
gtk_menu_attach_to_widget(GTK_MENU(popup_menu),
GTK_WIDGET(self),
popup_menu_detach);
for (gsize i = 0; i < code_actions->len; i++)
{
IdeCodeAction* code_action;
GtkWidget* menu_item;
code_action = g_ptr_array_index(code_actions, i);
ide_object_append(IDE_OBJECT(context), IDE_OBJECT(code_action));
menu_item = gtk_menu_item_new_with_label(ide_code_action_get_title(code_action));
g_signal_connect_swapped(menu_item,
"activate",
G_CALLBACK(execute_code_action_cb),
code_action);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(popup_menu), menu_item);
}
gtk_menu_shell_select_first(GTK_MENU_SHELL(popup_menu), FALSE);
text_view = GTK_TEXT_VIEW(self);
gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(text_view),
&iter,
gtk_text_buffer_get_insert(gtk_text_view_get_buffer(text_view)));
gtk_text_view_get_iter_location(text_view, &iter, &iter_location);
gtk_text_view_get_visible_rect(text_view, &visible_rect);
is_visible = (iter_location.x + iter_location.width > visible_rect.x &&
iter_location.x < visible_rect.x + visible_rect.width &&
iter_location.y + iter_location.height > visible_rect.y &&
iter_location.y < visible_rect.y + visible_rect.height);
if (is_visible)
{
gtk_text_view_buffer_to_window_coords(text_view,
GTK_TEXT_WINDOW_WIDGET,
iter_location.x,
iter_location.y,
&iter_location.x,
&iter_location.y);
gtk_menu_popup_at_rect(GTK_MENU(popup_menu),
gtk_widget_get_window(GTK_WIDGET(text_view)),
&iter_location,
GDK_GRAVITY_SOUTH_EAST,
GDK_GRAVITY_NORTH_WEST,
NULL);
}
}
IDE_EXIT;
}
static void
ide_source_view_real_code_action_query (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
ide_buffer_code_action_query_async (priv->buffer,
NULL,
ide_source_view_code_action_query_cb,
g_object_ref (self));
IDE_EXIT;
}
static void
ide_source_view_real_find_references_jump (IdeSourceView *self,
GtkListBoxRow *row,
GtkListBox *list_box)
{
IdeLocation *location;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_LIST_BOX_ROW (row));
g_assert (GTK_IS_LIST_BOX (list_box));
location = g_object_get_data (G_OBJECT (row), "IDE_LOCATION");
if (location != NULL)
g_signal_emit (self, signals [FOCUS_LOCATION], 0, location);
IDE_EXIT;
}
static gboolean
insert_mark_within_range (IdeBuffer *buffer,
IdeRange *range)
{
GtkTextMark *insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (buffer));
IdeLocation *begin = ide_range_get_begin (range);
IdeLocation *end = ide_range_get_end (range);
GtkTextIter iter;
GtkTextIter begin_iter;
GtkTextIter end_iter;
if (!begin || !end)
return FALSE;
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (buffer), &iter, insert);
ide_buffer_get_iter_at_location (buffer, &begin_iter, begin);
ide_buffer_get_iter_at_location (buffer, &end_iter, end);
return gtk_text_iter_compare (&begin_iter, &iter) <= 0 &&
gtk_text_iter_compare (&end_iter, &iter) >= 0;
}
static void
ide_source_view_find_references_cb (GObject *object,
GAsyncResult *result,
gpointer user_data)
{
IdeSymbolResolver *symbol_resolver = (IdeSymbolResolver *)object;
g_autoptr(GPtrArray) references = NULL;
g_autoptr(GError) error = NULL;
g_autoptr(IdeTask) task = user_data;
FindReferencesTaskData *data;
IdeSourceView *self;
IdeSourceViewPrivate *priv;
GtkScrolledWindow *scroller;
GtkPopover *popover;
GtkListBox *list_box;
GtkTextMark *insert;
GtkTextIter iter;
GdkRectangle loc;
IDE_ENTRY;
g_assert (IDE_IS_SYMBOL_RESOLVER (symbol_resolver));
g_assert (G_IS_ASYNC_RESULT (result));
g_assert (IDE_IS_TASK (task));
references = ide_symbol_resolver_find_references_finish (symbol_resolver, result, &error);
IDE_PTR_ARRAY_SET_FREE_FUNC (references, g_object_unref);
self = ide_task_get_source_object (task);
priv = ide_source_view_get_instance_private (self);
data = ide_task_get_task_data (task);
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (data != NULL);
g_assert (data->resolvers != NULL);
g_assert (data->resolvers->len > 0);
g_ptr_array_remove_index (data->resolvers, data->resolvers->len - 1);
/* If references are not found and symbol resolvers are left try those */
if (references == NULL && data->resolvers->len > 0)
{
GCancellable *cancellable;
IdeSymbolResolver *resolver;
cancellable = ide_task_get_cancellable (task);
resolver = g_ptr_array_index (data->resolvers, data->resolvers->len - 1);
ide_symbol_resolver_find_references_async (resolver,
data->location,
ide_buffer_get_language_id (priv->buffer),
cancellable,
ide_source_view_find_references_cb,
g_steal_pointer (&task));
return;
}
/* Ignore popover if we are no longer visible or not top-most */
if (!gtk_widget_get_visible (GTK_WIDGET (self)) ||
!gtk_widget_get_child_visible (GTK_WIDGET (self)))
IDE_EXIT;
insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (priv->buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer), &iter, insert);
gtk_text_buffer_select_range (GTK_TEXT_BUFFER (priv->buffer), &iter, &iter);
gtk_text_view_get_iter_location (GTK_TEXT_VIEW (self), &iter, &loc);
gtk_text_view_buffer_to_window_coords (GTK_TEXT_VIEW (self),
GTK_TEXT_WINDOW_WIDGET,
loc.x, loc.y, &loc.x, &loc.y);
popover = g_object_new (GTK_TYPE_POPOVER,
"modal", TRUE,
"position", GTK_POS_TOP,
"relative-to", self,
"pointing-to", &loc,
NULL);
scroller = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
"min-content-height", 35,
"max-content-height", 200,
"propagate-natural-height", TRUE,
"propagate-natural-width", TRUE,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (popover), GTK_WIDGET (scroller));
list_box = g_object_new (GTK_TYPE_LIST_BOX,
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (scroller), GTK_WIDGET (list_box));
if (references != NULL && references->len > 0)
{
g_autoptr(IdeContext) context = ide_buffer_ref_context (priv->buffer);
g_autoptr(GFile) workdir = ide_context_ref_workdir (context);
for (guint i = 0; i < references->len; i++)
{
IdeRange *range = g_ptr_array_index (references, i);
IdeLocation *begin = ide_range_get_begin (range);
GFile *file = ide_location_get_file (begin);
guint line = ide_location_get_line (begin);
guint line_offset = ide_location_get_line_offset (begin);
g_autofree gchar *name = NULL;
g_autofree gchar *text = NULL;
GtkListBoxRow *row;
GtkLabel *label;
if (g_file_has_prefix (file, workdir))
name = g_file_get_relative_path (workdir, file);
else if (g_file_is_native (file))
name = g_file_get_path (file);
else
name = g_file_get_uri (file);
/* translators: %s is the filename, then line number, column number. <> are pango markup */
text = g_strdup_printf (_("<b>%s</b> — <small>Line %u, Column %u</small>"),
name, line + 1, line_offset + 1);
label = g_object_new (GTK_TYPE_LABEL,
"xalign", 0.0f,
"label", text,
"use-markup", TRUE,
"visible", TRUE,
NULL);
row = g_object_new (GTK_TYPE_LIST_BOX_ROW,
"child", label,
"visible", TRUE,
NULL);
g_object_set_data_full (G_OBJECT (row),
"IDE_LOCATION",
g_object_ref (begin),
g_object_unref);
gtk_container_add (GTK_CONTAINER (list_box), GTK_WIDGET (row));
if (insert_mark_within_range (priv->buffer, range))
gtk_list_box_select_row (list_box, row);
}
}
else
{
GtkLabel *label = g_object_new (GTK_TYPE_LABEL,
"label", _("No references were found"),
"visible", TRUE,
NULL);
gtk_container_add (GTK_CONTAINER (list_box), GTK_WIDGET (label));
}
g_signal_connect_object (list_box,
"row-activated",
G_CALLBACK (ide_source_view_real_find_references_jump),
self,
G_CONNECT_SWAPPED);
gtk_popover_popup (popover);
g_signal_connect (popover, "hide", G_CALLBACK (gtk_widget_destroy), NULL);
ide_task_return_boolean (task, TRUE);
IDE_EXIT;
}
static void
ide_source_view_real_find_references (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_autoptr(IdeTask) task = NULL;
g_autoptr(GPtrArray) resolvers = NULL;
FindReferencesTaskData *data;
IdeSymbolResolver *resolver;
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
task = ide_task_new (self, NULL, NULL, NULL);
ide_task_set_source_tag (task, ide_source_view_real_find_references);
resolvers = ide_buffer_get_symbol_resolvers (priv->buffer);
IDE_PTR_ARRAY_SET_FREE_FUNC (resolvers, g_object_unref);
if (resolvers->len == 0)
{
g_debug ("No symbol resolver is available");
IDE_EXIT;
}
data = g_slice_new0 (FindReferencesTaskData);
data->resolvers = g_steal_pointer (&resolvers);
data->location = ide_buffer_get_insert_location (priv->buffer);
ide_task_set_task_data (task, data, find_references_task_data_free);
resolver = g_ptr_array_index (data->resolvers, data->resolvers->len - 1);
/* Try each symbol resolver one by one to find references. */
ide_symbol_resolver_find_references_async (resolver,
data->location,
ide_buffer_get_language_id (priv->buffer),
NULL,
ide_source_view_find_references_cb,
g_steal_pointer (&task));
IDE_EXIT;
}
static void
ide_source_view_real_request_documentation (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextIter iter;
g_assert (IDE_IS_SOURCE_VIEW (self));
if (priv->buffer == NULL)
return;
ide_buffer_get_selection_bounds (priv->buffer, &iter, NULL);
_ide_hover_display (priv->hover, &iter);
}
static void
ide_source_view_real_undo (GtkSourceView *view)
{
IdeSourceView *self = (IdeSourceView *)view;
g_assert (IDE_IS_SOURCE_VIEW (self));
/*
* Disable things that could confuse undo. For example, we need to bail on
* any in-flight snippets because they just can't deal with the buffer
* changes correctly given the GtkTextMark vs run-length design.
*/
ide_source_view_clear_snippets (self);
GTK_SOURCE_VIEW_CLASS (ide_source_view_parent_class)->undo (view);
}
static void
ide_source_view_real_reset (IdeSourceView *self)
{
g_assert (IDE_IS_SOURCE_VIEW (self));
g_signal_emit (self, signals [CLEAR_SEARCH], 0);
g_signal_emit (self, signals [CLEAR_MODIFIER], 0);
g_signal_emit (self, signals [CLEAR_SELECTION], 0);
g_signal_emit (self, signals [CLEAR_COUNT], 0);
g_signal_emit (self, signals [CLEAR_SNIPPETS], 0);
g_signal_emit (self, signals [HIDE_COMPLETION], 0);
g_signal_emit (self, signals [REMOVE_CURSORS], 0);
g_signal_emit (self, signals [SET_MODE], 0, NULL, IDE_SOURCE_VIEW_MODE_TYPE_PERMANENT);
}
static void
ide_source_view_destroy (GtkWidget *widget)
{
IdeSourceView *self = (IdeSourceView *)widget;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_assert (IDE_IS_SOURCE_VIEW (self));
/* Ensure we release the buffer immediately */
if (priv->buffer_signals != NULL)
dzl_signal_group_set_target (priv->buffer_signals, NULL);
GTK_WIDGET_CLASS (ide_source_view_parent_class)->destroy (widget);
}
static void
ide_source_view_dispose (GObject *object)
{
IdeSourceView *self = (IdeSourceView *)object;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
if (priv->hadj_animation)
{
dzl_animation_stop (priv->hadj_animation);
g_clear_weak_pointer (&priv->hadj_animation);
}
if (priv->vadj_animation)
{
dzl_animation_stop (priv->vadj_animation);
g_clear_weak_pointer (&priv->vadj_animation);
}
ide_source_view_clear_snippets (self);
g_clear_handle_id (&priv->delay_size_allocate_chainup, g_source_remove);
g_clear_object (&priv->hover);
g_clear_object (&priv->completion);
g_clear_object (&priv->capture);
ide_clear_and_destroy_object (&priv->indenter_adapter);
g_clear_object (&priv->css_provider);
g_clear_object (&priv->mode);
g_clear_object (&priv->buffer_signals);
g_clear_object (&priv->file_setting_bindings);
g_clear_object (&priv->gutter);
if (priv->command_str != NULL)
{
g_string_free (priv->command_str, TRUE);
priv->command_str = NULL;
}
G_OBJECT_CLASS (ide_source_view_parent_class)->dispose (object);
}
static void
ide_source_view_finalize (GObject *object)
{
IdeSourceView *self = (IdeSourceView *)object;
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_clear_pointer (&priv->display_name, g_free);
g_clear_pointer (&priv->font_desc, pango_font_description_free);
g_clear_pointer (&priv->selections, g_queue_free);
g_clear_pointer (&priv->snippets, g_queue_free);
g_clear_pointer (&priv->include_regex, g_regex_unref);
DZL_COUNTER_DEC (instances);
G_OBJECT_CLASS (ide_source_view_parent_class)->finalize (object);
}
static void
ide_source_view_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
IdeSourceView *self = IDE_SOURCE_VIEW (object);
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
switch (prop_id)
{
case PROP_AUTO_INDENT:
g_value_set_boolean (value, priv->auto_indent);
break;
case PROP_COMPLETION_N_ROWS:
g_value_set_uint (value, ide_completion_get_n_rows (priv->completion));
break;
case PROP_COUNT:
g_value_set_int (value, ide_source_view_get_count (self));
break;
case PROP_FILE_SETTINGS:
g_value_set_object (value, ide_source_view_get_file_settings (self));
break;
case PROP_FONT_DESC:
g_value_set_boxed (value, ide_source_view_get_font_desc (self));
break;
case PROP_HIGHLIGHT_CURRENT_LINE:
g_value_set_boolean (value, ide_source_view_get_highlight_current_line (self));
break;
case PROP_INDENTER:
g_value_set_object (value, ide_source_view_get_indenter (self));
break;
case PROP_INSERT_MATCHING_BRACE:
g_value_set_boolean (value, ide_source_view_get_insert_matching_brace (self));
break;
case PROP_INTERACTIVE_COMPLETION:
g_value_set_boolean (value, priv->interactive_completion);
break;
case PROP_MODE_DISPLAY_NAME:
g_value_set_string (value, ide_source_view_get_mode_display_name (self));
break;
case PROP_OVERWRITE:
g_value_set_boolean (value, ide_source_view_get_overwrite (self));
break;
case PROP_OVERWRITE_BRACES:
g_value_set_boolean (value, ide_source_view_get_overwrite_braces (self));
break;
case PROP_SCROLL_OFFSET:
g_value_set_uint (value, ide_source_view_get_scroll_offset (self));
break;
case PROP_SHOW_GRID_LINES:
g_value_set_boolean (value, ide_source_view_get_show_grid_lines (self));
break;
case PROP_SHOW_LINE_CHANGES:
g_value_set_boolean (value, ide_source_view_get_show_line_changes (self));
break;
case PROP_SHOW_LINE_DIAGNOSTICS:
g_value_set_boolean (value, ide_source_view_get_show_line_diagnostics (self));
break;
case PROP_SHOW_LINE_NUMBERS:
g_value_set_boolean (value, ide_source_view_get_show_line_numbers (self));
break;
case PROP_SHOW_RELATIVE_LINE_NUMBERS:
g_value_set_boolean (value, ide_source_view_get_show_relative_line_numbers (self));
break;
case PROP_OVERSCROLL:
g_value_set_int (value, priv->overscroll_num_lines);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
ide_source_view_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
IdeSourceView *self = IDE_SOURCE_VIEW (object);
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
switch (prop_id)
{
case PROP_AUTO_INDENT:
priv->auto_indent = !!g_value_get_boolean (value);
ide_source_view_update_auto_indent_override (self);
break;
case PROP_COMPLETION_N_ROWS:
if (priv->completion != NULL)
ide_completion_set_n_rows (priv->completion, g_value_get_uint (value));
break;
case PROP_COUNT:
ide_source_view_set_count (self, g_value_get_int (value));
break;
case PROP_FONT_NAME:
ide_source_view_set_font_name (self, g_value_get_string (value));
break;
case PROP_FONT_DESC:
ide_source_view_set_font_desc (self, g_value_get_boxed (value));
break;
case PROP_HIGHLIGHT_CURRENT_LINE:
ide_source_view_set_highlight_current_line (self, g_value_get_boolean (value));
break;
case PROP_INDENT_STYLE:
ide_source_view_set_indent_style (self, g_value_get_enum (value));
break;
case PROP_INSERT_MATCHING_BRACE:
ide_source_view_set_insert_matching_brace (self, g_value_get_boolean (value));
break;
case PROP_INTERACTIVE_COMPLETION:
ide_source_view_set_interactive_completion (self, g_value_get_boolean (value));
break;
case PROP_OVERWRITE:
gtk_text_view_set_overwrite (GTK_TEXT_VIEW (self), g_value_get_boolean (value));
break;
case PROP_OVERWRITE_BRACES:
ide_source_view_set_overwrite_braces (self, g_value_get_boolean (value));
break;
case PROP_SCROLL_OFFSET:
ide_source_view_set_scroll_offset (self, g_value_get_uint (value));
break;
case PROP_SHOW_GRID_LINES:
ide_source_view_set_show_grid_lines (self, g_value_get_boolean (value));
break;
case PROP_SHOW_LINE_CHANGES:
ide_source_view_set_show_line_changes (self, g_value_get_boolean (value));
break;
case PROP_SHOW_LINE_DIAGNOSTICS:
ide_source_view_set_show_line_diagnostics (self, g_value_get_boolean (value));
break;
case PROP_SHOW_LINE_NUMBERS:
ide_source_view_set_show_line_numbers (self, g_value_get_boolean (value));
break;
case PROP_SHOW_RELATIVE_LINE_NUMBERS:
ide_source_view_set_show_relative_line_numbers (self, g_value_get_boolean (value));
break;
case PROP_OVERSCROLL:
ide_source_view_set_overscroll_num_lines (self, g_value_get_int (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
}
}
static void
ide_source_view_class_init (IdeSourceViewClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GtkWidgetClass *widget_class = GTK_WIDGET_CLASS (klass);
GtkTextViewClass *text_view_class = GTK_TEXT_VIEW_CLASS (klass);
GtkSourceViewClass *gsv_class = GTK_SOURCE_VIEW_CLASS (klass);
GtkBindingSet *binding_set;
object_class->constructed = ide_source_view_constructed;
object_class->dispose = ide_source_view_dispose;
object_class->finalize = ide_source_view_finalize;
object_class->get_property = ide_source_view_get_property;
object_class->set_property = ide_source_view_set_property;
widget_class->button_press_event = ide_source_view_real_button_press_event;
widget_class->button_release_event = ide_source_view_real_button_release_event;
widget_class->motion_notify_event = ide_source_view_real_motion_notify_event;
widget_class->focus_in_event = ide_source_view_focus_in_event;
widget_class->focus_out_event = ide_source_view_focus_out_event;
widget_class->key_press_event = ide_source_view_key_press_event;
widget_class->key_release_event = ide_source_view_key_release_event;
widget_class->scroll_event = ide_source_view_scroll_event;
widget_class->size_allocate = ide_source_view_size_allocate;
widget_class->style_updated = ide_source_view_real_style_updated;
widget_class->destroy = ide_source_view_destroy;
text_view_class->delete_from_cursor = ide_source_view_real_delete_from_cursor;
text_view_class->draw_layer = ide_source_view_real_draw_layer;
text_view_class->insert_at_cursor = ide_source_view_real_insert_at_cursor;
text_view_class->populate_popup = ide_source_view_real_populate_popup;
gsv_class->undo = ide_source_view_real_undo;
klass->add_cursor = ide_source_view_real_add_cursor;
klass->remove_cursors = ide_source_view_real_remove_cursors;
klass->append_to_count = ide_source_view_real_append_to_count;
klass->begin_macro = ide_source_view_real_begin_macro;
klass->begin_rename = ide_source_view_real_begin_rename;
klass->capture_modifier = ide_source_view_real_capture_modifier;
klass->clear_count = ide_source_view_real_clear_count;
klass->clear_modifier = ide_source_view_real_clear_modifier;
klass->clear_selection = ide_source_view_real_clear_selection;
klass->clear_snippets = ide_source_view_clear_snippets;
klass->copy_clipboard_extended = ide_source_view_real_copy_clipboard_extended;
klass->cycle_completion = ide_source_view_real_cycle_completion;
klass->decrease_font_size = ide_source_view_real_decrease_font_size;
klass->delete_selection = ide_source_view_real_delete_selection;
klass->end_macro = ide_source_view_real_end_macro;
klass->goto_definition = ide_source_view_real_goto_definition;
klass->hide_completion = ide_source_view_real_hide_completion;
klass->increase_font_size = ide_source_view_real_increase_font_size;
klass->indent_selection = ide_source_view_real_indent_selection;
klass->insert_modifier = ide_source_view_real_insert_modifier;
klass->move_error = ide_source_view_real_move_error;
klass->movement = ide_source_view_real_movement;
klass->paste_clipboard_extended = ide_source_view_real_paste_clipboard_extended;
klass->pop_selection = ide_source_view_real_pop_selection;
klass->push_selection = ide_source_view_real_push_selection;
klass->rebuild_highlight = ide_source_view_real_rebuild_highlight;
klass->replay_macro = ide_source_view_real_replay_macro;
klass->request_documentation = ide_source_view_real_request_documentation;
klass->reset_font_size = ide_source_view_real_reset_font_size;
klass->restore_insert_mark = ide_source_view_real_restore_insert_mark;
klass->save_command = ide_source_view_real_save_command;
klass->save_insert_mark = ide_source_view_real_save_insert_mark;
klass->save_search_char = ide_source_view_real_save_search_char;
klass->select_inner = ide_source_view_real_select_inner;
klass->select_tag = ide_source_view_real_select_tag;
klass->selection_theatric = ide_source_view_real_selection_theatric;
klass->set_mode = ide_source_view_real_set_mode;
klass->set_overwrite = ide_source_view_real_set_overwrite;
klass->sort = ide_source_view_real_sort;
klass->swap_selection_bounds = ide_source_view_real_swap_selection_bounds;
g_object_class_override_property (object_class, PROP_AUTO_INDENT, "auto-indent");
properties [PROP_COMPLETION_N_ROWS] =
g_param_spec_uint ("completion-n-rows",
"Completion N Rows",
"The number of completion rows to display to the user",
1, 32, 5,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_COUNT] =
g_param_spec_int ("count",
"Count",
"The count for movements.",
-1,
G_MAXINT,
0,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_FILE_SETTINGS] =
g_param_spec_object ("file-settings",
"File Settings",
"The file settings that have been loaded for the file.",
IDE_TYPE_FILE_SETTINGS,
(G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
properties [PROP_FONT_DESC] =
g_param_spec_boxed ("font-desc",
"Font Description",
"The Pango font description to use for rendering source.",
PANGO_TYPE_FONT_DESCRIPTION,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_FONT_NAME] =
g_param_spec_string ("font-name",
"Font Name",
"The Pango font name to use for rendering source.",
"Monospace",
(G_PARAM_WRITABLE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS));
g_object_class_override_property (object_class,
PROP_HIGHLIGHT_CURRENT_LINE,
"highlight-current-line");
properties [PROP_INDENTER] =
g_param_spec_object ("indenter",
"Indenter",
"Indenter",
IDE_TYPE_INDENTER,
(G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
properties [PROP_INDENT_STYLE] =
g_param_spec_enum ("indent-style",
"Indent Style",
"Indent Style",
IDE_TYPE_INDENT_STYLE,
IDE_INDENT_STYLE_TABS,
(G_PARAM_WRITABLE | G_PARAM_STATIC_STRINGS));
properties [PROP_INTERACTIVE_COMPLETION] =
g_param_spec_boolean ("interactive-completion",
"Interactive Completion",
"If completion should be completed interactively",
TRUE,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_INSERT_MATCHING_BRACE] =
g_param_spec_boolean ("insert-matching-brace",
"Insert Matching Brace",
"Insert a matching brace/bracket/quotation/parenthesis.",
FALSE,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_override_property (object_class, PROP_OVERWRITE, "overwrite");
properties [PROP_MODE_DISPLAY_NAME] =
g_param_spec_string ("mode-display-name",
"Mode Display Name",
"The display name of the keybinding mode.",
NULL,
(G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
properties [PROP_OVERWRITE_BRACES] =
g_param_spec_boolean ("overwrite-braces",
"Overwrite Braces",
"Overwrite a matching brace/bracket/quotation/parenthesis.",
FALSE,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_SCROLL_OFFSET] =
g_param_spec_uint ("scroll-offset",
"Scroll Offset",
"The number of lines between the insertion cursor and screen boundary.",
0,
G_MAXUINT,
0,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_SHOW_GRID_LINES] =
g_param_spec_boolean ("show-grid-lines",
"Show Grid Lines",
"If the background grid should be shown.",
FALSE,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_SHOW_LINE_CHANGES] =
g_param_spec_boolean ("show-line-changes",
"Show Line Changes",
"If line changes should be shown in the left gutter.",
FALSE,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
/**
* IdeSourceView:show-line-diagnostics:
*
* If the diagnostics gutter should be visible.
*
* This also requires that IdeBuffer:highlight-diagnostics is set to %TRUE
* to generate diagnostics.
*
* Since: 3.32
*/
properties [PROP_SHOW_LINE_DIAGNOSTICS] =
g_param_spec_boolean ("show-line-diagnostics",
"Show Line Diagnostics",
"If line changes diagnostics should be shown in the left gutter.",
TRUE,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_override_property (object_class, PROP_SHOW_LINE_NUMBERS, "show-line-numbers");
properties [PROP_SHOW_RELATIVE_LINE_NUMBERS] =
g_param_spec_boolean ("show-relative-line-numbers",
"Show Relative Line Numbers",
"Show line numbers relative to the cursor line",
FALSE,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
properties [PROP_OVERSCROLL] =
g_param_spec_int ("overscroll",
"Overscroll",
"The number of lines to scroll beyond the end of the "
"buffer. A negative number of lines will scroll until "
"only that number of lines is visible",
G_MININT,
G_MAXINT,
DEFAULT_OVERSCROLL_NUM_LINES,
(G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
g_object_class_install_properties (object_class, LAST_PROP, properties);
signals [ACTION] =
g_signal_new_class_handler ("action",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (dzl_gtk_widget_action_with_string),
NULL, NULL, NULL,
G_TYPE_NONE,
3,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_STRING);
signals [APPEND_TO_COUNT] =
g_signal_new ("append-to-count",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, append_to_count),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
G_TYPE_INT);
/**
* IdeSourceView::begin-macro:
*
* This signal will begin recording input to the #IdeSourceView. This includes the current
* #IdeSourceViewMode, #IdeSourceView:count and #IdeSourceView:modifier which will be used
* to replay the sequence starting from the correct state.
*
* Pair this with an emission of #IdeSourceView::end-macro to complete the sequence.
*
* Since: 3.32
*/
signals [BEGIN_MACRO] =
g_signal_new ("begin-macro",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, begin_macro),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
/**
* IdeSourceView::begin-rename:
*
* This signal is emitted when the source view should begin a rename
* operation using the #IdeRenameProvider from the underlying buffer. The
* cursor position will be used as the location when sending the request to
* the provider.
*
* Since: 3.32
*/
signals [BEGIN_RENAME] =
g_signal_new ("begin-rename",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, begin_rename),
NULL, NULL, NULL, G_TYPE_NONE, 0);
signals [BEGIN_USER_ACTION] =
g_signal_new_class_handler ("begin-user-action",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (ide_source_view_begin_user_action),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [SAVE_COMMAND] =
g_signal_new ("save-command",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, save_command),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
signals [SAVE_SEARCH_CHAR] =
g_signal_new ("save-search-char",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, save_search_char),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
/**
* IdeSourceView::capture-modifier:
*
* This signal will block the main loop in a similar fashion to how
* gtk_dialog_run() performs until a key-press has occurred that can be
* captured for use in movements.
*
* Pressing Escape or unfocusing the widget will break from this loop.
*
* Use of this signal is not recommended except in very specific cases.
*
* Since: 3.32
*/
signals [CAPTURE_MODIFIER] =
g_signal_new ("capture-modifier",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, capture_modifier),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
g_signal_override_class_handler ("change-case",
G_TYPE_FROM_CLASS (klass),
G_CALLBACK (ide_source_view_real_change_case));
signals [CLEAR_COUNT] =
g_signal_new ("clear-count",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, clear_count),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [CLEAR_MODIFIER] =
g_signal_new ("clear-modifier",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, clear_modifier),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [CLEAR_SEARCH] =
g_signal_new ("clear-search",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, clear_search),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [CLEAR_SELECTION] =
g_signal_new ("clear-selection",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, clear_selection),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [CLEAR_SNIPPETS] =
g_signal_new ("clear-snippets",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, clear_snippets),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [COPY_CLIPBOARD_EXTENDED] =
g_signal_new ("copy-clipboard-extended",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, copy_clipboard_extended),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [CYCLE_COMPLETION] =
g_signal_new ("cycle-completion",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, cycle_completion),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
GTK_TYPE_DIRECTION_TYPE);
signals [DECREASE_FONT_SIZE] =
g_signal_new ("decrease-font-size",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, decrease_font_size),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [DELETE_SELECTION] =
g_signal_new ("delete-selection",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, delete_selection),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [DRAW_BUBBLES] =
g_signal_new ("draw-bubbles",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL,
g_cclosure_marshal_VOID__BOXED,
G_TYPE_NONE,
1,
CAIRO_GOBJECT_TYPE_CONTEXT);
g_signal_set_va_marshaller (signals [DRAW_BUBBLES],
G_TYPE_FROM_CLASS (klass),
g_cclosure_marshal_VOID__BOXEDv);
/**
* IdeSourceView::end-macro:
*
* You should call #IdeSourceView::begin-macro before emitting this signal.
*
* Complete a macro recording sequence. This may be called more times than is necessary,
* since #IdeSourceView will only keep the most recent macro recording. This can be
* helpful when implementing recording sequences such as in Vim.
*
* Since: 3.32
*/
signals [END_MACRO] =
g_signal_new ("end-macro",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, end_macro),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [END_USER_ACTION] =
g_signal_new_class_handler ("end-user-action",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (ide_source_view_end_user_action),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [FIND_REFERENCES] =
g_signal_new_class_handler ("find-references",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (ide_source_view_real_find_references),
NULL, NULL, NULL, G_TYPE_NONE, 0);
signals [FOCUS_LOCATION] =
g_signal_new ("focus-location",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (IdeSourceViewClass, focus_location),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
IDE_TYPE_LOCATION);
signals [FORMAT_SELECTION] =
g_signal_new_class_handler ("format-selection",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (ide_source_view_real_format_selection),
NULL, NULL, NULL, G_TYPE_NONE, 0);
signals [QUERY_CODE_ACTION] =
g_signal_new_class_handler ("query-code-action",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (ide_source_view_real_code_action_query),
NULL, NULL, NULL, G_TYPE_NONE, 0);
signals [GOTO_DEFINITION] =
g_signal_new ("goto-definition",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, goto_definition),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [HIDE_COMPLETION] =
g_signal_new ("hide-completion",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, hide_completion),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [INCREASE_FONT_SIZE] =
g_signal_new ("increase-font-size",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, increase_font_size),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [INDENT_SELECTION] =
g_signal_new ("indent-selection",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, indent_selection),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
G_TYPE_INT);
/**
* IdeSourceView::insert-modifier:
* @self: An #IdeSourceView
* @use_count: If the count property should be used to repeat.
*
* Inserts the current modifier character at the insert mark in the buffer.
* If @use_count is %TRUE, then the character will be inserted
* #IdeSourceView:count times.
*
* Since: 3.32
*/
signals [INSERT_MODIFIER] =
g_signal_new ("insert-modifier",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, insert_modifier),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
G_TYPE_BOOLEAN);
g_signal_override_class_handler ("join-lines",
G_TYPE_FROM_CLASS (klass),
G_CALLBACK (ide_source_view_real_join_lines));
signals [JUMP] =
g_signal_new ("jump",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET (IdeSourceViewClass, jump),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
signals [MOVEMENT] =
g_signal_new ("movement",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, movement),
NULL, NULL, NULL,
G_TYPE_NONE,
4,
IDE_TYPE_SOURCE_VIEW_MOVEMENT,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
/**
* IdeSourceView::move-error:
* @self: An #IdeSourceView.
* @dir: The direction to move.
*
* Moves to the next search result either forwards or backwards.
*
* Since: 3.32
*/
signals [MOVE_ERROR] =
g_signal_new ("move-error",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, move_error),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
GTK_TYPE_DIRECTION_TYPE);
signals [MOVE_SEARCH] =
g_signal_new ("move-search",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, move_search),
NULL, NULL, NULL,
G_TYPE_NONE,
6,
GTK_TYPE_DIRECTION_TYPE,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_INT);
signals [PASTE_CLIPBOARD_EXTENDED] =
g_signal_new ("paste-clipboard-extended",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, paste_clipboard_extended),
NULL, NULL, NULL,
G_TYPE_NONE,
3,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
/**
* IdeSourceView::pop-selection:
*
* Reselects a previousl selected range of text that was saved using
* IdeSourceView::push-selection.
*
* Since: 3.32
*/
signals [POP_SELECTION] =
g_signal_new ("pop-selection",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, pop_selection),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
/**
* IdeSourceView::pop-snippet:
* @self: An #IdeSourceView
* @snippet: An #IdeSnippet.
*
* Pops the current snippet from the sourceview if there is one.
*
* Since: 3.32
*/
signals [POP_SNIPPET] =
g_signal_new_class_handler ("pop-snippet",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
NULL,
NULL, NULL, NULL,
G_TYPE_NONE,
0);
/**
* IdeSourceView::push-selection:
*
* Saves the current selection away to be restored by a call to
* IdeSourceView::pop-selection. You must pop the selection to keep
* the selection stack in consistent order.
*
* Since: 3.32
*/
signals [PUSH_SELECTION] =
g_signal_new ("push-selection",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, push_selection),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
/**
* IdeSourceView::push-snippet:
* @self: An #IdeSourceView
* @snippet: An #IdeSnippet.
* @iter: (allow-none): The location for the snippet, or %NULL.
*
* Pushes @snippet onto the snippet stack at either @iter or the insertion
* mark if @iter is not provided.
*
* Since: 3.32
*/
signals [PUSH_SNIPPET] =
g_signal_new_class_handler ("push-snippet",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST,
G_CALLBACK (ide_source_view_real_push_snippet),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
IDE_TYPE_SNIPPET,
GTK_TYPE_TEXT_ITER | G_SIGNAL_TYPE_STATIC_SCOPE);
signals [REBUILD_HIGHLIGHT] =
g_signal_new ("rebuild-highlight",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, rebuild_highlight),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [DUPLICATE_ENTIRE_LINE] =
g_signal_new_class_handler ("duplicate-entire-line",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (ide_source_view_real_duplicate_entire_line),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [REINDENT] =
g_signal_new_class_handler ("reindent",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (ide_source_view_real_reindent),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
/**
* IdeSourceView:replay-macro:
* @self: an #IdeSourceView.
*
* Replays the last series of captured events that were captured between calls
* to #IdeSourceView::begin-macro and #IdeSourceView::end-macro.
*
* Since: 3.32
*/
signals [REPLAY_MACRO] =
g_signal_new ("replay-macro",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, replay_macro),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
G_TYPE_BOOLEAN);
signals [REQUEST_DOCUMENTATION] =
g_signal_new ("request-documentation",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, request_documentation),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
/**
* IdeSourceView::reset:
*
* This is a helper signal that will try to reset keyboard input
* and various stateful settings of the sourceview. This is a good
* signal to map to the "Escape" key.
*
* Since: 3.32
*/
signals [RESET] =
g_signal_new_class_handler ("reset",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_CALLBACK (ide_source_view_real_reset),
NULL, NULL, NULL, G_TYPE_NONE, 0);
signals [RESET_FONT_SIZE] =
g_signal_new ("reset-font-size",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, reset_font_size),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [RESTORE_INSERT_MARK] =
g_signal_new ("restore-insert-mark",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, restore_insert_mark),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [SAVE_INSERT_MARK] =
g_signal_new ("save-insert-mark",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, save_insert_mark),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
g_signal_override_class_handler ("select-all",
G_TYPE_FROM_CLASS (klass),
G_CALLBACK (ide_source_view_real_select_all));
signals [SELECT_INNER] =
g_signal_new ("select-inner",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, select_inner),
NULL, NULL, NULL,
G_TYPE_NONE,
4,
G_TYPE_STRING,
G_TYPE_STRING,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
signals [SELECT_TAG] =
g_signal_new ("select-tag",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, select_tag),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
G_TYPE_BOOLEAN);
signals [SELECTION_THEATRIC] =
g_signal_new ("selection-theatric",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, selection_theatric),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
IDE_TYPE_SOURCE_VIEW_THEATRIC);
signals [SET_MODE] =
g_signal_new ("set-mode",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, set_mode),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
G_TYPE_STRING,
IDE_TYPE_SOURCE_VIEW_MODE_TYPE);
signals [SET_OVERWRITE] =
g_signal_new ("set-overwrite",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, set_overwrite),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
G_TYPE_BOOLEAN);
signals [SET_SEARCH_TEXT] =
g_signal_new ("set-search-text",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, set_search_text),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
G_TYPE_STRING,
G_TYPE_BOOLEAN);
/**
* IdeSourceView::sort:
* @self: an #IdeSourceView.
* @ignore_case: If character case should be ignored.
* @reverse: If the lines should be sorted in reverse order
*
* This signal is meant to be activated from keybindings to sort the currently selected lines.
* The lines are sorted using qsort() and either strcmp() or strcasecmp().
*
* Since: 3.32
*/
signals [SORT] =
g_signal_new ("sort",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, sort),
NULL, NULL, NULL,
G_TYPE_NONE,
2,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
signals [SWAP_SELECTION_BOUNDS] =
g_signal_new ("swap-selection-bounds",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, swap_selection_bounds),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
signals [ADD_CURSOR] =
g_signal_new ("add-cursor",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, add_cursor),
NULL, NULL, NULL,
G_TYPE_NONE,
1,
IDE_TYPE_CURSOR_TYPE);
signals [REMOVE_CURSORS] =
g_signal_new ("remove-cursors",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (IdeSourceViewClass, remove_cursors),
NULL, NULL, NULL,
G_TYPE_NONE,
0);
binding_set = gtk_binding_set_by_class (klass);
gtk_binding_entry_add_signal (binding_set,
GDK_KEY_r,
GDK_CONTROL_MASK | GDK_SHIFT_MASK,
"begin-rename", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_KEY_q,
GDK_CONTROL_MASK | GDK_SHIFT_MASK,
"query-code-action", 0);
gtk_binding_entry_add_signal (binding_set,
GDK_KEY_space,
GDK_CONTROL_MASK | GDK_SHIFT_MASK,
"find-references", 0);
/* Override "Home" and "<Shift>Home" to use our movements
* instead of the smart home feature of GtkSourceView.
*/
gtk_binding_entry_add_signal (binding_set,
GDK_KEY_Home,
0,
"movement", 4,
IDE_TYPE_SOURCE_VIEW_MOVEMENT, IDE_SOURCE_VIEW_MOVEMENT_SMART_HOME,
G_TYPE_BOOLEAN, FALSE,
G_TYPE_BOOLEAN, TRUE,
G_TYPE_BOOLEAN, FALSE);
gtk_binding_entry_add_signal (binding_set,
GDK_KEY_Home,
GDK_MOD1_MASK | GDK_SHIFT_MASK,
"movement", 4,
IDE_TYPE_SOURCE_VIEW_MOVEMENT, IDE_SOURCE_VIEW_MOVEMENT_SMART_HOME,
G_TYPE_BOOLEAN, TRUE,
G_TYPE_BOOLEAN, TRUE,
G_TYPE_BOOLEAN, FALSE);
/* Remove Emoji from GtkTextView, we'll add back in various keybinding modes */
binding_set = gtk_binding_set_by_class (g_type_class_peek (GTK_TYPE_TEXT_VIEW));
gtk_binding_entry_remove (binding_set, GDK_KEY_period, GDK_CONTROL_MASK);
gtk_binding_entry_remove (binding_set, GDK_KEY_semicolon, GDK_CONTROL_MASK);
}
static void
ide_source_view_init (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
DZL_COUNTER_INC (instances);
gtk_widget_add_events (GTK_WIDGET (self), GDK_ENTER_NOTIFY_MASK);
gtk_widget_set_has_tooltip (GTK_WIDGET (self), FALSE);
priv->include_regex = g_regex_new (INCLUDE_STATEMENTS,
G_REGEX_OPTIMIZE,
0,
NULL);
priv->show_line_numbers = TRUE;
priv->show_line_changes = TRUE;
priv->show_line_diagnostics = TRUE;
priv->interactive_completion = TRUE;
priv->target_line_column = 0;
priv->snippets = g_queue_new ();
priv->selections = g_queue_new ();
priv->font_scale = FONT_SCALE_NORMAL;
priv->command_str = g_string_sized_new (32);
priv->overscroll_num_lines = DEFAULT_OVERSCROLL_NUM_LINES;
priv->hover = _ide_hover_new (self);
priv->file_setting_bindings = dzl_binding_group_new ();
dzl_binding_group_bind (priv->file_setting_bindings, "auto-indent",
self, "auto-indent", G_BINDING_SYNC_CREATE);
dzl_binding_group_bind (priv->file_setting_bindings, "indent-width",
self, "indent-width", G_BINDING_SYNC_CREATE);
dzl_binding_group_bind (priv->file_setting_bindings, "tab-width",
self, "tab-width", G_BINDING_SYNC_CREATE);
dzl_binding_group_bind (priv->file_setting_bindings, "right-margin-position",
self, "right-margin-position", G_BINDING_SYNC_CREATE);
dzl_binding_group_bind (priv->file_setting_bindings, "indent-style",
self, "indent-style", G_BINDING_SYNC_CREATE);
dzl_binding_group_bind (priv->file_setting_bindings, "show-right-margin",
self, "show-right-margin", G_BINDING_SYNC_CREATE);
dzl_binding_group_bind (priv->file_setting_bindings, "insert-matching-brace",
self, "insert-matching-brace", G_BINDING_SYNC_CREATE);
dzl_binding_group_bind (priv->file_setting_bindings, "overwrite-braces",
self, "overwrite-braces", G_BINDING_SYNC_CREATE);
priv->buffer_signals = dzl_signal_group_new (IDE_TYPE_BUFFER);
dzl_signal_group_connect_object (priv->buffer_signals,
"changed",
G_CALLBACK (ide_source_view__buffer_changed_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"request-scroll-to-insert",
G_CALLBACK (ide_source_view__buffer_request_scroll_to_insert_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"line-flags-changed",
G_CALLBACK (ide_source_view__buffer_line_flags_changed_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"notify::can-redo",
G_CALLBACK (ide_source_view__buffer__notify_can_redo),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"notify::can-undo",
G_CALLBACK (ide_source_view__buffer__notify_can_undo),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"notify::file-settings",
G_CALLBACK (ide_source_view__buffer_notify_file_settings_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"notify::language",
G_CALLBACK (ide_source_view__buffer_notify_language_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"notify::style-scheme",
G_CALLBACK (ide_source_view__buffer_notify_style_scheme_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"insert-text",
G_CALLBACK (ide_source_view__buffer_insert_text_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"insert-text",
G_CALLBACK (ide_source_view__buffer_insert_text_after_cb),
self,
G_CONNECT_SWAPPED | G_CONNECT_AFTER);
dzl_signal_group_connect_object (priv->buffer_signals,
"delete-range",
G_CALLBACK (ide_source_view__buffer_delete_range_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"delete-range",
G_CALLBACK (ide_source_view__buffer_delete_range_after_cb),
self,
G_CONNECT_SWAPPED | G_CONNECT_AFTER);
dzl_signal_group_connect_object (priv->buffer_signals,
"mark-set",
G_CALLBACK (ide_source_view__buffer_mark_set_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"loaded",
G_CALLBACK (ide_source_view__buffer_loaded_cb),
self,
G_CONNECT_SWAPPED);
dzl_signal_group_connect_object (priv->buffer_signals,
"notify::has-selection",
G_CALLBACK (ide_source_view__buffer_notify_has_selection_cb),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (priv->buffer_signals,
"bind",
G_CALLBACK (ide_source_view_bind_buffer),
self,
G_CONNECT_SWAPPED);
g_signal_connect_object (priv->buffer_signals,
"unbind",
G_CALLBACK (ide_source_view_unbind_buffer),
self,
G_CONNECT_SWAPPED);
g_object_bind_property_full (self, "buffer", priv->buffer_signals, "target", 0,
ignore_invalid_buffers, NULL, NULL, NULL);
dzl_widget_action_group_attach (self, "sourceview");
}
const PangoFontDescription *
ide_source_view_get_font_desc (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), NULL);
return priv->font_desc;
}
/**
* ide_source_view_get_scaled_font_desc:
* @self: a #IdeSourceView
*
* Like ide_source_view_get_font_desc() but takes the editor zoom into
* account. You must free the result with pango_font_description_free().
*
* Returns: (transfer full): a #PangoFontDescription
*
* Since: 3.32
*/
PangoFontDescription *
ide_source_view_get_scaled_font_desc (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
PangoFontDescription *copy;
gdouble font_scale;
guint font_size;
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), NULL);
copy = pango_font_description_copy (priv->font_desc);
font_size = pango_font_description_get_size (priv->font_desc);
font_scale = fontScale [priv->font_scale];
pango_font_description_set_size (copy, font_size * font_scale);
return g_steal_pointer (&copy);
}
void
ide_source_view_set_font_desc (IdeSourceView *self,
const PangoFontDescription *font_desc)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
if (font_desc != priv->font_desc)
{
g_clear_pointer (&priv->font_desc, pango_font_description_free);
if (font_desc)
priv->font_desc = pango_font_description_copy (font_desc);
else
priv->font_desc = pango_font_description_from_string (DEFAULT_FONT_DESC);
priv->font_scale = FONT_SCALE_NORMAL;
ide_source_view_rebuild_css (self);
}
}
void
ide_source_view_set_font_name (IdeSourceView *self,
const gchar *font_name)
{
PangoFontDescription *font_desc = NULL;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
if (font_name)
font_desc = pango_font_description_from_string (font_name);
ide_source_view_set_font_desc (self, font_desc);
if (font_desc)
pango_font_description_free (font_desc);
}
gboolean
ide_source_view_get_show_line_changes (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->show_line_changes;
}
void
ide_source_view_set_show_line_changes (IdeSourceView *self,
gboolean show_line_changes)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
priv->show_line_changes = !!show_line_changes;
if (priv->gutter)
{
ide_gutter_set_show_line_changes (priv->gutter, show_line_changes);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SHOW_LINE_CHANGES]);
}
}
gboolean
ide_source_view_get_show_line_diagnostics (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->show_line_diagnostics;
}
void
ide_source_view_set_show_line_diagnostics (IdeSourceView *self,
gboolean show_line_diagnostics)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
priv->show_line_diagnostics = !!show_line_diagnostics;
if (priv->gutter)
{
ide_gutter_set_show_line_diagnostics (priv->gutter, show_line_diagnostics);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SHOW_LINE_DIAGNOSTICS]);
}
}
gboolean
ide_source_view_get_show_grid_lines (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->show_grid_lines;
}
void
ide_source_view_set_show_grid_lines (IdeSourceView *self,
gboolean show_grid_lines)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
show_grid_lines = !!show_grid_lines;
if (show_grid_lines != priv->show_grid_lines)
{
priv->show_grid_lines = show_grid_lines;
if (show_grid_lines)
gtk_source_view_set_background_pattern (GTK_SOURCE_VIEW (self),
GTK_SOURCE_BACKGROUND_PATTERN_TYPE_GRID);
else
gtk_source_view_set_background_pattern (GTK_SOURCE_VIEW (self),
GTK_SOURCE_BACKGROUND_PATTERN_TYPE_NONE);
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SHOW_GRID_LINES]);
}
}
gboolean
ide_source_view_get_insert_matching_brace (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->insert_matching_brace;
}
void
ide_source_view_get_iter_at_visual_column (IdeSourceView *self,
guint column,
GtkTextIter *location)
{
gunichar tab_char;
guint visual_col = 0;
guint tab_width;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
tab_char = g_utf8_get_char ("\t");
tab_width = gtk_source_view_get_tab_width (GTK_SOURCE_VIEW (self));
gtk_text_iter_set_line_offset (location, 0);
while (!gtk_text_iter_ends_line (location))
{
if (gtk_text_iter_get_char (location) == tab_char)
visual_col += (tab_width - (visual_col % tab_width));
else
++visual_col;
if (visual_col > column)
break;
/* FIXME: this does not handle invisible text correctly, but
* * gtk_text_iter_forward_visible_cursor_position is too
* slow */
if (!gtk_text_iter_forward_char (location))
break;
}
}
const gchar *
ide_source_view_get_mode_name (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), NULL);
if (priv->mode)
return ide_source_view_mode_get_name (priv->mode);
return NULL;
}
const gchar *
ide_source_view_get_mode_display_name (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), NULL);
return priv->display_name;
}
gboolean
ide_source_view_get_overwrite_braces (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->overwrite_braces;
}
void
ide_source_view_set_insert_matching_brace (IdeSourceView *self,
gboolean insert_matching_brace)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
insert_matching_brace = !!insert_matching_brace;
if (insert_matching_brace != priv->insert_matching_brace)
{
priv->insert_matching_brace = insert_matching_brace;
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_INSERT_MATCHING_BRACE]);
}
}
void
ide_source_view_set_overwrite_braces (IdeSourceView *self,
gboolean overwrite_braces)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
overwrite_braces = !!overwrite_braces;
if (overwrite_braces != priv->overwrite_braces)
{
priv->overwrite_braces = overwrite_braces;
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_OVERWRITE_BRACES]);
}
}
void
ide_source_view_pop_snippet (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSnippet *snippet;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
if ((snippet = g_queue_pop_head (priv->snippets)))
{
g_autofree gchar *new_text = NULL;
new_text = ide_snippet_get_full_text (snippet);
ide_snippet_finish (snippet);
g_signal_emit (self, signals [POP_SNIPPET], 0, snippet);
g_object_unref (snippet);
if ((snippet = g_queue_peek_head (priv->snippets)))
{
ide_snippet_replace_current_chunk_text (snippet, new_text);
ide_snippet_unpause (snippet);
ide_snippet_move_next (snippet);
}
}
ide_source_view_invalidate_window (self);
}
void
ide_source_view_clear_snippets (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
while (priv->snippets->length)
ide_source_view_pop_snippet (self);
}
/**
* ide_source_view_push_snippet:
* @self: An #IdeSourceView
* @snippet: An #IdeSnippet.
* @location: (allow-none): A location for the snippet or %NULL.
*
* Pushes a new snippet onto the source view.
*
* Since: 3.32
*/
void
ide_source_view_push_snippet (IdeSourceView *self,
IdeSnippet *snippet,
const GtkTextIter *location)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IdeSnippetContext *context;
IdeSnippet *previous;
GtkTextBuffer *buffer;
GtkTextIter iter;
gboolean has_more_tab_stops;
gboolean insert_spaces;
gchar *line_prefix;
guint tab_width;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
g_return_if_fail (IDE_IS_SNIPPET (snippet));
g_return_if_fail (!location ||
(gtk_text_iter_get_buffer (location) == (void*)priv->buffer));
if ((previous = g_queue_peek_head (priv->snippets)))
ide_snippet_pause (previous);
g_queue_push_head (priv->snippets, g_object_ref (snippet));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
if (location != NULL)
iter = *location;
else
gtk_text_buffer_get_iter_at_mark (buffer, &iter, gtk_text_buffer_get_insert (buffer));
context = ide_snippet_get_context (snippet);
insert_spaces = gtk_source_view_get_insert_spaces_instead_of_tabs (GTK_SOURCE_VIEW (self));
ide_snippet_context_set_use_spaces (context, insert_spaces);
tab_width = gtk_source_view_get_tab_width (GTK_SOURCE_VIEW (self));
ide_snippet_context_set_tab_width (context, tab_width);
line_prefix = text_iter_get_line_prefix (&iter);
ide_snippet_context_set_line_prefix (context, line_prefix);
g_free (line_prefix);
g_signal_emit (self, signals [PUSH_SNIPPET], 0, snippet, &iter);
gtk_text_buffer_begin_user_action (buffer);
ide_source_view_block_handlers (self);
has_more_tab_stops = ide_snippet_begin (snippet, buffer, &iter);
ide_source_view_scroll_to_insert (self);
ide_source_view_unblock_handlers (self);
gtk_text_buffer_end_user_action (buffer);
if (!ide_source_view_can_animate (self))
{
GtkTextMark *mark_begin;
GtkTextMark *mark_end;
mark_begin = ide_snippet_get_mark_begin (snippet);
mark_end = ide_snippet_get_mark_end (snippet);
if (mark_begin != NULL && mark_end != NULL)
{
GtkTextIter begin;
GtkTextIter end;
gtk_text_buffer_get_iter_at_mark (buffer, &begin, mark_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &end, mark_end);
/*
* HACK:
*
* We need to let the GtkTextView catch up with us so that we can get
* a realistic area back for the location of the end iter. Without
* pumping the main loop, GtkTextView will clamp the result to the
* height of the insert line.
*/
while (gtk_events_pending ())
gtk_main_iteration ();
animate_expand (self, &begin, &end);
}
}
if (!has_more_tab_stops)
ide_source_view_pop_snippet (self);
ide_source_view_invalidate_window (self);
}
void
ide_source_view_jump (IdeSourceView *self,
const GtkTextIter *from,
const GtkTextIter *to)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IDE_ENTRY;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
if (priv->buffer != NULL &&
!ide_buffer_get_loading (priv->buffer))
{
GtkTextIter dummy_from;
GtkTextIter dummy_to;
if (from == NULL)
{
GtkTextMark *mark;
mark = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER (priv->buffer));
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (priv->buffer), &dummy_from, mark);
from = &dummy_from;
}
if (to == NULL)
{
dummy_to = *from;
to = &dummy_to;
}
g_signal_emit (self, signals [JUMP], 0, from, to);
}
IDE_EXIT;
}
/**
* ide_source_view_get_scroll_offset:
*
* Gets the #IdeSourceView:scroll-offset property. This property contains the number of lines
* that should be kept above or below the line containing the insertion cursor relative to the
* top and bottom of the visible text window.
*
* Since: 3.32
*/
guint
ide_source_view_get_scroll_offset (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), 0);
return priv->scroll_offset;
}
/**
* ide_source_view_set_scroll_offset:
*
* Sets the #IdeSourceView:scroll-offset property. See ide_source_view_get_scroll_offset() for
* more information. Set to 0 to unset this property.
*
* Since: 3.32
*/
void
ide_source_view_set_scroll_offset (IdeSourceView *self,
guint scroll_offset)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
if (scroll_offset != priv->scroll_offset)
{
priv->scroll_offset = scroll_offset;
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_SCROLL_OFFSET]);
}
}
/**
* ide_source_view_get_visible_rect:
* @self: An #IdeSourceView.
* @visible_rect: (out): a #GdkRectangle.
*
* Gets the visible region in buffer coordinates that is the visible area of the buffer. This
* is similar to gtk_text_view_get_visible_area() except that it takes into account the
* #IdeSourceView:scroll-offset property to ensure there is space above and below the
* visible_rect.
*
* Since: 3.32
*/
void
ide_source_view_get_visible_rect (IdeSourceView *self,
GdkRectangle *visible_rect)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextView *text_view = (GtkTextView *)self;
GdkRectangle area;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
g_return_if_fail (visible_rect);
gtk_text_view_get_visible_rect (text_view, &area);
/*
* If we don't have valid line height, not much we can do now. We can just adjust things
* later once it becomes available.
*/
if (priv->cached_char_height)
{
gint max_scroll_offset;
gint scroll_offset;
gint visible_lines;
gint scroll_offset_height;
visible_lines = area.height / priv->cached_char_height;
max_scroll_offset = (visible_lines - 1) / 2;
scroll_offset = MIN ((gint)priv->scroll_offset, max_scroll_offset);
scroll_offset_height = priv->cached_char_height * scroll_offset;
area.y += scroll_offset_height;
area.height -= (2 * scroll_offset_height);
/*
* If we have an even number of visible lines and scrolloffset is less than our
* desired scrolloffset, we need to remove an extra line so we don't have two
* visible lines.
*/
if ((scroll_offset < (gint)priv->scroll_offset) && (visible_lines & 1) == 0)
area.height -= priv->cached_char_height;
/*
* Use a multiple of the line height so we don't jump around when
* focusing the last line (due to Y2 not fitting in the visible area).
*/
area.height = (area.height / priv->cached_char_height) * priv->cached_char_height;
}
*visible_rect = area;
}
void
ide_source_view_scroll_mark_onscreen (IdeSourceView *self,
GtkTextMark *mark,
IdeSourceScrollAlign use_align,
gdouble alignx,
gdouble aligny)
{
GtkTextView *text_view = (GtkTextView *)self;
GtkTextBuffer *buffer;
GdkRectangle visible_rect;
GdkRectangle mark_rect;
GtkTextIter iter;
IDE_ENTRY;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
ide_source_view_get_visible_rect (self, &visible_rect);
buffer = gtk_text_view_get_buffer (text_view);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
gtk_text_view_get_iter_location (text_view, &iter, &mark_rect);
if (!_GDK_RECTANGLE_CONTAINS (&visible_rect, &mark_rect))
ide_source_view_scroll_to_mark (self, mark, 0.0, use_align, alignx, aligny, TRUE);
IDE_EXIT;
}
gboolean
ide_source_view_move_mark_onscreen (IdeSourceView *self,
GtkTextMark *mark)
{
GtkTextView *text_view = (GtkTextView *)self;
GtkTextBuffer *buffer;
GtkTextIter iter;
GtkTextIter end;
GdkRectangle visible_rect;
GdkRectangle iter_rect;
IDE_ENTRY;
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
g_return_val_if_fail (GTK_IS_TEXT_MARK (mark), FALSE);
buffer = gtk_text_view_get_buffer (text_view);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
gtk_text_buffer_get_end_iter (buffer, &end);
ide_source_view_get_visible_rect (self, &visible_rect);
gtk_text_view_get_iter_location (text_view, &iter, &iter_rect);
if (_GDK_RECTANGLE_CONTAINS (&visible_rect, &iter_rect))
IDE_RETURN (FALSE);
if (_GDK_RECTANGLE_Y2 (&iter_rect) > _GDK_RECTANGLE_Y2 (&visible_rect))
gtk_text_view_get_iter_at_location (text_view, &iter,
_GDK_RECTANGLE_X2 (&visible_rect),
_GDK_RECTANGLE_Y2 (&visible_rect));
else if (iter_rect.y < visible_rect.y)
gtk_text_view_get_iter_at_location (text_view, &iter, visible_rect.x, visible_rect.y);
else
return gtk_text_view_move_mark_onscreen (text_view, mark);
gtk_text_buffer_move_mark (buffer, mark, &iter);
IDE_RETURN (TRUE);
}
static gboolean
ide_source_view_mark_is_onscreen (IdeSourceView *self,
GtkTextMark *mark)
{
GtkTextBuffer *buffer;
GdkRectangle visible_rect;
GdkRectangle mark_rect;
GtkTextIter iter;
g_assert (IDE_IS_SOURCE_VIEW (self));
g_assert (GTK_IS_TEXT_MARK (mark));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
ide_source_view_get_visible_rect (self, &visible_rect);
gtk_text_view_get_iter_location (GTK_TEXT_VIEW (self), &iter, &mark_rect);
return (_GDK_RECTANGLE_CONTAINS (&visible_rect, &mark_rect));
}
static void
ide_source_view__vadj_animation_completed (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
IDE_ENTRY;
g_assert (IDE_IS_SOURCE_VIEW (self));
/*
* If the mark we were scrolling to is not yet on screen, then just wait for another size
* allocate so that we can continue making progress.
*/
if (!ide_source_view_mark_is_onscreen (self, priv->scroll_mark))
IDE_EXIT;
priv->scrolling_to_scroll_mark = FALSE;
IDE_EXIT;
}
/*
* Many parts of this function were taken from gtk_text_view_scroll_to_iter ()
* https://developer.gnome.org/gtk3/stable/GtkTextView.html#gtk-text-view-scroll-to-iter
*/
void
ide_source_view_scroll_to_iter (IdeSourceView *self,
const GtkTextIter *iter,
gdouble within_margin,
IdeSourceScrollAlign use_align,
gdouble xalign,
gdouble yalign,
gboolean animate_scroll)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextView *text_view = (GtkTextView *)self;
GtkTextBuffer *buffer;
GdkRectangle rect;
GdkRectangle screen;
gint xvalue = 0;
gint yvalue = 0;
gint scroll_dest;
gint screen_bottom;
gint screen_right;
gint screen_xoffset;
gint screen_yoffset;
gint current_x_scroll;
gint current_y_scroll;
GtkAdjustment *hadj;
GtkAdjustment *vadj;
IDE_ENTRY;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
g_return_if_fail (iter != NULL);
g_return_if_fail (within_margin >= 0.0 && within_margin <= 0.5);
g_return_if_fail (xalign >= 0.0 && xalign <= 1.0);
g_return_if_fail (yalign >= 0.0 && yalign <= 1.0);
if (!ide_source_view_can_animate (self))
animate_scroll = FALSE;
buffer = gtk_text_view_get_buffer (text_view);
gtk_text_buffer_move_mark (buffer, priv->scroll_mark, iter);
hadj = gtk_scrollable_get_hadjustment (GTK_SCROLLABLE (self));
vadj = gtk_scrollable_get_vadjustment (GTK_SCROLLABLE (self));
gtk_text_view_get_iter_location (text_view,
iter,
&rect);
gtk_text_view_get_visible_rect (text_view, &screen);
current_x_scroll = screen.x;
current_y_scroll = screen.y;
screen_xoffset = screen.width * within_margin;
screen_yoffset = screen.height * within_margin;
screen.x += screen_xoffset;
screen.y += screen_yoffset;
screen.width -= screen_xoffset * 2;
screen.height -= screen_yoffset * 2;
/* paranoia check */
if (screen.width < 1)
screen.width = 1;
if (screen.height < 1)
screen.height = 1;
/* The -1 here ensures that we leave enough space to draw the cursor
* when this function is used for horizontal scrolling.
*/
screen_right = screen.x + screen.width - 1;
screen_bottom = screen.y + screen.height;
/* The alignment affects the point in the target character that we
* choose to align. If we're doing right/bottom alignment, we align
* the right/bottom edge of the character the mark is at; if we're
* doing left/top we align the left/top edge of the character; if
* we're doing center alignment we align the center of the
* character.
*/
/* Vertical alignment */
scroll_dest = current_y_scroll;
if (SCROLL_Y (use_align))
{
scroll_dest = rect.y + (rect.height * yalign) - (screen.height * yalign);
/* if scroll_dest < screen.y, we move a negative increment (up),
* else a positive increment (down)
*/
yvalue = scroll_dest - screen.y + screen_yoffset;
}
else
{
/* move minimum to get onscreen */
if (rect.y < screen.y)
{
scroll_dest = rect.y;
yvalue = scroll_dest - screen.y - screen_yoffset;
}
else if ((rect.y + rect.height) > screen_bottom)
{
scroll_dest = rect.y + rect.height;
yvalue = scroll_dest - screen_bottom + screen_yoffset;
}
}
yvalue += current_y_scroll;
/* Scroll offset adjustment */
if (priv->cached_char_height)
{
gint max_scroll_offset;
gint visible_lines;
gint scroll_offset;
gint scroll_offset_height;
visible_lines = screen.height / priv->cached_char_height;
max_scroll_offset = (visible_lines - 1) / 2;
scroll_offset = MIN ((gint)priv->scroll_offset, max_scroll_offset);
scroll_offset_height = priv->cached_char_height * scroll_offset;
if (scroll_offset_height > 0)
{
if (rect.y - scroll_offset_height < yvalue)
yvalue -= (scroll_offset_height - (rect.y - yvalue));
else if (_GDK_RECTANGLE_Y2 (&rect) + scroll_offset_height > yvalue + screen.height)
yvalue += (_GDK_RECTANGLE_Y2 (&rect) + scroll_offset_height) - (yvalue + screen.height);
}
}
/* Horizontal alignment */
scroll_dest = current_x_scroll;
if (SCROLL_X (use_align))
{
scroll_dest = rect.x + (rect.width * xalign) - (screen.width * xalign);
/* if scroll_dest < screen.y, we move a negative increment (left),
* else a positive increment (right)
*/
xvalue = scroll_dest - screen.x + screen_xoffset;
}
else
{
/* move minimum to get onscreen */
if (rect.x < screen.x)
{
scroll_dest = rect.x;
xvalue = scroll_dest - screen.x - screen_xoffset;
}
else if ((rect.x + rect.width) > screen_right)
{
scroll_dest = rect.x + rect.width;
xvalue = scroll_dest - screen_right + screen_xoffset;
}
}
xvalue += current_x_scroll;
if (animate_scroll)
{
GdkFrameClock *frame_clock = gtk_widget_get_frame_clock (GTK_WIDGET (self));
guint duration_msec = LARGE_SCROLL_DURATION_MSEC;
gdouble difference;
gdouble page_size;
gdouble current;
current = gtk_adjustment_get_value (vadj);
page_size = gtk_adjustment_get_page_size (vadj);
difference = ABS (current - yvalue);
/*
* Ignore animations if we are scrolling less than two full lines. This
* helps when pressing up/down for key repeat. Also, if it's a partial
* page scroll (less than page size), use less time to animate, so it
* isn't so annoying.
*/
if (difference < (priv->cached_char_height * 2))
goto ignore_animation;
else if (difference <= page_size)
duration_msec = SMALL_SCROLL_DURATION_MSEC;
priv->scrolling_to_scroll_mark = TRUE;
if (priv->hadj_animation != NULL)
{
dzl_animation_stop (priv->hadj_animation);
g_clear_weak_pointer (&priv->hadj_animation);
}
priv->hadj_animation =
dzl_object_animate (hadj,
DZL_ANIMATION_EASE_OUT_CUBIC,
duration_msec,
frame_clock,
"value", (double)xvalue,
NULL);
g_object_add_weak_pointer (G_OBJECT (priv->hadj_animation),
(gpointer *)&priv->hadj_animation);
if (priv->vadj_animation != NULL)
{
dzl_animation_stop (priv->vadj_animation);
g_clear_weak_pointer (&priv->vadj_animation);
}
priv->vadj_animation =
dzl_object_animate_full (vadj,
DZL_ANIMATION_EASE_OUT_CUBIC,
duration_msec,
frame_clock,
(GDestroyNotify)ide_source_view__vadj_animation_completed,
self,
"value", (double)yvalue,
NULL);
g_object_add_weak_pointer (G_OBJECT (priv->vadj_animation),
(gpointer *)&priv->vadj_animation);
}
else
{
ignore_animation:
gtk_adjustment_set_value (hadj, xvalue);
gtk_adjustment_set_value (vadj, yvalue);
}
IDE_EXIT;
}
void
ide_source_view_scroll_to_mark (IdeSourceView *self,
GtkTextMark *mark,
gdouble within_margin,
IdeSourceScrollAlign use_align,
gdouble xalign,
gdouble yalign,
gboolean animate_scroll)
{
GtkTextBuffer *buffer;
GtkTextIter iter;
IDE_ENTRY;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
g_return_if_fail (GTK_IS_TEXT_MARK (mark));
g_return_if_fail (xalign >= 0.0);
g_return_if_fail (xalign <= 1.0);
g_return_if_fail (yalign >= 0.0);
g_return_if_fail (yalign <= 1.0);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
ide_source_view_scroll_to_iter (self, &iter, within_margin, use_align, xalign, yalign,
animate_scroll);
#ifdef IDE_ENABLE_TRACE
{
const gchar *name = gtk_text_mark_get_name (mark);
IDE_TRACE_MSG ("Scrolling to mark \"%s\" at %d:%d",
name ? name : "unnamed",
gtk_text_iter_get_line (&iter),
gtk_text_iter_get_line_offset (&iter));
}
#endif
IDE_EXIT;
}
gboolean
ide_source_view_place_cursor_onscreen (IdeSourceView *self)
{
GtkTextBuffer *buffer;
GtkTextMark *insert;
gboolean ret;
IDE_ENTRY;
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
insert = gtk_text_buffer_get_insert (buffer);
ret = ide_source_view_move_mark_onscreen (self, insert);
IDE_RETURN (ret);
}
/**
* ide_source_view_get_file_settings:
* @self: an #IdeSourceView.
*
* Gets the #IdeSourceView:file-settings property. This contains various
* settings for how the file should be rendered in the view, and preferences
* such as spaces vs tabs.
*
* Returns: (transfer none) (nullable): An #IdeFileSettings or %NULL.
*
* Since: 3.32
*/
IdeFileSettings *
ide_source_view_get_file_settings (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), NULL);
return (IdeFileSettings *)dzl_binding_group_get_source (priv->file_setting_bindings);
}
gboolean
ide_source_view_get_highlight_current_line (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->highlight_current_line;
}
void
ide_source_view_set_highlight_current_line (IdeSourceView *self,
gboolean highlight_current_line)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
/*
* This overrides the default GtkSourceView::highlight-current-line so that
* we can turn off the line highlight when the IdeSourceView is not in focus.
* See ide_source_view_real_focus_in_event() and
* ide_source_view_real_focus_out_event() for the machinery.
*/
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
highlight_current_line = !!highlight_current_line;
if (highlight_current_line != priv->highlight_current_line)
{
priv->highlight_current_line = highlight_current_line;
g_object_notify (G_OBJECT (self), "highlight-current-line");
}
}
guint
ide_source_view_get_visual_column (IdeSourceView *self,
const GtkTextIter *location)
{
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), 0);
return gtk_source_view_get_visual_column(GTK_SOURCE_VIEW (self), location);
}
void
ide_source_view_get_visual_position (IdeSourceView *self,
guint *line,
guint *line_column)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkTextBuffer *buffer;
GtkTextIter iter;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (self));
if (!gtk_widget_has_focus (GTK_WIDGET (self)))
{
gtk_text_buffer_get_iter_at_line_offset (buffer, &iter, priv->saved_line, 0);
ide_source_view_get_iter_at_visual_column (self, priv->saved_line_column, &iter);
}
else
{
GtkTextMark *mark;
mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &iter, mark);
}
if (line)
*line = gtk_text_iter_get_line (&iter);
if (line_column)
*line_column = gtk_source_view_get_visual_column (GTK_SOURCE_VIEW (self), &iter);
}
gint
ide_source_view_get_count (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), 0);
return priv->count;
}
void
ide_source_view_set_count (IdeSourceView *self,
gint count)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
if (count < 0)
count = 0;
if (count != priv->count)
{
priv->count = count;
g_object_notify_by_pspec (G_OBJECT (self), properties [PROP_COUNT]);
}
}
GtkTextMark *
_ide_source_view_get_scroll_mark (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), NULL);
return priv->scroll_mark;
}
/**
* ide_source_view_get_current_snippet:
*
* Gets the current snippet if there is one, otherwise %NULL.
*
* Returns: (transfer none) (nullable): An #IdeSnippet or %NULL.
*
* Since: 3.32
*/
IdeSnippet *
ide_source_view_get_current_snippet (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), NULL);
return g_queue_peek_head (priv->snippets);
}
gboolean
ide_source_view_get_show_line_numbers (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->show_line_numbers;
}
void
ide_source_view_set_show_line_numbers (IdeSourceView *self,
gboolean show_line_numbers)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
priv->show_line_numbers = !!show_line_numbers;
if (priv->gutter)
{
ide_gutter_set_show_line_numbers (priv->gutter, show_line_numbers);
g_object_notify (G_OBJECT (self), "show-line-numbers");
}
}
gboolean
ide_source_view_get_show_relative_line_numbers (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->show_relative_line_numbers;
}
void
ide_source_view_set_show_relative_line_numbers (IdeSourceView *self,
gboolean show_relative_line_numbers)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
priv->show_relative_line_numbers = !!show_relative_line_numbers;
if (priv->gutter)
{
ide_gutter_set_show_relative_line_numbers (priv->gutter, show_relative_line_numbers);
g_object_notify (G_OBJECT (self), "show-relative-line-numbers");
}
}
gboolean
ide_source_view_is_processing_key (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->in_key_press > 0;
}
/**
* ide_source_view_get_completion:
* @self: a #IdeSourceView
*
* Get the completion for the #IdeSourceView
*
* Returns: (transfer none): an #IdeCompletion
*
* Since: 3.32
*/
IdeCompletion *
ide_source_view_get_completion (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), NULL);
return priv->completion;
}
/**
* ide_source_view_has_snippet:
* @self: a #IdeSourceView
*
* Checks if there is an active snippet.
*
* Returns: %TRUE if there is an active snippet.
*
* Since: 3.32
*/
gboolean
ide_source_view_has_snippet (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->snippets->length > 0;
}
/**
* ide_source_view_set_gutter:
* @self: a #IdeSourceView
* @gutter: an #IdeGutter
*
* Allows setting the gutter for the sourceview.
*
* Generally, this will always be #IdeOmniGutterRenderer. However, to avoid
* circular dependencies, an interface is used to allow plugins to set
* this object.
*
* Since: 3.32
*/
void
ide_source_view_set_gutter (IdeSourceView *self,
IdeGutter *gutter)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
GtkSourceGutter *left_gutter;
g_return_if_fail (IDE_IS_SOURCE_VIEW (self));
g_return_if_fail (!gutter || IDE_IS_GUTTER (gutter));
g_return_if_fail (!gutter || GTK_SOURCE_IS_GUTTER_RENDERER (gutter));
if (gutter == priv->gutter)
return;
left_gutter = gtk_source_view_get_gutter (GTK_SOURCE_VIEW (self),
GTK_TEXT_WINDOW_LEFT);
if (priv->gutter)
{
gtk_source_gutter_remove (left_gutter, GTK_SOURCE_GUTTER_RENDERER (priv->gutter));
g_clear_object (&priv->gutter);
}
if (gutter)
{
priv->gutter = g_object_ref_sink (gutter);
gtk_source_gutter_insert (left_gutter,
GTK_SOURCE_GUTTER_RENDERER (gutter),
0);
ide_gutter_set_show_line_numbers (priv->gutter, priv->show_line_numbers);
ide_gutter_set_show_relative_line_numbers (priv->gutter, priv->show_relative_line_numbers);
ide_gutter_set_show_line_changes (priv->gutter, priv->show_line_changes);
ide_gutter_set_show_line_diagnostics (priv->gutter, priv->show_line_diagnostics);
ide_gutter_style_changed (gutter);
}
g_object_notify (G_OBJECT (self), "show-line-changes");
g_object_notify (G_OBJECT (self), "show-line-diagnostics");
g_object_notify (G_OBJECT (self), "show-line-numbers");
g_object_notify (G_OBJECT (self), "show-relative-line-numbers");
}
gboolean
_ide_source_view_has_cursors (IdeSourceView *self)
{
IdeSourceViewPrivate *priv = ide_source_view_get_instance_private (self);
g_return_val_if_fail (IDE_IS_SOURCE_VIEW (self), FALSE);
return priv->cursor != NULL && ide_cursor_is_enabled (priv->cursor);
}
Reference in New Issue View Git Blame Copy Permalink