godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
121e1df55b
godot/scene/gui/code_edit.cpp
Rémi Verschelde 1b31241445 Merge pull request #65540 from MewPurPur/easier-bookmarks 
Implement Shift+LMB as a Way to Toggle Bookmarks
2022-09-26 08:20:40 +02:00

3192 lines
108 KiB
C++
Raw Blame History

/*************************************************************************/
/* code_edit.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
#include "code_edit.h"
#include "core/os/keyboard.h"
#include "core/string/string_builder.h"
#include "core/string/ustring.h"
void CodeEdit::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_THEME_CHANGED:
case NOTIFICATION_ENTER_TREE: {
style_normal = get_theme_stylebox(SNAME("normal"));
font = get_theme_font(SNAME("font"));
font_size = get_theme_font_size(SNAME("font_size"));
line_spacing = get_theme_constant(SNAME("line_spacing"));
set_gutter_width(main_gutter, get_line_height());
set_gutter_width(line_number_gutter, (line_number_digits + 1) * font->get_char_size('0', font_size).width);
set_gutter_width(fold_gutter, get_line_height() / 1.2);
breakpoint_color = get_theme_color(SNAME("breakpoint_color"));
breakpoint_icon = get_theme_icon(SNAME("breakpoint"));
bookmark_color = get_theme_color(SNAME("bookmark_color"));
bookmark_icon = get_theme_icon(SNAME("bookmark"));
executing_line_color = get_theme_color(SNAME("executing_line_color"));
executing_line_icon = get_theme_icon(SNAME("executing_line"));
line_number_color = get_theme_color(SNAME("line_number_color"));
folding_color = get_theme_color(SNAME("code_folding_color"));
can_fold_icon = get_theme_icon(SNAME("can_fold"));
folded_icon = get_theme_icon(SNAME("folded"));
code_completion_max_width = get_theme_constant(SNAME("completion_max_width"));
code_completion_max_lines = get_theme_constant(SNAME("completion_lines"));
code_completion_scroll_width = get_theme_constant(SNAME("completion_scroll_width"));
code_completion_scroll_color = get_theme_color(SNAME("completion_scroll_color"));
code_completion_scroll_hovered_color = get_theme_color(SNAME("completion_scroll_hovered_color"));
code_completion_background_color = get_theme_color(SNAME("completion_background_color"));
code_completion_selected_color = get_theme_color(SNAME("completion_selected_color"));
code_completion_existing_color = get_theme_color(SNAME("completion_existing_color"));
line_length_guideline_color = get_theme_color(SNAME("line_length_guideline_color"));
} break;
case NOTIFICATION_DRAW: {
RID ci = get_canvas_item();
const Size2 size = get_size();
const bool caret_visible = is_caret_visible();
const bool rtl = is_layout_rtl();
const int row_height = get_line_height();
if (line_length_guideline_columns.size() > 0) {
const int xmargin_beg = style_normal->get_margin(SIDE_LEFT) + get_total_gutter_width();
const int xmargin_end = size.width - style_normal->get_margin(SIDE_RIGHT) - (is_drawing_minimap() ? get_minimap_width() : 0);
const float char_size = font->get_char_size('0', font_size).width;
for (int i = 0; i < line_length_guideline_columns.size(); i++) {
const int xoffset = xmargin_beg + char_size * (int)line_length_guideline_columns[i] - get_h_scroll();
if (xoffset > xmargin_beg && xoffset < xmargin_end) {
Color guideline_color = (i == 0) ? line_length_guideline_color : line_length_guideline_color * Color(1, 1, 1, 0.5);
if (rtl) {
RenderingServer::get_singleton()->canvas_item_add_line(ci, Point2(size.width - xoffset, 0), Point2(size.width - xoffset, size.height), guideline_color);
continue;
}
RenderingServer::get_singleton()->canvas_item_add_line(ci, Point2(xoffset, 0), Point2(xoffset, size.height), guideline_color);
}
}
}
bool code_completion_below = false;
if (caret_visible && code_completion_active && code_completion_options.size() > 0) {
Ref<StyleBox> csb = get_theme_stylebox(SNAME("completion"));
const int code_completion_options_count = code_completion_options.size();
const int lines = MIN(code_completion_options_count, code_completion_max_lines);
const int icon_hsep = get_theme_constant(SNAME("h_separation"), SNAME("ItemList"));
const Size2 icon_area_size(row_height, row_height);
code_completion_rect.size.width = code_completion_longest_line + icon_hsep + icon_area_size.width + 2;
code_completion_rect.size.height = lines * row_height;
const Point2 caret_pos = get_caret_draw_pos();
const int total_height = csb->get_minimum_size().y + code_completion_rect.size.height;
if (caret_pos.y + row_height + total_height > get_size().height) {
code_completion_rect.position.y = (caret_pos.y - total_height - row_height) + line_spacing;
} else {
code_completion_rect.position.y = caret_pos.y + (line_spacing / 2.0f);
code_completion_below = true;
}
const int scroll_width = code_completion_options_count > code_completion_max_lines ? code_completion_scroll_width : 0;
const int code_completion_base_width = font->get_string_size(code_completion_base, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width;
if (caret_pos.x - code_completion_base_width + code_completion_rect.size.width + scroll_width > get_size().width) {
code_completion_rect.position.x = get_size().width - code_completion_rect.size.width - scroll_width;
} else {
code_completion_rect.position.x = caret_pos.x - code_completion_base_width;
}
draw_style_box(csb, Rect2(code_completion_rect.position - csb->get_offset(), code_completion_rect.size + csb->get_minimum_size() + Size2(scroll_width, 0)));
if (code_completion_background_color.a > 0.01) {
RenderingServer::get_singleton()->canvas_item_add_rect(ci, Rect2(code_completion_rect.position, code_completion_rect.size + Size2(scroll_width, 0)), code_completion_background_color);
}
code_completion_scroll_rect.position = code_completion_rect.position + Vector2(code_completion_rect.size.width, 0);
code_completion_scroll_rect.size = Vector2(scroll_width, code_completion_rect.size.height);
code_completion_line_ofs = CLAMP(code_completion_current_selected - lines / 2, 0, code_completion_options_count - lines);
RenderingServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(code_completion_rect.position.x, code_completion_rect.position.y + (code_completion_current_selected - code_completion_line_ofs) * row_height), Size2(code_completion_rect.size.width, row_height)), code_completion_selected_color);
for (int i = 0; i < lines; i++) {
int l = code_completion_line_ofs + i;
ERR_CONTINUE(l < 0 || l >= code_completion_options_count);
Ref<TextLine> tl;
tl.instantiate();
tl->add_string(code_completion_options[l].display, font, font_size);
int yofs = (row_height - tl->get_size().y) / 2;
Point2 title_pos(code_completion_rect.position.x, code_completion_rect.position.y + i * row_height + yofs);
/* Draw completion icon if it is valid. */
const Ref<Texture2D> &icon = code_completion_options[l].icon;
Rect2 icon_area(code_completion_rect.position.x, code_completion_rect.position.y + i * row_height, icon_area_size.width, icon_area_size.height);
if (icon.is_valid()) {
Size2 icon_size = icon_area.size * 0.7;
icon->draw_rect(ci, Rect2(icon_area.position + (icon_area.size - icon_size) / 2, icon_size));
}
title_pos.x = icon_area.position.x + icon_area.size.width + icon_hsep;
tl->set_width(code_completion_rect.size.width - (icon_area_size.x + icon_hsep));
if (rtl) {
if (code_completion_options[l].default_value.get_type() == Variant::COLOR) {
draw_rect(Rect2(Point2(code_completion_rect.position.x, icon_area.position.y), icon_area_size), (Color)code_completion_options[l].default_value);
}
tl->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_RIGHT);
} else {
if (code_completion_options[l].default_value.get_type() == Variant::COLOR) {
draw_rect(Rect2(Point2(code_completion_rect.position.x + code_completion_rect.size.width - icon_area_size.x, icon_area.position.y), icon_area_size), (Color)code_completion_options[l].default_value);
}
tl->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_LEFT);
}
Point2 match_pos = Point2(code_completion_rect.position.x + icon_area_size.x + icon_hsep, code_completion_rect.position.y + i * row_height);
for (int j = 0; j < code_completion_options[l].matches.size(); j++) {
Pair<int, int> match = code_completion_options[l].matches[j];
int match_offset = font->get_string_size(code_completion_options[l].display.substr(0, match.first), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width;
int match_len = font->get_string_size(code_completion_options[l].display.substr(match.first, match.second), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width;
draw_rect(Rect2(match_pos + Point2(match_offset, 0), Size2(match_len, row_height)), code_completion_existing_color);
}
tl->draw(ci, title_pos, code_completion_options[l].font_color);
}
/* Draw a small scroll rectangle to show a position in the options. */
if (scroll_width) {
Color scroll_color = is_code_completion_scroll_hovered || is_code_completion_scroll_pressed ? code_completion_scroll_hovered_color : code_completion_scroll_color;
float r = (float)code_completion_max_lines / code_completion_options_count;
float o = (float)code_completion_line_ofs / code_completion_options_count;
draw_rect(Rect2(code_completion_rect.position.x + code_completion_rect.size.width, code_completion_rect.position.y + o * code_completion_rect.size.y, scroll_width, code_completion_rect.size.y * r), scroll_color);
}
}
/* Code hint */
if (caret_visible && !code_hint.is_empty() && (!code_completion_active || (code_completion_below != code_hint_draw_below))) {
const int font_height = font->get_height(font_size);
Ref<StyleBox> sb = get_theme_stylebox(SNAME("panel"), SNAME("TooltipPanel"));
Color font_color = get_theme_color(SNAME("font_color"), SNAME("TooltipLabel"));
Vector<String> code_hint_lines = code_hint.split("\n");
int line_count = code_hint_lines.size();
int max_width = 0;
for (int i = 0; i < line_count; i++) {
max_width = MAX(max_width, font->get_string_size(code_hint_lines[i], HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x);
}
Size2 minsize = sb->get_minimum_size() + Size2(max_width, line_count * font_height + (line_spacing * line_count - 1));
int offset = font->get_string_size(code_hint_lines[0].substr(0, code_hint_lines[0].find(String::chr(0xFFFF))), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x;
if (code_hint_xpos == -0xFFFF) {
code_hint_xpos = get_caret_draw_pos().x - offset;
}
Point2 hint_ofs = Vector2(code_hint_xpos, get_caret_draw_pos().y);
if (code_hint_draw_below) {
hint_ofs.y += line_spacing / 2.0f;
} else {
hint_ofs.y -= (minsize.y + row_height) - line_spacing;
}
draw_style_box(sb, Rect2(hint_ofs, minsize));
int yofs = 0;
for (int i = 0; i < line_count; i++) {
const String &line = code_hint_lines[i];
int begin = 0;
int end = 0;
if (line.contains(String::chr(0xFFFF))) {
begin = font->get_string_size(line.substr(0, line.find(String::chr(0xFFFF))), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x;
end = font->get_string_size(line.substr(0, line.rfind(String::chr(0xFFFF))), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).x;
}
Point2 round_ofs = hint_ofs + sb->get_offset() + Vector2(0, font->get_ascent(font_size) + font_height * i + yofs);
round_ofs = round_ofs.round();
draw_string(font, round_ofs, line.replace(String::chr(0xFFFF), ""), HORIZONTAL_ALIGNMENT_LEFT, -1, font_size, font_color);
if (end > 0) {
// Draw an underline for the currently edited function parameter.
const Vector2 b = hint_ofs + sb->get_offset() + Vector2(begin, font_height + font_height * i + yofs);
draw_line(b, b + Vector2(end - begin, 0), font_color, 2);
// Draw a translucent text highlight as well.
const Rect2 highlight_rect = Rect2(
b - Vector2(0, font_height),
Vector2(end - begin, font_height));
draw_rect(highlight_rect, font_color * Color(1, 1, 1, 0.2));
}
yofs += line_spacing;
}
}
} break;
}
}
void CodeEdit::gui_input(const Ref<InputEvent> &p_gui_input) {
Ref<InputEventMouseButton> mb = p_gui_input;
if (mb.is_valid()) {
/* Ignore mouse clicks in IME input mode. */
if (has_ime_text()) {
return;
}
if (is_code_completion_scroll_pressed && mb->get_button_index() == MouseButton::LEFT) {
is_code_completion_scroll_pressed = false;
queue_redraw();
return;
}
if (code_completion_active && code_completion_rect.has_point(mb->get_position())) {
if (!mb->is_pressed()) {
return;
}
switch (mb->get_button_index()) {
case MouseButton::WHEEL_UP: {
if (code_completion_current_selected > 0) {
code_completion_current_selected--;
queue_redraw();
}
} break;
case MouseButton::WHEEL_DOWN: {
if (code_completion_current_selected < code_completion_options.size() - 1) {
code_completion_current_selected++;
queue_redraw();
}
} break;
case MouseButton::LEFT: {
code_completion_current_selected = CLAMP(code_completion_line_ofs + (mb->get_position().y - code_completion_rect.position.y) / get_line_height(), 0, code_completion_options.size() - 1);
if (mb->is_double_click()) {
confirm_code_completion();
}
queue_redraw();
} break;
default:
break;
}
return;
} else if (code_completion_active && code_completion_scroll_rect.has_point(mb->get_position())) {
if (mb->get_button_index() != MouseButton::LEFT) {
return;
}
if (mb->is_pressed()) {
is_code_completion_scroll_pressed = true;
_update_scroll_selected_line(mb->get_position().y);
queue_redraw();
}
return;
}
cancel_code_completion();
set_code_hint("");
if (mb->is_pressed()) {
Vector2i mpos = mb->get_position();
if (is_layout_rtl()) {
mpos.x = get_size().x - mpos.x;
}
Point2i pos = get_line_column_at_pos(mpos, false);
int line = pos.y;
int col = pos.x;
if (line != -1 && mb->get_button_index() == MouseButton::LEFT) {
if (is_line_folded(line)) {
int wrap_index = get_line_wrap_index_at_column(line, col);
if (wrap_index == get_line_wrap_count(line)) {
int eol_icon_width = folded_eol_icon->get_width();
int left_margin = get_total_gutter_width() + eol_icon_width + get_line_width(line, wrap_index) - get_h_scroll();
if (mpos.x > left_margin && mpos.x <= left_margin + eol_icon_width + 3) {
unfold_line(line);
return;
}
}
}
}
} else {
if (mb->get_button_index() == MouseButton::LEFT) {
if (mb->is_command_or_control_pressed() && !symbol_lookup_word.is_empty()) {
Vector2i mpos = mb->get_position();
if (is_layout_rtl()) {
mpos.x = get_size().x - mpos.x;
}
Point2i pos = get_line_column_at_pos(mpos, false);
int line = pos.y;
int col = pos.x;
if (line != -1) {
emit_signal(SNAME("symbol_lookup"), symbol_lookup_word, line, col);
}
return;
}
}
}
}
Ref<InputEventMouseMotion> mm = p_gui_input;
if (mm.is_valid()) {
Vector2i mpos = mm->get_position();
if (is_layout_rtl()) {
mpos.x = get_size().x - mpos.x;
}
if (symbol_lookup_on_click_enabled) {
if (mm->is_command_or_control_pressed() && mm->get_button_mask() == MouseButton::NONE && !is_dragging_cursor()) {
symbol_lookup_new_word = get_word_at_pos(mpos);
if (symbol_lookup_new_word != symbol_lookup_word) {
emit_signal(SNAME("symbol_validate"), symbol_lookup_new_word);
}
} else {
set_symbol_lookup_word_as_valid(false);
}
}
bool scroll_hovered = code_completion_scroll_rect.has_point(mpos);
if (is_code_completion_scroll_hovered != scroll_hovered) {
is_code_completion_scroll_hovered = scroll_hovered;
queue_redraw();
}
if (is_code_completion_scroll_pressed) {
_update_scroll_selected_line(mpos.y);
queue_redraw();
return;
}
}
Ref<InputEventKey> k = p_gui_input;
if (TextEdit::alt_input(p_gui_input)) {
accept_event();
return;
}
bool update_code_completion = false;
if (!k.is_valid()) {
TextEdit::gui_input(p_gui_input);
return;
}
/* Ctrl + Hover symbols */
#ifdef MACOS_ENABLED
if (k->get_keycode() == Key::META) {
#else
if (k->get_keycode() == Key::CTRL) {
#endif
if (symbol_lookup_on_click_enabled) {
if (k->is_pressed() && !is_dragging_cursor()) {
symbol_lookup_new_word = get_word_at_pos(get_local_mouse_pos());
if (symbol_lookup_new_word != symbol_lookup_word) {
emit_signal(SNAME("symbol_validate"), symbol_lookup_new_word);
}
} else {
set_symbol_lookup_word_as_valid(false);
}
}
return;
}
/* If a modifier has been pressed, and nothing else, return. */
if (!k->is_pressed() || k->get_keycode() == Key::CTRL || k->get_keycode() == Key::ALT || k->get_keycode() == Key::SHIFT || k->get_keycode() == Key::META) {
return;
}
/* Allow unicode handling if: */
/* No Modifiers are pressed (except shift) */
bool allow_unicode_handling = !(k->is_command_or_control_pressed() || k->is_ctrl_pressed() || k->is_alt_pressed() || k->is_meta_pressed());
/* AUTO-COMPLETE */
if (code_completion_enabled && k->is_action("ui_text_completion_query", true)) {
request_code_completion(true);
accept_event();
return;
}
if (code_completion_active) {
if (k->is_action("ui_up", true)) {
if (code_completion_current_selected > 0) {
code_completion_current_selected--;
} else {
code_completion_current_selected = code_completion_options.size() - 1;
}
queue_redraw();
accept_event();
return;
}
if (k->is_action("ui_down", true)) {
if (code_completion_current_selected < code_completion_options.size() - 1) {
code_completion_current_selected++;
} else {
code_completion_current_selected = 0;
}
queue_redraw();
accept_event();
return;
}
if (k->is_action("ui_page_up", true)) {
code_completion_current_selected = MAX(0, code_completion_current_selected - code_completion_max_lines);
queue_redraw();
accept_event();
return;
}
if (k->is_action("ui_page_down", true)) {
code_completion_current_selected = MIN(code_completion_options.size() - 1, code_completion_current_selected + code_completion_max_lines);
queue_redraw();
accept_event();
return;
}
if (k->is_action("ui_home", true)) {
code_completion_current_selected = 0;
queue_redraw();
accept_event();
return;
}
if (k->is_action("ui_end", true)) {
code_completion_current_selected = code_completion_options.size() - 1;
queue_redraw();
accept_event();
return;
}
if (k->is_action("ui_text_completion_replace", true) || k->is_action("ui_text_completion_accept", true)) {
confirm_code_completion(k->is_action("ui_text_completion_replace", true));
accept_event();
return;
}
if (k->is_action("ui_cancel", true)) {
cancel_code_completion();
accept_event();
return;
}
if (k->is_action("ui_text_backspace", true)) {
backspace();
_filter_code_completion_candidates_impl();
accept_event();
return;
}
if (k->is_action("ui_left", true) || k->is_action("ui_right", true)) {
update_code_completion = true;
} else {
update_code_completion = (allow_unicode_handling && k->get_unicode() >= 32);
}
if (!update_code_completion) {
cancel_code_completion();
}
}
/* MISC */
if (!code_hint.is_empty() && k->is_action("ui_cancel", true)) {
set_code_hint("");
accept_event();
return;
}
if (allow_unicode_handling && k->get_unicode() == ')') {
set_code_hint("");
}
/* Indentation */
if (k->is_action("ui_text_indent", true)) {
do_indent();
accept_event();
return;
}
if (k->is_action("ui_text_dedent", true)) {
do_unindent();
accept_event();
return;
}
// Override new line actions, for auto indent
if (k->is_action("ui_text_newline_above", true)) {
_new_line(false, true);
accept_event();
return;
}
if (k->is_action("ui_text_newline_blank", true)) {
_new_line(false);
accept_event();
return;
}
if (k->is_action("ui_text_newline", true)) {
_new_line();
accept_event();
return;
}
/* Remove shift otherwise actions will not match. */
k = k->duplicate();
k->set_shift_pressed(false);
if (k->is_action("ui_text_caret_up", true) ||
k->is_action("ui_text_caret_down", true) ||
k->is_action("ui_text_caret_line_start", true) ||
k->is_action("ui_text_caret_line_end", true) ||
k->is_action("ui_text_caret_page_up", true) ||
k->is_action("ui_text_caret_page_down", true)) {
set_code_hint("");
}
TextEdit::gui_input(p_gui_input);
if (update_code_completion) {
_filter_code_completion_candidates_impl();
}
}
/* General overrides */
Control::CursorShape CodeEdit::get_cursor_shape(const Point2 &p_pos) const {
if (!symbol_lookup_word.is_empty()) {
return CURSOR_POINTING_HAND;
}
if ((code_completion_active && code_completion_rect.has_point(p_pos)) || (!is_editable() && (!is_selecting_enabled() || get_line_count() == 0))) {
return CURSOR_ARROW;
}
if (code_completion_active && code_completion_scroll_rect.has_point(p_pos)) {
return CURSOR_ARROW;
}
Point2i pos = get_line_column_at_pos(p_pos, false);
int line = pos.y;
int col = pos.x;
if (line != -1 && is_line_folded(line)) {
int wrap_index = get_line_wrap_index_at_column(line, col);
if (wrap_index == get_line_wrap_count(line)) {
int eol_icon_width = folded_eol_icon->get_width();
int left_margin = get_total_gutter_width() + eol_icon_width + get_line_width(line, wrap_index) - get_h_scroll();
if (p_pos.x > left_margin && p_pos.x <= left_margin + eol_icon_width + 3) {
return CURSOR_POINTING_HAND;
}
}
}
return TextEdit::get_cursor_shape(p_pos);
}
/* Text manipulation */
// Overridable actions
void CodeEdit::_handle_unicode_input_internal(const uint32_t p_unicode) {
bool had_selection = has_selection();
String selection_text = (had_selection ? get_selected_text() : "");
if (had_selection) {
begin_complex_operation();
delete_selection();
}
// Remove the old character if in overtype mode and no selection.
if (is_overtype_mode_enabled() && !had_selection) {
begin_complex_operation();
/* Make sure we don't try and remove empty space. */
if (get_caret_column() < get_line(get_caret_line()).length()) {
remove_text(get_caret_line(), get_caret_column(), get_caret_line(), get_caret_column() + 1);
}
}
const char32_t chr[2] = { (char32_t)p_unicode, 0 };
if (auto_brace_completion_enabled) {
int cl = get_caret_line();
int cc = get_caret_column();
if (had_selection) {
insert_text_at_caret(chr);
String close_key = get_auto_brace_completion_close_key(chr);
if (!close_key.is_empty()) {
insert_text_at_caret(selection_text + close_key);
set_caret_column(get_caret_column() - 1);
}
} else {
int caret_move_offset = 1;
int post_brace_pair = cc < get_line(cl).length() ? _get_auto_brace_pair_close_at_pos(cl, cc) : -1;
if (has_string_delimiter(chr) && cc > 0 && !is_symbol(get_line(cl)[cc - 1]) && post_brace_pair == -1) {
insert_text_at_caret(chr);
} else if (cc < get_line(cl).length() && !is_symbol(get_line(cl)[cc])) {
insert_text_at_caret(chr);
} else if (post_brace_pair != -1 && auto_brace_completion_pairs[post_brace_pair].close_key[0] == chr[0]) {
caret_move_offset = auto_brace_completion_pairs[post_brace_pair].close_key.length();
} else if (is_in_comment(cl, cc) != -1 || (is_in_string(cl, cc) != -1 && has_string_delimiter(chr))) {
insert_text_at_caret(chr);
} else {
insert_text_at_caret(chr);
int pre_brace_pair = _get_auto_brace_pair_open_at_pos(cl, cc + 1);
if (pre_brace_pair != -1) {
insert_text_at_caret(auto_brace_completion_pairs[pre_brace_pair].close_key);
}
}
set_caret_column(cc + caret_move_offset);
}
} else {
insert_text_at_caret(chr);
}
if ((is_overtype_mode_enabled() && !had_selection) || (had_selection)) {
end_complex_operation();
}
}
void CodeEdit::_backspace_internal() {
if (!is_editable()) {
return;
}
if (has_selection()) {
delete_selection();
return;
}
int cc = get_caret_column();
int cl = get_caret_line();
if (cc == 0 && cl == 0) {
return;
}
if (cl > 0 && _is_line_hidden(cl - 1)) {
unfold_line(get_caret_line() - 1);
}
int prev_line = cc ? cl : cl - 1;
int prev_column = cc ? (cc - 1) : (get_line(cl - 1).length());
merge_gutters(prev_line, cl);
if (auto_brace_completion_enabled && cc > 0) {
int idx = _get_auto_brace_pair_open_at_pos(cl, cc);
if (idx != -1) {
prev_column = cc - auto_brace_completion_pairs[idx].open_key.length();
if (_get_auto_brace_pair_close_at_pos(cl, cc) == idx) {
remove_text(prev_line, prev_column, cl, cc + auto_brace_completion_pairs[idx].close_key.length());
} else {
remove_text(prev_line, prev_column, cl, cc);
}
set_caret_line(prev_line, false, true);
set_caret_column(prev_column);
return;
}
}
// For space indentation we need to do a simple unindent if there are no chars to the left, acting in the
// same way as tabs.
if (indent_using_spaces && cc != 0) {
if (get_first_non_whitespace_column(cl) >= cc) {
prev_column = cc - _calculate_spaces_till_next_left_indent(cc);
prev_line = cl;
}
}
remove_text(prev_line, prev_column, cl, cc);
set_caret_line(prev_line, false, true);
set_caret_column(prev_column);
}
/* Indent management */
void CodeEdit::set_indent_size(const int p_size) {
ERR_FAIL_COND_MSG(p_size <= 0, "Indend size must be greater than 0.");
if (indent_size == p_size) {
return;
}
indent_size = p_size;
if (indent_using_spaces) {
indent_text = String(" ").repeat(p_size);
} else {
indent_text = "\t";
}
set_tab_size(p_size);
}
int CodeEdit::get_indent_size() const {
return indent_size;
}
void CodeEdit::set_indent_using_spaces(const bool p_use_spaces) {
indent_using_spaces = p_use_spaces;
if (indent_using_spaces) {
indent_text = String(" ").repeat(indent_size);
} else {
indent_text = "\t";
}
}
bool CodeEdit::is_indent_using_spaces() const {
return indent_using_spaces;
}
void CodeEdit::set_auto_indent_enabled(bool p_enabled) {
auto_indent = p_enabled;
}
bool CodeEdit::is_auto_indent_enabled() const {
return auto_indent;
}
void CodeEdit::set_auto_indent_prefixes(const TypedArray<String> &p_prefixes) {
auto_indent_prefixes.clear();
for (int i = 0; i < p_prefixes.size(); i++) {
const String prefix = p_prefixes[i];
auto_indent_prefixes.insert(prefix[0]);
}
}
TypedArray<String> CodeEdit::get_auto_indent_prefixes() const {
TypedArray<String> prefixes;
for (const char32_t &E : auto_indent_prefixes) {
prefixes.push_back(String::chr(E));
}
return prefixes;
}
void CodeEdit::do_indent() {
if (!is_editable()) {
return;
}
if (has_selection()) {
indent_lines();
return;
}
if (!indent_using_spaces) {
insert_text_at_caret("\t");
return;
}
int spaces_to_add = _calculate_spaces_till_next_right_indent(get_caret_column());
if (spaces_to_add > 0) {
insert_text_at_caret(String(" ").repeat(spaces_to_add));
}
}
void CodeEdit::indent_lines() {
if (!is_editable()) {
return;
}
begin_complex_operation();
/* This value informs us by how much we changed selection position by indenting right. */
/* Default is 1 for tab indentation. */
int selection_offset = 1;
int start_line = get_caret_line();
int end_line = start_line;
if (has_selection()) {
start_line = get_selection_from_line();
end_line = get_selection_to_line();
/* Ignore the last line if the selection is not past the first column. */
if (get_selection_to_column() == 0) {
selection_offset = 0;
end_line--;
}
}
for (int i = start_line; i <= end_line; i++) {
const String line_text = get_line(i);
if (line_text.size() == 0 && has_selection()) {
continue;
}
if (!indent_using_spaces) {
set_line(i, '\t' + line_text);
continue;
}
/* We don't really care where selection is - we just need to know indentation level at the beginning of the line. */
/* Since we will add this many spaces, we want to move the whole selection and caret by this much. */
int spaces_to_add = _calculate_spaces_till_next_right_indent(get_first_non_whitespace_column(i));
set_line(i, String(" ").repeat(spaces_to_add) + line_text);
selection_offset = spaces_to_add;
}
/* Fix selection and caret being off after shifting selection right.*/
if (has_selection()) {
select(start_line, get_selection_from_column() + selection_offset, get_selection_to_line(), get_selection_to_column() + selection_offset);
}
set_caret_column(get_caret_column() + selection_offset, false);
end_complex_operation();
}
void CodeEdit::do_unindent() {
if (!is_editable()) {
return;
}
int cc = get_caret_column();
if (has_selection() || cc <= 0) {
unindent_lines();
return;
}
int cl = get_caret_line();
const String &line = get_line(cl);
if (line[cc - 1] == '\t') {
remove_text(cl, cc - 1, cl, cc);
set_caret_column(MAX(0, cc - 1));
return;
}
if (line[cc - 1] != ' ') {
return;
}
int spaces_to_remove = _calculate_spaces_till_next_left_indent(cc);
if (spaces_to_remove > 0) {
for (int i = 1; i <= spaces_to_remove; i++) {
if (line[cc - i] != ' ') {
spaces_to_remove = i - 1;
break;
}
}
remove_text(cl, cc - spaces_to_remove, cl, cc);
set_caret_column(MAX(0, cc - spaces_to_remove));
}
}
void CodeEdit::unindent_lines() {
if (!is_editable()) {
return;
}
begin_complex_operation();
/* Moving caret and selection after unindenting can get tricky because */
/* changing content of line can move caret and selection on its own (if new line ends before previous position of either), */
/* therefore we just remember initial values and at the end of the operation offset them by number of removed characters. */
int removed_characters = 0;
int initial_selection_end_column = 0;
int initial_cursor_column = get_caret_column();
int start_line = get_caret_line();
int end_line = start_line;
if (has_selection()) {
start_line = get_selection_from_line();
end_line = get_selection_to_line();
/* Ignore the last line if the selection is not past the first column. */
initial_selection_end_column = get_selection_to_column();
if (initial_selection_end_column == 0) {
end_line--;
}
}
bool first_line_edited = false;
bool last_line_edited = false;
for (int i = start_line; i <= end_line; i++) {
String line_text = get_line(i);
if (line_text.begins_with("\t")) {
line_text = line_text.substr(1, line_text.length());
set_line(i, line_text);
removed_characters = 1;
first_line_edited = (i == start_line) ? true : first_line_edited;
last_line_edited = (i == end_line) ? true : last_line_edited;
continue;
}
if (line_text.begins_with(" ")) {
/* When unindenting we aim to remove spaces before line that has selection no matter what is selected, */
/* Here we remove only enough spaces to align text to nearest full multiple of indentation_size. */
/* In case where selection begins at the start of indentation_size multiple we remove whole indentation level. */
int spaces_to_remove = _calculate_spaces_till_next_left_indent(get_first_non_whitespace_column(i));
line_text = line_text.substr(spaces_to_remove, line_text.length());
set_line(i, line_text);
removed_characters = spaces_to_remove;
first_line_edited = (i == start_line) ? true : first_line_edited;
last_line_edited = (i == end_line) ? true : last_line_edited;
}
}
if (has_selection()) {
/* Fix selection being off by one on the first line. */
if (first_line_edited) {
select(get_selection_from_line(), get_selection_from_column() - removed_characters, get_selection_to_line(), initial_selection_end_column);
}
/* Fix selection being off by one on the last line. */
if (last_line_edited) {
select(get_selection_from_line(), get_selection_from_column(), get_selection_to_line(), initial_selection_end_column - removed_characters);
}
}
set_caret_column(initial_cursor_column - removed_characters, false);
end_complex_operation();
}
int CodeEdit::_calculate_spaces_till_next_left_indent(int p_column) const {
int spaces_till_indent = p_column % indent_size;
if (spaces_till_indent == 0) {
spaces_till_indent = indent_size;
}
return spaces_till_indent;
}
int CodeEdit::_calculate_spaces_till_next_right_indent(int p_column) const {
return indent_size - p_column % indent_size;
}
void CodeEdit::_new_line(bool p_split_current_line, bool p_above) {
if (!is_editable()) {
return;
}
/* When not splitting the line, we need to factor in indentation from the end of the current line. */
const int cc = p_split_current_line ? get_caret_column() : get_line(get_caret_line()).length();
const int cl = get_caret_line();
const String line = get_line(cl);
String ins = "\n";
/* Append current indentation. */
int space_count = 0;
int line_col = 0;
for (; line_col < cc; line_col++) {
if (line[line_col] == '\t') {
ins += indent_text;
space_count = 0;
continue;
}
if (line[line_col] == ' ') {
space_count++;
if (space_count == indent_size) {
ins += indent_text;
space_count = 0;
}
continue;
}
break;
}
if (is_line_folded(cl)) {
unfold_line(cl);
}
/* Indent once again if the previous line needs it, ie ':'. */
/* Then add an addition new line for any closing pairs aka '()'. */
/* Skip this in comments or if we are going above. */
bool brace_indent = false;
if (auto_indent && !p_above && cc > 0 && is_in_comment(cl) == -1) {
bool should_indent = false;
char32_t indent_char = ' ';
for (; line_col < cc; line_col++) {
char32_t c = line[line_col];
if (auto_indent_prefixes.has(c)) {
should_indent = true;
indent_char = c;
continue;
}
/* Make sure this is the last char, trailing whitespace or comments are okay. */
/* Increment column for comments because the delimiter (#) should be ignored. */
if (should_indent && (!is_whitespace(c) && is_in_comment(cl, line_col + 1) == -1)) {
should_indent = false;
}
}
if (should_indent) {
ins += indent_text;
String closing_pair = get_auto_brace_completion_close_key(String::chr(indent_char));
if (!closing_pair.is_empty() && line.find(closing_pair, cc) == cc) {
/* No need to move the brace below if we are not taking the text with us. */
if (p_split_current_line) {
brace_indent = true;
ins += "\n" + ins.substr(indent_text.size(), ins.length() - 2);
} else {
brace_indent = false;
ins = "\n" + ins.substr(indent_text.size(), ins.length() - 2);
}
}
}
}
begin_complex_operation();
bool first_line = false;
if (!p_split_current_line) {
deselect();
if (p_above) {
if (cl > 0) {
set_caret_line(cl - 1, false);
set_caret_column(get_line(get_caret_line()).length());
} else {
set_caret_column(0);
first_line = true;
}
} else {
set_caret_column(line.length());
}
}
insert_text_at_caret(ins);
if (first_line) {
set_caret_line(0);
} else if (brace_indent) {
set_caret_line(get_caret_line() - 1, false);
set_caret_column(get_line(get_caret_line()).length());
}
end_complex_operation();
}
/* Auto brace completion */
void CodeEdit::set_auto_brace_completion_enabled(bool p_enabled) {
auto_brace_completion_enabled = p_enabled;
}
bool CodeEdit::is_auto_brace_completion_enabled() const {
return auto_brace_completion_enabled;
}
void CodeEdit::set_highlight_matching_braces_enabled(bool p_enabled) {
highlight_matching_braces_enabled = p_enabled;
queue_redraw();
}
bool CodeEdit::is_highlight_matching_braces_enabled() const {
return highlight_matching_braces_enabled;
}
void CodeEdit::add_auto_brace_completion_pair(const String &p_open_key, const String &p_close_key) {
ERR_FAIL_COND_MSG(p_open_key.is_empty(), "auto brace completion open key cannot be empty");
ERR_FAIL_COND_MSG(p_close_key.is_empty(), "auto brace completion close key cannot be empty");
for (int i = 0; i < p_open_key.length(); i++) {
ERR_FAIL_COND_MSG(!is_symbol(p_open_key[i]), "auto brace completion open key must be a symbol");
}
for (int i = 0; i < p_close_key.length(); i++) {
ERR_FAIL_COND_MSG(!is_symbol(p_close_key[i]), "auto brace completion close key must be a symbol");
}
int at = 0;
for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
ERR_FAIL_COND_MSG(auto_brace_completion_pairs[i].open_key == p_open_key, "auto brace completion open key '" + p_open_key + "' already exists.");
if (p_open_key.length() < auto_brace_completion_pairs[i].open_key.length()) {
at++;
}
}
BracePair brace_pair;
brace_pair.open_key = p_open_key;
brace_pair.close_key = p_close_key;
auto_brace_completion_pairs.insert(at, brace_pair);
}
void CodeEdit::set_auto_brace_completion_pairs(const Dictionary &p_auto_brace_completion_pairs) {
auto_brace_completion_pairs.clear();
Array keys = p_auto_brace_completion_pairs.keys();
for (int i = 0; i < keys.size(); i++) {
add_auto_brace_completion_pair(keys[i], p_auto_brace_completion_pairs[keys[i]]);
}
}
Dictionary CodeEdit::get_auto_brace_completion_pairs() const {
Dictionary brace_pairs;
for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
brace_pairs[auto_brace_completion_pairs[i].open_key] = auto_brace_completion_pairs[i].close_key;
}
return brace_pairs;
}
bool CodeEdit::has_auto_brace_completion_open_key(const String &p_open_key) const {
for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
if (auto_brace_completion_pairs[i].open_key == p_open_key) {
return true;
}
}
return false;
}
bool CodeEdit::has_auto_brace_completion_close_key(const String &p_close_key) const {
for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
if (auto_brace_completion_pairs[i].close_key == p_close_key) {
return true;
}
}
return false;
}
String CodeEdit::get_auto_brace_completion_close_key(const String &p_open_key) const {
for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
if (auto_brace_completion_pairs[i].open_key == p_open_key) {
return auto_brace_completion_pairs[i].close_key;
}
}
return String();
}
/* Main Gutter */
void CodeEdit::_update_draw_main_gutter() {
set_gutter_draw(main_gutter, draw_breakpoints || draw_bookmarks || draw_executing_lines);
}
void CodeEdit::set_draw_breakpoints_gutter(bool p_draw) {
draw_breakpoints = p_draw;
set_gutter_clickable(main_gutter, p_draw);
_update_draw_main_gutter();
}
bool CodeEdit::is_drawing_breakpoints_gutter() const {
return draw_breakpoints;
}
void CodeEdit::set_draw_bookmarks_gutter(bool p_draw) {
draw_bookmarks = p_draw;
_update_draw_main_gutter();
}
bool CodeEdit::is_drawing_bookmarks_gutter() const {
return draw_bookmarks;
}
void CodeEdit::set_draw_executing_lines_gutter(bool p_draw) {
draw_executing_lines = p_draw;
_update_draw_main_gutter();
}
bool CodeEdit::is_drawing_executing_lines_gutter() const {
return draw_executing_lines;
}
void CodeEdit::_main_gutter_draw_callback(int p_line, int p_gutter, const Rect2 &p_region) {
bool shift_pressed = Input::get_singleton()->is_key_pressed(Key::SHIFT);
if (draw_breakpoints && breakpoint_icon.is_valid()) {
bool hovering = p_region.has_point(get_local_mouse_pos());
bool breakpointed = is_line_breakpointed(p_line);
if (breakpointed || (hovering && !is_dragging_cursor() && !shift_pressed)) {
int padding = p_region.size.x / 6;
Rect2 icon_region = p_region;
icon_region.position += Point2(padding, padding);
icon_region.size -= Point2(padding, padding) * 2;
// Darken icon when hovering, shift not pressed & not yet breakpointed.
Color use_color = hovering && !breakpointed && !shift_pressed ? breakpoint_color.darkened(0.4) : breakpoint_color;
breakpoint_icon->draw_rect(get_canvas_item(), icon_region, false, use_color);
}
}
if (draw_bookmarks && bookmark_icon.is_valid()) {
bool hovering = p_region.has_point(get_local_mouse_pos());
bool bookmarked = is_line_bookmarked(p_line);
if (bookmarked || (hovering && !is_dragging_cursor() && shift_pressed)) {
int horizontal_padding = p_region.size.x / 2;
int vertical_padding = p_region.size.y / 4;
Rect2 icon_region = p_region;
icon_region.position += Point2(horizontal_padding, 0);
icon_region.size -= Point2(horizontal_padding * 1.1, vertical_padding);
// Darken icon when hovering, shift pressed & not yet bookmarked.
Color use_color = hovering && !bookmarked && shift_pressed ? bookmark_color.darkened(0.4) : bookmark_color;
bookmark_icon->draw_rect(get_canvas_item(), icon_region, false, use_color);
}
}
if (draw_executing_lines && is_line_executing(p_line) && executing_line_icon.is_valid()) {
int horizontal_padding = p_region.size.x / 10;
int vertical_padding = p_region.size.y / 4;
Rect2 executing_line_region = p_region;
executing_line_region.position += Point2(horizontal_padding, vertical_padding);
executing_line_region.size -= Point2(horizontal_padding, vertical_padding) * 2;
executing_line_icon->draw_rect(get_canvas_item(), executing_line_region, false, executing_line_color);
}
}
// Breakpoints
void CodeEdit::set_line_as_breakpoint(int p_line, bool p_breakpointed) {
ERR_FAIL_INDEX(p_line, get_line_count());
int mask = get_line_gutter_metadata(p_line, main_gutter);
set_line_gutter_metadata(p_line, main_gutter, p_breakpointed ? mask | MAIN_GUTTER_BREAKPOINT : mask & ~MAIN_GUTTER_BREAKPOINT);
if (p_breakpointed) {
breakpointed_lines[p_line] = true;
} else if (breakpointed_lines.has(p_line)) {
breakpointed_lines.erase(p_line);
}
emit_signal(SNAME("breakpoint_toggled"), p_line);
queue_redraw();
}
bool CodeEdit::is_line_breakpointed(int p_line) const {
return (int)get_line_gutter_metadata(p_line, main_gutter) & MAIN_GUTTER_BREAKPOINT;
}
void CodeEdit::clear_breakpointed_lines() {
for (int i = 0; i < get_line_count(); i++) {
if (is_line_breakpointed(i)) {
set_line_as_breakpoint(i, false);
}
}
}
PackedInt32Array CodeEdit::get_breakpointed_lines() const {
PackedInt32Array ret;
for (int i = 0; i < get_line_count(); i++) {
if (is_line_breakpointed(i)) {
ret.append(i);
}
}
return ret;
}
// Bookmarks
void CodeEdit::set_line_as_bookmarked(int p_line, bool p_bookmarked) {
int mask = get_line_gutter_metadata(p_line, main_gutter);
set_line_gutter_metadata(p_line, main_gutter, p_bookmarked ? mask | MAIN_GUTTER_BOOKMARK : mask & ~MAIN_GUTTER_BOOKMARK);
queue_redraw();
}
bool CodeEdit::is_line_bookmarked(int p_line) const {
return (int)get_line_gutter_metadata(p_line, main_gutter) & MAIN_GUTTER_BOOKMARK;
}
void CodeEdit::clear_bookmarked_lines() {
for (int i = 0; i < get_line_count(); i++) {
if (is_line_bookmarked(i)) {
set_line_as_bookmarked(i, false);
}
}
}
PackedInt32Array CodeEdit::get_bookmarked_lines() const {
PackedInt32Array ret;
for (int i = 0; i < get_line_count(); i++) {
if (is_line_bookmarked(i)) {
ret.append(i);
}
}
return ret;
}
// executing lines
void CodeEdit::set_line_as_executing(int p_line, bool p_executing) {
int mask = get_line_gutter_metadata(p_line, main_gutter);
set_line_gutter_metadata(p_line, main_gutter, p_executing ? mask | MAIN_GUTTER_EXECUTING : mask & ~MAIN_GUTTER_EXECUTING);
queue_redraw();
}
bool CodeEdit::is_line_executing(int p_line) const {
return (int)get_line_gutter_metadata(p_line, main_gutter) & MAIN_GUTTER_EXECUTING;
}
void CodeEdit::clear_executing_lines() {
for (int i = 0; i < get_line_count(); i++) {
if (is_line_executing(i)) {
set_line_as_executing(i, false);
}
}
}
PackedInt32Array CodeEdit::get_executing_lines() const {
PackedInt32Array ret;
for (int i = 0; i < get_line_count(); i++) {
if (is_line_executing(i)) {
ret.append(i);
}
}
return ret;
}
/* Line numbers */
void CodeEdit::set_draw_line_numbers(bool p_draw) {
set_gutter_draw(line_number_gutter, p_draw);
}
bool CodeEdit::is_draw_line_numbers_enabled() const {
return is_gutter_drawn(line_number_gutter);
}
void CodeEdit::set_line_numbers_zero_padded(bool p_zero_padded) {
p_zero_padded ? line_number_padding = "0" : line_number_padding = " ";
queue_redraw();
}
bool CodeEdit::is_line_numbers_zero_padded() const {
return line_number_padding == "0";
}
void CodeEdit::_line_number_draw_callback(int p_line, int p_gutter, const Rect2 &p_region) {
String fc = TS->format_number(String::num(p_line + 1).lpad(line_number_digits, line_number_padding));
Ref<TextLine> tl;
tl.instantiate();
tl->add_string(fc, font, font_size);
int yofs = p_region.position.y + (get_line_height() - tl->get_size().y) / 2;
Color number_color = get_line_gutter_item_color(p_line, line_number_gutter);
if (number_color == Color(1, 1, 1)) {
number_color = line_number_color;
}
tl->draw(get_canvas_item(), Point2(p_region.position.x, yofs), number_color);
}
/* Fold Gutter */
void CodeEdit::set_draw_fold_gutter(bool p_draw) {
set_gutter_draw(fold_gutter, p_draw);
}
bool CodeEdit::is_drawing_fold_gutter() const {
return is_gutter_drawn(fold_gutter);
}
void CodeEdit::_fold_gutter_draw_callback(int p_line, int p_gutter, Rect2 p_region) {
if (!can_fold_line(p_line) && !is_line_folded(p_line)) {
set_line_gutter_clickable(p_line, fold_gutter, false);
return;
}
set_line_gutter_clickable(p_line, fold_gutter, true);
int horizontal_padding = p_region.size.x / 10;
int vertical_padding = p_region.size.y / 6;
p_region.position += Point2(horizontal_padding, vertical_padding);
p_region.size -= Point2(horizontal_padding, vertical_padding) * 2;
if (can_fold_line(p_line)) {
can_fold_icon->draw_rect(get_canvas_item(), p_region, false, folding_color);
return;
}
folded_icon->draw_rect(get_canvas_item(), p_region, false, folding_color);
}
/* Line Folding */
void CodeEdit::set_line_folding_enabled(bool p_enabled) {
line_folding_enabled = p_enabled;
_set_hiding_enabled(p_enabled);
}
bool CodeEdit::is_line_folding_enabled() const {
return line_folding_enabled;
}
bool CodeEdit::can_fold_line(int p_line) const {
ERR_FAIL_INDEX_V(p_line, get_line_count(), false);
if (!line_folding_enabled) {
return false;
}
if (p_line + 1 >= get_line_count() || get_line(p_line).strip_edges().size() == 0) {
return false;
}
if (_is_line_hidden(p_line) || is_line_folded(p_line)) {
return false;
}
/* Check for full multiline line or block strings / comments. */
int in_comment = is_in_comment(p_line);
int in_string = (in_comment == -1) ? is_in_string(p_line) : -1;
if (in_string != -1 || in_comment != -1) {
if (get_delimiter_start_position(p_line, get_line(p_line).size() - 1).y != p_line) {
return false;
}
int delimter_end_line = get_delimiter_end_position(p_line, get_line(p_line).size() - 1).y;
/* No end line, therefore we have a multiline region over the rest of the file. */
if (delimter_end_line == -1) {
return true;
}
/* End line is the same therefore we have a block. */
if (delimter_end_line == p_line) {
/* Check we are the start of the block. */
if (p_line - 1 >= 0) {
if ((in_string != -1 && is_in_string(p_line - 1) != -1) || (in_comment != -1 && is_in_comment(p_line - 1) != -1)) {
return false;
}
}
/* Check it continues for at least one line. */
return ((in_string != -1 && is_in_string(p_line + 1) != -1) || (in_comment != -1 && is_in_comment(p_line + 1) != -1));
}
return ((in_string != -1 && is_in_string(delimter_end_line) != -1) || (in_comment != -1 && is_in_comment(delimter_end_line) != -1));
}
/* Otherwise check indent levels. */
int start_indent = get_indent_level(p_line);
for (int i = p_line + 1; i < get_line_count(); i++) {
if (is_in_string(i) != -1 || is_in_comment(i) != -1 || get_line(i).strip_edges().size() == 0) {
continue;
}
return (get_indent_level(i) > start_indent);
}
return false;
}
void CodeEdit::fold_line(int p_line) {
ERR_FAIL_INDEX(p_line, get_line_count());
if (!is_line_folding_enabled() || !can_fold_line(p_line)) {
return;
}
/* Find the last line to be hidden. */
const int line_count = get_line_count() - 1;
int end_line = line_count;
int in_comment = is_in_comment(p_line);
int in_string = (in_comment == -1) ? is_in_string(p_line) : -1;
if (in_string != -1 || in_comment != -1) {
end_line = get_delimiter_end_position(p_line, get_line(p_line).size() - 1).y;
/* End line is the same therefore we have a block of single line delimiters. */
if (end_line == p_line) {
for (int i = p_line + 1; i <= line_count; i++) {
if ((in_string != -1 && is_in_string(i) == -1) || (in_comment != -1 && is_in_comment(i) == -1)) {
break;
}
end_line = i;
}
}
} else {
int start_indent = get_indent_level(p_line);
for (int i = p_line + 1; i <= line_count; i++) {
if (get_line(i).strip_edges().size() == 0) {
continue;
}
if (get_indent_level(i) > start_indent) {
end_line = i;
continue;
}
if (is_in_string(i) == -1 && is_in_comment(i) == -1) {
break;
}
}
}
for (int i = p_line + 1; i <= end_line; i++) {
_set_line_as_hidden(i, true);
}
/* Fix selection. */
if (has_selection()) {
if (_is_line_hidden(get_selection_from_line()) && _is_line_hidden(get_selection_to_line())) {
deselect();
} else if (_is_line_hidden(get_selection_from_line())) {
select(p_line, 9999, get_selection_to_line(), get_selection_to_column());
} else if (_is_line_hidden(get_selection_to_line())) {
select(get_selection_from_line(), get_selection_from_column(), p_line, 9999);
}
}
/* Reset caret. */
if (_is_line_hidden(get_caret_line())) {
set_caret_line(p_line, false, false);
set_caret_column(get_line(p_line).length(), false);
}
queue_redraw();
}
void CodeEdit::unfold_line(int p_line) {
ERR_FAIL_INDEX(p_line, get_line_count());
if (!is_line_folded(p_line) && !_is_line_hidden(p_line)) {
return;
}
int fold_start = p_line;
for (; fold_start > 0; fold_start--) {
if (is_line_folded(fold_start)) {
break;
}
}
fold_start = is_line_folded(fold_start) ? fold_start : p_line;
for (int i = fold_start + 1; i < get_line_count(); i++) {
if (!_is_line_hidden(i)) {
break;
}
_set_line_as_hidden(i, false);
}
queue_redraw();
}
void CodeEdit::fold_all_lines() {
for (int i = 0; i < get_line_count(); i++) {
fold_line(i);
}
queue_redraw();
}
void CodeEdit::unfold_all_lines() {
_unhide_all_lines();
}
void CodeEdit::toggle_foldable_line(int p_line) {
ERR_FAIL_INDEX(p_line, get_line_count());
if (is_line_folded(p_line)) {
unfold_line(p_line);
return;
}
fold_line(p_line);
}
bool CodeEdit::is_line_folded(int p_line) const {
ERR_FAIL_INDEX_V(p_line, get_line_count(), false);
return p_line + 1 < get_line_count() && !_is_line_hidden(p_line) && _is_line_hidden(p_line + 1);
}
TypedArray<int> CodeEdit::get_folded_lines() const {
TypedArray<int> folded_lines;
for (int i = 0; i < get_line_count(); i++) {
if (is_line_folded(i)) {
folded_lines.push_back(i);
}
}
return folded_lines;
}
/* Delimiters */
// Strings
void CodeEdit::add_string_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only) {
_add_delimiter(p_start_key, p_end_key, p_line_only, TYPE_STRING);
}
void CodeEdit::remove_string_delimiter(const String &p_start_key) {
_remove_delimiter(p_start_key, TYPE_STRING);
}
bool CodeEdit::has_string_delimiter(const String &p_start_key) const {
return _has_delimiter(p_start_key, TYPE_STRING);
}
void CodeEdit::set_string_delimiters(const TypedArray<String> &p_string_delimiters) {
_set_delimiters(p_string_delimiters, TYPE_STRING);
}
void CodeEdit::clear_string_delimiters() {
_clear_delimiters(TYPE_STRING);
}
TypedArray<String> CodeEdit::get_string_delimiters() const {
return _get_delimiters(TYPE_STRING);
}
int CodeEdit::is_in_string(int p_line, int p_column) const {
return _is_in_delimiter(p_line, p_column, TYPE_STRING);
}
// Comments
void CodeEdit::add_comment_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only) {
_add_delimiter(p_start_key, p_end_key, p_line_only, TYPE_COMMENT);
}
void CodeEdit::remove_comment_delimiter(const String &p_start_key) {
_remove_delimiter(p_start_key, TYPE_COMMENT);
}
bool CodeEdit::has_comment_delimiter(const String &p_start_key) const {
return _has_delimiter(p_start_key, TYPE_COMMENT);
}
void CodeEdit::set_comment_delimiters(const TypedArray<String> &p_comment_delimiters) {
_set_delimiters(p_comment_delimiters, TYPE_COMMENT);
}
void CodeEdit::clear_comment_delimiters() {
_clear_delimiters(TYPE_COMMENT);
}
TypedArray<String> CodeEdit::get_comment_delimiters() const {
return _get_delimiters(TYPE_COMMENT);
}
int CodeEdit::is_in_comment(int p_line, int p_column) const {
return _is_in_delimiter(p_line, p_column, TYPE_COMMENT);
}
String CodeEdit::get_delimiter_start_key(int p_delimiter_idx) const {
ERR_FAIL_INDEX_V(p_delimiter_idx, delimiters.size(), "");
return delimiters[p_delimiter_idx].start_key;
}
String CodeEdit::get_delimiter_end_key(int p_delimiter_idx) const {
ERR_FAIL_INDEX_V(p_delimiter_idx, delimiters.size(), "");
return delimiters[p_delimiter_idx].end_key;
}
Point2 CodeEdit::get_delimiter_start_position(int p_line, int p_column) const {
if (delimiters.size() == 0) {
return Point2(-1, -1);
}
ERR_FAIL_INDEX_V(p_line, get_line_count(), Point2(-1, -1));
ERR_FAIL_COND_V(p_column - 1 > get_line(p_line).size(), Point2(-1, -1));
Point2 start_position;
start_position.y = -1;
start_position.x = -1;
bool in_region = ((p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->get()) != -1;
/* Check the keys for this line. */
for (const KeyValue<int, int> &E : delimiter_cache[p_line]) {
if (E.key > p_column) {
break;
}
in_region = E.value != -1;
start_position.x = in_region ? E.key : -1;
}
/* Region was found on this line and is not a multiline continuation. */
int line_length = get_line(p_line).length();
if (start_position.x != -1 && line_length > 0 && start_position.x != line_length + 1) {
start_position.y = p_line;
return start_position;
}
/* Not in a region */
if (!in_region) {
return start_position;
}
/* Region starts on a previous line */
for (int i = p_line - 1; i >= 0; i--) {
if (delimiter_cache[i].size() < 1) {
continue;
}
start_position.y = i;
start_position.x = delimiter_cache[i].back()->key();
/* Make sure it's not a multiline continuation. */
line_length = get_line(i).length();
if (line_length > 0 && start_position.x != line_length + 1) {
break;
}
}
return start_position;
}
Point2 CodeEdit::get_delimiter_end_position(int p_line, int p_column) const {
if (delimiters.size() == 0) {
return Point2(-1, -1);
}
ERR_FAIL_INDEX_V(p_line, get_line_count(), Point2(-1, -1));
ERR_FAIL_COND_V(p_column - 1 > get_line(p_line).size(), Point2(-1, -1));
Point2 end_position;
end_position.y = -1;
end_position.x = -1;
int region = (p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->value();
/* Check the keys for this line. */
for (const KeyValue<int, int> &E : delimiter_cache[p_line]) {
end_position.x = (E.value == -1) ? E.key : -1;
if (E.key > p_column) {
break;
}
region = E.value;
}
/* Region was found on this line and is not a multiline continuation. */
if (region != -1 && end_position.x != -1 && (delimiters[region].line_only || end_position.x != get_line(p_line).length() + 1)) {
end_position.y = p_line;
return end_position;
}
/* Not in a region */
if (region == -1) {
end_position.x = -1;
return end_position;
}
/* Region ends on a later line */
for (int i = p_line + 1; i < get_line_count(); i++) {
if (delimiter_cache[i].size() < 1 || delimiter_cache[i].front()->value() != -1) {
continue;
}
end_position.x = delimiter_cache[i].front()->key();
/* Make sure it's not a multiline continuation. */
if (get_line(i).length() > 0 && end_position.x != get_line(i).length() + 1) {
end_position.y = i;
break;
}
end_position.x = -1;
}
return end_position;
}
/* Code hint */
void CodeEdit::set_code_hint(const String &p_hint) {
code_hint = p_hint;
code_hint_xpos = -0xFFFF;
queue_redraw();
}
void CodeEdit::set_code_hint_draw_below(bool p_below) {
code_hint_draw_below = p_below;
queue_redraw();
}
/* Code Completion */
void CodeEdit::set_code_completion_enabled(bool p_enable) {
code_completion_enabled = p_enable;
}
bool CodeEdit::is_code_completion_enabled() const {
return code_completion_enabled;
}
void CodeEdit::set_code_completion_prefixes(const TypedArray<String> &p_prefixes) {
code_completion_prefixes.clear();
for (int i = 0; i < p_prefixes.size(); i++) {
const String prefix = p_prefixes[i];
ERR_CONTINUE_MSG(prefix.is_empty(), "Code completion prefix cannot be empty.");
code_completion_prefixes.insert(prefix[0]);
}
}
TypedArray<String> CodeEdit::get_code_completion_prefixes() const {
TypedArray<String> prefixes;
for (const char32_t &E : code_completion_prefixes) {
prefixes.push_back(String::chr(E));
}
return prefixes;
}
String CodeEdit::get_text_for_code_completion() const {
StringBuilder completion_text;
const int text_size = get_line_count();
for (int i = 0; i < text_size; i++) {
String line = get_line(i);
if (i == get_caret_line()) {
completion_text += line.substr(0, get_caret_column());
/* Not unicode, represents the caret. */
completion_text += String::chr(0xFFFF);
completion_text += line.substr(get_caret_column(), line.size());
} else {
completion_text += line;
}
if (i != text_size - 1) {
completion_text += "\n";
}
}
return completion_text.as_string();
}
void CodeEdit::request_code_completion(bool p_force) {
if (GDVIRTUAL_CALL(_request_code_completion, p_force)) {
return;
}
/* Don't re-query if all existing options are quoted types, eg path, signal. */
bool ignored = code_completion_active && !code_completion_options.is_empty();
if (ignored) {
ScriptLanguage::CodeCompletionKind kind = ScriptLanguage::CODE_COMPLETION_KIND_PLAIN_TEXT;
const ScriptLanguage::CodeCompletionOption *previous_option = nullptr;
for (int i = 0; i < code_completion_options.size(); i++) {
const ScriptLanguage::CodeCompletionOption &current_option = code_completion_options[i];
if (!previous_option) {
previous_option = &current_option;
kind = current_option.kind;
}
if (previous_option->kind != current_option.kind) {
ignored = false;
break;
}
}
ignored = ignored && (kind == ScriptLanguage::CODE_COMPLETION_KIND_FILE_PATH || kind == ScriptLanguage::CODE_COMPLETION_KIND_NODE_PATH || kind == ScriptLanguage::CODE_COMPLETION_KIND_SIGNAL);
}
if (ignored) {
return;
}
if (p_force) {
emit_signal(SNAME("code_completion_requested"));
return;
}
String line = get_line(get_caret_line());
int ofs = CLAMP(get_caret_column(), 0, line.length());
if (ofs > 0 && (is_in_string(get_caret_line(), ofs) != -1 || !is_symbol(line[ofs - 1]) || code_completion_prefixes.has(line[ofs - 1]))) {
emit_signal(SNAME("code_completion_requested"));
} else if (ofs > 1 && line[ofs - 1] == ' ' && code_completion_prefixes.has(line[ofs - 2])) {
emit_signal(SNAME("code_completion_requested"));
}
}
void CodeEdit::add_code_completion_option(CodeCompletionKind p_type, const String &p_display_text, const String &p_insert_text, const Color &p_text_color, const Ref<Resource> &p_icon, const Variant &p_value) {
ScriptLanguage::CodeCompletionOption completion_option;
completion_option.kind = (ScriptLanguage::CodeCompletionKind)p_type;
completion_option.display = p_display_text;
completion_option.insert_text = p_insert_text;
completion_option.font_color = p_text_color;
completion_option.icon = p_icon;
completion_option.default_value = p_value;
code_completion_option_submitted.push_back(completion_option);
}
void CodeEdit::update_code_completion_options(bool p_forced) {
code_completion_forced = p_forced;
code_completion_option_sources = code_completion_option_submitted;
code_completion_option_submitted.clear();
_filter_code_completion_candidates_impl();
}
TypedArray<Dictionary> CodeEdit::get_code_completion_options() const {
if (!code_completion_active) {
return TypedArray<Dictionary>();
}
TypedArray<Dictionary> completion_options;
completion_options.resize(code_completion_options.size());
for (int i = 0; i < code_completion_options.size(); i++) {
Dictionary option;
option["kind"] = code_completion_options[i].kind;
option["display_text"] = code_completion_options[i].display;
option["insert_text"] = code_completion_options[i].insert_text;
option["font_color"] = code_completion_options[i].font_color;
option["icon"] = code_completion_options[i].icon;
option["default_value"] = code_completion_options[i].default_value;
completion_options[i] = option;
}
return completion_options;
}
Dictionary CodeEdit::get_code_completion_option(int p_index) const {
if (!code_completion_active) {
return Dictionary();
}
ERR_FAIL_INDEX_V(p_index, code_completion_options.size(), Dictionary());
Dictionary option;
option["kind"] = code_completion_options[p_index].kind;
option["display_text"] = code_completion_options[p_index].display;
option["insert_text"] = code_completion_options[p_index].insert_text;
option["font_color"] = code_completion_options[p_index].font_color;
option["icon"] = code_completion_options[p_index].icon;
option["default_value"] = code_completion_options[p_index].default_value;
return option;
}
int CodeEdit::get_code_completion_selected_index() const {
return (code_completion_active) ? code_completion_current_selected : -1;
}
void CodeEdit::set_code_completion_selected_index(int p_index) {
if (!code_completion_active) {
return;
}
ERR_FAIL_INDEX(p_index, code_completion_options.size());
code_completion_current_selected = p_index;
queue_redraw();
}
void CodeEdit::confirm_code_completion(bool p_replace) {
if (!is_editable() || !code_completion_active) {
return;
}
if (GDVIRTUAL_CALL(_confirm_code_completion, p_replace)) {
return;
}
begin_complex_operation();
int caret_line = get_caret_line();
const String &insert_text = code_completion_options[code_completion_current_selected].insert_text;
const String &display_text = code_completion_options[code_completion_current_selected].display;
if (p_replace) {
/* Find end of current section */
const String line = get_line(caret_line);
int caret_col = get_caret_column();
int caret_remove_line = caret_line;
bool merge_text = true;
int in_string = is_in_string(caret_line, caret_col);
if (in_string != -1) {
Point2 string_end = get_delimiter_end_position(caret_line, caret_col);
if (string_end.x != -1) {
merge_text = false;
caret_remove_line = string_end.y;
caret_col = string_end.x - 1;
}
}
if (merge_text) {
for (; caret_col < line.length(); caret_col++) {
if (is_symbol(line[caret_col])) {
break;
}
}
}
/* Replace. */
remove_text(caret_line, get_caret_column() - code_completion_base.length(), caret_remove_line, caret_col);
set_caret_column(get_caret_column() - code_completion_base.length(), false);
insert_text_at_caret(insert_text);
} else {
/* Get first non-matching char. */
const String line = get_line(caret_line);
int caret_col = get_caret_column();
int matching_chars = code_completion_base.length();
for (; matching_chars <= insert_text.length(); matching_chars++) {
if (caret_col >= line.length() || line[caret_col] != insert_text[matching_chars]) {
break;
}
caret_col++;
}
/* Remove base completion text. */
remove_text(caret_line, get_caret_column() - code_completion_base.length(), caret_line, get_caret_column());
set_caret_column(get_caret_column() - code_completion_base.length(), false);
/* Merge with text. */
insert_text_at_caret(insert_text.substr(0, code_completion_base.length()));
set_caret_column(caret_col, false);
insert_text_at_caret(insert_text.substr(matching_chars));
}
/* Handle merging of symbols eg strings, brackets. */
const String line = get_line(caret_line);
char32_t next_char = line[get_caret_column()];
char32_t last_completion_char = insert_text[insert_text.length() - 1];
char32_t last_completion_char_display = display_text[display_text.length() - 1];
int pre_brace_pair = get_caret_column() > 0 ? _get_auto_brace_pair_open_at_pos(caret_line, get_caret_column()) : -1;
int post_brace_pair = get_caret_column() < get_line(caret_line).length() ? _get_auto_brace_pair_close_at_pos(caret_line, get_caret_column()) : -1;
if (post_brace_pair != -1 && (last_completion_char == next_char || last_completion_char_display == next_char)) {
remove_text(caret_line, get_caret_column(), caret_line, get_caret_column() + 1);
}
if (pre_brace_pair != -1 && pre_brace_pair != post_brace_pair && (last_completion_char == next_char || last_completion_char_display == next_char)) {
remove_text(caret_line, get_caret_column(), caret_line, get_caret_column() + 1);
} else if (auto_brace_completion_enabled && pre_brace_pair != -1 && post_brace_pair == -1) {
insert_text_at_caret(auto_brace_completion_pairs[pre_brace_pair].close_key);
set_caret_column(get_caret_column() - auto_brace_completion_pairs[pre_brace_pair].close_key.length());
}
if (pre_brace_pair == -1 && post_brace_pair == -1 && get_caret_column() > 0 && get_caret_column() < get_line(caret_line).length()) {
pre_brace_pair = _get_auto_brace_pair_open_at_pos(caret_line, get_caret_column() + 1);
if (pre_brace_pair != -1 && pre_brace_pair == _get_auto_brace_pair_close_at_pos(caret_line, get_caret_column() - 1)) {
remove_text(caret_line, get_caret_column() - 2, caret_line, get_caret_column());
if (_get_auto_brace_pair_close_at_pos(caret_line, get_caret_column() - 1) != pre_brace_pair) {
set_caret_column(get_caret_column() - 1);
}
}
}
end_complex_operation();
cancel_code_completion();
if (code_completion_prefixes.has(last_completion_char)) {
request_code_completion();
}
}
void CodeEdit::cancel_code_completion() {
if (!code_completion_active) {
return;
}
code_completion_forced = false;
code_completion_active = false;
queue_redraw();
}
/* Line length guidelines */
void CodeEdit::set_line_length_guidelines(TypedArray<int> p_guideline_columns) {
line_length_guideline_columns = p_guideline_columns;
queue_redraw();
}
TypedArray<int> CodeEdit::get_line_length_guidelines() const {
return line_length_guideline_columns;
}
/* Symbol lookup */
void CodeEdit::set_symbol_lookup_on_click_enabled(bool p_enabled) {
symbol_lookup_on_click_enabled = p_enabled;
set_symbol_lookup_word_as_valid(false);
}
bool CodeEdit::is_symbol_lookup_on_click_enabled() const {
return symbol_lookup_on_click_enabled;
}
String CodeEdit::get_text_for_symbol_lookup() {
Point2i mp = get_local_mouse_pos();
Point2i pos = get_line_column_at_pos(mp, false);
int line = pos.y;
int col = pos.x;
if (line == -1) {
return String();
}
StringBuilder lookup_text;
const int text_size = get_line_count();
for (int i = 0; i < text_size; i++) {
String text = get_line(i);
if (i == line) {
lookup_text += text.substr(0, col);
/* Not unicode, represents the cursor. */
lookup_text += String::chr(0xFFFF);
lookup_text += text.substr(col, text.size());
} else {
lookup_text += text;
}
if (i != text_size - 1) {
lookup_text += "\n";
}
}
return lookup_text.as_string();
}
void CodeEdit::set_symbol_lookup_word_as_valid(bool p_valid) {
symbol_lookup_word = p_valid ? symbol_lookup_new_word : "";
symbol_lookup_new_word = "";
if (lookup_symbol_word != symbol_lookup_word) {
_set_symbol_lookup_word(symbol_lookup_word);
}
}
void CodeEdit::_bind_methods() {
/* Indent management */
ClassDB::bind_method(D_METHOD("set_indent_size", "size"), &CodeEdit::set_indent_size);
ClassDB::bind_method(D_METHOD("get_indent_size"), &CodeEdit::get_indent_size);
ClassDB::bind_method(D_METHOD("set_indent_using_spaces", "use_spaces"), &CodeEdit::set_indent_using_spaces);
ClassDB::bind_method(D_METHOD("is_indent_using_spaces"), &CodeEdit::is_indent_using_spaces);
ClassDB::bind_method(D_METHOD("set_auto_indent_enabled", "enable"), &CodeEdit::set_auto_indent_enabled);
ClassDB::bind_method(D_METHOD("is_auto_indent_enabled"), &CodeEdit::is_auto_indent_enabled);
ClassDB::bind_method(D_METHOD("set_auto_indent_prefixes", "prefixes"), &CodeEdit::set_auto_indent_prefixes);
ClassDB::bind_method(D_METHOD("get_auto_indent_prefixes"), &CodeEdit::get_auto_indent_prefixes);
ClassDB::bind_method(D_METHOD("do_indent"), &CodeEdit::do_indent);
ClassDB::bind_method(D_METHOD("do_unindent"), &CodeEdit::do_unindent);
ClassDB::bind_method(D_METHOD("indent_lines"), &CodeEdit::indent_lines);
ClassDB::bind_method(D_METHOD("unindent_lines"), &CodeEdit::unindent_lines);
/* Auto brace completion */
ClassDB::bind_method(D_METHOD("set_auto_brace_completion_enabled", "enable"), &CodeEdit::set_auto_brace_completion_enabled);
ClassDB::bind_method(D_METHOD("is_auto_brace_completion_enabled"), &CodeEdit::is_auto_brace_completion_enabled);
ClassDB::bind_method(D_METHOD("set_highlight_matching_braces_enabled", "enable"), &CodeEdit::set_highlight_matching_braces_enabled);
ClassDB::bind_method(D_METHOD("is_highlight_matching_braces_enabled"), &CodeEdit::is_highlight_matching_braces_enabled);
ClassDB::bind_method(D_METHOD("add_auto_brace_completion_pair", "start_key", "end_key"), &CodeEdit::add_auto_brace_completion_pair);
ClassDB::bind_method(D_METHOD("set_auto_brace_completion_pairs", "pairs"), &CodeEdit::set_auto_brace_completion_pairs);
ClassDB::bind_method(D_METHOD("get_auto_brace_completion_pairs"), &CodeEdit::get_auto_brace_completion_pairs);
ClassDB::bind_method(D_METHOD("has_auto_brace_completion_open_key", "open_key"), &CodeEdit::has_auto_brace_completion_open_key);
ClassDB::bind_method(D_METHOD("has_auto_brace_completion_close_key", "close_key"), &CodeEdit::has_auto_brace_completion_close_key);
ClassDB::bind_method(D_METHOD("get_auto_brace_completion_close_key", "open_key"), &CodeEdit::get_auto_brace_completion_close_key);
/* Main Gutter */
ClassDB::bind_method(D_METHOD("set_draw_breakpoints_gutter", "enable"), &CodeEdit::set_draw_breakpoints_gutter);
ClassDB::bind_method(D_METHOD("is_drawing_breakpoints_gutter"), &CodeEdit::is_drawing_breakpoints_gutter);
ClassDB::bind_method(D_METHOD("set_draw_bookmarks_gutter", "enable"), &CodeEdit::set_draw_bookmarks_gutter);
ClassDB::bind_method(D_METHOD("is_drawing_bookmarks_gutter"), &CodeEdit::is_drawing_bookmarks_gutter);
ClassDB::bind_method(D_METHOD("set_draw_executing_lines_gutter", "enable"), &CodeEdit::set_draw_executing_lines_gutter);
ClassDB::bind_method(D_METHOD("is_drawing_executing_lines_gutter"), &CodeEdit::is_drawing_executing_lines_gutter);
// Breakpoints
ClassDB::bind_method(D_METHOD("set_line_as_breakpoint", "line", "breakpointed"), &CodeEdit::set_line_as_breakpoint);
ClassDB::bind_method(D_METHOD("is_line_breakpointed", "line"), &CodeEdit::is_line_breakpointed);
ClassDB::bind_method(D_METHOD("clear_breakpointed_lines"), &CodeEdit::clear_breakpointed_lines);
ClassDB::bind_method(D_METHOD("get_breakpointed_lines"), &CodeEdit::get_breakpointed_lines);
// Bookmarks
ClassDB::bind_method(D_METHOD("set_line_as_bookmarked", "line", "bookmarked"), &CodeEdit::set_line_as_bookmarked);
ClassDB::bind_method(D_METHOD("is_line_bookmarked", "line"), &CodeEdit::is_line_bookmarked);
ClassDB::bind_method(D_METHOD("clear_bookmarked_lines"), &CodeEdit::clear_bookmarked_lines);
ClassDB::bind_method(D_METHOD("get_bookmarked_lines"), &CodeEdit::get_bookmarked_lines);
// executing lines
ClassDB::bind_method(D_METHOD("set_line_as_executing", "line", "executing"), &CodeEdit::set_line_as_executing);
ClassDB::bind_method(D_METHOD("is_line_executing", "line"), &CodeEdit::is_line_executing);
ClassDB::bind_method(D_METHOD("clear_executing_lines"), &CodeEdit::clear_executing_lines);
ClassDB::bind_method(D_METHOD("get_executing_lines"), &CodeEdit::get_executing_lines);
/* Line numbers */
ClassDB::bind_method(D_METHOD("set_draw_line_numbers", "enable"), &CodeEdit::set_draw_line_numbers);
ClassDB::bind_method(D_METHOD("is_draw_line_numbers_enabled"), &CodeEdit::is_draw_line_numbers_enabled);
ClassDB::bind_method(D_METHOD("set_line_numbers_zero_padded", "enable"), &CodeEdit::set_line_numbers_zero_padded);
ClassDB::bind_method(D_METHOD("is_line_numbers_zero_padded"), &CodeEdit::is_line_numbers_zero_padded);
/* Fold Gutter */
ClassDB::bind_method(D_METHOD("set_draw_fold_gutter", "enable"), &CodeEdit::set_draw_fold_gutter);
ClassDB::bind_method(D_METHOD("is_drawing_fold_gutter"), &CodeEdit::is_drawing_fold_gutter);
/* Line folding */
ClassDB::bind_method(D_METHOD("set_line_folding_enabled", "enabled"), &CodeEdit::set_line_folding_enabled);
ClassDB::bind_method(D_METHOD("is_line_folding_enabled"), &CodeEdit::is_line_folding_enabled);
ClassDB::bind_method(D_METHOD("can_fold_line", "line"), &CodeEdit::can_fold_line);
ClassDB::bind_method(D_METHOD("fold_line", "line"), &CodeEdit::fold_line);
ClassDB::bind_method(D_METHOD("unfold_line", "line"), &CodeEdit::unfold_line);
ClassDB::bind_method(D_METHOD("fold_all_lines"), &CodeEdit::fold_all_lines);
ClassDB::bind_method(D_METHOD("unfold_all_lines"), &CodeEdit::unfold_all_lines);
ClassDB::bind_method(D_METHOD("toggle_foldable_line", "line"), &CodeEdit::toggle_foldable_line);
ClassDB::bind_method(D_METHOD("is_line_folded", "line"), &CodeEdit::is_line_folded);
ClassDB::bind_method(D_METHOD("get_folded_lines"), &CodeEdit::get_folded_lines);
/* Delimiters */
// Strings
ClassDB::bind_method(D_METHOD("add_string_delimiter", "start_key", "end_key", "line_only"), &CodeEdit::add_string_delimiter, DEFVAL(false));
ClassDB::bind_method(D_METHOD("remove_string_delimiter", "start_key"), &CodeEdit::remove_string_delimiter);
ClassDB::bind_method(D_METHOD("has_string_delimiter", "start_key"), &CodeEdit::has_string_delimiter);
ClassDB::bind_method(D_METHOD("set_string_delimiters", "string_delimiters"), &CodeEdit::set_string_delimiters);
ClassDB::bind_method(D_METHOD("clear_string_delimiters"), &CodeEdit::clear_string_delimiters);
ClassDB::bind_method(D_METHOD("get_string_delimiters"), &CodeEdit::get_string_delimiters);
ClassDB::bind_method(D_METHOD("is_in_string", "line", "column"), &CodeEdit::is_in_string, DEFVAL(-1));
// Comments
ClassDB::bind_method(D_METHOD("add_comment_delimiter", "start_key", "end_key", "line_only"), &CodeEdit::add_comment_delimiter, DEFVAL(false));
ClassDB::bind_method(D_METHOD("remove_comment_delimiter", "start_key"), &CodeEdit::remove_comment_delimiter);
ClassDB::bind_method(D_METHOD("has_comment_delimiter", "start_key"), &CodeEdit::has_comment_delimiter);
ClassDB::bind_method(D_METHOD("set_comment_delimiters", "comment_delimiters"), &CodeEdit::set_comment_delimiters);
ClassDB::bind_method(D_METHOD("clear_comment_delimiters"), &CodeEdit::clear_comment_delimiters);
ClassDB::bind_method(D_METHOD("get_comment_delimiters"), &CodeEdit::get_comment_delimiters);
ClassDB::bind_method(D_METHOD("is_in_comment", "line", "column"), &CodeEdit::is_in_comment, DEFVAL(-1));
// Util
ClassDB::bind_method(D_METHOD("get_delimiter_start_key", "delimiter_index"), &CodeEdit::get_delimiter_start_key);
ClassDB::bind_method(D_METHOD("get_delimiter_end_key", "delimiter_index"), &CodeEdit::get_delimiter_end_key);
ClassDB::bind_method(D_METHOD("get_delimiter_start_position", "line", "column"), &CodeEdit::get_delimiter_start_position);
ClassDB::bind_method(D_METHOD("get_delimiter_end_position", "line", "column"), &CodeEdit::get_delimiter_end_position);
/* Code hint */
ClassDB::bind_method(D_METHOD("set_code_hint", "code_hint"), &CodeEdit::set_code_hint);
ClassDB::bind_method(D_METHOD("set_code_hint_draw_below", "draw_below"), &CodeEdit::set_code_hint_draw_below);
/* Code Completion */
BIND_ENUM_CONSTANT(KIND_CLASS);
BIND_ENUM_CONSTANT(KIND_FUNCTION);
BIND_ENUM_CONSTANT(KIND_SIGNAL);
BIND_ENUM_CONSTANT(KIND_VARIABLE);
BIND_ENUM_CONSTANT(KIND_MEMBER);
BIND_ENUM_CONSTANT(KIND_ENUM);
BIND_ENUM_CONSTANT(KIND_CONSTANT);
BIND_ENUM_CONSTANT(KIND_NODE_PATH);
BIND_ENUM_CONSTANT(KIND_FILE_PATH);
BIND_ENUM_CONSTANT(KIND_PLAIN_TEXT);
ClassDB::bind_method(D_METHOD("get_text_for_code_completion"), &CodeEdit::get_text_for_code_completion);
ClassDB::bind_method(D_METHOD("request_code_completion", "force"), &CodeEdit::request_code_completion, DEFVAL(false));
ClassDB::bind_method(D_METHOD("add_code_completion_option", "type", "display_text", "insert_text", "text_color", "icon", "value"), &CodeEdit::add_code_completion_option, DEFVAL(Color(1, 1, 1)), DEFVAL(Ref<Resource>()), DEFVAL(Variant::NIL));
ClassDB::bind_method(D_METHOD("update_code_completion_options", "force"), &CodeEdit::update_code_completion_options);
ClassDB::bind_method(D_METHOD("get_code_completion_options"), &CodeEdit::get_code_completion_options);
ClassDB::bind_method(D_METHOD("get_code_completion_option", "index"), &CodeEdit::get_code_completion_option);
ClassDB::bind_method(D_METHOD("get_code_completion_selected_index"), &CodeEdit::get_code_completion_selected_index);
ClassDB::bind_method(D_METHOD("set_code_completion_selected_index", "index"), &CodeEdit::set_code_completion_selected_index);
ClassDB::bind_method(D_METHOD("confirm_code_completion", "replace"), &CodeEdit::confirm_code_completion, DEFVAL(false));
ClassDB::bind_method(D_METHOD("cancel_code_completion"), &CodeEdit::cancel_code_completion);
ClassDB::bind_method(D_METHOD("set_code_completion_enabled", "enable"), &CodeEdit::set_code_completion_enabled);
ClassDB::bind_method(D_METHOD("is_code_completion_enabled"), &CodeEdit::is_code_completion_enabled);
ClassDB::bind_method(D_METHOD("set_code_completion_prefixes", "prefixes"), &CodeEdit::set_code_completion_prefixes);
ClassDB::bind_method(D_METHOD("get_code_comletion_prefixes"), &CodeEdit::get_code_completion_prefixes);
// Overridable
GDVIRTUAL_BIND(_confirm_code_completion, "replace")
GDVIRTUAL_BIND(_request_code_completion, "force")
GDVIRTUAL_BIND(_filter_code_completion_candidates, "candidates")
/* Line length guidelines */
ClassDB::bind_method(D_METHOD("set_line_length_guidelines", "guideline_columns"), &CodeEdit::set_line_length_guidelines);
ClassDB::bind_method(D_METHOD("get_line_length_guidelines"), &CodeEdit::get_line_length_guidelines);
/* Symbol lookup */
ClassDB::bind_method(D_METHOD("set_symbol_lookup_on_click_enabled", "enable"), &CodeEdit::set_symbol_lookup_on_click_enabled);
ClassDB::bind_method(D_METHOD("is_symbol_lookup_on_click_enabled"), &CodeEdit::is_symbol_lookup_on_click_enabled);
ClassDB::bind_method(D_METHOD("get_text_for_symbol_lookup"), &CodeEdit::get_text_for_symbol_lookup);
ClassDB::bind_method(D_METHOD("set_symbol_lookup_word_as_valid", "valid"), &CodeEdit::set_symbol_lookup_word_as_valid);
/* Inspector */
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "symbol_lookup_on_click"), "set_symbol_lookup_on_click_enabled", "is_symbol_lookup_on_click_enabled");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "line_folding"), "set_line_folding_enabled", "is_line_folding_enabled");
ADD_PROPERTY(PropertyInfo(Variant::PACKED_INT32_ARRAY, "line_length_guidelines"), "set_line_length_guidelines", "get_line_length_guidelines");
ADD_GROUP("Gutters", "gutters_");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_breakpoints_gutter"), "set_draw_breakpoints_gutter", "is_drawing_breakpoints_gutter");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_bookmarks"), "set_draw_bookmarks_gutter", "is_drawing_bookmarks_gutter");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_executing_lines"), "set_draw_executing_lines_gutter", "is_drawing_executing_lines_gutter");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_line_numbers"), "set_draw_line_numbers", "is_draw_line_numbers_enabled");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_zero_pad_line_numbers"), "set_line_numbers_zero_padded", "is_line_numbers_zero_padded");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "gutters_draw_fold_gutter"), "set_draw_fold_gutter", "is_drawing_fold_gutter");
ADD_GROUP("Delimiters", "delimiter_");
ADD_PROPERTY(PropertyInfo(Variant::PACKED_STRING_ARRAY, "delimiter_strings"), "set_string_delimiters", "get_string_delimiters");
ADD_PROPERTY(PropertyInfo(Variant::PACKED_STRING_ARRAY, "delimiter_comments"), "set_comment_delimiters", "get_comment_delimiters");
ADD_GROUP("Code Completion", "code_completion_");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "code_completion_enabled"), "set_code_completion_enabled", "is_code_completion_enabled");
ADD_PROPERTY(PropertyInfo(Variant::PACKED_STRING_ARRAY, "code_completion_prefixes"), "set_code_completion_prefixes", "get_code_comletion_prefixes");
ADD_GROUP("Indentation", "indent_");
ADD_PROPERTY(PropertyInfo(Variant::INT, "indent_size"), "set_indent_size", "get_indent_size");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "indent_use_spaces"), "set_indent_using_spaces", "is_indent_using_spaces");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "indent_automatic"), "set_auto_indent_enabled", "is_auto_indent_enabled");
ADD_PROPERTY(PropertyInfo(Variant::PACKED_STRING_ARRAY, "indent_automatic_prefixes"), "set_auto_indent_prefixes", "get_auto_indent_prefixes");
ADD_GROUP("Auto Brace Completion", "auto_brace_completion_");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_brace_completion_enabled"), "set_auto_brace_completion_enabled", "is_auto_brace_completion_enabled");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "auto_brace_completion_highlight_matching"), "set_highlight_matching_braces_enabled", "is_highlight_matching_braces_enabled");
ADD_PROPERTY(PropertyInfo(Variant::DICTIONARY, "auto_brace_completion_pairs"), "set_auto_brace_completion_pairs", "get_auto_brace_completion_pairs");
/* Signals */
/* Gutters */
ADD_SIGNAL(MethodInfo("breakpoint_toggled", PropertyInfo(Variant::INT, "line")));
/* Code Completion */
ADD_SIGNAL(MethodInfo("code_completion_requested"));
/* Symbol lookup */
ADD_SIGNAL(MethodInfo("symbol_lookup", PropertyInfo(Variant::STRING, "symbol"), PropertyInfo(Variant::INT, "line"), PropertyInfo(Variant::INT, "column")));
ADD_SIGNAL(MethodInfo("symbol_validate", PropertyInfo(Variant::STRING, "symbol")));
}
/* Auto brace completion */
int CodeEdit::_get_auto_brace_pair_open_at_pos(int p_line, int p_col) {
const String &line = get_line(p_line);
/* Should be fast enough, expecting low amount of pairs... */
for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
const String &open_key = auto_brace_completion_pairs[i].open_key;
if (p_col - open_key.length() < 0) {
continue;
}
bool is_match = true;
for (int j = 0; j < open_key.length(); j++) {
if (line[(p_col - 1) - j] != open_key[(open_key.length() - 1) - j]) {
is_match = false;
break;
}
}
if (is_match) {
return i;
}
}
return -1;
}
int CodeEdit::_get_auto_brace_pair_close_at_pos(int p_line, int p_col) {
const String &line = get_line(p_line);
/* Should be fast enough, expecting low amount of pairs... */
for (int i = 0; i < auto_brace_completion_pairs.size(); i++) {
if (p_col + auto_brace_completion_pairs[i].close_key.length() > line.length()) {
continue;
}
bool is_match = true;
for (int j = 0; j < auto_brace_completion_pairs[i].close_key.length(); j++) {
if (line[p_col + j] != auto_brace_completion_pairs[i].close_key[j]) {
is_match = false;
break;
}
}
if (is_match) {
return i;
}
}
return -1;
}
/* Gutters */
void CodeEdit::_gutter_clicked(int p_line, int p_gutter) {
bool shift_pressed = Input::get_singleton()->is_key_pressed(Key::SHIFT);
if (p_gutter == main_gutter) {
if (draw_breakpoints && !shift_pressed) {
set_line_as_breakpoint(p_line, !is_line_breakpointed(p_line));
} else if (draw_bookmarks && shift_pressed) {
set_line_as_bookmarked(p_line, !is_line_bookmarked(p_line));
}
return;
}
if (p_gutter == line_number_gutter) {
set_selection_mode(TextEdit::SelectionMode::SELECTION_MODE_LINE, p_line, 0);
select(p_line, 0, p_line + 1, 0);
set_caret_line(p_line + 1);
set_caret_column(0);
return;
}
if (p_gutter == fold_gutter) {
if (is_line_folded(p_line)) {
unfold_line(p_line);
} else if (can_fold_line(p_line)) {
fold_line(p_line);
}
return;
}
}
void CodeEdit::_update_gutter_indexes() {
for (int i = 0; i < get_gutter_count(); i++) {
if (get_gutter_name(i) == "main_gutter") {
main_gutter = i;
continue;
}
if (get_gutter_name(i) == "line_numbers") {
line_number_gutter = i;
continue;
}
if (get_gutter_name(i) == "fold_gutter") {
fold_gutter = i;
continue;
}
}
}
/* Delimiters */
void CodeEdit::_update_delimiter_cache(int p_from_line, int p_to_line) {
if (delimiters.size() == 0) {
return;
}
int line_count = get_line_count();
if (p_to_line == -1) {
p_to_line = line_count;
}
int start_line = MIN(p_from_line, p_to_line);
int end_line = MAX(p_from_line, p_to_line);
/* Make sure delimiter_cache has all the lines. */
if (start_line != end_line) {
if (p_to_line < p_from_line) {
for (int i = end_line; i > start_line; i--) {
delimiter_cache.remove_at(i);
}
} else {
for (int i = start_line; i < end_line; i++) {
delimiter_cache.insert(i, RBMap<int, int>());
}
}
}
int in_region = -1;
for (int i = start_line; i < MIN(end_line + 1, line_count); i++) {
int current_end_region = (i <= 0 || delimiter_cache[i].size() < 1) ? -1 : delimiter_cache[i].back()->value();
in_region = (i <= 0 || delimiter_cache[i - 1].size() < 1) ? -1 : delimiter_cache[i - 1].back()->value();
const String &str = get_line(i);
const int line_length = str.length();
delimiter_cache.write[i].clear();
if (str.length() == 0) {
if (in_region != -1) {
delimiter_cache.write[i][0] = in_region;
}
if (i == end_line && current_end_region != in_region) {
end_line++;
end_line = MIN(end_line, line_count);
}
continue;
}
int end_region = -1;
for (int j = 0; j < line_length; j++) {
int from = j;
for (; from < line_length; from++) {
if (str[from] == '\\') {
from++;
continue;
}
break;
}
/* check if we are in entering a region */
bool same_line = false;
if (in_region == -1) {
for (int d = 0; d < delimiters.size(); d++) {
/* check there is enough room */
int chars_left = line_length - from;
int start_key_length = delimiters[d].start_key.length();
int end_key_length = delimiters[d].end_key.length();
if (chars_left < start_key_length) {
continue;
}
/* search the line */
bool match = true;
const char32_t *start_key = delimiters[d].start_key.get_data();
for (int k = 0; k < start_key_length; k++) {
if (start_key[k] != str[from + k]) {
match = false;
break;
}
}
if (!match) {
continue;
}
same_line = true;
in_region = d;
delimiter_cache.write[i][from + 1] = d;
from += start_key_length;
/* check if it's the whole line */
if (end_key_length == 0 || delimiters[d].line_only || from + end_key_length > line_length) {
j = line_length;
if (delimiters[d].line_only) {
delimiter_cache.write[i][line_length + 1] = -1;
} else {
end_region = in_region;
}
}
break;
}
if (j == line_length || in_region == -1) {
continue;
}
}
/* if we are in one find the end key */
/* search the line */
int region_end_index = -1;
int end_key_length = delimiters[in_region].end_key.length();
const char32_t *end_key = delimiters[in_region].end_key.get_data();
for (; from < line_length; from++) {
if (line_length - from < end_key_length) {
break;
}
if (!is_symbol(str[from])) {
continue;
}
if (str[from] == '\\') {
from++;
continue;
}
region_end_index = from;
for (int k = 0; k < end_key_length; k++) {
if (end_key[k] != str[from + k]) {
region_end_index = -1;
break;
}
}
if (region_end_index != -1) {
break;
}
}
j = from + (end_key_length - 1);
end_region = (region_end_index == -1) ? in_region : -1;
if (!same_line || region_end_index != -1) {
delimiter_cache.write[i][j + 1] = end_region;
}
in_region = -1;
}
if (i == end_line && current_end_region != end_region) {
end_line++;
end_line = MIN(end_line, line_count);
}
}
}
int CodeEdit::_is_in_delimiter(int p_line, int p_column, DelimiterType p_type) const {
if (delimiters.size() == 0) {
return -1;
}
ERR_FAIL_INDEX_V(p_line, get_line_count(), 0);
int region = (p_line <= 0 || delimiter_cache[p_line - 1].size() < 1) ? -1 : delimiter_cache[p_line - 1].back()->value();
bool in_region = region != -1 && delimiters[region].type == p_type;
for (RBMap<int, int>::Element *E = delimiter_cache[p_line].front(); E; E = E->next()) {
/* If column is specified, loop until the key is larger then the column. */
if (p_column != -1) {
if (E->key() > p_column) {
break;
}
in_region = E->value() != -1 && delimiters[E->value()].type == p_type;
region = in_region ? E->value() : -1;
continue;
}
/* If no column, calculate if the entire line is a region */
/* excluding whitespace. */
const String line = get_line(p_line);
if (!in_region) {
if (E->value() == -1 || delimiters[E->value()].type != p_type) {
break;
}
region = E->value();
in_region = true;
for (int i = E->key() - 2; i >= 0; i--) {
if (!is_whitespace(line[i])) {
return -1;
}
}
}
if (delimiters[region].line_only) {
return region;
}
int end_col = E->key();
if (E->value() != -1) {
if (!E->next()) {
return region;
}
end_col = E->next()->key();
}
for (int i = end_col; i < line.length(); i++) {
if (!is_whitespace(line[i])) {
return -1;
}
}
return region;
}
return in_region ? region : -1;
}
void CodeEdit::_add_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only, DelimiterType p_type) {
// If we are the editor allow "null" as a valid start key, otherwise users cannot add delimiters via the inspector.
if (!(Engine::get_singleton()->is_editor_hint() && p_start_key == "null")) {
ERR_FAIL_COND_MSG(p_start_key.is_empty(), "delimiter start key cannot be empty");
for (int i = 0; i < p_start_key.length(); i++) {
ERR_FAIL_COND_MSG(!is_symbol(p_start_key[i]), "delimiter must start with a symbol");
}
}
if (p_end_key.length() > 0) {
for (int i = 0; i < p_end_key.length(); i++) {
ERR_FAIL_COND_MSG(!is_symbol(p_end_key[i]), "delimiter must end with a symbol");
}
}
int at = 0;
for (int i = 0; i < delimiters.size(); i++) {
ERR_FAIL_COND_MSG(delimiters[i].start_key == p_start_key, "delimiter with start key '" + p_start_key + "' already exists.");
if (p_start_key.length() < delimiters[i].start_key.length()) {
at++;
}
}
Delimiter delimiter;
delimiter.type = p_type;
delimiter.start_key = p_start_key;
delimiter.end_key = p_end_key;
delimiter.line_only = p_line_only || p_end_key.is_empty();
delimiters.insert(at, delimiter);
if (!setting_delimiters) {
delimiter_cache.clear();
_update_delimiter_cache();
}
}
void CodeEdit::_remove_delimiter(const String &p_start_key, DelimiterType p_type) {
for (int i = 0; i < delimiters.size(); i++) {
if (delimiters[i].start_key != p_start_key) {
continue;
}
if (delimiters[i].type != p_type) {
break;
}
delimiters.remove_at(i);
if (!setting_delimiters) {
delimiter_cache.clear();
_update_delimiter_cache();
}
break;
}
}
bool CodeEdit::_has_delimiter(const String &p_start_key, DelimiterType p_type) const {
for (int i = 0; i < delimiters.size(); i++) {
if (delimiters[i].start_key == p_start_key) {
return delimiters[i].type == p_type;
}
}
return false;
}
void CodeEdit::_set_delimiters(const TypedArray<String> &p_delimiters, DelimiterType p_type) {
setting_delimiters = true;
_clear_delimiters(p_type);
for (int i = 0; i < p_delimiters.size(); i++) {
String key = p_delimiters[i];
if (key.is_empty()) {
continue;
}
const String start_key = key.get_slice(" ", 0);
const String end_key = key.get_slice_count(" ") > 1 ? key.get_slice(" ", 1) : String();
_add_delimiter(start_key, end_key, end_key.is_empty(), p_type);
}
setting_delimiters = false;
_update_delimiter_cache();
}
void CodeEdit::_clear_delimiters(DelimiterType p_type) {
for (int i = delimiters.size() - 1; i >= 0; i--) {
if (delimiters[i].type == p_type) {
delimiters.remove_at(i);
}
}
delimiter_cache.clear();
if (!setting_delimiters) {
_update_delimiter_cache();
}
}
TypedArray<String> CodeEdit::_get_delimiters(DelimiterType p_type) const {
TypedArray<String> r_delimiters;
for (int i = 0; i < delimiters.size(); i++) {
if (delimiters[i].type != p_type) {
continue;
}
r_delimiters.push_back(delimiters[i].start_key + (delimiters[i].end_key.is_empty() ? "" : " " + delimiters[i].end_key));
}
return r_delimiters;
}
/* Code Completion */
void CodeEdit::_update_scroll_selected_line(float p_mouse_y) {
float percent = (float)(p_mouse_y - code_completion_scroll_rect.position.y) / code_completion_scroll_rect.size.height;
percent = CLAMP(percent, 0.0f, 1.0f);
code_completion_current_selected = (int)(percent * (code_completion_options.size() - 1));
}
void CodeEdit::_filter_code_completion_candidates_impl() {
int line_height = get_line_height();
if (GDVIRTUAL_IS_OVERRIDDEN(_filter_code_completion_candidates)) {
code_completion_options.clear();
code_completion_base = "";
/* Build options argument. */
TypedArray<Dictionary> completion_options_sources;
completion_options_sources.resize(code_completion_option_sources.size());
int i = 0;
for (const ScriptLanguage::CodeCompletionOption &E : code_completion_option_sources) {
Dictionary option;
option["kind"] = E.kind;
option["display_text"] = E.display;
option["insert_text"] = E.insert_text;
option["font_color"] = E.font_color;
option["icon"] = E.icon;
option["default_value"] = E.default_value;
completion_options_sources[i] = option;
i++;
}
TypedArray<Dictionary> completion_options;
GDVIRTUAL_CALL(_filter_code_completion_candidates, completion_options_sources, completion_options);
/* No options to complete, cancel. */
if (completion_options.size() == 0) {
cancel_code_completion();
return;
}
/* Convert back into options. */
int max_width = 0;
for (i = 0; i < completion_options.size(); i++) {
ScriptLanguage::CodeCompletionOption option;
option.kind = (ScriptLanguage::CodeCompletionKind)(int)completion_options[i].get("kind");
option.display = completion_options[i].get("display_text");
option.insert_text = completion_options[i].get("insert_text");
option.font_color = completion_options[i].get("font_color");
option.icon = completion_options[i].get("icon");
option.default_value = completion_options[i].get("default_value");
int offset = 0;
if (option.default_value.get_type() == Variant::COLOR) {
offset = line_height;
}
max_width = MAX(max_width, font->get_string_size(option.display, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width + offset);
code_completion_options.push_back(option);
}
code_completion_longest_line = MIN(max_width, code_completion_max_width * font_size);
code_completion_current_selected = 0;
code_completion_active = true;
queue_redraw();
return;
}
const int caret_line = get_caret_line();
const int caret_column = get_caret_column();
const String line = get_line(caret_line);
if (caret_column > 0 && line[caret_column - 1] == '(' && !code_completion_forced) {
cancel_code_completion();
return;
}
/* Get string status, are we in one or at the close. */
int in_string = is_in_string(caret_line, caret_column);
int first_quote_col = -1;
if (in_string != -1) {
Point2 string_start_pos = get_delimiter_start_position(caret_line, caret_column);
first_quote_col = (string_start_pos.y == caret_line) ? string_start_pos.x : -1;
} else if (caret_column > 0) {
if (is_in_string(caret_line, caret_column - 1) != -1) {
first_quote_col = caret_column - 1;
}
}
int cofs = caret_column;
String string_to_complete;
bool prev_is_word = false;
/* Cancel if we are at the close of a string. */
if (caret_column > 0 && in_string == -1 && first_quote_col == cofs - 1) {
cancel_code_completion();
return;
/* In a string, therefore we are trying to complete the string text. */
} else if (in_string != -1 && first_quote_col != -1) {
int key_length = delimiters[in_string].start_key.length();
string_to_complete = line.substr(first_quote_col - key_length, (cofs - first_quote_col) + key_length);
/* If we have a space, previous word might be a keyword. eg "func |". */
} else if (cofs > 0 && line[cofs - 1] == ' ') {
int ofs = cofs - 1;
while (ofs > 0 && line[ofs] == ' ') {
ofs--;
}
prev_is_word = !is_symbol(line[ofs]);
/* Otherwise get current word and set cofs to the start. */
} else {
int start_cofs = cofs;
while (cofs > 0 && line[cofs - 1] > 32 && (line[cofs - 1] == '/' || !is_symbol(line[cofs - 1]))) {
cofs--;
}
string_to_complete = line.substr(cofs, start_cofs - cofs);
}
/* If all else fails, check for a prefix. */
/* Single space between caret and prefix is okay. */
bool prev_is_prefix = false;
if (cofs > 0 && code_completion_prefixes.has(line[cofs - 1])) {
prev_is_prefix = true;
} else if (cofs > 1 && line[cofs - 1] == ' ' && code_completion_prefixes.has(line[cofs - 2])) {
prev_is_prefix = true;
}
if (!prev_is_word && string_to_complete.is_empty() && (cofs == 0 || !prev_is_prefix)) {
cancel_code_completion();
return;
}
/* Filter Options. */
/* For now handle only tradional quoted strings. */
bool single_quote = in_string != -1 && first_quote_col > 0 && delimiters[in_string].start_key == "'";
code_completion_options.clear();
code_completion_base = string_to_complete;
Vector<ScriptLanguage::CodeCompletionOption> completion_options_casei;
Vector<ScriptLanguage::CodeCompletionOption> completion_options_substr;
Vector<ScriptLanguage::CodeCompletionOption> completion_options_substr_casei;
Vector<ScriptLanguage::CodeCompletionOption> completion_options_subseq;
Vector<ScriptLanguage::CodeCompletionOption> completion_options_subseq_casei;
int max_width = 0;
String string_to_complete_lower = string_to_complete.to_lower();
for (ScriptLanguage::CodeCompletionOption &option : code_completion_option_sources) {
if (single_quote && option.display.is_quoted()) {
option.display = option.display.unquote().quote("'");
}
int offset = 0;
if (option.default_value.get_type() == Variant::COLOR) {
offset = line_height;
}
if (in_string != -1) {
String quote = single_quote ? "'" : "\"";
option.display = option.display.unquote().quote(quote);
option.insert_text = option.insert_text.unquote().quote(quote);
}
if (option.display.length() == 0) {
continue;
}
if (string_to_complete.length() == 0) {
code_completion_options.push_back(option);
max_width = MAX(max_width, font->get_string_size(option.display, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width + offset);
continue;
}
/* This code works the same as:
if (option.display.begins_with(s)) {
completion_options.push_back(option);
} else if (option.display.to_lower().begins_with(s.to_lower())) {
completion_options_casei.push_back(option);
} else if (s.is_subsequence_of(option.display)) {
completion_options_subseq.push_back(option);
} else if (s.is_subsequence_ofn(option.display)) {
completion_options_subseq_casei.push_back(option);
}
But is more performant due to being inlined and looping over the characters only once
*/
String display_lower = option.display.to_lower();
const char32_t *ssq = &string_to_complete[0];
const char32_t *ssq_lower = &string_to_complete_lower[0];
const char32_t *tgt = &option.display[0];
const char32_t *tgt_lower = &display_lower[0];
const char32_t *sst = &string_to_complete[0];
const char32_t *sst_lower = &display_lower[0];
Vector<Pair<int, int>> ssq_matches;
int ssq_match_start = 0;
int ssq_match_len = 0;
Vector<Pair<int, int>> ssq_lower_matches;
int ssq_lower_match_start = 0;
int ssq_lower_match_len = 0;
int sst_start = -1;
int sst_lower_start = -1;
for (int i = 0; *tgt; tgt++, tgt_lower++, i++) {
// Check substring.
if (*sst == *tgt) {
sst++;
if (sst_start == -1) {
sst_start = i;
}
} else if (sst_start != -1 && *sst) {
sst = &string_to_complete[0];
sst_start = -1;
}
// Check subsequence.
if (*ssq == *tgt) {
ssq++;
if (ssq_match_len == 0) {
ssq_match_start = i;
}
ssq_match_len++;
} else if (ssq_match_len > 0) {
ssq_matches.push_back(Pair<int, int>(ssq_match_start, ssq_match_len));
ssq_match_len = 0;
}
// Check lower substring.
if (*sst_lower == *tgt) {
sst_lower++;
if (sst_lower_start == -1) {
sst_lower_start = i;
}
} else if (sst_lower_start != -1 && *sst_lower) {
sst_lower = &string_to_complete[0];
sst_lower_start = -1;
}
// Check lower subsequence.
if (*ssq_lower == *tgt_lower) {
ssq_lower++;
if (ssq_lower_match_len == 0) {
ssq_lower_match_start = i;
}
ssq_lower_match_len++;
} else if (ssq_lower_match_len > 0) {
ssq_lower_matches.push_back(Pair<int, int>(ssq_lower_match_start, ssq_lower_match_len));
ssq_lower_match_len = 0;
}
}
/* Matched the whole subsequence in s. */
if (!*ssq) { // Matched the whole subsequence in s.
option.matches.clear();
if (sst_start == 0) { // Matched substring in beginning of s.
option.matches.push_back(Pair<int, int>(sst_start, string_to_complete.length()));
code_completion_options.push_back(option);
} else if (sst_start > 0) { // Matched substring in s.
option.matches.push_back(Pair<int, int>(sst_start, string_to_complete.length()));
completion_options_substr.push_back(option);
} else {
if (ssq_match_len > 0) {
ssq_matches.push_back(Pair<int, int>(ssq_match_start, ssq_match_len));
}
option.matches.append_array(ssq_matches);
completion_options_subseq.push_back(option);
}
max_width = MAX(max_width, font->get_string_size(option.display, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width + offset);
} else if (!*ssq_lower) { // Matched the whole subsequence in s_lower.
option.matches.clear();
if (sst_lower_start == 0) { // Matched substring in beginning of s_lower.
option.matches.push_back(Pair<int, int>(sst_lower_start, string_to_complete.length()));
completion_options_casei.push_back(option);
} else if (sst_lower_start > 0) { // Matched substring in s_lower.
option.matches.push_back(Pair<int, int>(sst_lower_start, string_to_complete.length()));
completion_options_substr_casei.push_back(option);
} else {
if (ssq_lower_match_len > 0) {
ssq_lower_matches.push_back(Pair<int, int>(ssq_lower_match_start, ssq_lower_match_len));
}
option.matches.append_array(ssq_lower_matches);
completion_options_subseq_casei.push_back(option);
}
max_width = MAX(max_width, font->get_string_size(option.display, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size).width + offset);
}
}
code_completion_options.append_array(completion_options_casei);
code_completion_options.append_array(completion_options_subseq);
code_completion_options.append_array(completion_options_subseq_casei);
/* No options to complete, cancel. */
if (code_completion_options.size() == 0) {
cancel_code_completion();
return;
}
/* A perfect match, stop completion. */
if (code_completion_options.size() == 1 && string_to_complete == code_completion_options[0].display) {
cancel_code_completion();
return;
}
code_completion_longest_line = MIN(max_width, code_completion_max_width * font_size);
code_completion_current_selected = 0;
code_completion_active = true;
queue_redraw();
}
void CodeEdit::_lines_edited_from(int p_from_line, int p_to_line) {
_update_delimiter_cache(p_from_line, p_to_line);
if (p_from_line == p_to_line) {
return;
}
lines_edited_changed += p_to_line - p_from_line;
lines_edited_from = (lines_edited_from == -1) ? MIN(p_from_line, p_to_line) : MIN(lines_edited_from, MIN(p_from_line, p_to_line));
lines_edited_to = (lines_edited_to == -1) ? MAX(p_from_line, p_to_line) : MAX(lines_edited_from, MAX(p_from_line, p_to_line));
}
void CodeEdit::_text_set() {
lines_edited_from = 0;
lines_edited_to = 9999;
_text_changed();
}
void CodeEdit::_text_changed() {
if (lines_edited_from == -1) {
return;
}
int lc = get_line_count();
line_number_digits = 1;
while (lc /= 10) {
line_number_digits++;
}
if (font.is_valid()) {
set_gutter_width(line_number_gutter, (line_number_digits + 1) * font->get_char_size('0', font_size).width);
}
lc = get_line_count();
List<int> breakpoints;
for (const KeyValue<int, bool> &E : breakpointed_lines) {
breakpoints.push_back(E.key);
}
for (const int &line : breakpoints) {
if (line < lines_edited_from || (line < lc && is_line_breakpointed(line))) {
continue;
}
breakpointed_lines.erase(line);
emit_signal(SNAME("breakpoint_toggled"), line);
int next_line = line + lines_edited_changed;
if (next_line > -1 && next_line < lc && is_line_breakpointed(next_line)) {
emit_signal(SNAME("breakpoint_toggled"), next_line);
breakpointed_lines[next_line] = true;
continue;
}
}
lines_edited_from = -1;
lines_edited_to = -1;
lines_edited_changed = 0;
}
CodeEdit::CodeEdit() {
/* Indent management */
auto_indent_prefixes.insert(':');
auto_indent_prefixes.insert('{');
auto_indent_prefixes.insert('[');
auto_indent_prefixes.insert('(');
/* Auto brace completion */
add_auto_brace_completion_pair("(", ")");
add_auto_brace_completion_pair("{", "}");
add_auto_brace_completion_pair("[", "]");
add_auto_brace_completion_pair("\"", "\"");
add_auto_brace_completion_pair("\'", "\'");
/* Delimiter tracking */
add_string_delimiter("\"", "\"", false);
add_string_delimiter("\'", "\'", false);
/* Text Direction */
set_layout_direction(LAYOUT_DIRECTION_LTR);
set_text_direction(TEXT_DIRECTION_LTR);
/* Gutters */
int gutter_idx = 0;
/* Main Gutter */
add_gutter();
set_gutter_name(gutter_idx, "main_gutter");
set_gutter_draw(gutter_idx, false);
set_gutter_overwritable(gutter_idx, true);
set_gutter_type(gutter_idx, GUTTER_TYPE_CUSTOM);
set_gutter_custom_draw(gutter_idx, callable_mp(this, &CodeEdit::_main_gutter_draw_callback));
gutter_idx++;
/* Line numbers */
add_gutter();
set_gutter_name(gutter_idx, "line_numbers");
set_gutter_draw(gutter_idx, false);
set_gutter_type(gutter_idx, GUTTER_TYPE_CUSTOM);
set_gutter_custom_draw(gutter_idx, callable_mp(this, &CodeEdit::_line_number_draw_callback));
gutter_idx++;
/* Fold Gutter */
add_gutter();
set_gutter_name(gutter_idx, "fold_gutter");
set_gutter_draw(gutter_idx, false);
set_gutter_type(gutter_idx, GUTTER_TYPE_CUSTOM);
set_gutter_custom_draw(gutter_idx, callable_mp(this, &CodeEdit::_fold_gutter_draw_callback));
gutter_idx++;
connect("lines_edited_from", callable_mp(this, &CodeEdit::_lines_edited_from));
connect("text_set", callable_mp(this, &CodeEdit::_text_set));
connect("text_changed", callable_mp(this, &CodeEdit::_text_changed));
connect("gutter_clicked", callable_mp(this, &CodeEdit::_gutter_clicked));
connect("gutter_added", callable_mp(this, &CodeEdit::_update_gutter_indexes));
connect("gutter_removed", callable_mp(this, &CodeEdit::_update_gutter_indexes));
_update_gutter_indexes();
}
CodeEdit::~CodeEdit() {
}
Reference in New Issue View Git Blame Copy Permalink