maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Move and expose AutoComplete in CodeEdit

Browse source
This commit is contained in:
Paulb23 2020-09-13 21:14:20 +01:00
parent 680dc9e81a
commit 1c16673798
10 changed files with 966 additions and 791 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
core/input/input_map.cpp
View file

@ -474,10 +474,14 @@ const OrderedHashMap<String, List<Ref<InputEvent>>> &InputMap::get_builtins() {
default_builtin_cache.insert("ui_text_completion_query", inputs);
inputs = List<Ref<InputEvent>>();
inputs.push_back(InputEventKey::create_reference(KEY_TAB));
inputs.push_back(InputEventKey::create_reference(KEY_ENTER));
inputs.push_back(InputEventKey::create_reference(KEY_KP_ENTER));
default_builtin_cache.insert("ui_text_completion_accept", inputs);
inputs = List<Ref<InputEvent>>();
inputs.push_back(InputEventKey::create_reference(KEY_TAB));
default_builtin_cache.insert("ui_text_completion_replace", inputs);
// Newlines
inputs = List<Ref<InputEvent>>();
inputs.push_back(InputEventKey::create_reference(KEY_ENTER));

2
core/object/script_language.h
View file

@ -242,6 +242,8 @@ public:
};
struct ScriptCodeCompletionOption {
/* Keep enum in Sync with: */
/* /scene/gui/code_edit.h - CodeEdit::CodeCompletionKind */
enum Kind {
KIND_CLASS,
KIND_FUNCTION,

29
editor/code_editor.cpp
View file

@ -816,12 +816,12 @@ void CodeTextEditor::_code_complete_timer_timeout() {
if (!is_visible_in_tree()) {
return;
}
text_editor->query_code_comple();
text_editor->request_code_completion();
}
void CodeTextEditor::_complete_request() {
List<ScriptCodeCompletionOption> entries;
String ctext = text_editor->get_text_for_completion();
String ctext = text_editor->get_text_for_code_completion();
_code_complete_script(ctext, &entries);
bool forced = false;
if (code_complete_func) {
@ -832,16 +832,17 @@ void CodeTextEditor::_complete_request() {
}
for (List<ScriptCodeCompletionOption>::Element *E = entries.front(); E; E = E->next()) {
ScriptCodeCompletionOption *e = &E->get();
e->icon = _get_completion_icon(*e);
e->font_color = completion_font_color;
if (e->insert_text.begins_with("\"") || e->insert_text.begins_with("\'")) {
e->font_color = completion_string_color;
} else if (e->insert_text.begins_with("#") || e->insert_text.begins_with("//")) {
e->font_color = completion_comment_color;
ScriptCodeCompletionOption &e = E->get();
Color font_color = completion_font_color;
if (e.insert_text.begins_with("\"") || e.insert_text.begins_with("\'")) {
font_color = completion_string_color;
} else if (e.insert_text.begins_with("#") || e.insert_text.begins_with("//")) {
font_color = completion_comment_color;
}
text_editor->add_code_completion_option((CodeEdit::CodeCompletionKind)e.kind, e.display, e.insert_text, font_color, _get_completion_icon(e), e.default_value);
}
text_editor->code_complete(entries, forced);
text_editor->update_code_completion_options(forced);
}
Ref<Texture2D> CodeTextEditor::_get_completion_icon(const ScriptCodeCompletionOption &p_option) {
@ -1847,15 +1848,17 @@ CodeTextEditor::CodeTextEditor() {
text_editor->connect("gui_input", callable_mp(this, &CodeTextEditor::_text_editor_gui_input));
text_editor->connect("cursor_changed", callable_mp(this, &CodeTextEditor::_line_col_changed));
text_editor->connect("text_changed", callable_mp(this, &CodeTextEditor::_text_changed));
text_editor->connect("request_completion", callable_mp(this, &CodeTextEditor::_complete_request));
Vector<String> cs;
text_editor->connect("request_code_completion", callable_mp(this, &CodeTextEditor::_complete_request));
TypedArray<String> cs;
cs.push_back(".");
cs.push_back(",");
cs.push_back("(");
cs.push_back("=");
cs.push_back("$");
cs.push_back("@");
text_editor->set_completion(true, cs);
cs.push_back("\"");
cs.push_back("\'");
text_editor->set_code_completion_prefixes(cs);
idle->connect("timeout", callable_mp(this, &CodeTextEditor::_text_changed_idle_timeout));
code_complete_timer->connect("timeout", callable_mp(this, &CodeTextEditor::_code_complete_timer_timeout));

2
editor/plugins/script_text_editor.cpp
View file

@ -1076,7 +1076,7 @@ void ScriptTextEditor::_edit_option(int p_op) {
_edit_option_toggle_inline_comment();
} break;
case EDIT_COMPLETE: {
tx->query_code_comple();
tx->request_code_completion(true);
} break;
case EDIT_AUTO_INDENT: {
String text = tx->get_text();

2
editor/plugins/shader_editor_plugin.cpp
View file

@ -352,7 +352,7 @@ void ShaderEditor::_menu_option(int p_option) {
} break;
case EDIT_COMPLETE: {
shader_editor->get_text_editor()->query_code_comple();
shader_editor->get_text_editor()->request_code_completion();
} break;
case SEARCH_FIND: {
shader_editor->get_find_replace_bar()->popup_search();

798
scene/gui/code_edit.cpp
View file

@ -30,12 +30,18 @@
#include "code_edit.h"
#include "core/os/keyboard.h"
#include "core/string/string_builder.h"
#include "core/string/ustring.h"
static bool _is_whitespace(char32_t c) {
return c == '\t' || c == ' ';
}
static bool _is_char(char32_t c) {
return !is_symbol(c);
}
void CodeEdit::_notification(int p_what) {
switch (p_what) {
case NOTIFICATION_THEME_CHANGED:
@ -58,12 +64,254 @@ void CodeEdit::_notification(int p_what) {
folding_color = get_theme_color("code_folding_color");
can_fold_icon = get_theme_icon("can_fold");
folded_icon = get_theme_icon("folded");
code_completion_max_width = get_theme_constant("completion_max_width") * cache.font->get_char_size('x').x;
code_completion_max_lines = get_theme_constant("completion_lines");
code_completion_scroll_width = get_theme_constant("completion_scroll_width");
code_completion_scroll_color = get_theme_color("completion_scroll_color");
code_completion_background_color = get_theme_color("completion_background_color");
code_completion_selected_color = get_theme_color("completion_selected_color");
code_completion_existing_color = get_theme_color("completion_existing_color");
} break;
case NOTIFICATION_DRAW: {
RID ci = get_canvas_item();
const bool caret_visible = is_caret_visible();
const bool rtl = is_layout_rtl();
const int row_height = get_row_height();
bool code_completion_below = false;
if (caret_visible && code_completion_active && code_completion_options.size() > 0) {
Ref<StyleBox> csb = get_theme_stylebox("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("hseparation", "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) + cache.line_spacing;
} else {
code_completion_rect.position.y = caret_pos.y + (cache.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 = cache.font->get_string_size(code_completion_base).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_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);
draw_rect(Rect2(code_completion_rect.position + Vector2(icon_area_size.x + icon_hsep, 0), Size2(MIN(code_completion_base_width, code_completion_rect.size.width - (icon_area_size.x + icon_hsep)), code_completion_rect.size.height)), code_completion_existing_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.instance();
tl->add_string(code_completion_options[l].display, cache.font, cache.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_align(HALIGN_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_align(HALIGN_LEFT);
}
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) {
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), code_completion_scroll_color);
}
}
} break;
}
}
void CodeEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
Ref<InputEventMouseButton> mb = p_gui_input;
if (mb.is_valid()) {
if (code_completion_active && code_completion_rect.has_point(mb->get_position())) {
if (!mb->is_pressed()) {
return;
}
switch (mb->get_button_index()) {
case MOUSE_BUTTON_WHEEL_UP: {
if (code_completion_current_selected > 0) {
code_completion_current_selected--;
update();
}
} break;
case MOUSE_BUTTON_WHEEL_DOWN: {
if (code_completion_current_selected < code_completion_options.size() - 1) {
code_completion_current_selected++;
update();
}
} break;
case MOUSE_BUTTON_LEFT: {
code_completion_current_selected = CLAMP(code_completion_line_ofs + (mb->get_position().y - code_completion_rect.position.y) / get_row_height(), 0, code_completion_options.size() - 1);
if (mb->is_double_click()) {
confirm_code_completion();
}
update();
} break;
}
return;
}
cancel_code_completion();
}
Ref<InputEventKey> k = p_gui_input;
bool update_code_completion = false;
if (!k.is_valid()) {
TextEdit::_gui_input(p_gui_input);
return;
}
if (!k->is_pressed()) {
return;
}
// If a modifier has been pressed, and nothing else, return.
if (k->get_keycode() == KEY_CONTROL || 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_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;
}
update();
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;
}
update();
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);
update();
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);
update();
accept_event();
return;
}
if (k->is_action("ui_home", true)) {
code_completion_current_selected = 0;
update();
accept_event();
return;
}
if (k->is_action("ui_end", true)) {
code_completion_current_selected = MIN(code_completion_options.size() - 1, code_completion_current_selected + code_completion_max_lines);
update();
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_at_cursor();
_filter_code_completion_candidates();
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();
}
}
TextEdit::_gui_input(p_gui_input);
if (update_code_completion) {
_filter_code_completion_candidates();
}
}
Control::CursorShape CodeEdit::get_cursor_shape(const Point2 &p_pos) const {
if ((code_completion_active && code_completion_rect.has_point(p_pos)) || (is_readonly() && (!is_selecting_enabled() || get_line_count() == 0))) {
return CURSOR_ARROW;
}
return TextEdit::get_cursor_shape(p_pos);
}
/* Main Gutter */
void CodeEdit::_update_draw_main_gutter() {
set_gutter_draw(main_gutter, draw_breakpoints || draw_bookmarks || draw_executing_lines);
@ -450,6 +698,274 @@ Point2 CodeEdit::get_delimiter_end_position(int p_line, int p_column) const {
return end_position;
}
/* 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++) {
code_completion_prefixes.insert(p_prefixes[i]);
}
}
TypedArray<String> CodeEdit::get_code_completion_prefixes() const {
TypedArray<String> prefixes;
for (Set<String>::Element *E = code_completion_prefixes.front(); E; E = E->next()) {
prefixes.push_back(E->get());
}
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 == cursor_get_line()) {
completion_text += line.substr(0, cursor_get_column());
/* Not unicode, represents the caret. */
completion_text += String::chr(0xFFFF);
completion_text += line.substr(cursor_get_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) {
ScriptInstance *si = get_script_instance();
if (si && si->has_method("_request_code_completion")) {
si->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) {
ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_PLAIN_TEXT;
const ScriptCodeCompletionOption *previous_option = nullptr;
for (int i = 0; i < code_completion_options.size(); i++) {
const ScriptCodeCompletionOption &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 == ScriptCodeCompletionOption::KIND_FILE_PATH || kind == ScriptCodeCompletionOption::KIND_NODE_PATH || kind == ScriptCodeCompletionOption::KIND_SIGNAL);
}
if (ignored) {
return;
}
if (p_force) {
emit_signal("request_code_completion");
return;
}
String line = get_line(cursor_get_line());
int ofs = CLAMP(cursor_get_column(), 0, line.length());
if (ofs > 0 && (is_in_string(cursor_get_line(), ofs) != -1 || _is_char(line[ofs - 1]) || code_completion_prefixes.has(String::chr(line[ofs - 1])))) {
emit_signal("request_code_completion");
} else if (ofs > 1 && line[ofs - 1] == ' ' && code_completion_prefixes.has(String::chr(line[ofs - 2]))) {
emit_signal("request_code_completion");
}
}
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 RES &p_icon, const Variant &p_value) {
ScriptCodeCompletionOption completion_option;
completion_option.kind = (ScriptCodeCompletionOption::Kind)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();
}
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;
update();
}
void CodeEdit::confirm_code_completion(bool p_replace) {
if (is_readonly() || !code_completion_active) {
return;
}
ScriptInstance *si = get_script_instance();
if (si && si->has_method("_confirm_code_completion")) {
si->call("_confirm_code_completion", p_replace);
return;
}
begin_complex_operation();
int caret_line = cursor_get_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 = cursor_get_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_char(line[caret_col])) {
break;
}
}
}
/* Replace. */
_remove_text(caret_line, cursor_get_column() - code_completion_base.length(), caret_remove_line, caret_col);
cursor_set_column(cursor_get_column() - code_completion_base.length(), false);
insert_text_at_cursor(insert_text);
} else {
/* Get first non-matching char. */
const String line = get_line(caret_line);
int caret_col = cursor_get_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, cursor_get_column() - code_completion_base.length(), caret_line, cursor_get_column());
cursor_set_column(cursor_get_column() - code_completion_base.length(), false);
/* Merge with text. */
insert_text_at_cursor(insert_text.substr(0, code_completion_base.length()));
cursor_set_column(caret_col, false);
insert_text_at_cursor(insert_text.substr(matching_chars));
}
/* TODO: merge with autobrace completion, when in CodeEdit. */
/* Handle merging of symbols eg strings, brackets. */
const String line = get_line(caret_line);
char32_t next_char = line[cursor_get_column()];
char32_t last_completion_char = insert_text[insert_text.length() - 1];
char32_t last_completion_char_display = display_text[display_text.length() - 1];
if ((last_completion_char == '"' || last_completion_char == '\'') && (last_completion_char == next_char || last_completion_char_display == next_char)) {
_remove_text(caret_line, cursor_get_column(), caret_line, cursor_get_column() + 1);
}
if (last_completion_char == '(') {
if (next_char == last_completion_char) {
_remove_text(caret_line, cursor_get_column() - 1, caret_line, cursor_get_column());
} else if (auto_brace_completion_enabled) {
insert_text_at_cursor(")");
cursor_set_column(cursor_get_column() - 1);
}
} else if (last_completion_char == ')' && next_char == '(') {
_remove_text(caret_line, cursor_get_column() - 2, caret_line, cursor_get_column());
if (line[cursor_get_column() + 1] != ')') {
cursor_set_column(cursor_get_column() - 1);
}
}
end_complex_operation();
cancel_code_completion();
if (last_completion_char == '(') {
request_code_completion();
}
}
void CodeEdit::cancel_code_completion() {
if (!code_completion_active) {
return;
}
code_completion_forced = false;
code_completion_active = false;
update();
}
void CodeEdit::_bind_methods() {
/* Main Gutter */
ClassDB::bind_method(D_METHOD("_main_gutter_draw_callback"), &CodeEdit::_main_gutter_draw_callback);
@ -525,6 +1041,42 @@ void CodeEdit::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_delimiter_start_postion", "line", "column"), &CodeEdit::get_delimiter_start_position);
ClassDB::bind_method(D_METHOD("get_delimiter_end_postion", "line", "column"), &CodeEdit::get_delimiter_end_position);
/* 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(RES()), 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
BIND_VMETHOD(MethodInfo("_confirm_code_completion", PropertyInfo(Variant::BOOL, "replace")));
BIND_VMETHOD(MethodInfo("_request_code_completion", PropertyInfo(Variant::BOOL, "force")));
BIND_VMETHOD(MethodInfo(Variant::ARRAY, "_filter_code_completion_candidates", PropertyInfo(Variant::ARRAY, "candidates")));
/* Inspector */
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "draw_breakpoints_gutter"), "set_draw_breakpoints_gutter", "is_drawing_breakpoints_gutter");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "draw_bookmarks"), "set_draw_bookmarks_gutter", "is_drawing_bookmarks_gutter");
@ -540,7 +1092,13 @@ void CodeEdit::_bind_methods() {
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");
/* Signals */
ADD_SIGNAL(MethodInfo("breakpoint_toggled", PropertyInfo(Variant::INT, "line")));
ADD_SIGNAL(MethodInfo("request_code_completion"));
}
void CodeEdit::_gutter_clicked(int p_line, int p_gutter) {
@ -629,7 +1187,8 @@ void CodeEdit::_update_delimiter_cache(int p_from_line, int p_to_line) {
delimiter_cache.write[i][0] = in_region;
}
if (i == end_line && current_end_region != in_region) {
end_line = MIN(end_line++, line_count);
end_line++;
end_line = MIN(end_line, line_count);
}
continue;
}
@ -732,7 +1291,8 @@ void CodeEdit::_update_delimiter_cache(int p_from_line, int p_to_line) {
}
if (i == end_line && current_end_region != end_region) {
end_line = MIN(end_line++, line_count);
end_line++;
end_line = MIN(end_line, line_count);
}
}
}
@ -887,11 +1447,243 @@ TypedArray<String> CodeEdit::_get_delimiters(DelimiterType p_type) const {
if (delimiters[i].type != p_type) {
continue;
}
r_delimiters.push_back(delimiters[i].start_key + (delimiters[i].end_key.empty() ? "" : " " + delimiters[i].end_key));
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::_filter_code_completion_candidates() {
ScriptInstance *si = get_script_instance();
if (si && si->has_method("_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 (List<ScriptCodeCompletionOption>::Element *E = code_completion_option_sources.front(); E; E = E->next()) {
Dictionary option;
option["kind"] = E->get().kind;
option["display_text"] = E->get().display;
option["insert_text"] = E->get().insert_text;
option["font_color"] = E->get().font_color;
option["icon"] = E->get().icon;
option["default_value"] = E->get().default_value;
completion_options_sources[i] = option;
i++;
}
TypedArray<Dictionary> completion_options = si->call("_filter_code_completion_candidates", completion_options_sources);
/* 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++) {
ScriptCodeCompletionOption option;
option.kind = (ScriptCodeCompletionOption::Kind)(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");
max_width = MAX(max_width, cache.font->get_string_size(option.display).width);
code_completion_options.push_back(option);
}
code_completion_longest_line = MIN(max_width, code_completion_max_width);
code_completion_current_selected = 0;
code_completion_active = true;
update();
return;
}
const int caret_line = cursor_get_line();
const int caret_column = cursor_get_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 (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_char(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_char(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(String::chr(line[cofs - 1]))) {
prev_is_prefix = true;
} else if (cofs > 1 && line[cofs - 1] == ' ' && code_completion_prefixes.has(String::chr(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<ScriptCodeCompletionOption> completion_options_casei;
Vector<ScriptCodeCompletionOption> completion_options_subseq;
Vector<ScriptCodeCompletionOption> completion_options_subseq_casei;
int max_width = 0;
String string_to_complete_lower = string_to_complete.to_lower();
for (List<ScriptCodeCompletionOption>::Element *E = code_completion_option_sources.front(); E; E = E->next()) {
ScriptCodeCompletionOption &option = E->get();
if (single_quote && option.display.is_quoted()) {
option.display = option.display.unquote().quote("'");
}
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, cache.font->get_string_size(option.display).width);
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_ofi(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 *ssq_last_tgt = nullptr;
const char32_t *ssq_lower_last_tgt = nullptr;
for (; *tgt; tgt++, tgt_lower++) {
if (*ssq == *tgt) {
ssq++;
ssq_last_tgt = tgt;
}
if (*ssq_lower == *tgt_lower) {
ssq_lower++;
ssq_lower_last_tgt = tgt;
}
}
/* Matched the whole subsequence in s. */
if (!*ssq) {
/* Finished matching in the first s.length() characters. */
if (ssq_last_tgt == &option.display[string_to_complete.length() - 1]) {
code_completion_options.push_back(option);
} else {
completion_options_subseq.push_back(option);
}
max_width = MAX(max_width, cache.font->get_string_size(option.display).width);
/* Matched the whole subsequence in s_lower. */
} else if (!*ssq_lower) {
/* Finished matching in the first s.length() characters. */
if (ssq_lower_last_tgt == &option.display[string_to_complete.length() - 1]) {
completion_options_casei.push_back(option);
} else {
completion_options_subseq_casei.push_back(option);
}
max_width = MAX(max_width, cache.font->get_string_size(option.display).width);
}
}
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);
code_completion_current_selected = 0;
code_completion_active = true;
update();
}
void CodeEdit::_lines_edited_from(int p_from_line, int p_to_line) {
_update_delimiter_cache(p_from_line, p_to_line);

70
scene/gui/code_edit.h
View file

@ -36,6 +36,22 @@
class CodeEdit : public TextEdit {
GDCLASS(CodeEdit, TextEdit)
public:
/* Keep enum in sync with: */
/* /core/object/script_language.h - ScriptCodeCompletionOption::Kind */
enum CodeCompletionKind {
KIND_CLASS,
KIND_FUNCTION,
KIND_SIGNAL,
KIND_VARIABLE,
KIND_MEMBER,
KIND_ENUM,
KIND_CONSTANT,
KIND_NODE_PATH,
KIND_FILE_PATH,
KIND_PLAIN_TEXT,
};
private:
/* Main Gutter */
enum MainGutterType {
@ -144,14 +160,43 @@ private:
void _clear_delimiters(DelimiterType p_type);
TypedArray<String> _get_delimiters(DelimiterType p_type) const;
/* Code Completion */
bool code_completion_enabled = false;
bool code_completion_forced = false;
int code_completion_max_width = 0;
int code_completion_max_lines = 7;
int code_completion_scroll_width = 0;
Color code_completion_scroll_color = Color(0, 0, 0, 0);
Color code_completion_background_color = Color(0, 0, 0, 0);
Color code_completion_selected_color = Color(0, 0, 0, 0);
Color code_completion_existing_color = Color(0, 0, 0, 0);
bool code_completion_active = false;
Vector<ScriptCodeCompletionOption> code_completion_options;
int code_completion_line_ofs = 0;
int code_completion_current_selected = 0;
int code_completion_longest_line = 0;
Rect2i code_completion_rect;
Set<String> code_completion_prefixes;
List<ScriptCodeCompletionOption> code_completion_option_submitted;
List<ScriptCodeCompletionOption> code_completion_option_sources;
String code_completion_base;
void _filter_code_completion_candidates();
void _lines_edited_from(int p_from_line, int p_to_line);
protected:
void _gui_input(const Ref<InputEvent> &p_gui_input) override;
void _notification(int p_what);
static void _bind_methods();
public:
virtual CursorShape get_cursor_shape(const Point2 &p_pos = Point2i()) const override;
/* Main Gutter */
void set_draw_breakpoints_gutter(bool p_draw);
bool is_drawing_breakpoints_gutter() const;
@ -217,8 +262,33 @@ public:
Point2 get_delimiter_start_position(int p_line, int p_column) const;
Point2 get_delimiter_end_position(int p_line, int p_column) const;
/* Code Completion */
void set_code_completion_enabled(bool p_enable);
bool is_code_completion_enabled() const;
void set_code_completion_prefixes(const TypedArray<String> &p_prefixes);
TypedArray<String> get_code_completion_prefixes() const;
String get_text_for_code_completion() const;
void request_code_completion(bool p_force = false);
void add_code_completion_option(CodeCompletionKind p_type, const String &p_display_text, const String &p_insert_text, const Color &p_text_color = Color(1, 1, 1), const RES &p_icon = RES(), const Variant &p_value = Variant::NIL);
void update_code_completion_options(bool p_forced = false);
TypedArray<Dictionary> get_code_completion_options() const;
Dictionary get_code_completion_option(int p_index) const;
int get_code_completion_selected_index() const;
void set_code_completion_selected_index(int p_index);
void confirm_code_completion(bool p_replace = false);
void cancel_code_completion();
CodeEdit();
~CodeEdit();
};
VARIANT_ENUM_CAST(CodeEdit::CodeCompletionKind);
#endif // CODEEDIT_H

800
scene/gui/text_edit.cpp
View file

@ -801,9 +801,6 @@ void TextEdit::_notification(int p_what) {
}
}
bool is_cursor_line_visible = false;
Point2 cursor_pos;
// Get the highlighted words.
String highlighted_text = get_selection_text();
@ -987,6 +984,8 @@ void TextEdit::_notification(int p_what) {
}
// draw main text
cursor.visible = false;
const int caret_wrap_index = get_cursor_wrap_index();
int row_height = get_row_height();
int line = first_visible_line;
for (int i = 0; i < draw_amount; i++) {
@ -1266,7 +1265,6 @@ void TextEdit::_notification(int p_what) {
}
}
const int line_top_offset_y = ofs_y;
ofs_y += (row_height - text_height) / 2;
const Vector<TextServer::Glyph> visual = TS->shaped_text_get_glyphs(rid);
@ -1371,9 +1369,9 @@ void TextEdit::_notification(int p_what) {
#else
int caret_width = 1;
#endif
if (!clipped && cursor.line == line && ((line_wrap_index == line_wrap_amount) || (cursor.column != TS->shaped_text_get_range(rid).y))) {
is_cursor_line_visible = true;
cursor_pos.y = line_top_offset_y;
if (!clipped && cursor.line == line && line_wrap_index == caret_wrap_index) {
cursor.draw_pos.y = ofs_y + ldata->get_line_descent(line_wrap_index);
if (ime_text.length() == 0) {
Rect2 l_caret, t_caret;
@ -1394,57 +1392,60 @@ void TextEdit::_notification(int p_what) {
}
if ((l_caret != Rect2() && (l_dir == TextServer::DIRECTION_AUTO || l_dir == (TextServer::Direction)input_direction)) || (t_caret == Rect2())) {
cursor_pos.x = char_margin + ofs_x + l_caret.position.x;
cursor.draw_pos.x = char_margin + ofs_x + l_caret.position.x;
} else {
cursor_pos.x = char_margin + ofs_x + t_caret.position.x;
cursor.draw_pos.x = char_margin + ofs_x + t_caret.position.x;
}
if (draw_caret && cursor_pos.x >= xmargin_beg && cursor_pos.x < xmargin_end) {
if (block_caret || insert_mode) {
//Block or underline caret, draw trailing carets at full height.
int h = cache.font->get_height(cache.font_size);
if (cursor.draw_pos.x >= xmargin_beg && cursor.draw_pos.x < xmargin_end) {
cursor.visible = true;
if (draw_caret) {
if (block_caret || insert_mode) {
//Block or underline caret, draw trailing carets at full height.
int h = cache.font->get_height(cache.font_size);
if (t_caret != Rect2()) {
if (insert_mode) {
t_caret.position.y = TS->shaped_text_get_descent(rid);
t_caret.size.y = caret_width;
} else {
t_caret.position.y = -TS->shaped_text_get_ascent(rid);
t_caret.size.y = h;
if (t_caret != Rect2()) {
if (insert_mode) {
t_caret.position.y = TS->shaped_text_get_descent(rid);
t_caret.size.y = caret_width;
} else {
t_caret.position.y = -TS->shaped_text_get_ascent(rid);
t_caret.size.y = h;
}
t_caret.position += Vector2(char_margin + ofs_x, ofs_y);
draw_rect(t_caret, cache.caret_color, false);
} else { // End of the line.
if (insert_mode) {
l_caret.position.y = TS->shaped_text_get_descent(rid);
l_caret.size.y = caret_width;
} else {
l_caret.position.y = -TS->shaped_text_get_ascent(rid);
l_caret.size.y = h;
}
l_caret.position += Vector2(char_margin + ofs_x, ofs_y);
l_caret.size.x = cache.font->get_char_size('M', 0, cache.font_size).x;
draw_rect(l_caret, cache.caret_color, false);
}
t_caret.position += Vector2(char_margin + ofs_x, ofs_y);
draw_rect(t_caret, cache.caret_color, false);
} else { // End of the line.
if (insert_mode) {
l_caret.position.y = TS->shaped_text_get_descent(rid);
l_caret.size.y = caret_width;
} else {
l_caret.position.y = -TS->shaped_text_get_ascent(rid);
l_caret.size.y = h;
} else {
// Normal caret.
if (l_caret != Rect2() && l_dir == TextServer::DIRECTION_AUTO) {
// Draw extra marker on top of mid caret.
Rect2 trect = Rect2(l_caret.position.x - 3 * caret_width, l_caret.position.y, 6 * caret_width, caret_width);
trect.position += Vector2(char_margin + ofs_x, ofs_y);
RenderingServer::get_singleton()->canvas_item_add_rect(ci, trect, cache.caret_color);
}
l_caret.position += Vector2(char_margin + ofs_x, ofs_y);
l_caret.size.x = cache.font->get_char_size('M', 0, cache.font_size).x;
l_caret.size.x = caret_width;
draw_rect(l_caret, cache.caret_color, false);
draw_rect(l_caret, cache.caret_color);
t_caret.position += Vector2(char_margin + ofs_x, ofs_y);
t_caret.size.x = caret_width;
draw_rect(t_caret, cache.caret_color);
}
} else {
// Normal caret.
if (l_caret != Rect2() && l_dir == TextServer::DIRECTION_AUTO) {
// Draw extra marker on top of mid caret.
Rect2 trect = Rect2(l_caret.position.x - 3 * caret_width, l_caret.position.y, 6 * caret_width, caret_width);
trect.position += Vector2(char_margin + ofs_x, ofs_y);
RenderingServer::get_singleton()->canvas_item_add_rect(ci, trect, cache.caret_color);
}
l_caret.position += Vector2(char_margin + ofs_x, ofs_y);
l_caret.size.x = caret_width;
draw_rect(l_caret, cache.caret_color);
t_caret.position += Vector2(char_margin + ofs_x, ofs_y);
t_caret.size.x = caret_width;
draw_rect(t_caret, cache.caret_color);
}
}
} else {
@ -1464,7 +1465,7 @@ void TextEdit::_notification(int p_what) {
}
rect.size.y = caret_width;
draw_rect(rect, cache.caret_color);
cursor_pos.x = rect.position.x;
cursor.draw_pos.x = rect.position.x;
}
}
{
@ -1483,7 +1484,7 @@ void TextEdit::_notification(int p_what) {
}
rect.size.y = caret_width * 3;
draw_rect(rect, cache.caret_color);
cursor_pos.x = rect.position.x;
cursor.draw_pos.x = rect.position.x;
}
}
}
@ -1491,227 +1492,10 @@ void TextEdit::_notification(int p_what) {
}
}
bool completion_below = false;
if (completion_active && is_cursor_line_visible && completion_options.size() > 0) {
// Completion panel
const Ref<StyleBox> csb = get_theme_stylebox("completion");
const int maxlines = get_theme_constant("completion_lines");
const int cmax_width = get_theme_constant("completion_max_width") * cache.font->get_char_size('x', 0, cache.font_size).x;
const Color scrollc = get_theme_color("completion_scroll_color");
const int completion_options_size = completion_options.size();
const int row_count = MIN(completion_options_size, maxlines);
const int completion_rows_height = row_count * row_height;
const int completion_base_width = cache.font->get_string_size(completion_base, cache.font_size).width;
int scroll_rectangle_width = get_theme_constant("completion_scroll_width");
int width = 0;
// Compute max width of the panel based on the longest completion option
if (completion_options_size < 50) {
for (int i = 0; i < completion_options_size; i++) {
int line_width = MIN(cache.font->get_string_size(completion_options[i].display, cache.font_size).x, cmax_width);
if (line_width > width) {
width = line_width;
}
}
} else {
width = cmax_width;
}
// Add space for completion icons.
const int icon_hsep = get_theme_constant("hseparation", "ItemList");
const Size2 icon_area_size(row_height, row_height);
const int icon_area_width = icon_area_size.width + icon_hsep;
width += icon_area_width;
const int line_from = CLAMP(completion_index - row_count / 2, 0, completion_options_size - row_count);
for (int i = 0; i < row_count; i++) {
int l = line_from + i;
ERR_CONTINUE(l < 0 || l >= completion_options_size);
if (completion_options[l].default_value.get_type() == Variant::COLOR) {
width += icon_area_size.width;
break;
}
}
// Position completion panel
completion_rect.size.width = width + 2;
completion_rect.size.height = completion_rows_height;
if (completion_options_size <= maxlines) {
scroll_rectangle_width = 0;
}
const Point2 csb_offset = csb->get_offset();
const int total_width = completion_rect.size.width + csb->get_minimum_size().x + scroll_rectangle_width;
const int total_height = completion_rect.size.height + csb->get_minimum_size().y;
const int rect_left_border_x = cursor_pos.x - completion_base_width - icon_area_width - csb_offset.x;
const int rect_right_border_x = rect_left_border_x + total_width;
if (rect_left_border_x < 0) {
// Anchor the completion panel to the left
completion_rect.position.x = 0;
} else if (rect_right_border_x > get_size().width) {
// Anchor the completion panel to the right
completion_rect.position.x = get_size().width - total_width;
} else {
// Let the completion panel float with the cursor
completion_rect.position.x = rect_left_border_x;
}
if (cursor_pos.y + row_height + total_height > get_size().height && cursor_pos.y > total_height) {
// Completion panel above the cursor line
completion_rect.position.y = cursor_pos.y - total_height;
} else {
// Completion panel below the cursor line
completion_rect.position.y = cursor_pos.y + row_height;
completion_below = true;
}
draw_style_box(csb, Rect2(completion_rect.position - csb_offset, completion_rect.size + csb->get_minimum_size() + Size2(scroll_rectangle_width, 0)));
if (cache.completion_background_color.a > 0.01) {
RenderingServer::get_singleton()->canvas_item_add_rect(ci, Rect2(completion_rect.position, completion_rect.size + Size2(scroll_rectangle_width, 0)), cache.completion_background_color);
}
RenderingServer::get_singleton()->canvas_item_add_rect(ci, Rect2(Point2(completion_rect.position.x, completion_rect.position.y + (completion_index - line_from) * get_row_height()), Size2(completion_rect.size.width, get_row_height())), cache.completion_selected_color);
draw_rect(Rect2(completion_rect.position + Vector2(icon_area_size.x + icon_hsep, 0), Size2(MIN(completion_base_width, completion_rect.size.width - (icon_area_size.x + icon_hsep)), completion_rect.size.height)), cache.completion_existing_color);
for (int i = 0; i < row_count; i++) {
int l = line_from + i;
ERR_CONTINUE(l < 0 || l >= completion_options_size);
Ref<TextLine> tl;
tl.instance();
tl->add_string(completion_options[l].display, cache.font, cache.font_size);
int yofs = (row_height - tl->get_size().y) / 2;
Point2 title_pos(completion_rect.position.x, completion_rect.position.y + i * row_height + yofs);
// Draw completion icon if it is valid.
Ref<Texture2D> icon = completion_options[l].icon;
Rect2 icon_area(completion_rect.position.x, completion_rect.position.y + i * row_height, icon_area_size.width, icon_area_size.height);
if (icon.is_valid()) {
const real_t max_scale = 0.7f;
const real_t side = max_scale * icon_area.size.width;
real_t scale = MIN(side / icon->get_width(), side / icon->get_height());
Size2 icon_size = icon->get_size() * scale;
draw_texture_rect(icon, 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(completion_rect.size.width - (icon_area_size.x + icon_hsep));
if (rtl) {
if (completion_options[l].default_value.get_type() == Variant::COLOR) {
draw_rect(Rect2(Point2(completion_rect.position.x, icon_area.position.y), icon_area_size), (Color)completion_options[l].default_value);
}
tl->set_align(HALIGN_RIGHT);
} else {
if (completion_options[l].default_value.get_type() == Variant::COLOR) {
draw_rect(Rect2(Point2(completion_rect.position.x + completion_rect.size.width - icon_area_size.x, icon_area.position.y), icon_area_size), (Color)completion_options[l].default_value);
}
tl->set_align(HALIGN_LEFT);
}
if (cache.outline_size > 0 && cache.outline_color.a > 0) {
tl->draw_outline(ci, title_pos, cache.outline_size, cache.outline_color);
}
tl->draw(ci, title_pos, completion_options[l].font_color);
}
if (scroll_rectangle_width) {
// Draw a small scroll rectangle to show a position in the options.
float r = (float)maxlines / completion_options_size;
float o = (float)line_from / completion_options_size;
draw_rect(Rect2(completion_rect.position.x + completion_rect.size.width, completion_rect.position.y + o * completion_rect.size.y, scroll_rectangle_width, completion_rect.size.y * r), scrollc);
}
completion_line_ofs = line_from;
}
// Check to see if the hint should be drawn.
bool show_hint = false;
if (is_cursor_line_visible && completion_hint != "") {
if (completion_active) {
if (completion_below && !callhint_below) {
show_hint = true;
} else if (!completion_below && callhint_below) {
show_hint = true;
}
} else {
show_hint = true;
}
}
if (show_hint) {
Ref<StyleBox> sb = get_theme_stylebox("panel", "TooltipPanel");
Ref<Font> font = cache.font;
Color font_color = get_theme_color("font_color", "TooltipLabel");
int max_w = 0;
int sc = completion_hint.get_slice_count("\n");
int offset = 0;
int spacing = 0;
for (int i = 0; i < sc; i++) {
String l = completion_hint.get_slice("\n", i);
int len = font->get_string_size(l, cache.font_size).x;
max_w = MAX(len, max_w);
if (i == 0) {
offset = font->get_string_size(l.substr(0, l.find(String::chr(0xFFFF))), cache.font_size).x;
} else {
spacing += cache.line_spacing;
}
}
Size2 size2 = Size2(max_w, sc * font->get_height(cache.font_size) + spacing);
Size2 minsize = size2 + sb->get_minimum_size();
if (completion_hint_offset == -0xFFFF) {
completion_hint_offset = cursor_pos.x - offset;
}
Point2 hint_ofs = Vector2(completion_hint_offset, cursor_pos.y) + callhint_offset;
if (callhint_below) {
hint_ofs.y += row_height + sb->get_offset().y;
} else {
hint_ofs.y -= minsize.y + sb->get_offset().y;
}
draw_style_box(sb, Rect2(hint_ofs, minsize));
spacing = 0;
for (int i = 0; i < sc; i++) {
int begin = 0;
int end = 0;
String l = completion_hint.get_slice("\n", i);
if (l.find(String::chr(0xFFFF)) != -1) {
begin = font->get_string_size(l.substr(0, l.find(String::chr(0xFFFF))), cache.font_size).x;
end = font->get_string_size(l.substr(0, l.rfind(String::chr(0xFFFF))), cache.font_size).x;
}
Point2 round_ofs = hint_ofs + sb->get_offset() + Vector2(0, font->get_ascent(cache.font_size) + font->get_height(cache.font_size) * i + spacing);
round_ofs = round_ofs.round();
draw_string(font, round_ofs, l.replace(String::chr(0xFFFF), ""), HALIGN_LEFT, -1, cache.font_size, font_color);
if (end > 0) {
Vector2 b = hint_ofs + sb->get_offset() + Vector2(begin, font->get_height(cache.font_size) + font->get_height(cache.font_size) * i + spacing - 1);
draw_line(b, b + Vector2(end - begin, 0), font_color);
}
spacing += cache.line_spacing;
}
}
if (has_focus()) {
if (get_viewport()->get_window_id() != DisplayServer::INVALID_WINDOW_ID && DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_IME)) {
DisplayServer::get_singleton()->window_set_ime_active(true, get_viewport()->get_window_id());
DisplayServer::get_singleton()->window_set_ime_position(get_global_position() + cursor_pos, get_viewport()->get_window_id());
DisplayServer::get_singleton()->window_set_ime_position(get_global_position() + cursor.draw_pos, get_viewport()->get_window_id());
}
}
} break;
@ -2492,7 +2276,6 @@ void TextEdit::_move_cursor_to_line_start(bool p_select) {
_post_shift_selection();
}
_cancel_completion();
completion_hint = "";
}
@ -2519,7 +2302,6 @@ void TextEdit::_move_cursor_to_line_end(bool p_select) {
if (p_select) {
_post_shift_selection();
}
_cancel_completion();
completion_hint = "";
}
@ -2538,7 +2320,6 @@ void TextEdit::_move_cursor_page_up(bool p_select) {
_post_shift_selection();
}
_cancel_completion();
completion_hint = "";
}
@ -2557,7 +2338,6 @@ void TextEdit::_move_cursor_page_down(bool p_select) {
_post_shift_selection();
}
_cancel_completion();
completion_hint = "";
}
@ -2691,11 +2471,7 @@ void TextEdit::_move_cursor_document_end(bool p_select) {
}
}
void TextEdit::_handle_unicode_character(uint32_t unicode, bool p_had_selection, bool p_update_auto_complete) {
if (p_update_auto_complete) {
_reset_caret_blink_timer();
}
void TextEdit::_handle_unicode_character(uint32_t unicode, bool p_had_selection) {
if (p_had_selection) {
_delete_selection();
}
@ -2726,10 +2502,6 @@ void TextEdit::_handle_unicode_character(uint32_t unicode, bool p_had_selection,
if ((insert_mode && !p_had_selection) || (selection.active != p_had_selection)) {
end_complex_operation();
}
if (p_update_auto_complete) {
_update_completion_candidates();
}
}
void TextEdit::_get_mouse_pos(const Point2i &p_mouse, int &r_row, int &r_col) const {
@ -2885,40 +2657,6 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
// Ignore mouse clicks in IME input mode.
return;
}
if (completion_active && completion_rect.has_point(mpos)) {
if (!mb->is_pressed()) {
return;
}
if (mb->get_button_index() == MOUSE_BUTTON_WHEEL_UP) {
if (completion_index > 0) {
completion_index--;
completion_current = completion_options[completion_index];
update();
}
}
if (mb->get_button_index() == MOUSE_BUTTON_WHEEL_DOWN) {
if (completion_index < completion_options.size() - 1) {
completion_index++;
completion_current = completion_options[completion_index];
update();
}
}
if (mb->get_button_index() == MOUSE_BUTTON_LEFT) {
completion_index = CLAMP(completion_line_ofs + (mpos.y - completion_rect.position.y) / get_row_height(), 0, completion_options.size() - 1);
completion_current = completion_options[completion_index];
update();
if (mb->is_double_click()) {
_confirm_completion();
}
}
return;
} else {
_cancel_completion();
_cancel_code_hint();
}
if (mb->is_pressed()) {
if (mb->get_button_index() == MOUSE_BUTTON_WHEEL_UP && !mb->is_command_pressed()) {
@ -3215,96 +2953,6 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
// Check and handle all built in shortcuts.
// AUTO-COMPLETE
if (k->is_action("ui_text_completion_query", true)) {
query_code_comple();
accept_event();
return;
}
if (completion_active) {
if (k->is_action("ui_up", true)) {
if (completion_index > 0) {
completion_index--;
} else {
completion_index = completion_options.size() - 1;
}
completion_current = completion_options[completion_index];
update();
accept_event();
return;
}
if (k->is_action("ui_down", true)) {
if (completion_index < completion_options.size() - 1) {
completion_index++;
} else {
completion_index = 0;
}
completion_current = completion_options[completion_index];
update();
accept_event();
return;
}
if (k->is_action("ui_page_up", true)) {
completion_index -= get_theme_constant("completion_lines");
if (completion_index < 0) {
completion_index = 0;
}
completion_current = completion_options[completion_index];
update();
accept_event();
return;
}
if (k->is_action("ui_page_down", true)) {
completion_index += get_theme_constant("completion_lines");
if (completion_index >= completion_options.size()) {
completion_index = completion_options.size() - 1;
}
completion_current = completion_options[completion_index];
update();
accept_event();
return;
}
if (k->is_action("ui_home", true)) {
if (completion_index > 0) {
completion_index = 0;
completion_current = completion_options[completion_index];
update();
}
accept_event();
return;
}
if (k->is_action("ui_end", true)) {
if (completion_index < completion_options.size() - 1) {
completion_index = completion_options.size() - 1;
completion_current = completion_options[completion_index];
update();
}
accept_event();
return;
}
if (k->is_action("ui_text_completion_accept", true)) {
_confirm_completion();
accept_event();
return;
}
if (k->is_action("ui_cancel", true)) {
_cancel_completion();
accept_event();
return;
}
// Handle Unicode here (if no modifiers active) and update autocomplete.
if (k->get_unicode() >= 32) {
if (allow_unicode_handling && !readonly) {
_handle_unicode_character(k->get_unicode(), had_selection, true);
accept_event();
return;
}
}
}
// NEWLINES.
if (k->is_action("ui_text_newline_above", true)) {
_new_line(false, true);
@ -3347,9 +2995,6 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
}
if (k->is_action("ui_text_backspace", true)) {
_backspace();
if (completion_active) {
_update_completion_candidates();
}
accept_event();
return;
}
@ -3532,7 +3177,7 @@ void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) {
if (allow_unicode_handling && !readonly && k->get_unicode() >= 32) {
// Handle Unicode (if no modifiers active).
_handle_unicode_character(k->get_unicode(), had_selection, false);
_handle_unicode_character(k->get_unicode(), had_selection);
accept_event();
return;
}
@ -4293,6 +3938,14 @@ void TextEdit::cursor_set_line(int p_row, bool p_adjust_viewport, bool p_can_be_
}
}
Point2 TextEdit::get_caret_draw_pos() const {
return cursor.draw_pos;
}
bool TextEdit::is_caret_visible() const {
return cursor.visible;
}
int TextEdit::cursor_get_column() const {
return cursor.column;
}
@ -4470,10 +4123,6 @@ Control::CursorShape TextEdit::get_cursor_shape(const Point2 &p_pos) const {
return CURSOR_POINTING_HAND;
}
if ((completion_active && completion_rect.has_point(p_pos)) || (is_readonly() && (!is_selecting_enabled() || text.size() == 0))) {
return CURSOR_ARROW;
}
int row, col;
_get_mouse_pos(p_pos, row, col);
@ -4685,26 +4334,6 @@ String TextEdit::get_text_for_lookup_completion() {
return longthing;
}
String TextEdit::get_text_for_completion() {
String longthing;
int len = text.size();
for (int i = 0; i < len; i++) {
if (i == cursor.line) {
longthing += text[i].substr(0, cursor.column);
longthing += String::chr(0xFFFF); // Not unicode, represents the cursor.
longthing += text[i].substr(cursor.column, text[i].size());
} else {
longthing += text[i];
}
if (i != len - 1) {
longthing += "\n";
}
}
return longthing;
};
String TextEdit::get_line(int line) const {
if (line < 0 || line >= text.size()) {
return "";
@ -4787,10 +4416,6 @@ void TextEdit::_update_caches() {
cache.style_normal = get_theme_stylebox("normal");
cache.style_focus = get_theme_stylebox("focus");
cache.style_readonly = get_theme_stylebox("read_only");
cache.completion_background_color = get_theme_color("completion_background_color");
cache.completion_selected_color = get_theme_color("completion_selected_color");
cache.completion_existing_color = get_theme_color("completion_existing_color");
cache.completion_font_color = get_theme_color("completion_font_color");
cache.font = get_theme_font("font");
cache.font_size = get_theme_font_size("font_size");
cache.outline_color = get_theme_color("font_outline_color");
@ -6161,313 +5786,17 @@ float TextEdit::get_v_scroll_speed() const {
return v_scroll_speed;
}
void TextEdit::set_completion(bool p_enabled, const Vector<String> &p_prefixes) {
completion_prefixes.clear();
completion_enabled = p_enabled;
for (int i = 0; i < p_prefixes.size(); i++) {
completion_prefixes.insert(p_prefixes[i]);
}
}
void TextEdit::_confirm_completion() {
begin_complex_operation();
_remove_text(cursor.line, cursor.column - completion_base.length(), cursor.line, cursor.column);
cursor_set_column(cursor.column - completion_base.length(), false);
insert_text_at_cursor(completion_current.insert_text);
// When inserted into the middle of an existing string/method, don't add an unnecessary quote/bracket.
String line = text[cursor.line];
char32_t next_char = line[cursor.column];
char32_t last_completion_char = completion_current.insert_text[completion_current.insert_text.length() - 1];
char32_t last_completion_char_display = completion_current.display[completion_current.display.length() - 1];
if ((last_completion_char == '"' || last_completion_char == '\'') && (last_completion_char == next_char || last_completion_char_display == next_char)) {
_remove_text(cursor.line, cursor.column, cursor.line, cursor.column + 1);
}
if (last_completion_char == '(') {
if (next_char == last_completion_char) {
_base_remove_text(cursor.line, cursor.column - 1, cursor.line, cursor.column);
} else if (auto_brace_completion_enabled) {
insert_text_at_cursor(")");
cursor.column--;
}
} else if (last_completion_char == ')' && next_char == '(') {
_base_remove_text(cursor.line, cursor.column - 2, cursor.line, cursor.column);
if (line[cursor.column + 1] != ')') {
cursor.column--;
}
}
end_complex_operation();
_cancel_completion();
if (last_completion_char == '(') {
query_code_comple();
}
}
void TextEdit::_cancel_code_hint() {
completion_hint = "";
update();
}
void TextEdit::_cancel_completion() {
if (!completion_active) {
return;
}
completion_active = false;
completion_forced = false;
update();
}
static bool _is_completable(char32_t c) {
return !_is_symbol(c) || c == '"' || c == '\'';
}
void TextEdit::_update_completion_candidates() {
String l = text[cursor.line];
int cofs = CLAMP(cursor.column, 0, l.length());
String s;
// Look for keywords first.
bool inquote = false;
int first_quote = -1;
int restore_quotes = -1;
int c = cofs - 1;
while (c >= 0) {
if (l[c] == '"' || l[c] == '\'') {
inquote = !inquote;
if (first_quote == -1) {
first_quote = c;
}
restore_quotes = 0;
} else if (restore_quotes == 0 && l[c] == '$') {
restore_quotes = 1;
} else if (restore_quotes == 0 && !_is_whitespace(l[c])) {
restore_quotes = -1;
}
c--;
}
bool pre_keyword = false;
bool cancel = false;
if (!inquote && first_quote == cofs - 1) {
// No completion here.
cancel = true;
} else if (inquote && first_quote != -1) {
s = l.substr(first_quote, cofs - first_quote);
} else if (cofs > 0 && l[cofs - 1] == ' ') {
int kofs = cofs - 1;
String kw;
while (kofs >= 0 && l[kofs] == ' ') {
kofs--;
}
while (kofs >= 0 && l[kofs] > 32 && _is_completable(l[kofs])) {
kw = String::chr(l[kofs]) + kw;
kofs--;
}
pre_keyword = keywords.has(kw);
} else {
while (cofs > 0 && l[cofs - 1] > 32 && (l[cofs - 1] == '/' || _is_completable(l[cofs - 1]))) {
s = String::chr(l[cofs - 1]) + s;
if (l[cofs - 1] == '\'' || l[cofs - 1] == '"' || l[cofs - 1] == '$') {
break;
}
cofs--;
}
}
if (cursor.column > 0 && l[cursor.column - 1] == '(' && !pre_keyword && !completion_forced) {
cancel = true;
}
update();
bool prev_is_prefix = false;
if (cofs > 0 && completion_prefixes.has(String::chr(l[cofs - 1]))) {
prev_is_prefix = true;
}
// Check with one space before prefix, to allow indent.
if (cofs > 1 && l[cofs - 1] == ' ' && completion_prefixes.has(String::chr(l[cofs - 2]))) {
prev_is_prefix = true;
}
if (cancel || (!pre_keyword && s == "" && (cofs == 0 || !prev_is_prefix))) {
// None to complete, cancel.
_cancel_completion();
return;
}
completion_options.clear();
completion_index = 0;
completion_base = s;
Vector<float> sim_cache;
bool single_quote = s.begins_with("'");
Vector<ScriptCodeCompletionOption> completion_options_casei;
Vector<ScriptCodeCompletionOption> completion_options_subseq;
Vector<ScriptCodeCompletionOption> completion_options_subseq_casei;
String s_lower = s.to_lower();
for (List<ScriptCodeCompletionOption>::Element *E = completion_sources.front(); E; E = E->next()) {
ScriptCodeCompletionOption &option = E->get();
if (single_quote && option.display.is_quoted()) {
option.display = option.display.unquote().quote("'");
}
if (inquote && restore_quotes == 1 && !option.display.is_quoted()) {
String quote = single_quote ? "'" : "\"";
option.display = option.display.quote(quote);
option.insert_text = option.insert_text.quote(quote);
}
if (option.display.length() == 0) {
continue;
} else if (s.length() == 0) {
completion_options.push_back(option);
} else {
// 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_ofi(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 = &s[0];
const char32_t *ssq_lower = &s_lower[0];
const char32_t *tgt = &option.display[0];
const char32_t *tgt_lower = &display_lower[0];
const char32_t *ssq_last_tgt = nullptr;
const char32_t *ssq_lower_last_tgt = nullptr;
for (; *tgt; tgt++, tgt_lower++) {
if (*ssq == *tgt) {
ssq++;
ssq_last_tgt = tgt;
}
if (*ssq_lower == *tgt_lower) {
ssq_lower++;
ssq_lower_last_tgt = tgt;
}
}
if (!*ssq) { // Matched the whole subsequence in s
if (ssq_last_tgt == &option.display[s.length() - 1]) { // Finished matching in the first s.length() characters
completion_options.push_back(option);
} else {
completion_options_subseq.push_back(option);
}
} else if (!*ssq_lower) { // Matched the whole subsequence in s_lower
if (ssq_lower_last_tgt == &option.display[s.length() - 1]) { // Finished matching in the first s.length() characters
completion_options_casei.push_back(option);
} else {
completion_options_subseq_casei.push_back(option);
}
}
}
}
completion_options.append_array(completion_options_casei);
completion_options.append_array(completion_options_subseq);
completion_options.append_array(completion_options_subseq_casei);
if (completion_options.size() == 0) {
// No options to complete, cancel.
_cancel_completion();
return;
}
if (completion_options.size() == 1 && s == completion_options[0].display) {
// A perfect match, stop completion.
_cancel_completion();
return;
}
// The top of the list is the best match.
completion_current = completion_options[0];
completion_enabled = true;
}
void TextEdit::query_code_comple() {
String l = text[cursor.line];
int ofs = CLAMP(cursor.column, 0, l.length());
bool inquote = false;
int c = ofs - 1;
while (c >= 0) {
if (l[c] == '"' || l[c] == '\'') {
inquote = !inquote;
}
c--;
}
bool ignored = completion_active && !completion_options.is_empty();
if (ignored) {
ScriptCodeCompletionOption::Kind kind = ScriptCodeCompletionOption::KIND_PLAIN_TEXT;
const ScriptCodeCompletionOption *previous_option = nullptr;
for (int i = 0; i < completion_options.size(); i++) {
const ScriptCodeCompletionOption &current_option = 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 == ScriptCodeCompletionOption::KIND_FILE_PATH || kind == ScriptCodeCompletionOption::KIND_NODE_PATH || kind == ScriptCodeCompletionOption::KIND_SIGNAL);
}
if (!ignored) {
if (ofs > 0 && (inquote || _is_completable(l[ofs - 1]) || completion_prefixes.has(String::chr(l[ofs - 1])))) {
emit_signal("request_completion");
} else if (ofs > 1 && l[ofs - 1] == ' ' && completion_prefixes.has(String::chr(l[ofs - 2]))) { // Make it work with a space too, it's good enough.
emit_signal("request_completion");
}
}
}
void TextEdit::set_code_hint(const String &p_hint) {
completion_hint = p_hint;
completion_hint_offset = -0xFFFF;
update();
}
void TextEdit::code_complete(const List<ScriptCodeCompletionOption> &p_strings, bool p_forced) {
completion_sources = p_strings;
completion_active = true;
completion_forced = p_forced;
completion_current = ScriptCodeCompletionOption();
completion_index = 0;
_update_completion_candidates();
}
String TextEdit::get_word_at_pos(const Vector2 &p_pos) const {
int row, col;
_get_mouse_pos(p_pos, row, col);
@ -6915,6 +6244,8 @@ void TextEdit::_bind_methods() {
ClassDB::bind_method(D_METHOD("cursor_set_column", "column", "adjust_viewport"), &TextEdit::cursor_set_column, DEFVAL(true));
ClassDB::bind_method(D_METHOD("cursor_set_line", "line", "adjust_viewport", "can_be_hidden", "wrap_index"), &TextEdit::cursor_set_line, DEFVAL(true), DEFVAL(true), DEFVAL(0));
ClassDB::bind_method(D_METHOD("get_caret_draw_pos"), &TextEdit::get_caret_draw_pos);
ClassDB::bind_method(D_METHOD("is_caret_visible"), &TextEdit::is_caret_visible);
ClassDB::bind_method(D_METHOD("cursor_get_column"), &TextEdit::cursor_get_column);
ClassDB::bind_method(D_METHOD("cursor_get_line"), &TextEdit::cursor_get_line);
ClassDB::bind_method(D_METHOD("cursor_set_blink_enabled", "enable"), &TextEdit::cursor_set_blink_enabled);
@ -7095,7 +6426,6 @@ void TextEdit::_bind_methods() {
ADD_SIGNAL(MethodInfo("cursor_changed"));
ADD_SIGNAL(MethodInfo("text_changed"));
ADD_SIGNAL(MethodInfo("lines_edited_from", PropertyInfo(Variant::INT, "from_line"), PropertyInfo(Variant::INT, "to_line")));
ADD_SIGNAL(MethodInfo("request_completion"));
ADD_SIGNAL(MethodInfo("gutter_clicked", PropertyInfo(Variant::INT, "line"), PropertyInfo(Variant::INT, "gutter")));
ADD_SIGNAL(MethodInfo("gutter_added"));
ADD_SIGNAL(MethodInfo("gutter_removed"));

39
scene/gui/text_edit.h
View file

@ -173,6 +173,8 @@ private:
};
struct Cursor {
Point2 draw_pos;
bool visible = false;
int last_fit_x = 0;
int line = 0;
int column = 0; ///< cursor
@ -239,20 +241,6 @@ private:
Dictionary _get_line_syntax_highlighting(int p_line);
Set<String> completion_prefixes;
bool completion_enabled = false;
List<ScriptCodeCompletionOption> completion_sources;
Vector<ScriptCodeCompletionOption> completion_options;
bool completion_active = false;
bool completion_forced = false;
ScriptCodeCompletionOption completion_current;
String completion_base;
int completion_index = 0;
Rect2i completion_rect;
int completion_line_ofs = 0;
String completion_hint;
int completion_hint_offset = 0;
bool setting_text = false;
// data
@ -306,10 +294,10 @@ private:
bool highlight_all_occurrences = false;
bool scroll_past_end_of_file_enabled = false;
bool auto_brace_completion_enabled = false;
bool brace_matching_enabled = false;
bool highlight_current_line = false;
bool auto_indent = false;
String cut_copy_line;
bool insert_mode = false;
bool select_identifiers_enabled = false;
@ -343,6 +331,8 @@ private:
bool callhint_below = false;
Vector2 callhint_offset;
String completion_hint = "";
int completion_hint_offset = 0;
String search_text;
uint32_t search_flags = 0;
@ -437,10 +427,7 @@ private:
PopupMenu *menu_ctl;
void _clear();
void _cancel_completion();
void _cancel_code_hint();
void _confirm_completion();
void _update_completion_candidates();
int _calculate_spaces_till_next_left_indent(int column);
int _calculate_spaces_till_next_right_indent(int column);
@ -463,9 +450,11 @@ private:
void _delete_selection();
void _move_cursor_document_start(bool p_select);
void _move_cursor_document_end(bool p_select);
void _handle_unicode_character(uint32_t unicode, bool p_had_selection, bool p_update_auto_complete);
void _handle_unicode_character(uint32_t unicode, bool p_had_selection);
protected:
bool auto_brace_completion_enabled = false;
struct Cache {
Ref<Texture2D> tab_icon;
Ref<Texture2D> space_icon;
@ -477,10 +466,6 @@ protected:
int font_size = 16;
int outline_size = 0;
Color outline_color;
Color completion_background_color;
Color completion_selected_color;
Color completion_existing_color;
Color completion_font_color;
Color caret_color;
Color caret_background_color;
Color font_color;
@ -505,7 +490,7 @@ protected:
void _insert_text(int p_line, int p_char, const String &p_text, int *r_end_line = nullptr, int *r_end_char = nullptr);
void _remove_text(int p_from_line, int p_from_column, int p_to_line, int p_to_column);
void _insert_text_at_cursor(const String &p_text);
void _gui_input(const Ref<InputEvent> &p_gui_input);
virtual void _gui_input(const Ref<InputEvent> &p_gui_input);
void _notification(int p_what);
void _consume_pair_symbol(char32_t ch);
@ -695,6 +680,8 @@ public:
void cursor_set_column(int p_col, bool p_adjust_viewport = true);
void cursor_set_line(int p_row, bool p_adjust_viewport = true, bool p_can_be_hidden = true, int p_wrap_index = 0);
Point2 get_caret_draw_pos() const;
bool is_caret_visible() const;
int cursor_get_column() const;
int cursor_get_line() const;
Vector2i _get_cursor_pixel_pos(bool p_adjust_viewport = true);
@ -811,10 +798,7 @@ public:
void set_tooltip_request_func(Object *p_obj, const StringName &p_function, const Variant &p_udata);
void set_completion(bool p_enabled, const Vector<String> &p_prefixes);
void code_complete(const List<ScriptCodeCompletionOption> &p_strings, bool p_forced = false);
void set_code_hint(const String &p_hint);
void query_code_comple();
void set_select_identifiers_on_hover(bool p_enable);
bool is_selecting_identifiers_on_hover_enabled() const;
@ -833,7 +817,6 @@ public:
PopupMenu *get_menu() const;
String get_text_for_completion();
String get_text_for_lookup_completion();
virtual bool is_text_field() const override;

9
scene/resources/default_theme/default_theme.cpp
View file

@ -432,7 +432,6 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const
theme->set_stylebox("normal", "TextEdit", make_stylebox(tree_bg_png, 3, 3, 3, 3, 0, 0, 0, 0));
theme->set_stylebox("focus", "TextEdit", focus);
theme->set_stylebox("read_only", "TextEdit", make_stylebox(tree_bg_disabled_png, 4, 4, 4, 4, 0, 0, 0, 0));
theme->set_stylebox("completion", "TextEdit", make_stylebox(tree_bg_png, 3, 3, 3, 3, 0, 0, 0, 0));
theme->set_icon("tab", "TextEdit", make_icon(tab_png));
theme->set_icon("space", "TextEdit", make_icon(space_png));
@ -441,11 +440,6 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const
theme->set_font_size("font_size", "TextEdit", -1);
theme->set_color("background_color", "TextEdit", Color(0, 0, 0, 0));
theme->set_color("completion_background_color", "TextEdit", Color(0.17, 0.16, 0.2));
theme->set_color("completion_selected_color", "TextEdit", Color(0.26, 0.26, 0.27));
theme->set_color("completion_existing_color", "TextEdit", Color(0.87, 0.87, 0.87, 0.13));
theme->set_color("completion_scroll_color", "TextEdit", control_font_pressed_color);
theme->set_color("completion_font_color", "TextEdit", Color(0.67, 0.67, 0.67));
theme->set_color("font_color", "TextEdit", control_font_color);
theme->set_color("font_selected_color", "TextEdit", Color(0, 0, 0));
theme->set_color("font_readonly_color", "TextEdit", Color(control_font_color.r, control_font_color.g, control_font_color.b, 0.5f));
@ -458,9 +452,6 @@ void fill_default_theme(Ref<Theme> &theme, const Ref<Font> &default_font, const
theme->set_color("brace_mismatch_color", "TextEdit", Color(1, 0.2, 0.2));
theme->set_color("word_highlighted_color", "TextEdit", Color(0.8, 0.9, 0.9, 0.15));
theme->set_constant("completion_lines", "TextEdit", 7);
theme->set_constant("completion_max_width", "TextEdit", 50);
theme->set_constant("completion_scroll_width", "TextEdit", 3);
theme->set_constant("line_spacing", "TextEdit", 4 * scale);
theme->set_constant("outline_size", "TextEdit", 0);