de5387ab82
Backspace word was deleting all text before the cursor, and delete word was no updating until another action was performed on the LineEdit (in order to update it)
2287 lines
71 KiB
C++
2287 lines
71 KiB
C++
/*************************************************************************/
|
|
/* line_edit.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2021 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 "line_edit.h"
|
|
|
|
#include "core/input/input_map.h"
|
|
#include "core/object/message_queue.h"
|
|
#include "core/os/keyboard.h"
|
|
#include "core/os/os.h"
|
|
#include "core/string/print_string.h"
|
|
#include "core/string/translation.h"
|
|
#include "label.h"
|
|
#include "servers/display_server.h"
|
|
#include "servers/text_server.h"
|
|
#ifdef TOOLS_ENABLED
|
|
#include "editor/editor_scale.h"
|
|
#include "editor/editor_settings.h"
|
|
#endif
|
|
#include "scene/main/window.h"
|
|
|
|
void LineEdit::_swap_current_input_direction() {
|
|
if (input_direction == TEXT_DIRECTION_LTR) {
|
|
input_direction = TEXT_DIRECTION_RTL;
|
|
} else {
|
|
input_direction = TEXT_DIRECTION_LTR;
|
|
}
|
|
set_caret_column(get_caret_column());
|
|
update();
|
|
}
|
|
|
|
void LineEdit::_move_caret_left(bool p_select, bool p_move_by_word) {
|
|
if (selection.enabled && !p_select) {
|
|
set_caret_column(selection.begin);
|
|
deselect();
|
|
return;
|
|
}
|
|
|
|
shift_selection_check_pre(p_select);
|
|
|
|
if (p_move_by_word) {
|
|
int cc = caret_column;
|
|
|
|
Vector<Vector2i> words = TS->shaped_text_get_word_breaks(text_rid);
|
|
for (int i = words.size() - 1; i >= 0; i--) {
|
|
if (words[i].x < cc) {
|
|
cc = words[i].x;
|
|
break;
|
|
}
|
|
}
|
|
|
|
set_caret_column(cc);
|
|
} else {
|
|
if (caret_mid_grapheme_enabled) {
|
|
set_caret_column(get_caret_column() - 1);
|
|
} else {
|
|
set_caret_column(TS->shaped_text_prev_grapheme_pos(text_rid, get_caret_column()));
|
|
}
|
|
}
|
|
|
|
shift_selection_check_post(p_select);
|
|
}
|
|
|
|
void LineEdit::_move_caret_right(bool p_select, bool p_move_by_word) {
|
|
if (selection.enabled && !p_select) {
|
|
set_caret_column(selection.end);
|
|
deselect();
|
|
return;
|
|
}
|
|
|
|
shift_selection_check_pre(p_select);
|
|
|
|
if (p_move_by_word) {
|
|
int cc = caret_column;
|
|
|
|
Vector<Vector2i> words = TS->shaped_text_get_word_breaks(text_rid);
|
|
for (int i = 0; i < words.size(); i++) {
|
|
if (words[i].y > cc) {
|
|
cc = words[i].y;
|
|
break;
|
|
}
|
|
}
|
|
|
|
set_caret_column(cc);
|
|
} else {
|
|
if (caret_mid_grapheme_enabled) {
|
|
set_caret_column(get_caret_column() + 1);
|
|
} else {
|
|
set_caret_column(TS->shaped_text_next_grapheme_pos(text_rid, get_caret_column()));
|
|
}
|
|
}
|
|
|
|
shift_selection_check_post(p_select);
|
|
}
|
|
|
|
void LineEdit::_move_caret_start(bool p_select) {
|
|
shift_selection_check_pre(p_select);
|
|
set_caret_column(0);
|
|
shift_selection_check_post(p_select);
|
|
}
|
|
|
|
void LineEdit::_move_caret_end(bool p_select) {
|
|
shift_selection_check_pre(p_select);
|
|
set_caret_column(text.length());
|
|
shift_selection_check_post(p_select);
|
|
}
|
|
|
|
void LineEdit::_backspace(bool p_word, bool p_all_to_left) {
|
|
if (!editable) {
|
|
return;
|
|
}
|
|
|
|
if (p_all_to_left) {
|
|
deselect();
|
|
text = text.substr(0, caret_column);
|
|
_text_changed();
|
|
return;
|
|
}
|
|
|
|
if (selection.enabled) {
|
|
selection_delete();
|
|
return;
|
|
}
|
|
|
|
if (p_word) {
|
|
int cc = caret_column;
|
|
|
|
Vector<Vector2i> words = TS->shaped_text_get_word_breaks(text_rid);
|
|
for (int i = words.size() - 1; i >= 0; i--) {
|
|
if (words[i].x < cc) {
|
|
cc = words[i].x;
|
|
break;
|
|
}
|
|
}
|
|
|
|
delete_text(cc, caret_column);
|
|
|
|
set_caret_column(cc);
|
|
} else {
|
|
delete_char();
|
|
}
|
|
}
|
|
|
|
void LineEdit::_delete(bool p_word, bool p_all_to_right) {
|
|
if (!editable) {
|
|
return;
|
|
}
|
|
|
|
if (p_all_to_right) {
|
|
deselect();
|
|
text = text.substr(caret_column, text.length() - caret_column);
|
|
_shape();
|
|
set_caret_column(0);
|
|
_text_changed();
|
|
return;
|
|
}
|
|
|
|
if (selection.enabled) {
|
|
selection_delete();
|
|
return;
|
|
}
|
|
|
|
int text_len = text.length();
|
|
|
|
if (caret_column == text_len) {
|
|
return; // Nothing to do.
|
|
}
|
|
|
|
if (p_word) {
|
|
int cc = caret_column;
|
|
Vector<Vector2i> words = TS->shaped_text_get_word_breaks(text_rid);
|
|
for (int i = 0; i < words.size(); i++) {
|
|
if (words[i].y > cc) {
|
|
cc = words[i].y;
|
|
break;
|
|
}
|
|
}
|
|
|
|
delete_text(caret_column, cc);
|
|
set_caret_column(caret_column);
|
|
} else {
|
|
if (caret_mid_grapheme_enabled) {
|
|
set_caret_column(caret_column + 1);
|
|
delete_char();
|
|
} else {
|
|
int cc = caret_column;
|
|
set_caret_column(TS->shaped_text_next_grapheme_pos(text_rid, caret_column));
|
|
delete_text(cc, caret_column);
|
|
}
|
|
}
|
|
}
|
|
|
|
void LineEdit::_gui_input(Ref<InputEvent> p_event) {
|
|
ERR_FAIL_COND(p_event.is_null());
|
|
|
|
Ref<InputEventMouseButton> b = p_event;
|
|
|
|
if (b.is_valid()) {
|
|
if (ime_text.length() != 0) {
|
|
// Ignore mouse clicks in IME input mode.
|
|
return;
|
|
}
|
|
if (b->is_pressed() && b->get_button_index() == MOUSE_BUTTON_RIGHT && context_menu_enabled) {
|
|
menu->set_position(get_screen_transform().xform(get_local_mouse_position()));
|
|
menu->set_size(Vector2(1, 1));
|
|
_generate_context_menu();
|
|
menu->popup();
|
|
grab_focus();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (b->get_button_index() != MOUSE_BUTTON_LEFT) {
|
|
return;
|
|
}
|
|
|
|
_reset_caret_blink_timer();
|
|
if (b->is_pressed()) {
|
|
accept_event(); //don't pass event further when clicked on text field
|
|
if (!text.is_empty() && is_editable() && _is_over_clear_button(b->get_position())) {
|
|
clear_button_status.press_attempt = true;
|
|
clear_button_status.pressing_inside = true;
|
|
update();
|
|
return;
|
|
}
|
|
|
|
shift_selection_check_pre(b->get_shift());
|
|
|
|
set_caret_at_pixel_pos(b->get_position().x);
|
|
|
|
if (b->get_shift()) {
|
|
selection_fill_at_caret();
|
|
selection.creating = true;
|
|
|
|
} else {
|
|
if (selecting_enabled) {
|
|
if (!b->is_doubleclick() && (OS::get_singleton()->get_ticks_msec() - selection.last_dblclk) < 600) {
|
|
// Triple-click select all.
|
|
selection.enabled = true;
|
|
selection.begin = 0;
|
|
selection.end = text.length();
|
|
selection.doubleclick = true;
|
|
selection.last_dblclk = 0;
|
|
caret_column = selection.begin;
|
|
} else if (b->is_doubleclick()) {
|
|
// Double-click select word.
|
|
Vector<Vector2i> words = TS->shaped_text_get_word_breaks(text_rid);
|
|
for (int i = 0; i < words.size(); i++) {
|
|
if (words[i].x < caret_column && words[i].y > caret_column) {
|
|
selection.enabled = true;
|
|
selection.begin = words[i].x;
|
|
selection.end = words[i].y;
|
|
selection.doubleclick = true;
|
|
selection.last_dblclk = OS::get_singleton()->get_ticks_msec();
|
|
caret_column = selection.end;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
selection.drag_attempt = false;
|
|
|
|
if ((caret_column < selection.begin) || (caret_column > selection.end) || !selection.enabled) {
|
|
deselect();
|
|
selection.start_column = caret_column;
|
|
selection.creating = true;
|
|
} else if (selection.enabled) {
|
|
selection.drag_attempt = true;
|
|
}
|
|
}
|
|
|
|
update();
|
|
|
|
} else {
|
|
if (!text.is_empty() && is_editable() && clear_button_enabled) {
|
|
bool press_attempt = clear_button_status.press_attempt;
|
|
clear_button_status.press_attempt = false;
|
|
if (press_attempt && clear_button_status.pressing_inside && _is_over_clear_button(b->get_position())) {
|
|
clear();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ((!selection.creating) && (!selection.doubleclick)) {
|
|
deselect();
|
|
}
|
|
selection.creating = false;
|
|
selection.doubleclick = false;
|
|
|
|
show_virtual_keyboard();
|
|
}
|
|
|
|
update();
|
|
}
|
|
|
|
Ref<InputEventMouseMotion> m = p_event;
|
|
|
|
if (m.is_valid()) {
|
|
if (!text.is_empty() && is_editable() && clear_button_enabled) {
|
|
bool last_press_inside = clear_button_status.pressing_inside;
|
|
clear_button_status.pressing_inside = clear_button_status.press_attempt && _is_over_clear_button(m->get_position());
|
|
if (last_press_inside != clear_button_status.pressing_inside) {
|
|
update();
|
|
}
|
|
}
|
|
|
|
if (m->get_button_mask() & MOUSE_BUTTON_LEFT) {
|
|
if (selection.creating) {
|
|
set_caret_at_pixel_pos(m->get_position().x);
|
|
selection_fill_at_caret();
|
|
}
|
|
}
|
|
}
|
|
|
|
Ref<InputEventKey> k = p_event;
|
|
|
|
if (k.is_valid()) {
|
|
if (!k->is_pressed()) {
|
|
return;
|
|
}
|
|
|
|
if (context_menu_enabled) {
|
|
if (k->is_action("ui_menu", true)) {
|
|
Point2 pos = Point2(get_caret_pixel_pos().x, (get_size().y + get_theme_font("font")->get_height(get_theme_font_size("font_size"))) / 2);
|
|
menu->set_position(get_global_transform().xform(pos));
|
|
menu->set_size(Vector2(1, 1));
|
|
_generate_context_menu();
|
|
menu->popup();
|
|
menu->grab_focus();
|
|
}
|
|
}
|
|
|
|
// Default is ENTER, KP_ENTER. Cannot use ui_accept as default includes SPACE
|
|
if (k->is_action("ui_text_newline", true)) {
|
|
emit_signal("text_entered", text);
|
|
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_VIRTUAL_KEYBOARD) && virtual_keyboard_enabled) {
|
|
DisplayServer::get_singleton()->virtual_keyboard_hide();
|
|
}
|
|
}
|
|
|
|
if (is_shortcut_keys_enabled()) {
|
|
if (k->is_action("ui_copy", true)) {
|
|
copy_text();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (k->is_action("ui_text_select_all", true)) {
|
|
select();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
// Cut / Paste
|
|
if (k->is_action("ui_cut", true)) {
|
|
cut_text();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (k->is_action("ui_paste", true)) {
|
|
paste_text();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
// Undo / Redo
|
|
if (k->is_action("ui_undo", true)) {
|
|
undo();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (k->is_action("ui_redo", true)) {
|
|
redo();
|
|
accept_event();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// BACKSPACE
|
|
if (k->is_action("ui_text_backspace_all_to_left", true)) {
|
|
_backspace(false, true);
|
|
accept_event();
|
|
return;
|
|
}
|
|
if (k->is_action("ui_text_backspace_word", true)) {
|
|
_backspace(true);
|
|
accept_event();
|
|
return;
|
|
}
|
|
if (k->is_action("ui_text_backspace", true)) {
|
|
_backspace();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
// DELETE
|
|
if (k->is_action("ui_text_delete_all_to_right", true)) {
|
|
_delete(false, true);
|
|
accept_event();
|
|
return;
|
|
}
|
|
if (k->is_action("ui_text_delete_word", true)) {
|
|
_delete(true);
|
|
accept_event();
|
|
return;
|
|
}
|
|
if (k->is_action("ui_text_delete", true)) {
|
|
_delete();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
// Cursor Movement
|
|
|
|
k = k->duplicate();
|
|
bool shift_pressed = k->get_shift();
|
|
// Remove shift or else actions will not match. Use above variable for selection.
|
|
k->set_shift(false);
|
|
|
|
if (k->is_action("ui_text_caret_word_left", true)) {
|
|
_move_caret_left(shift_pressed, true);
|
|
accept_event();
|
|
return;
|
|
}
|
|
if (k->is_action("ui_text_caret_left", true)) {
|
|
_move_caret_left(shift_pressed);
|
|
accept_event();
|
|
return;
|
|
}
|
|
if (k->is_action("ui_text_caret_word_right", true)) {
|
|
_move_caret_right(shift_pressed, true);
|
|
accept_event();
|
|
return;
|
|
}
|
|
if (k->is_action("ui_text_caret_right", true)) {
|
|
_move_caret_right(shift_pressed, false);
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
// Up = Home, Down = End
|
|
if (k->is_action("ui_text_caret_up", true) || k->is_action("ui_text_caret_line_start", true) || k->is_action("ui_text_caret_page_up", true)) {
|
|
_move_caret_start(shift_pressed);
|
|
accept_event();
|
|
return;
|
|
}
|
|
if (k->is_action("ui_text_caret_down", true) || k->is_action("ui_text_caret_line_end", true) || k->is_action("ui_text_caret_page_down", true)) {
|
|
_move_caret_end(shift_pressed);
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
// Misc
|
|
if (k->is_action("ui_swap_input_direction", true)) {
|
|
_swap_current_input_direction();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
_reset_caret_blink_timer();
|
|
|
|
// Allow unicode handling if:
|
|
// * No Modifiers are pressed (except shift)
|
|
bool allow_unicode_handling = !(k->get_command() || k->get_control() || k->get_alt() || k->get_metakey());
|
|
|
|
if (allow_unicode_handling && editable && k->get_unicode() >= 32) {
|
|
// Handle Unicode (if no modifiers active)
|
|
selection_delete();
|
|
char32_t ucodestr[2] = { (char32_t)k->get_unicode(), 0 };
|
|
int prev_len = text.length();
|
|
insert_text_at_caret(ucodestr);
|
|
if (text.length() != prev_len) {
|
|
_text_changed();
|
|
}
|
|
accept_event();
|
|
}
|
|
}
|
|
}
|
|
|
|
void LineEdit::set_align(Align p_align) {
|
|
ERR_FAIL_INDEX((int)p_align, 4);
|
|
if (align != p_align) {
|
|
align = p_align;
|
|
_shape();
|
|
}
|
|
update();
|
|
}
|
|
|
|
LineEdit::Align LineEdit::get_align() const {
|
|
return align;
|
|
}
|
|
|
|
Variant LineEdit::get_drag_data(const Point2 &p_point) {
|
|
if (selection.drag_attempt && selection.enabled) {
|
|
String t = text.substr(selection.begin, selection.end - selection.begin);
|
|
Label *l = memnew(Label);
|
|
l->set_text(t);
|
|
set_drag_preview(l);
|
|
return t;
|
|
}
|
|
|
|
return Variant();
|
|
}
|
|
|
|
bool LineEdit::can_drop_data(const Point2 &p_point, const Variant &p_data) const {
|
|
bool drop_override = Control::can_drop_data(p_point, p_data); // In case user wants to drop custom data.
|
|
if (drop_override) {
|
|
return drop_override;
|
|
}
|
|
|
|
return p_data.get_type() == Variant::STRING;
|
|
}
|
|
|
|
void LineEdit::drop_data(const Point2 &p_point, const Variant &p_data) {
|
|
Control::drop_data(p_point, p_data);
|
|
|
|
if (p_data.get_type() == Variant::STRING) {
|
|
set_caret_at_pixel_pos(p_point.x);
|
|
int selected = selection.end - selection.begin;
|
|
|
|
text.erase(selection.begin, selected);
|
|
_shape();
|
|
|
|
insert_text_at_caret(p_data);
|
|
selection.begin = caret_column - selected;
|
|
selection.end = caret_column;
|
|
}
|
|
}
|
|
|
|
Control::CursorShape LineEdit::get_cursor_shape(const Point2 &p_pos) const {
|
|
if (!text.is_empty() && is_editable() && _is_over_clear_button(p_pos)) {
|
|
return CURSOR_ARROW;
|
|
}
|
|
return Control::get_cursor_shape(p_pos);
|
|
}
|
|
|
|
bool LineEdit::_is_over_clear_button(const Point2 &p_pos) const {
|
|
if (!clear_button_enabled || !has_point(p_pos)) {
|
|
return false;
|
|
}
|
|
Ref<Texture2D> icon = Control::get_theme_icon("clear");
|
|
int x_ofs = get_theme_stylebox("normal")->get_offset().x;
|
|
return p_pos.x > get_size().width - icon->get_width() - x_ofs;
|
|
}
|
|
|
|
void LineEdit::_notification(int p_what) {
|
|
switch (p_what) {
|
|
#ifdef TOOLS_ENABLED
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
if (Engine::get_singleton()->is_editor_hint() && !get_tree()->is_node_being_edited(this)) {
|
|
set_caret_blink_enabled(EDITOR_DEF("text_editor/cursor/caret_blink", false));
|
|
set_caret_blink_speed(EDITOR_DEF("text_editor/cursor/caret_blink_speed", 0.65));
|
|
|
|
if (!EditorSettings::get_singleton()->is_connected("settings_changed", callable_mp(this, &LineEdit::_editor_settings_changed))) {
|
|
EditorSettings::get_singleton()->connect("settings_changed", callable_mp(this, &LineEdit::_editor_settings_changed));
|
|
}
|
|
}
|
|
} break;
|
|
#endif
|
|
case NOTIFICATION_RESIZED: {
|
|
_fit_to_width();
|
|
scroll_offset = 0;
|
|
set_caret_column(get_caret_column());
|
|
} break;
|
|
case NOTIFICATION_LAYOUT_DIRECTION_CHANGED:
|
|
case NOTIFICATION_THEME_CHANGED: {
|
|
_shape();
|
|
update();
|
|
} break;
|
|
case NOTIFICATION_TRANSLATION_CHANGED: {
|
|
placeholder_translated = tr(placeholder);
|
|
_shape();
|
|
update();
|
|
} break;
|
|
case NOTIFICATION_WM_WINDOW_FOCUS_IN: {
|
|
window_has_focus = true;
|
|
draw_caret = true;
|
|
update();
|
|
} break;
|
|
case NOTIFICATION_WM_WINDOW_FOCUS_OUT: {
|
|
window_has_focus = false;
|
|
draw_caret = false;
|
|
update();
|
|
} break;
|
|
case NOTIFICATION_DRAW: {
|
|
if ((!has_focus() && !menu->has_focus() && !caret_force_displayed) || !window_has_focus) {
|
|
draw_caret = false;
|
|
}
|
|
|
|
int width, height;
|
|
bool rtl = is_layout_rtl();
|
|
|
|
Size2 size = get_size();
|
|
width = size.width;
|
|
height = size.height;
|
|
|
|
RID ci = get_canvas_item();
|
|
|
|
Ref<StyleBox> style = get_theme_stylebox("normal");
|
|
if (!is_editable()) {
|
|
style = get_theme_stylebox("read_only");
|
|
draw_caret = false;
|
|
}
|
|
Ref<Font> font = get_theme_font("font");
|
|
|
|
style->draw(ci, Rect2(Point2(), size));
|
|
|
|
if (has_focus()) {
|
|
get_theme_stylebox("focus")->draw(ci, Rect2(Point2(), size));
|
|
}
|
|
|
|
int x_ofs = 0;
|
|
bool using_placeholder = text.is_empty() && ime_text.is_empty();
|
|
float text_width = TS->shaped_text_get_size(text_rid).x;
|
|
float text_height = TS->shaped_text_get_size(text_rid).y + font->get_spacing(Font::SPACING_TOP) + font->get_spacing(Font::SPACING_BOTTOM);
|
|
|
|
switch (align) {
|
|
case ALIGN_FILL:
|
|
case ALIGN_LEFT: {
|
|
if (rtl) {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - style->get_margin(SIDE_RIGHT) - (text_width)));
|
|
} else {
|
|
x_ofs = style->get_offset().x;
|
|
}
|
|
} break;
|
|
case ALIGN_CENTER: {
|
|
if (scroll_offset != 0) {
|
|
x_ofs = style->get_offset().x;
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - (text_width)) / 2);
|
|
}
|
|
} break;
|
|
case ALIGN_RIGHT: {
|
|
if (rtl) {
|
|
x_ofs = style->get_offset().x;
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - style->get_margin(SIDE_RIGHT) - (text_width)));
|
|
}
|
|
} break;
|
|
}
|
|
|
|
int ofs_max = width - style->get_margin(SIDE_RIGHT);
|
|
|
|
int y_area = height - style->get_minimum_size().height;
|
|
int y_ofs = style->get_offset().y + (y_area - text_height) / 2;
|
|
|
|
Color selection_color = get_theme_color("selection_color");
|
|
Color font_color = is_editable() ? get_theme_color("font_color") : get_theme_color("font_uneditable_color");
|
|
Color font_selected_color = get_theme_color("font_selected_color");
|
|
Color caret_color = get_theme_color("caret_color");
|
|
|
|
// Draw placeholder color.
|
|
if (using_placeholder) {
|
|
font_color.a *= placeholder_alpha;
|
|
}
|
|
|
|
bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
|
|
if (right_icon.is_valid() || display_clear_icon) {
|
|
Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon("clear") : right_icon;
|
|
Color color_icon(1, 1, 1, !is_editable() ? .5 * .9 : .9);
|
|
if (display_clear_icon) {
|
|
if (clear_button_status.press_attempt && clear_button_status.pressing_inside) {
|
|
color_icon = get_theme_color("clear_button_color_pressed");
|
|
} else {
|
|
color_icon = get_theme_color("clear_button_color");
|
|
}
|
|
}
|
|
|
|
r_icon->draw(ci, Point2(width - r_icon->get_width() - style->get_margin(SIDE_RIGHT), height / 2 - r_icon->get_height() / 2), color_icon);
|
|
|
|
if (align == ALIGN_CENTER) {
|
|
if (scroll_offset == 0) {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(size.width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
|
|
}
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT));
|
|
}
|
|
|
|
ofs_max -= r_icon->get_width();
|
|
}
|
|
|
|
#ifdef TOOLS_ENABLED
|
|
int caret_width = Math::round(EDSCALE);
|
|
#else
|
|
int caret_width = 1;
|
|
#endif
|
|
|
|
// Draw selections rects.
|
|
Vector2 ofs = Point2(x_ofs + scroll_offset, y_ofs);
|
|
if (selection.enabled) {
|
|
Vector<Vector2> sel = TS->shaped_text_get_selection(text_rid, selection.begin, selection.end);
|
|
for (int i = 0; i < sel.size(); i++) {
|
|
Rect2 rect = Rect2(sel[i].x + ofs.x, ofs.y, sel[i].y - sel[i].x, text_height);
|
|
if (rect.position.x + rect.size.x <= x_ofs || rect.position.x > ofs_max) {
|
|
continue;
|
|
}
|
|
if (rect.position.x < x_ofs) {
|
|
rect.size.x -= (x_ofs - rect.position.x);
|
|
rect.position.x = x_ofs;
|
|
} else if (rect.position.x + rect.size.x > ofs_max) {
|
|
rect.size.x = ofs_max - rect.position.x;
|
|
}
|
|
RenderingServer::get_singleton()->canvas_item_add_rect(ci, rect, selection_color);
|
|
}
|
|
}
|
|
const Vector<TextServer::Glyph> visual = TS->shaped_text_get_glyphs(text_rid);
|
|
const TextServer::Glyph *glyphs = visual.ptr();
|
|
int gl_size = visual.size();
|
|
|
|
// Draw text.
|
|
ofs.y += TS->shaped_text_get_ascent(text_rid);
|
|
Color font_outline_color = get_theme_color("font_outline_color");
|
|
int outline_size = get_theme_constant("outline_size");
|
|
if (outline_size > 0 && font_outline_color.a > 0) {
|
|
Vector2 oofs = ofs;
|
|
for (int i = 0; i < gl_size; i++) {
|
|
for (int j = 0; j < glyphs[i].repeat; j++) {
|
|
if (ceil(oofs.x) >= x_ofs && (oofs.x + glyphs[i].advance) <= ofs_max) {
|
|
if (glyphs[i].font_rid != RID()) {
|
|
TS->font_draw_glyph_outline(glyphs[i].font_rid, ci, glyphs[i].font_size, outline_size, oofs + Vector2(glyphs[i].x_off, glyphs[i].y_off), glyphs[i].index, font_outline_color);
|
|
}
|
|
}
|
|
oofs.x += glyphs[i].advance;
|
|
}
|
|
if (oofs.x >= ofs_max) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
for (int i = 0; i < gl_size; i++) {
|
|
bool selected = selection.enabled && glyphs[i].start >= selection.begin && glyphs[i].end <= selection.end;
|
|
for (int j = 0; j < glyphs[i].repeat; j++) {
|
|
if (ceil(ofs.x) >= x_ofs && (ofs.x + glyphs[i].advance) <= ofs_max) {
|
|
if (glyphs[i].font_rid != RID()) {
|
|
TS->font_draw_glyph(glyphs[i].font_rid, ci, glyphs[i].font_size, ofs + Vector2(glyphs[i].x_off, glyphs[i].y_off), glyphs[i].index, selected ? font_selected_color : font_color);
|
|
} else if ((glyphs[i].flags & TextServer::GRAPHEME_IS_VIRTUAL) != TextServer::GRAPHEME_IS_VIRTUAL) {
|
|
TS->draw_hex_code_box(ci, glyphs[i].font_size, ofs + Vector2(glyphs[i].x_off, glyphs[i].y_off), glyphs[i].index, selected ? font_selected_color : font_color);
|
|
}
|
|
}
|
|
ofs.x += glyphs[i].advance;
|
|
}
|
|
if (ofs.x >= ofs_max) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Draw carets.
|
|
ofs.x = x_ofs + scroll_offset;
|
|
if (draw_caret) {
|
|
if (ime_text.length() == 0) {
|
|
// Normal caret.
|
|
Rect2 l_caret, t_caret;
|
|
TextServer::Direction l_dir, t_dir;
|
|
TS->shaped_text_get_carets(text_rid, caret_column, l_caret, l_dir, t_caret, t_dir);
|
|
|
|
if (l_caret == Rect2() && t_caret == Rect2()) {
|
|
// No carets, add one at the start.
|
|
int h = get_theme_font("font")->get_height(get_theme_font_size("font_size"));
|
|
int y = style->get_offset().y + (y_area - h) / 2;
|
|
if (rtl) {
|
|
l_dir = TextServer::DIRECTION_RTL;
|
|
l_caret = Rect2(Vector2(ofs_max, y), Size2(caret_width, h));
|
|
} else {
|
|
l_dir = TextServer::DIRECTION_LTR;
|
|
l_caret = Rect2(Vector2(x_ofs, y), Size2(caret_width, h));
|
|
}
|
|
RenderingServer::get_singleton()->canvas_item_add_rect(ci, l_caret, caret_color);
|
|
} else {
|
|
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 += ofs;
|
|
RenderingServer::get_singleton()->canvas_item_add_rect(ci, trect, caret_color);
|
|
}
|
|
|
|
l_caret.position += ofs;
|
|
l_caret.size.x = caret_width;
|
|
RenderingServer::get_singleton()->canvas_item_add_rect(ci, l_caret, caret_color);
|
|
|
|
t_caret.position += ofs;
|
|
t_caret.size.x = caret_width;
|
|
|
|
RenderingServer::get_singleton()->canvas_item_add_rect(ci, t_caret, caret_color);
|
|
}
|
|
} else {
|
|
{
|
|
// IME intermediate text range.
|
|
Vector<Vector2> sel = TS->shaped_text_get_selection(text_rid, caret_column, caret_column + ime_text.length());
|
|
for (int i = 0; i < sel.size(); i++) {
|
|
Rect2 rect = Rect2(sel[i].x + ofs.x, ofs.y, sel[i].y - sel[i].x, text_height);
|
|
if (rect.position.x + rect.size.x <= x_ofs || rect.position.x > ofs_max) {
|
|
continue;
|
|
}
|
|
if (rect.position.x < x_ofs) {
|
|
rect.size.x -= (x_ofs - rect.position.x);
|
|
rect.position.x = x_ofs;
|
|
} else if (rect.position.x + rect.size.x > ofs_max) {
|
|
rect.size.x = ofs_max - rect.position.x;
|
|
}
|
|
rect.size.y = caret_width;
|
|
RenderingServer::get_singleton()->canvas_item_add_rect(ci, rect, caret_color);
|
|
}
|
|
}
|
|
{
|
|
// IME caret.
|
|
Vector<Vector2> sel = TS->shaped_text_get_selection(text_rid, caret_column + ime_selection.x, caret_column + ime_selection.x + ime_selection.y);
|
|
for (int i = 0; i < sel.size(); i++) {
|
|
Rect2 rect = Rect2(sel[i].x + ofs.x, ofs.y, sel[i].y - sel[i].x, text_height);
|
|
if (rect.position.x + rect.size.x <= x_ofs || rect.position.x > ofs_max) {
|
|
continue;
|
|
}
|
|
if (rect.position.x < x_ofs) {
|
|
rect.size.x -= (x_ofs - rect.position.x);
|
|
rect.position.x = x_ofs;
|
|
} else if (rect.position.x + rect.size.x > ofs_max) {
|
|
rect.size.x = ofs_max - rect.position.x;
|
|
}
|
|
rect.size.y = caret_width * 3;
|
|
RenderingServer::get_singleton()->canvas_item_add_rect(ci, rect, caret_color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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() + Point2(using_placeholder ? 0 : x_ofs, y_ofs + TS->shaped_text_get_size(text_rid).y), get_viewport()->get_window_id());
|
|
}
|
|
}
|
|
} break;
|
|
case NOTIFICATION_FOCUS_ENTER: {
|
|
if (!caret_force_displayed) {
|
|
if (caret_blink_enabled) {
|
|
if (caret_blink_timer->is_stopped()) {
|
|
caret_blink_timer->start();
|
|
}
|
|
} else {
|
|
draw_caret = true;
|
|
}
|
|
}
|
|
|
|
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());
|
|
Point2 caret_column = Point2(get_caret_column(), 1) * get_minimum_size().height;
|
|
DisplayServer::get_singleton()->window_set_ime_position(get_global_position() + caret_column, get_viewport()->get_window_id());
|
|
}
|
|
|
|
show_virtual_keyboard();
|
|
} break;
|
|
case NOTIFICATION_FOCUS_EXIT: {
|
|
if (caret_blink_enabled && !caret_force_displayed) {
|
|
caret_blink_timer->stop();
|
|
}
|
|
|
|
if (get_viewport()->get_window_id() != DisplayServer::INVALID_WINDOW_ID && DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_IME)) {
|
|
DisplayServer::get_singleton()->window_set_ime_position(Point2(), get_viewport()->get_window_id());
|
|
DisplayServer::get_singleton()->window_set_ime_active(false, get_viewport()->get_window_id());
|
|
}
|
|
ime_text = "";
|
|
ime_selection = Point2();
|
|
_shape();
|
|
set_caret_column(caret_column); // Update scroll_offset
|
|
|
|
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_VIRTUAL_KEYBOARD) && virtual_keyboard_enabled) {
|
|
DisplayServer::get_singleton()->virtual_keyboard_hide();
|
|
}
|
|
|
|
} break;
|
|
case MainLoop::NOTIFICATION_OS_IME_UPDATE: {
|
|
if (has_focus()) {
|
|
ime_text = DisplayServer::get_singleton()->ime_get_text();
|
|
ime_selection = DisplayServer::get_singleton()->ime_get_selection();
|
|
_shape();
|
|
set_caret_column(caret_column); // Update scroll_offset
|
|
|
|
update();
|
|
}
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void LineEdit::copy_text() {
|
|
if (selection.enabled && !pass) {
|
|
DisplayServer::get_singleton()->clipboard_set(text.substr(selection.begin, selection.end - selection.begin));
|
|
}
|
|
}
|
|
|
|
void LineEdit::cut_text() {
|
|
if (editable && selection.enabled && !pass) {
|
|
DisplayServer::get_singleton()->clipboard_set(text.substr(selection.begin, selection.end - selection.begin));
|
|
selection_delete();
|
|
}
|
|
}
|
|
|
|
void LineEdit::paste_text() {
|
|
if (!editable) {
|
|
return;
|
|
}
|
|
|
|
// Strip escape characters like \n and \t as they can't be displayed on LineEdit.
|
|
String paste_buffer = DisplayServer::get_singleton()->clipboard_get().strip_escapes();
|
|
|
|
if (paste_buffer != "") {
|
|
int prev_len = text.length();
|
|
if (selection.enabled) {
|
|
selection_delete();
|
|
}
|
|
insert_text_at_caret(paste_buffer);
|
|
|
|
if (!text_changed_dirty) {
|
|
if (is_inside_tree() && text.length() != prev_len) {
|
|
MessageQueue::get_singleton()->push_call(this, "_text_changed");
|
|
}
|
|
text_changed_dirty = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
void LineEdit::undo() {
|
|
if (!editable) {
|
|
return;
|
|
}
|
|
|
|
if (undo_stack_pos == nullptr) {
|
|
if (undo_stack.size() <= 1) {
|
|
return;
|
|
}
|
|
undo_stack_pos = undo_stack.back();
|
|
} else if (undo_stack_pos == undo_stack.front()) {
|
|
return;
|
|
}
|
|
undo_stack_pos = undo_stack_pos->prev();
|
|
TextOperation op = undo_stack_pos->get();
|
|
text = op.text;
|
|
scroll_offset = op.scroll_offset;
|
|
set_caret_column(op.caret_column);
|
|
|
|
_shape();
|
|
_emit_text_change();
|
|
}
|
|
|
|
void LineEdit::redo() {
|
|
if (!editable) {
|
|
return;
|
|
}
|
|
|
|
if (undo_stack_pos == nullptr) {
|
|
return;
|
|
}
|
|
if (undo_stack_pos == undo_stack.back()) {
|
|
return;
|
|
}
|
|
undo_stack_pos = undo_stack_pos->next();
|
|
TextOperation op = undo_stack_pos->get();
|
|
text = op.text;
|
|
scroll_offset = op.scroll_offset;
|
|
set_caret_column(op.caret_column);
|
|
|
|
_shape();
|
|
_emit_text_change();
|
|
}
|
|
|
|
void LineEdit::shift_selection_check_pre(bool p_shift) {
|
|
if (!selection.enabled && p_shift) {
|
|
selection.start_column = caret_column;
|
|
}
|
|
if (!p_shift) {
|
|
deselect();
|
|
}
|
|
}
|
|
|
|
void LineEdit::shift_selection_check_post(bool p_shift) {
|
|
if (p_shift) {
|
|
selection_fill_at_caret();
|
|
}
|
|
}
|
|
|
|
void LineEdit::set_caret_at_pixel_pos(int p_x) {
|
|
Ref<StyleBox> style = get_theme_stylebox("normal");
|
|
bool rtl = is_layout_rtl();
|
|
|
|
int x_ofs = 0;
|
|
float text_width = TS->shaped_text_get_size(text_rid).x;
|
|
switch (align) {
|
|
case ALIGN_FILL:
|
|
case ALIGN_LEFT: {
|
|
if (rtl) {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
|
|
} else {
|
|
x_ofs = style->get_offset().x;
|
|
}
|
|
} break;
|
|
case ALIGN_CENTER: {
|
|
if (scroll_offset != 0) {
|
|
x_ofs = style->get_offset().x;
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
|
|
}
|
|
} break;
|
|
case ALIGN_RIGHT: {
|
|
if (rtl) {
|
|
x_ofs = style->get_offset().x;
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
|
|
}
|
|
} break;
|
|
}
|
|
|
|
bool using_placeholder = text.is_empty() && ime_text.is_empty();
|
|
bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
|
|
if (right_icon.is_valid() || display_clear_icon) {
|
|
Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon("clear") : right_icon;
|
|
if (align == ALIGN_CENTER) {
|
|
if (scroll_offset == 0) {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
|
|
}
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT));
|
|
}
|
|
}
|
|
|
|
int ofs = TS->shaped_text_hit_test_position(text_rid, p_x - x_ofs - scroll_offset);
|
|
set_caret_column(ofs);
|
|
}
|
|
|
|
Vector2i LineEdit::get_caret_pixel_pos() {
|
|
Ref<StyleBox> style = get_theme_stylebox("normal");
|
|
bool rtl = is_layout_rtl();
|
|
|
|
int x_ofs = 0;
|
|
float text_width = TS->shaped_text_get_size(text_rid).x;
|
|
switch (align) {
|
|
case ALIGN_FILL:
|
|
case ALIGN_LEFT: {
|
|
if (rtl) {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
|
|
} else {
|
|
x_ofs = style->get_offset().x;
|
|
}
|
|
} break;
|
|
case ALIGN_CENTER: {
|
|
if (scroll_offset != 0) {
|
|
x_ofs = style->get_offset().x;
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
|
|
}
|
|
} break;
|
|
case ALIGN_RIGHT: {
|
|
if (rtl) {
|
|
x_ofs = style->get_offset().x;
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
|
|
}
|
|
} break;
|
|
}
|
|
|
|
bool using_placeholder = text.is_empty() && ime_text.is_empty();
|
|
bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
|
|
if (right_icon.is_valid() || display_clear_icon) {
|
|
Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon("clear") : right_icon;
|
|
if (align == ALIGN_CENTER) {
|
|
if (scroll_offset == 0) {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
|
|
}
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT));
|
|
}
|
|
}
|
|
|
|
Vector2i ret;
|
|
Rect2 l_caret, t_caret;
|
|
TextServer::Direction l_dir, t_dir;
|
|
// Get position of the start of caret.
|
|
if (ime_text.length() != 0 && ime_selection.x != 0) {
|
|
TS->shaped_text_get_carets(text_rid, caret_column + ime_selection.x, l_caret, l_dir, t_caret, t_dir);
|
|
} else {
|
|
TS->shaped_text_get_carets(text_rid, caret_column, l_caret, l_dir, t_caret, t_dir);
|
|
}
|
|
|
|
if ((l_caret != Rect2() && (l_dir == TextServer::DIRECTION_AUTO || l_dir == (TextServer::Direction)input_direction)) || (t_caret == Rect2())) {
|
|
ret.x = x_ofs + l_caret.position.x + scroll_offset;
|
|
} else {
|
|
ret.x = x_ofs + t_caret.position.x + scroll_offset;
|
|
}
|
|
|
|
// Get position of the end of caret.
|
|
if (ime_text.length() != 0) {
|
|
if (ime_selection.y != 0) {
|
|
TS->shaped_text_get_carets(text_rid, caret_column + ime_selection.x + ime_selection.y, l_caret, l_dir, t_caret, t_dir);
|
|
} else {
|
|
TS->shaped_text_get_carets(text_rid, caret_column + ime_text.size(), l_caret, l_dir, t_caret, t_dir);
|
|
}
|
|
if ((l_caret != Rect2() && (l_dir == TextServer::DIRECTION_AUTO || l_dir == (TextServer::Direction)input_direction)) || (t_caret == Rect2())) {
|
|
ret.y = x_ofs + l_caret.position.x + scroll_offset;
|
|
} else {
|
|
ret.y = x_ofs + t_caret.position.x + scroll_offset;
|
|
}
|
|
} else {
|
|
ret.y = ret.x;
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void LineEdit::set_caret_mid_grapheme_enabled(const bool p_enabled) {
|
|
caret_mid_grapheme_enabled = p_enabled;
|
|
}
|
|
|
|
bool LineEdit::is_caret_mid_grapheme_enabled() const {
|
|
return caret_mid_grapheme_enabled;
|
|
}
|
|
|
|
bool LineEdit::is_caret_blink_enabled() const {
|
|
return caret_blink_enabled;
|
|
}
|
|
|
|
void LineEdit::set_caret_blink_enabled(const bool p_enabled) {
|
|
caret_blink_enabled = p_enabled;
|
|
|
|
if (has_focus() || caret_force_displayed) {
|
|
if (p_enabled) {
|
|
if (caret_blink_timer->is_stopped()) {
|
|
caret_blink_timer->start();
|
|
}
|
|
} else {
|
|
caret_blink_timer->stop();
|
|
}
|
|
}
|
|
|
|
draw_caret = true;
|
|
|
|
notify_property_list_changed();
|
|
}
|
|
|
|
bool LineEdit::is_caret_force_displayed() const {
|
|
return caret_force_displayed;
|
|
}
|
|
|
|
void LineEdit::set_caret_force_displayed(const bool p_enabled) {
|
|
caret_force_displayed = p_enabled;
|
|
set_caret_blink_enabled(caret_blink_enabled);
|
|
update();
|
|
}
|
|
|
|
float LineEdit::get_caret_blink_speed() const {
|
|
return caret_blink_timer->get_wait_time();
|
|
}
|
|
|
|
void LineEdit::set_caret_blink_speed(const float p_speed) {
|
|
ERR_FAIL_COND(p_speed <= 0);
|
|
caret_blink_timer->set_wait_time(p_speed);
|
|
}
|
|
|
|
void LineEdit::_reset_caret_blink_timer() {
|
|
if (caret_blink_enabled) {
|
|
draw_caret = true;
|
|
if (has_focus()) {
|
|
caret_blink_timer->stop();
|
|
caret_blink_timer->start();
|
|
update();
|
|
}
|
|
}
|
|
}
|
|
|
|
void LineEdit::_toggle_draw_caret() {
|
|
draw_caret = !draw_caret;
|
|
if (is_visible_in_tree() && ((has_focus() && window_has_focus) || caret_force_displayed)) {
|
|
update();
|
|
}
|
|
}
|
|
|
|
void LineEdit::delete_char() {
|
|
if ((text.length() <= 0) || (caret_column == 0)) {
|
|
return;
|
|
}
|
|
|
|
text.erase(caret_column - 1, 1);
|
|
_shape();
|
|
|
|
set_caret_column(get_caret_column() - 1);
|
|
|
|
_text_changed();
|
|
}
|
|
|
|
void LineEdit::delete_text(int p_from_column, int p_to_column) {
|
|
ERR_FAIL_COND_MSG(p_from_column < 0 || p_from_column > p_to_column || p_to_column > text.length(),
|
|
vformat("Positional parameters (from: %d, to: %d) are inverted or outside the text length (%d).", p_from_column, p_to_column, text.length()));
|
|
|
|
text.erase(p_from_column, p_to_column - p_from_column);
|
|
_shape();
|
|
|
|
caret_column -= CLAMP(caret_column - p_from_column, 0, p_to_column - p_from_column);
|
|
|
|
if (caret_column >= text.length()) {
|
|
caret_column = text.length();
|
|
}
|
|
|
|
if (!text_changed_dirty) {
|
|
if (is_inside_tree()) {
|
|
MessageQueue::get_singleton()->push_call(this, "_text_changed");
|
|
}
|
|
text_changed_dirty = true;
|
|
}
|
|
}
|
|
|
|
void LineEdit::set_text(String p_text) {
|
|
clear_internal();
|
|
insert_text_at_caret(p_text);
|
|
_create_undo_state();
|
|
|
|
update();
|
|
caret_column = 0;
|
|
scroll_offset = 0;
|
|
}
|
|
|
|
void LineEdit::set_text_direction(Control::TextDirection p_text_direction) {
|
|
ERR_FAIL_COND((int)p_text_direction < -1 || (int)p_text_direction > 3);
|
|
if (text_direction != p_text_direction) {
|
|
text_direction = p_text_direction;
|
|
if (text_direction != TEXT_DIRECTION_AUTO && text_direction != TEXT_DIRECTION_INHERITED) {
|
|
input_direction = text_direction;
|
|
}
|
|
_shape();
|
|
|
|
menu_dir->set_item_checked(menu_dir->get_item_index(MENU_DIR_INHERITED), text_direction == TEXT_DIRECTION_INHERITED);
|
|
menu_dir->set_item_checked(menu_dir->get_item_index(MENU_DIR_AUTO), text_direction == TEXT_DIRECTION_AUTO);
|
|
menu_dir->set_item_checked(menu_dir->get_item_index(MENU_DIR_LTR), text_direction == TEXT_DIRECTION_LTR);
|
|
menu_dir->set_item_checked(menu_dir->get_item_index(MENU_DIR_RTL), text_direction == TEXT_DIRECTION_RTL);
|
|
update();
|
|
}
|
|
}
|
|
|
|
Control::TextDirection LineEdit::get_text_direction() const {
|
|
return text_direction;
|
|
}
|
|
|
|
void LineEdit::clear_opentype_features() {
|
|
opentype_features.clear();
|
|
_shape();
|
|
update();
|
|
}
|
|
|
|
void LineEdit::set_opentype_feature(const String &p_name, int p_value) {
|
|
int32_t tag = TS->name_to_tag(p_name);
|
|
if (!opentype_features.has(tag) || (int)opentype_features[tag] != p_value) {
|
|
opentype_features[tag] = p_value;
|
|
_shape();
|
|
update();
|
|
}
|
|
}
|
|
|
|
int LineEdit::get_opentype_feature(const String &p_name) const {
|
|
int32_t tag = TS->name_to_tag(p_name);
|
|
if (!opentype_features.has(tag)) {
|
|
return -1;
|
|
}
|
|
return opentype_features[tag];
|
|
}
|
|
|
|
void LineEdit::set_language(const String &p_language) {
|
|
if (language != p_language) {
|
|
language = p_language;
|
|
_shape();
|
|
update();
|
|
}
|
|
}
|
|
|
|
String LineEdit::get_language() const {
|
|
return language;
|
|
}
|
|
|
|
void LineEdit::set_draw_control_chars(bool p_draw_control_chars) {
|
|
if (draw_control_chars != p_draw_control_chars) {
|
|
draw_control_chars = p_draw_control_chars;
|
|
menu->set_item_checked(menu->get_item_index(MENU_DISPLAY_UCC), draw_control_chars);
|
|
_shape();
|
|
update();
|
|
}
|
|
}
|
|
|
|
bool LineEdit::get_draw_control_chars() const {
|
|
return draw_control_chars;
|
|
}
|
|
|
|
void LineEdit::set_structured_text_bidi_override(Control::StructuredTextParser p_parser) {
|
|
if (st_parser != p_parser) {
|
|
st_parser = p_parser;
|
|
_shape();
|
|
update();
|
|
}
|
|
}
|
|
|
|
Control::StructuredTextParser LineEdit::get_structured_text_bidi_override() const {
|
|
return st_parser;
|
|
}
|
|
|
|
void LineEdit::set_structured_text_bidi_override_options(Array p_args) {
|
|
st_args = p_args;
|
|
_shape();
|
|
update();
|
|
}
|
|
|
|
Array LineEdit::get_structured_text_bidi_override_options() const {
|
|
return st_args;
|
|
}
|
|
|
|
void LineEdit::clear() {
|
|
clear_internal();
|
|
_text_changed();
|
|
|
|
// This should reset virtual keyboard state if needed.
|
|
if (has_focus()) {
|
|
show_virtual_keyboard();
|
|
}
|
|
}
|
|
|
|
void LineEdit::show_virtual_keyboard() {
|
|
if (DisplayServer::get_singleton()->has_feature(DisplayServer::FEATURE_VIRTUAL_KEYBOARD) && virtual_keyboard_enabled) {
|
|
if (selection.enabled) {
|
|
DisplayServer::get_singleton()->virtual_keyboard_show(text, get_global_rect(), false, max_length, selection.begin, selection.end);
|
|
} else {
|
|
DisplayServer::get_singleton()->virtual_keyboard_show(text, get_global_rect(), false, max_length, caret_column);
|
|
}
|
|
}
|
|
}
|
|
|
|
String LineEdit::get_text() const {
|
|
return text;
|
|
}
|
|
|
|
void LineEdit::set_placeholder(String p_text) {
|
|
placeholder = p_text;
|
|
placeholder_translated = tr(placeholder);
|
|
_shape();
|
|
update();
|
|
}
|
|
|
|
String LineEdit::get_placeholder() const {
|
|
return placeholder;
|
|
}
|
|
|
|
void LineEdit::set_placeholder_alpha(float p_alpha) {
|
|
placeholder_alpha = p_alpha;
|
|
update();
|
|
}
|
|
|
|
float LineEdit::get_placeholder_alpha() const {
|
|
return placeholder_alpha;
|
|
}
|
|
|
|
void LineEdit::set_caret_column(int p_column) {
|
|
if (p_column > (int)text.length()) {
|
|
p_column = text.length();
|
|
}
|
|
|
|
if (p_column < 0) {
|
|
p_column = 0;
|
|
}
|
|
|
|
caret_column = p_column;
|
|
|
|
// Fit to window.
|
|
|
|
if (!is_inside_tree()) {
|
|
scroll_offset = 0;
|
|
return;
|
|
}
|
|
|
|
Ref<StyleBox> style = get_theme_stylebox("normal");
|
|
bool rtl = is_layout_rtl();
|
|
|
|
int x_ofs = 0;
|
|
float text_width = TS->shaped_text_get_size(text_rid).x;
|
|
switch (align) {
|
|
case ALIGN_FILL:
|
|
case ALIGN_LEFT: {
|
|
if (rtl) {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
|
|
} else {
|
|
x_ofs = style->get_offset().x;
|
|
}
|
|
} break;
|
|
case ALIGN_CENTER: {
|
|
if (scroll_offset != 0) {
|
|
x_ofs = style->get_offset().x;
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - (text_width)) / 2);
|
|
}
|
|
} break;
|
|
case ALIGN_RIGHT: {
|
|
if (rtl) {
|
|
x_ofs = style->get_offset().x;
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - style->get_margin(SIDE_RIGHT) - (text_width)));
|
|
}
|
|
} break;
|
|
}
|
|
|
|
int ofs_max = get_size().width - style->get_margin(SIDE_RIGHT);
|
|
bool using_placeholder = text.is_empty() && ime_text.is_empty();
|
|
bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
|
|
if (right_icon.is_valid() || display_clear_icon) {
|
|
Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon("clear") : right_icon;
|
|
if (align == ALIGN_CENTER) {
|
|
if (scroll_offset == 0) {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), int(get_size().width - text_width - r_icon->get_width() - style->get_margin(SIDE_RIGHT) * 2) / 2);
|
|
}
|
|
} else {
|
|
x_ofs = MAX(style->get_margin(SIDE_LEFT), x_ofs - r_icon->get_width() - style->get_margin(SIDE_RIGHT));
|
|
}
|
|
ofs_max -= r_icon->get_width();
|
|
}
|
|
|
|
// Note: Use two coordinates to fit IME input range.
|
|
Vector2i primary_catret_offset = get_caret_pixel_pos();
|
|
|
|
if (MIN(primary_catret_offset.x, primary_catret_offset.y) <= x_ofs) {
|
|
scroll_offset += (x_ofs - MIN(primary_catret_offset.x, primary_catret_offset.y));
|
|
} else if (MAX(primary_catret_offset.x, primary_catret_offset.y) >= ofs_max) {
|
|
scroll_offset += (ofs_max - MAX(primary_catret_offset.x, primary_catret_offset.y));
|
|
}
|
|
scroll_offset = MIN(0, scroll_offset);
|
|
|
|
update();
|
|
}
|
|
|
|
int LineEdit::get_caret_column() const {
|
|
return caret_column;
|
|
}
|
|
|
|
void LineEdit::set_scroll_offset(int p_pos) {
|
|
scroll_offset = p_pos;
|
|
if (scroll_offset < 0) {
|
|
scroll_offset = 0;
|
|
}
|
|
}
|
|
|
|
int LineEdit::get_scroll_offset() const {
|
|
return scroll_offset;
|
|
}
|
|
|
|
void LineEdit::insert_text_at_caret(String p_text) {
|
|
if ((max_length <= 0) || (text.length() + p_text.length() <= max_length)) {
|
|
String pre = text.substr(0, caret_column);
|
|
String post = text.substr(caret_column, text.length() - caret_column);
|
|
text = pre + p_text + post;
|
|
_shape();
|
|
TextServer::Direction dir = TS->shaped_text_get_dominant_direciton_in_range(text_rid, caret_column, caret_column + p_text.length());
|
|
if (dir != TextServer::DIRECTION_AUTO) {
|
|
input_direction = (TextDirection)dir;
|
|
}
|
|
set_caret_column(caret_column + p_text.length());
|
|
} else {
|
|
emit_signal("text_change_rejected");
|
|
}
|
|
}
|
|
|
|
void LineEdit::clear_internal() {
|
|
deselect();
|
|
_clear_undo_stack();
|
|
caret_column = 0;
|
|
scroll_offset = 0;
|
|
undo_text = "";
|
|
text = "";
|
|
_shape();
|
|
update();
|
|
}
|
|
|
|
Size2 LineEdit::get_minimum_size() const {
|
|
Ref<StyleBox> style = get_theme_stylebox("normal");
|
|
Ref<Font> font = get_theme_font("font");
|
|
int font_size = get_theme_font_size("font_size");
|
|
|
|
Size2 min_size;
|
|
|
|
// Minimum size of text.
|
|
int em_space_size = font->get_char_size('M', 0, font_size).x;
|
|
min_size.width = get_theme_constant("minimum_character_width") * em_space_size;
|
|
|
|
if (expand_to_text_length) {
|
|
// Add a space because some fonts are too exact, and because caret needs a bit more when at the end.
|
|
min_size.width = MAX(min_size.width, full_width + em_space_size);
|
|
}
|
|
|
|
min_size.height = MAX(TS->shaped_text_get_size(text_rid).y + font->get_spacing(Font::SPACING_TOP) + font->get_spacing(Font::SPACING_BOTTOM), font->get_height(font_size));
|
|
|
|
// Take icons into account.
|
|
bool using_placeholder = text.is_empty() && ime_text.is_empty();
|
|
bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
|
|
if (right_icon.is_valid() || display_clear_icon) {
|
|
Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon("clear") : right_icon;
|
|
min_size.width += r_icon->get_width();
|
|
min_size.height = MAX(min_size.height, r_icon->get_height());
|
|
}
|
|
|
|
return style->get_minimum_size() + min_size;
|
|
}
|
|
|
|
void LineEdit::deselect() {
|
|
selection.begin = 0;
|
|
selection.end = 0;
|
|
selection.start_column = 0;
|
|
selection.enabled = false;
|
|
selection.creating = false;
|
|
selection.doubleclick = false;
|
|
update();
|
|
}
|
|
|
|
void LineEdit::selection_delete() {
|
|
if (selection.enabled) {
|
|
delete_text(selection.begin, selection.end);
|
|
}
|
|
|
|
deselect();
|
|
}
|
|
|
|
void LineEdit::set_max_length(int p_max_length) {
|
|
ERR_FAIL_COND(p_max_length < 0);
|
|
max_length = p_max_length;
|
|
set_text(text);
|
|
}
|
|
|
|
int LineEdit::get_max_length() const {
|
|
return max_length;
|
|
}
|
|
|
|
void LineEdit::selection_fill_at_caret() {
|
|
if (!selecting_enabled) {
|
|
return;
|
|
}
|
|
|
|
selection.begin = caret_column;
|
|
selection.end = selection.start_column;
|
|
|
|
if (selection.end < selection.begin) {
|
|
int aux = selection.end;
|
|
selection.end = selection.begin;
|
|
selection.begin = aux;
|
|
}
|
|
|
|
selection.enabled = (selection.begin != selection.end);
|
|
}
|
|
|
|
void LineEdit::select_all() {
|
|
if (!selecting_enabled) {
|
|
return;
|
|
}
|
|
|
|
if (!text.length()) {
|
|
return;
|
|
}
|
|
|
|
selection.begin = 0;
|
|
selection.end = text.length();
|
|
selection.enabled = true;
|
|
update();
|
|
}
|
|
|
|
void LineEdit::set_editable(bool p_editable) {
|
|
if (editable == p_editable) {
|
|
return;
|
|
}
|
|
|
|
editable = p_editable;
|
|
_generate_context_menu();
|
|
|
|
minimum_size_changed();
|
|
update();
|
|
}
|
|
|
|
bool LineEdit::is_editable() const {
|
|
return editable;
|
|
}
|
|
|
|
void LineEdit::set_secret(bool p_secret) {
|
|
if (pass != p_secret) {
|
|
pass = p_secret;
|
|
_shape();
|
|
}
|
|
update();
|
|
}
|
|
|
|
bool LineEdit::is_secret() const {
|
|
return pass;
|
|
}
|
|
|
|
void LineEdit::set_secret_character(const String &p_string) {
|
|
// An empty string as the secret character would crash the engine.
|
|
// It also wouldn't make sense to use multiple characters as the secret character.
|
|
ERR_FAIL_COND_MSG(p_string.length() != 1, "Secret character must be exactly one character long (" + itos(p_string.length()) + " characters given).");
|
|
|
|
if (secret_character != p_string) {
|
|
secret_character = p_string;
|
|
_shape();
|
|
}
|
|
update();
|
|
}
|
|
|
|
String LineEdit::get_secret_character() const {
|
|
return secret_character;
|
|
}
|
|
|
|
void LineEdit::select(int p_from, int p_to) {
|
|
if (!selecting_enabled) {
|
|
return;
|
|
}
|
|
|
|
if (p_from == 0 && p_to == 0) {
|
|
deselect();
|
|
return;
|
|
}
|
|
|
|
int len = text.length();
|
|
if (p_from < 0) {
|
|
p_from = 0;
|
|
}
|
|
if (p_from > len) {
|
|
p_from = len;
|
|
}
|
|
if (p_to < 0 || p_to > len) {
|
|
p_to = len;
|
|
}
|
|
|
|
if (p_from >= p_to) {
|
|
return;
|
|
}
|
|
|
|
selection.enabled = true;
|
|
selection.begin = p_from;
|
|
selection.end = p_to;
|
|
selection.creating = false;
|
|
selection.doubleclick = false;
|
|
update();
|
|
}
|
|
|
|
bool LineEdit::is_text_field() const {
|
|
return true;
|
|
}
|
|
|
|
void LineEdit::menu_option(int p_option) {
|
|
switch (p_option) {
|
|
case MENU_CUT: {
|
|
if (editable) {
|
|
cut_text();
|
|
}
|
|
} break;
|
|
case MENU_COPY: {
|
|
copy_text();
|
|
} break;
|
|
case MENU_PASTE: {
|
|
if (editable) {
|
|
paste_text();
|
|
}
|
|
} break;
|
|
case MENU_CLEAR: {
|
|
if (editable) {
|
|
clear();
|
|
}
|
|
} break;
|
|
case MENU_SELECT_ALL: {
|
|
select_all();
|
|
} break;
|
|
case MENU_UNDO: {
|
|
if (editable) {
|
|
undo();
|
|
}
|
|
} break;
|
|
case MENU_REDO: {
|
|
if (editable) {
|
|
redo();
|
|
}
|
|
} break;
|
|
case MENU_DIR_INHERITED: {
|
|
set_text_direction(TEXT_DIRECTION_INHERITED);
|
|
} break;
|
|
case MENU_DIR_AUTO: {
|
|
set_text_direction(TEXT_DIRECTION_AUTO);
|
|
} break;
|
|
case MENU_DIR_LTR: {
|
|
set_text_direction(TEXT_DIRECTION_LTR);
|
|
} break;
|
|
case MENU_DIR_RTL: {
|
|
set_text_direction(TEXT_DIRECTION_RTL);
|
|
} break;
|
|
case MENU_DISPLAY_UCC: {
|
|
set_draw_control_chars(!get_draw_control_chars());
|
|
} break;
|
|
case MENU_INSERT_LRM: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x200E));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_RLM: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x200F));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_LRE: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x202A));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_RLE: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x202B));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_LRO: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x202D));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_RLO: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x202E));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_PDF: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x202C));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_ALM: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x061C));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_LRI: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x2066));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_RLI: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x2067));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_FSI: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x2068));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_PDI: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x2069));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_ZWJ: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x200D));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_ZWNJ: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x200C));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_WJ: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x2060));
|
|
}
|
|
} break;
|
|
case MENU_INSERT_SHY: {
|
|
if (editable) {
|
|
insert_text_at_caret(String::chr(0x00AD));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void LineEdit::set_context_menu_enabled(bool p_enable) {
|
|
context_menu_enabled = p_enable;
|
|
}
|
|
|
|
bool LineEdit::is_context_menu_enabled() {
|
|
return context_menu_enabled;
|
|
}
|
|
|
|
PopupMenu *LineEdit::get_menu() const {
|
|
return menu;
|
|
}
|
|
|
|
void LineEdit::_editor_settings_changed() {
|
|
#ifdef TOOLS_ENABLED
|
|
set_caret_blink_enabled(EDITOR_DEF("text_editor/cursor/caret_blink", false));
|
|
set_caret_blink_speed(EDITOR_DEF("text_editor/cursor/caret_blink_speed", 0.65));
|
|
#endif
|
|
}
|
|
|
|
void LineEdit::set_expand_to_text_length_enabled(bool p_enabled) {
|
|
expand_to_text_length = p_enabled;
|
|
minimum_size_changed();
|
|
set_caret_column(caret_column);
|
|
}
|
|
|
|
bool LineEdit::is_expand_to_text_length_enabled() const {
|
|
return expand_to_text_length;
|
|
}
|
|
|
|
void LineEdit::set_clear_button_enabled(bool p_enabled) {
|
|
if (clear_button_enabled == p_enabled) {
|
|
return;
|
|
}
|
|
clear_button_enabled = p_enabled;
|
|
_fit_to_width();
|
|
minimum_size_changed();
|
|
update();
|
|
}
|
|
|
|
bool LineEdit::is_clear_button_enabled() const {
|
|
return clear_button_enabled;
|
|
}
|
|
|
|
void LineEdit::set_shortcut_keys_enabled(bool p_enabled) {
|
|
shortcut_keys_enabled = p_enabled;
|
|
|
|
_generate_context_menu();
|
|
}
|
|
|
|
bool LineEdit::is_shortcut_keys_enabled() const {
|
|
return shortcut_keys_enabled;
|
|
}
|
|
|
|
void LineEdit::set_virtual_keyboard_enabled(bool p_enable) {
|
|
virtual_keyboard_enabled = p_enable;
|
|
}
|
|
|
|
bool LineEdit::is_virtual_keyboard_enabled() const {
|
|
return virtual_keyboard_enabled;
|
|
}
|
|
|
|
void LineEdit::set_selecting_enabled(bool p_enabled) {
|
|
selecting_enabled = p_enabled;
|
|
|
|
if (!selecting_enabled) {
|
|
deselect();
|
|
}
|
|
|
|
_generate_context_menu();
|
|
}
|
|
|
|
bool LineEdit::is_selecting_enabled() const {
|
|
return selecting_enabled;
|
|
}
|
|
|
|
void LineEdit::set_right_icon(const Ref<Texture2D> &p_icon) {
|
|
if (right_icon == p_icon) {
|
|
return;
|
|
}
|
|
right_icon = p_icon;
|
|
_fit_to_width();
|
|
minimum_size_changed();
|
|
update();
|
|
}
|
|
|
|
Ref<Texture2D> LineEdit::get_right_icon() {
|
|
return right_icon;
|
|
}
|
|
|
|
void LineEdit::_text_changed() {
|
|
_emit_text_change();
|
|
_clear_redo();
|
|
}
|
|
|
|
void LineEdit::_emit_text_change() {
|
|
emit_signal("text_changed", text);
|
|
text_changed_dirty = false;
|
|
}
|
|
|
|
void LineEdit::_shape() {
|
|
Size2 old_size = TS->shaped_text_get_size(text_rid);
|
|
TS->shaped_text_clear(text_rid);
|
|
|
|
String t;
|
|
if (text.length() == 0) {
|
|
t = placeholder_translated;
|
|
} else if (pass) {
|
|
t = secret_character.repeat(text.length() + ime_text.length());
|
|
} else {
|
|
if (ime_text.length() > 0) {
|
|
t = text.substr(0, caret_column) + ime_text + text.substr(caret_column, text.length());
|
|
} else {
|
|
t = text;
|
|
}
|
|
}
|
|
if (text_direction == Control::TEXT_DIRECTION_INHERITED) {
|
|
TS->shaped_text_set_direction(text_rid, is_layout_rtl() ? TextServer::DIRECTION_RTL : TextServer::DIRECTION_LTR);
|
|
} else {
|
|
TS->shaped_text_set_direction(text_rid, (TextServer::Direction)text_direction);
|
|
}
|
|
TS->shaped_text_set_preserve_control(text_rid, draw_control_chars);
|
|
|
|
const Ref<Font> &font = get_theme_font("font");
|
|
int font_size = get_theme_font_size("font_size");
|
|
TS->shaped_text_add_string(text_rid, t, font->get_rids(), font_size, opentype_features, (language != "") ? language : TranslationServer::get_singleton()->get_tool_locale());
|
|
TS->shaped_text_set_bidi_override(text_rid, structured_text_parser(st_parser, st_args, t));
|
|
|
|
full_width = TS->shaped_text_get_size(text_rid).x;
|
|
_fit_to_width();
|
|
|
|
Size2 size = TS->shaped_text_get_size(text_rid);
|
|
|
|
if ((expand_to_text_length && old_size.x != size.x) || (old_size.y != size.y)) {
|
|
minimum_size_changed();
|
|
}
|
|
}
|
|
|
|
void LineEdit::_fit_to_width() {
|
|
if (align == ALIGN_FILL) {
|
|
Ref<StyleBox> style = get_theme_stylebox("normal");
|
|
int t_width = get_size().width - style->get_margin(SIDE_RIGHT) - style->get_margin(SIDE_LEFT);
|
|
bool using_placeholder = text.is_empty() && ime_text.is_empty();
|
|
bool display_clear_icon = !using_placeholder && is_editable() && clear_button_enabled;
|
|
if (right_icon.is_valid() || display_clear_icon) {
|
|
Ref<Texture2D> r_icon = display_clear_icon ? Control::get_theme_icon("clear") : right_icon;
|
|
t_width -= r_icon->get_width();
|
|
}
|
|
TS->shaped_text_fit_to_width(text_rid, MAX(t_width, full_width));
|
|
}
|
|
}
|
|
|
|
void LineEdit::_clear_redo() {
|
|
_create_undo_state();
|
|
if (undo_stack_pos == nullptr) {
|
|
return;
|
|
}
|
|
|
|
undo_stack_pos = undo_stack_pos->next();
|
|
while (undo_stack_pos) {
|
|
List<TextOperation>::Element *elem = undo_stack_pos;
|
|
undo_stack_pos = undo_stack_pos->next();
|
|
undo_stack.erase(elem);
|
|
}
|
|
_create_undo_state();
|
|
}
|
|
|
|
void LineEdit::_clear_undo_stack() {
|
|
undo_stack.clear();
|
|
undo_stack_pos = nullptr;
|
|
_create_undo_state();
|
|
}
|
|
|
|
void LineEdit::_create_undo_state() {
|
|
TextOperation op;
|
|
op.text = text;
|
|
op.caret_column = caret_column;
|
|
op.scroll_offset = scroll_offset;
|
|
undo_stack.push_back(op);
|
|
}
|
|
|
|
int LineEdit::_get_menu_action_accelerator(const String &p_action) {
|
|
const List<Ref<InputEvent>> *events = InputMap::get_singleton()->action_get_events(p_action);
|
|
if (!events) {
|
|
return 0;
|
|
}
|
|
|
|
// Use first event in the list for the accelerator.
|
|
const List<Ref<InputEvent>>::Element *first_event = events->front();
|
|
if (!first_event) {
|
|
return 0;
|
|
}
|
|
|
|
const Ref<InputEventKey> event = first_event->get();
|
|
if (event.is_null()) {
|
|
return 0;
|
|
}
|
|
|
|
// Use physical keycode if non-zero
|
|
if (event->get_physical_keycode() != 0) {
|
|
return event->get_physical_keycode_with_modifiers();
|
|
} else {
|
|
return event->get_keycode_with_modifiers();
|
|
}
|
|
}
|
|
|
|
void LineEdit::_generate_context_menu() {
|
|
// Reorganize context menu.
|
|
menu->clear();
|
|
if (editable) {
|
|
menu->add_item(RTR("Cut"), MENU_CUT, is_shortcut_keys_enabled() ? _get_menu_action_accelerator("ui_cut") : 0);
|
|
}
|
|
menu->add_item(RTR("Copy"), MENU_COPY, is_shortcut_keys_enabled() ? _get_menu_action_accelerator("ui_copy") : 0);
|
|
if (editable) {
|
|
menu->add_item(RTR("Paste"), MENU_PASTE, is_shortcut_keys_enabled() ? _get_menu_action_accelerator("ui_paste") : 0);
|
|
}
|
|
menu->add_separator();
|
|
if (is_selecting_enabled()) {
|
|
menu->add_item(RTR("Select All"), MENU_SELECT_ALL, is_shortcut_keys_enabled() ? _get_menu_action_accelerator("ui_text_select_all") : 0);
|
|
}
|
|
if (editable) {
|
|
menu->add_item(RTR("Clear"), MENU_CLEAR);
|
|
menu->add_separator();
|
|
menu->add_item(RTR("Undo"), MENU_UNDO, is_shortcut_keys_enabled() ? _get_menu_action_accelerator("ui_undo") : 0);
|
|
menu->add_item(RTR("Redo"), MENU_REDO, is_shortcut_keys_enabled() ? _get_menu_action_accelerator("ui_redo") : 0);
|
|
}
|
|
menu->add_separator();
|
|
menu->add_submenu_item(RTR("Text writing direction"), "DirMenu");
|
|
menu->add_separator();
|
|
menu->add_check_item(RTR("Display control characters"), MENU_DISPLAY_UCC);
|
|
if (editable) {
|
|
menu->add_submenu_item(RTR("Insert control character"), "CTLMenu");
|
|
}
|
|
}
|
|
|
|
bool LineEdit::_set(const StringName &p_name, const Variant &p_value) {
|
|
String str = p_name;
|
|
if (str.begins_with("opentype_features/")) {
|
|
String name = str.get_slicec('/', 1);
|
|
int32_t tag = TS->name_to_tag(name);
|
|
double value = p_value;
|
|
if (value == -1) {
|
|
if (opentype_features.has(tag)) {
|
|
opentype_features.erase(tag);
|
|
_shape();
|
|
update();
|
|
}
|
|
} else {
|
|
if ((double)opentype_features[tag] != value) {
|
|
opentype_features[tag] = value;
|
|
_shape();
|
|
update();
|
|
}
|
|
}
|
|
notify_property_list_changed();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool LineEdit::_get(const StringName &p_name, Variant &r_ret) const {
|
|
String str = p_name;
|
|
if (str.begins_with("opentype_features/")) {
|
|
String name = str.get_slicec('/', 1);
|
|
int32_t tag = TS->name_to_tag(name);
|
|
if (opentype_features.has(tag)) {
|
|
r_ret = opentype_features[tag];
|
|
return true;
|
|
} else {
|
|
r_ret = -1;
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void LineEdit::_get_property_list(List<PropertyInfo> *p_list) const {
|
|
for (const Variant *ftr = opentype_features.next(nullptr); ftr != nullptr; ftr = opentype_features.next(ftr)) {
|
|
String name = TS->tag_to_name(*ftr);
|
|
p_list->push_back(PropertyInfo(Variant::FLOAT, "opentype_features/" + name));
|
|
}
|
|
p_list->push_back(PropertyInfo(Variant::NIL, "opentype_features/_new", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_EDITOR));
|
|
}
|
|
|
|
void LineEdit::_validate_property(PropertyInfo &property) const {
|
|
if (!caret_blink_enabled && property.name == "caret_blink_speed") {
|
|
property.usage = PROPERTY_USAGE_NOEDITOR;
|
|
}
|
|
}
|
|
|
|
void LineEdit::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("_text_changed"), &LineEdit::_text_changed);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_align", "align"), &LineEdit::set_align);
|
|
ClassDB::bind_method(D_METHOD("get_align"), &LineEdit::get_align);
|
|
|
|
ClassDB::bind_method(D_METHOD("_gui_input"), &LineEdit::_gui_input);
|
|
ClassDB::bind_method(D_METHOD("clear"), &LineEdit::clear);
|
|
ClassDB::bind_method(D_METHOD("select", "from", "to"), &LineEdit::select, DEFVAL(0), DEFVAL(-1));
|
|
ClassDB::bind_method(D_METHOD("select_all"), &LineEdit::select_all);
|
|
ClassDB::bind_method(D_METHOD("deselect"), &LineEdit::deselect);
|
|
ClassDB::bind_method(D_METHOD("set_text", "text"), &LineEdit::set_text);
|
|
ClassDB::bind_method(D_METHOD("get_text"), &LineEdit::get_text);
|
|
ClassDB::bind_method(D_METHOD("get_draw_control_chars"), &LineEdit::get_draw_control_chars);
|
|
ClassDB::bind_method(D_METHOD("set_draw_control_chars", "enable"), &LineEdit::set_draw_control_chars);
|
|
ClassDB::bind_method(D_METHOD("set_text_direction", "direction"), &LineEdit::set_text_direction);
|
|
ClassDB::bind_method(D_METHOD("get_text_direction"), &LineEdit::get_text_direction);
|
|
ClassDB::bind_method(D_METHOD("set_opentype_feature", "tag", "value"), &LineEdit::set_opentype_feature);
|
|
ClassDB::bind_method(D_METHOD("get_opentype_feature", "tag"), &LineEdit::get_opentype_feature);
|
|
ClassDB::bind_method(D_METHOD("clear_opentype_features"), &LineEdit::clear_opentype_features);
|
|
ClassDB::bind_method(D_METHOD("set_language", "language"), &LineEdit::set_language);
|
|
ClassDB::bind_method(D_METHOD("get_language"), &LineEdit::get_language);
|
|
ClassDB::bind_method(D_METHOD("set_structured_text_bidi_override", "parser"), &LineEdit::set_structured_text_bidi_override);
|
|
ClassDB::bind_method(D_METHOD("get_structured_text_bidi_override"), &LineEdit::get_structured_text_bidi_override);
|
|
ClassDB::bind_method(D_METHOD("set_structured_text_bidi_override_options", "args"), &LineEdit::set_structured_text_bidi_override_options);
|
|
ClassDB::bind_method(D_METHOD("get_structured_text_bidi_override_options"), &LineEdit::get_structured_text_bidi_override_options);
|
|
ClassDB::bind_method(D_METHOD("set_placeholder", "text"), &LineEdit::set_placeholder);
|
|
ClassDB::bind_method(D_METHOD("get_placeholder"), &LineEdit::get_placeholder);
|
|
ClassDB::bind_method(D_METHOD("set_placeholder_alpha", "alpha"), &LineEdit::set_placeholder_alpha);
|
|
ClassDB::bind_method(D_METHOD("get_placeholder_alpha"), &LineEdit::get_placeholder_alpha);
|
|
ClassDB::bind_method(D_METHOD("set_caret_column", "position"), &LineEdit::set_caret_column);
|
|
ClassDB::bind_method(D_METHOD("get_caret_column"), &LineEdit::get_caret_column);
|
|
ClassDB::bind_method(D_METHOD("get_scroll_offset"), &LineEdit::get_scroll_offset);
|
|
ClassDB::bind_method(D_METHOD("set_expand_to_text_length_enabled", "enabled"), &LineEdit::set_expand_to_text_length_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_expand_to_text_length_enabled"), &LineEdit::is_expand_to_text_length_enabled);
|
|
ClassDB::bind_method(D_METHOD("set_caret_blink_enabled", "enabled"), &LineEdit::set_caret_blink_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_caret_blink_enabled"), &LineEdit::is_caret_blink_enabled);
|
|
ClassDB::bind_method(D_METHOD("set_caret_mid_grapheme_enabled", "enabled"), &LineEdit::set_caret_mid_grapheme_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_caret_mid_grapheme_enabled"), &LineEdit::is_caret_mid_grapheme_enabled);
|
|
ClassDB::bind_method(D_METHOD("set_caret_force_displayed", "enabled"), &LineEdit::set_caret_force_displayed);
|
|
ClassDB::bind_method(D_METHOD("is_caret_force_displayed"), &LineEdit::is_caret_force_displayed);
|
|
ClassDB::bind_method(D_METHOD("set_caret_blink_speed", "blink_speed"), &LineEdit::set_caret_blink_speed);
|
|
ClassDB::bind_method(D_METHOD("get_caret_blink_speed"), &LineEdit::get_caret_blink_speed);
|
|
ClassDB::bind_method(D_METHOD("set_max_length", "chars"), &LineEdit::set_max_length);
|
|
ClassDB::bind_method(D_METHOD("get_max_length"), &LineEdit::get_max_length);
|
|
ClassDB::bind_method(D_METHOD("insert_text_at_caret", "text"), &LineEdit::insert_text_at_caret);
|
|
ClassDB::bind_method(D_METHOD("delete_char_at_caret"), &LineEdit::delete_char);
|
|
ClassDB::bind_method(D_METHOD("delete_text", "from_column", "to_column"), &LineEdit::delete_text);
|
|
ClassDB::bind_method(D_METHOD("set_editable", "enabled"), &LineEdit::set_editable);
|
|
ClassDB::bind_method(D_METHOD("is_editable"), &LineEdit::is_editable);
|
|
ClassDB::bind_method(D_METHOD("set_secret", "enabled"), &LineEdit::set_secret);
|
|
ClassDB::bind_method(D_METHOD("is_secret"), &LineEdit::is_secret);
|
|
ClassDB::bind_method(D_METHOD("set_secret_character", "character"), &LineEdit::set_secret_character);
|
|
ClassDB::bind_method(D_METHOD("get_secret_character"), &LineEdit::get_secret_character);
|
|
ClassDB::bind_method(D_METHOD("menu_option", "option"), &LineEdit::menu_option);
|
|
ClassDB::bind_method(D_METHOD("get_menu"), &LineEdit::get_menu);
|
|
ClassDB::bind_method(D_METHOD("set_context_menu_enabled", "enable"), &LineEdit::set_context_menu_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_context_menu_enabled"), &LineEdit::is_context_menu_enabled);
|
|
ClassDB::bind_method(D_METHOD("set_virtual_keyboard_enabled", "enable"), &LineEdit::set_virtual_keyboard_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_virtual_keyboard_enabled"), &LineEdit::is_virtual_keyboard_enabled);
|
|
ClassDB::bind_method(D_METHOD("set_clear_button_enabled", "enable"), &LineEdit::set_clear_button_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_clear_button_enabled"), &LineEdit::is_clear_button_enabled);
|
|
ClassDB::bind_method(D_METHOD("set_shortcut_keys_enabled", "enable"), &LineEdit::set_shortcut_keys_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_shortcut_keys_enabled"), &LineEdit::is_shortcut_keys_enabled);
|
|
ClassDB::bind_method(D_METHOD("set_selecting_enabled", "enable"), &LineEdit::set_selecting_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_selecting_enabled"), &LineEdit::is_selecting_enabled);
|
|
ClassDB::bind_method(D_METHOD("set_right_icon", "icon"), &LineEdit::set_right_icon);
|
|
ClassDB::bind_method(D_METHOD("get_right_icon"), &LineEdit::get_right_icon);
|
|
|
|
ADD_SIGNAL(MethodInfo("text_changed", PropertyInfo(Variant::STRING, "new_text")));
|
|
ADD_SIGNAL(MethodInfo("text_change_rejected"));
|
|
ADD_SIGNAL(MethodInfo("text_entered", PropertyInfo(Variant::STRING, "new_text")));
|
|
|
|
BIND_ENUM_CONSTANT(ALIGN_LEFT);
|
|
BIND_ENUM_CONSTANT(ALIGN_CENTER);
|
|
BIND_ENUM_CONSTANT(ALIGN_RIGHT);
|
|
BIND_ENUM_CONSTANT(ALIGN_FILL);
|
|
|
|
BIND_ENUM_CONSTANT(MENU_CUT);
|
|
BIND_ENUM_CONSTANT(MENU_COPY);
|
|
BIND_ENUM_CONSTANT(MENU_PASTE);
|
|
BIND_ENUM_CONSTANT(MENU_CLEAR);
|
|
BIND_ENUM_CONSTANT(MENU_SELECT_ALL);
|
|
BIND_ENUM_CONSTANT(MENU_UNDO);
|
|
BIND_ENUM_CONSTANT(MENU_REDO);
|
|
BIND_ENUM_CONSTANT(MENU_DIR_INHERITED);
|
|
BIND_ENUM_CONSTANT(MENU_DIR_AUTO);
|
|
BIND_ENUM_CONSTANT(MENU_DIR_LTR);
|
|
BIND_ENUM_CONSTANT(MENU_DIR_RTL);
|
|
BIND_ENUM_CONSTANT(MENU_DISPLAY_UCC);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_LRM);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_RLM);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_LRE);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_RLE);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_LRO);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_RLO);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_PDF);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_ALM);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_LRI);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_RLI);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_FSI);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_PDI);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_ZWJ);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_ZWNJ);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_WJ);
|
|
BIND_ENUM_CONSTANT(MENU_INSERT_SHY);
|
|
BIND_ENUM_CONSTANT(MENU_MAX);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "text"), "set_text", "get_text");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "align", PROPERTY_HINT_ENUM, "Left,Center,Right,Fill"), "set_align", "get_align");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "max_length"), "set_max_length", "get_max_length");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "editable"), "set_editable", "is_editable");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "secret"), "set_secret", "is_secret");
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "secret_character"), "set_secret_character", "get_secret_character");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "expand_to_text_length"), "set_expand_to_text_length_enabled", "is_expand_to_text_length_enabled");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "context_menu_enabled"), "set_context_menu_enabled", "is_context_menu_enabled");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "virtual_keyboard_enabled"), "set_virtual_keyboard_enabled", "is_virtual_keyboard_enabled");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "clear_button_enabled"), "set_clear_button_enabled", "is_clear_button_enabled");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "shortcut_keys_enabled"), "set_shortcut_keys_enabled", "is_shortcut_keys_enabled");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "selecting_enabled"), "set_selecting_enabled", "is_selecting_enabled");
|
|
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "right_icon", PROPERTY_HINT_RESOURCE_TYPE, "Texture"), "set_right_icon", "get_right_icon");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "text_direction", PROPERTY_HINT_ENUM, "Auto,LTR,RTL,Inherited"), "set_text_direction", "get_text_direction");
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "language"), "set_language", "get_language");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "draw_control_chars"), "set_draw_control_chars", "get_draw_control_chars");
|
|
ADD_GROUP("Structured Text", "structured_text_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "structured_text_bidi_override", PROPERTY_HINT_ENUM, "Default,URI,File,Email,List,None,Custom"), "set_structured_text_bidi_override", "get_structured_text_bidi_override");
|
|
ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "structured_text_bidi_override_options"), "set_structured_text_bidi_override_options", "get_structured_text_bidi_override_options");
|
|
ADD_GROUP("Placeholder", "placeholder_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::STRING, "placeholder_text"), "set_placeholder", "get_placeholder");
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "placeholder_alpha", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_placeholder_alpha", "get_placeholder_alpha");
|
|
ADD_GROUP("Caret", "caret_");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "caret_blink"), "set_caret_blink_enabled", "is_caret_blink_enabled");
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "caret_blink_speed", PROPERTY_HINT_RANGE, "0.1,10,0.01"), "set_caret_blink_speed", "get_caret_blink_speed");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "caret_column"), "set_caret_column", "get_caret_column");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "caret_force_displayed"), "set_caret_force_displayed", "is_caret_force_displayed");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "caret_mid_grapheme"), "set_caret_mid_grapheme_enabled", "is_caret_mid_grapheme_enabled");
|
|
}
|
|
|
|
LineEdit::LineEdit() {
|
|
text_rid = TS->create_shaped_text();
|
|
_create_undo_state();
|
|
|
|
deselect();
|
|
set_focus_mode(FOCUS_ALL);
|
|
set_default_cursor_shape(CURSOR_IBEAM);
|
|
set_mouse_filter(MOUSE_FILTER_STOP);
|
|
|
|
caret_blink_timer = memnew(Timer);
|
|
add_child(caret_blink_timer);
|
|
caret_blink_timer->set_wait_time(0.65);
|
|
caret_blink_timer->connect("timeout", callable_mp(this, &LineEdit::_toggle_draw_caret));
|
|
set_caret_blink_enabled(false);
|
|
|
|
menu = memnew(PopupMenu);
|
|
add_child(menu);
|
|
|
|
menu_dir = memnew(PopupMenu);
|
|
menu_dir->set_name("DirMenu");
|
|
menu_dir->add_radio_check_item(RTR("Same as layout direction"), MENU_DIR_INHERITED);
|
|
menu_dir->add_radio_check_item(RTR("Auto-detect direction"), MENU_DIR_AUTO);
|
|
menu_dir->add_radio_check_item(RTR("Left-to-right"), MENU_DIR_LTR);
|
|
menu_dir->add_radio_check_item(RTR("Right-to-left"), MENU_DIR_RTL);
|
|
menu_dir->set_item_checked(menu_dir->get_item_index(MENU_DIR_INHERITED), true);
|
|
menu->add_child(menu_dir);
|
|
|
|
menu_ctl = memnew(PopupMenu);
|
|
menu_ctl->set_name("CTLMenu");
|
|
menu_ctl->add_item(RTR("Left-to-right mark (LRM)"), MENU_INSERT_LRM);
|
|
menu_ctl->add_item(RTR("Right-to-left mark (RLM)"), MENU_INSERT_RLM);
|
|
menu_ctl->add_item(RTR("Start of left-to-right embedding (LRE)"), MENU_INSERT_LRE);
|
|
menu_ctl->add_item(RTR("Start of right-to-left embedding (RLE)"), MENU_INSERT_RLE);
|
|
menu_ctl->add_item(RTR("Start of left-to-right override (LRO)"), MENU_INSERT_LRO);
|
|
menu_ctl->add_item(RTR("Start of right-to-left override (RLO)"), MENU_INSERT_RLO);
|
|
menu_ctl->add_item(RTR("Pop direction formatting (PDF)"), MENU_INSERT_PDF);
|
|
menu_ctl->add_separator();
|
|
menu_ctl->add_item(RTR("Arabic letter mark (ALM)"), MENU_INSERT_ALM);
|
|
menu_ctl->add_item(RTR("Left-to-right isolate (LRI)"), MENU_INSERT_LRI);
|
|
menu_ctl->add_item(RTR("Right-to-left isolate (RLI)"), MENU_INSERT_RLI);
|
|
menu_ctl->add_item(RTR("First strong isolate (FSI)"), MENU_INSERT_FSI);
|
|
menu_ctl->add_item(RTR("Pop direction isolate (PDI)"), MENU_INSERT_PDI);
|
|
menu_ctl->add_separator();
|
|
menu_ctl->add_item(RTR("Zero width joiner (ZWJ)"), MENU_INSERT_ZWJ);
|
|
menu_ctl->add_item(RTR("Zero width non-joiner (ZWNJ)"), MENU_INSERT_ZWNJ);
|
|
menu_ctl->add_item(RTR("Word joiner (WJ)"), MENU_INSERT_WJ);
|
|
menu_ctl->add_item(RTR("Soft hyphen (SHY)"), MENU_INSERT_SHY);
|
|
menu->add_child(menu_ctl);
|
|
|
|
set_editable(true); // Initialise to opposite first, so we get past the early-out in set_editable.
|
|
menu->connect("id_pressed", callable_mp(this, &LineEdit::menu_option));
|
|
menu_dir->connect("id_pressed", callable_mp(this, &LineEdit::menu_option));
|
|
menu_ctl->connect("id_pressed", callable_mp(this, &LineEdit::menu_option));
|
|
}
|
|
|
|
LineEdit::~LineEdit() {
|
|
TS->free(text_rid);
|
|
}
|