godot/scene/gui/code_edit.cpp

/**************************************************************************/
/*  code_edit.cpp                                                         */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* Permission is hereby granted, free of charge, to any person obtaining  */
/* a copy of this software and associated documentation files (the        */
/* "Software"), to deal in the Software without restriction, including    */
/* without limitation the rights to use, copy, modify, merge, publish,    */
/* distribute, sublicense, and/or sell copies of the Software, and to     */
/* permit persons to whom the Software is furnished to do so, subject to  */
/* the following conditions:                                              */
/*                                                                        */
/* The above copyright notice and this permission notice shall be         */
/* included in all copies or substantial portions of the Software.        */
/*                                                                        */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,        */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF     */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY   */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,   */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE      */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                 */
/**************************************************************************/

#include "code_edit.h"
#include "code_edit.compat.inc"

#include "core/os/keyboard.h"
#include "core/string/string_builder.h"
#include "core/string/ustring.h"
#include "scene/theme/theme_db.h"

void CodeEdit::_notification(int p_what) { … }

void CodeEdit::gui_input(const Ref<InputEvent> &p_gui_input) { … }

/* General overrides */
Control::CursorShape CodeEdit::get_cursor_shape(const Point2 &p_pos) const { … }

void CodeEdit::_unhide_carets() { … }

/* Text manipulation */

// Overridable actions
void CodeEdit::_handle_unicode_input_internal(const uint32_t p_unicode, int p_caret) { … }

void CodeEdit::_backspace_internal(int p_caret) { … }

void CodeEdit::_cut_internal(int p_caret) { … }

/* Indent management */
void CodeEdit::set_indent_size(const int p_size) { … }

int CodeEdit::get_indent_size() const { … }

void CodeEdit::set_indent_using_spaces(const bool p_use_spaces) { … }

bool CodeEdit::is_indent_using_spaces() const { … }

void CodeEdit::set_auto_indent_enabled(bool p_enabled) { … }

bool CodeEdit::is_auto_indent_enabled() const { … }

void CodeEdit::set_auto_indent_prefixes(const TypedArray<String> &p_prefixes) { … }

TypedArray<String> CodeEdit::get_auto_indent_prefixes() const { … }

void CodeEdit::do_indent() { … }

void CodeEdit::indent_lines() { … }

void CodeEdit::unindent_lines() { … }

void CodeEdit::convert_indent(int p_from_line, int p_to_line) { … }

int CodeEdit::_calculate_spaces_till_next_left_indent(int p_column) const { … }

int CodeEdit::_calculate_spaces_till_next_right_indent(int p_column) const { … }

void CodeEdit::_new_line(bool p_split_current_line, bool p_above) { … }

/* Auto brace completion */
void CodeEdit::set_auto_brace_completion_enabled(bool p_enabled) { … }

bool CodeEdit::is_auto_brace_completion_enabled() const { … }

void CodeEdit::set_highlight_matching_braces_enabled(bool p_enabled) { … }

bool CodeEdit::is_highlight_matching_braces_enabled() const { … }

void CodeEdit::add_auto_brace_completion_pair(const String &p_open_key, const String &p_close_key) { … }

void CodeEdit::set_auto_brace_completion_pairs(const Dictionary &p_auto_brace_completion_pairs) { … }

Dictionary CodeEdit::get_auto_brace_completion_pairs() const { … }

bool CodeEdit::has_auto_brace_completion_open_key(const String &p_open_key) const { … }

bool CodeEdit::has_auto_brace_completion_close_key(const String &p_close_key) const { … }

String CodeEdit::get_auto_brace_completion_close_key(const String &p_open_key) const { … }

/* Main Gutter */
void CodeEdit::_update_draw_main_gutter() { … }

void CodeEdit::set_draw_breakpoints_gutter(bool p_draw) { … }

bool CodeEdit::is_drawing_breakpoints_gutter() const { … }

void CodeEdit::set_draw_bookmarks_gutter(bool p_draw) { … }

bool CodeEdit::is_drawing_bookmarks_gutter() const { … }

void CodeEdit::set_draw_executing_lines_gutter(bool p_draw) { … }

bool CodeEdit::is_drawing_executing_lines_gutter() const { … }

void CodeEdit::_main_gutter_draw_callback(int p_line, int p_gutter, const Rect2 &p_region) { … }

// Breakpoints
void CodeEdit::set_line_as_breakpoint(int p_line, bool p_breakpointed) { … }

bool CodeEdit::is_line_breakpointed(int p_line) const { … }

void CodeEdit::clear_breakpointed_lines() { … }

PackedInt32Array CodeEdit::get_breakpointed_lines() const { … }

// Bookmarks
void CodeEdit::set_line_as_bookmarked(int p_line, bool p_bookmarked) { … }

bool CodeEdit::is_line_bookmarked(int p_line) const { … }

void CodeEdit::clear_bookmarked_lines() { … }

PackedInt32Array CodeEdit::get_bookmarked_lines() const { … }

// Executing lines
void CodeEdit::set_line_as_executing(int p_line, bool p_executing) { … }

bool CodeEdit::is_line_executing(int p_line) const { … }

void CodeEdit::clear_executing_lines() { … }

PackedInt32Array CodeEdit::get_executing_lines() const { … }

/* Line numbers */
void CodeEdit::set_draw_line_numbers(bool p_draw) { … }

bool CodeEdit::is_draw_line_numbers_enabled() const { … }

void CodeEdit::set_line_numbers_zero_padded(bool p_zero_padded) { … }

bool CodeEdit::is_line_numbers_zero_padded() const { … }

void CodeEdit::_line_number_draw_callback(int p_line, int p_gutter, const Rect2 &p_region) { … }

void CodeEdit::_clear_line_number_text_cache() { … }

void CodeEdit::_update_line_number_gutter_width() { … }

/* Fold Gutter */
void CodeEdit::set_draw_fold_gutter(bool p_draw) { … }

bool CodeEdit::is_drawing_fold_gutter() const { … }

void CodeEdit::_fold_gutter_draw_callback(int p_line, int p_gutter, Rect2 p_region) { … }

/* Line Folding */
void CodeEdit::set_line_folding_enabled(bool p_enabled) { … }

bool CodeEdit::is_line_folding_enabled() const { … }

bool CodeEdit::can_fold_line(int p_line) const { … }

void CodeEdit::fold_line(int p_line) { … }

void CodeEdit::unfold_line(int p_line) { … }

void CodeEdit::fold_all_lines() { … }

void CodeEdit::unfold_all_lines() { … }

void CodeEdit::toggle_foldable_line(int p_line) { … }

void CodeEdit::toggle_foldable_lines_at_carets() { … }

bool CodeEdit::is_line_folded(int p_line) const { … }

TypedArray<int> CodeEdit::get_folded_lines() const { … }

/* Code region */
void CodeEdit::create_code_region() { … }

String CodeEdit::get_code_region_start_tag() const { … }

String CodeEdit::get_code_region_end_tag() const { … }

void CodeEdit::set_code_region_tags(const String &p_start, const String &p_end) { … }

bool CodeEdit::is_line_code_region_start(int p_line) const { … }

bool CodeEdit::is_line_code_region_end(int p_line) const { … }

/* Delimiters */
// Strings
void CodeEdit::add_string_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only) { … }

void CodeEdit::remove_string_delimiter(const String &p_start_key) { … }

bool CodeEdit::has_string_delimiter(const String &p_start_key) const { … }

void CodeEdit::set_string_delimiters(const TypedArray<String> &p_string_delimiters) { … }

void CodeEdit::clear_string_delimiters() { … }

TypedArray<String> CodeEdit::get_string_delimiters() const { … }

int CodeEdit::is_in_string(int p_line, int p_column) const { … }

// Comments
void CodeEdit::add_comment_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only) { … }

void CodeEdit::remove_comment_delimiter(const String &p_start_key) { … }

bool CodeEdit::has_comment_delimiter(const String &p_start_key) const { … }

void CodeEdit::set_comment_delimiters(const TypedArray<String> &p_comment_delimiters) { … }

void CodeEdit::clear_comment_delimiters() { … }

TypedArray<String> CodeEdit::get_comment_delimiters() const { … }

int CodeEdit::is_in_comment(int p_line, int p_column) const { … }

String CodeEdit::get_delimiter_start_key(int p_delimiter_idx) const { … }

String CodeEdit::get_delimiter_end_key(int p_delimiter_idx) const { … }

Point2 CodeEdit::get_delimiter_start_position(int p_line, int p_column) const { … }

Point2 CodeEdit::get_delimiter_end_position(int p_line, int p_column) const { … }

/* Code hint */
void CodeEdit::set_code_hint(const String &p_hint) { … }

void CodeEdit::set_code_hint_draw_below(bool p_below) { … }

/* Code Completion */
void CodeEdit::set_code_completion_enabled(bool p_enable) { … }

bool CodeEdit::is_code_completion_enabled() const { … }

void CodeEdit::set_code_completion_prefixes(const TypedArray<String> &p_prefixes) { … }

TypedArray<String> CodeEdit::get_code_completion_prefixes() const { … }

String CodeEdit::get_text_for_code_completion() const { … }

void CodeEdit::request_code_completion(bool p_force) { … }

void CodeEdit::add_code_completion_option(CodeCompletionKind p_type, const String &p_display_text, const String &p_insert_text, const Color &p_text_color, const Ref<Resource> &p_icon, const Variant &p_value, int p_location) { … }

void CodeEdit::update_code_completion_options(bool p_forced) { … }

TypedArray<Dictionary> CodeEdit::get_code_completion_options() const { … }

Dictionary CodeEdit::get_code_completion_option(int p_index) const { … }

int CodeEdit::get_code_completion_selected_index() const { … }

void CodeEdit::set_code_completion_selected_index(int p_index) { … }

void CodeEdit::confirm_code_completion(bool p_replace) { … }

void CodeEdit::cancel_code_completion() { … }

/* Line length guidelines */
void CodeEdit::set_line_length_guidelines(TypedArray<int> p_guideline_columns) { … }

TypedArray<int> CodeEdit::get_line_length_guidelines() const { … }

/* Symbol lookup */
void CodeEdit::set_symbol_lookup_on_click_enabled(bool p_enabled) { … }

bool CodeEdit::is_symbol_lookup_on_click_enabled() const { … }

String CodeEdit::get_text_for_symbol_lookup() const { … }

String CodeEdit::get_text_with_cursor_char(int p_line, int p_column) const { … }

void CodeEdit::set_symbol_lookup_word_as_valid(bool p_valid) { … }

/* Text manipulation */
void CodeEdit::move_lines_up() { … }

void CodeEdit::move_lines_down() { … }

void CodeEdit::delete_lines() { … }

void CodeEdit::duplicate_selection() { … }

void CodeEdit::duplicate_lines() { … }

/* Visual */
Color CodeEdit::_get_brace_mismatch_color() const { … }

Color CodeEdit::_get_code_folding_color() const { … }

Ref<Texture2D> CodeEdit::_get_folded_eol_icon() const { … }

void CodeEdit::_bind_methods() { … }

/* Auto brace completion */
int CodeEdit::_get_auto_brace_pair_open_at_pos(int p_line, int p_col) { … }

int CodeEdit::_get_auto_brace_pair_close_at_pos(int p_line, int p_col) { … }

/* Gutters */
void CodeEdit::_gutter_clicked(int p_line, int p_gutter) { … }

void CodeEdit::_update_gutter_indexes() { … }

/* Code Region */
void CodeEdit::_update_code_region_tags() { … }

/* Delimiters */
void CodeEdit::_update_delimiter_cache(int p_from_line, int p_to_line) { … }

int CodeEdit::_is_in_delimiter(int p_line, int p_column, DelimiterType p_type) const { … }

void CodeEdit::_add_delimiter(const String &p_start_key, const String &p_end_key, bool p_line_only, DelimiterType p_type) { … }

void CodeEdit::_remove_delimiter(const String &p_start_key, DelimiterType p_type) { … }

bool CodeEdit::_has_delimiter(const String &p_start_key, DelimiterType p_type) const { … }

void CodeEdit::_set_delimiters(const TypedArray<String> &p_delimiters, DelimiterType p_type) { … }

void CodeEdit::_clear_delimiters(DelimiterType p_type) { … }

TypedArray<String> CodeEdit::_get_delimiters(DelimiterType p_type) const { … }

/* Code Completion */
void CodeEdit::_update_scroll_selected_line(float p_mouse_y) { … }

void CodeEdit::_filter_code_completion_candidates_impl() { … }

// Assumes both the new_options and the code_completion_options are sorted.
bool CodeEdit::_should_reset_selected_option_for_new_options(const Vector<ScriptLanguage::CodeCompletionOption> &p_new_options) { … }

void CodeEdit::_lines_edited_from(int p_from_line, int p_to_line) { … }

void CodeEdit::_text_set() { … }

void CodeEdit::_text_changed() { … }

CodeEdit::CodeEdit() { … }

CodeEdit::~CodeEdit() { … }

// Return true if l should come before r
bool CodeCompletionOptionCompare::operator()(const ScriptLanguage::CodeCompletionOption &l, const ScriptLanguage::CodeCompletionOption &r) const { … }