4674 lines
111 KiB
C++
4674 lines
111 KiB
C++
/*************************************************************************/
|
|
/* text_edit.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* http://www.godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2016 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 "text_edit.h"
|
|
#include "os/keyboard.h"
|
|
#include "os/input.h"
|
|
#include "os/os.h"
|
|
|
|
#include "globals.h"
|
|
#include "message_queue.h"
|
|
|
|
#define TAB_PIXELS
|
|
|
|
static bool _is_text_char(CharType c) {
|
|
|
|
return (c>='a' && c<='z') || (c>='A' && c<='Z') || (c>='0' && c<='9') || c=='_';
|
|
}
|
|
|
|
static bool _is_symbol(CharType c) {
|
|
|
|
return c!='_' && ((c>='!' && c<='/') || (c>=':' && c<='@') || (c>='[' && c<='`') || (c>='{' && c<='~') || c=='\t' || c==' ');
|
|
}
|
|
|
|
static bool _is_char(CharType c) {
|
|
|
|
return (c>='a' && c<='z') || (c>='A' && c<='Z') || c=='_';
|
|
}
|
|
|
|
static bool _is_number(CharType c) {
|
|
return (c >= '0' && c <= '9');
|
|
}
|
|
|
|
static bool _is_hex_symbol(CharType c) {
|
|
return ((c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F'));
|
|
}
|
|
|
|
static bool _is_pair_right_symbol(CharType c) {
|
|
return
|
|
c == '"' ||
|
|
c == '\'' ||
|
|
c == ')' ||
|
|
c == ']' ||
|
|
c == '}';
|
|
}
|
|
|
|
static bool _is_pair_left_symbol(CharType c) {
|
|
return
|
|
c == '"' ||
|
|
c == '\'' ||
|
|
c == '(' ||
|
|
c == '[' ||
|
|
c == '{';
|
|
}
|
|
|
|
static bool _is_pair_symbol(CharType c) {
|
|
return _is_pair_left_symbol(c) || _is_pair_right_symbol(c);
|
|
}
|
|
|
|
static CharType _get_right_pair_symbol(CharType c) {
|
|
if(c == '"')
|
|
return '"';
|
|
if(c == '\'')
|
|
return '\'';
|
|
if(c == '(')
|
|
return ')';
|
|
if(c == '[')
|
|
return ']';
|
|
if(c == '{')
|
|
return '}';
|
|
return 0;
|
|
}
|
|
|
|
void TextEdit::Text::set_font(const Ref<Font>& p_font) {
|
|
|
|
font=p_font;
|
|
}
|
|
|
|
void TextEdit::Text::set_tab_size(int p_tab_size) {
|
|
|
|
tab_size=p_tab_size;
|
|
}
|
|
|
|
void TextEdit::Text::_update_line_cache(int p_line) const {
|
|
|
|
int w = 0;
|
|
int tab_w=font->get_char_size(' ').width*tab_size;
|
|
|
|
int len = text[p_line].data.length();
|
|
const CharType *str = text[p_line].data.c_str();
|
|
|
|
//update width
|
|
|
|
for(int i=0;i<len;i++) {
|
|
if (str[i]=='\t') {
|
|
|
|
int left = w%tab_w;
|
|
if (left==0)
|
|
w+=tab_w;
|
|
else
|
|
w+=tab_w-w%tab_w; // is right...
|
|
|
|
} else {
|
|
|
|
w+=font->get_char_size(str[i],str[i+1]).width;
|
|
}
|
|
}
|
|
|
|
|
|
text[p_line].width_cache=w;
|
|
|
|
//update regions
|
|
|
|
text[p_line].region_info.clear();
|
|
|
|
for(int i=0;i<len;i++) {
|
|
|
|
if (!_is_symbol(str[i]))
|
|
continue;
|
|
if (str[i]=='\\') {
|
|
i++; //skip quoted anything
|
|
continue;
|
|
}
|
|
|
|
int left=len-i;
|
|
|
|
for(int j=0;j<color_regions->size();j++) {
|
|
|
|
const ColorRegion& cr=color_regions->operator [](j);
|
|
|
|
/* BEGIN */
|
|
|
|
int lr=cr.begin_key.length();
|
|
if (lr==0 || lr>left)
|
|
continue;
|
|
|
|
const CharType* kc = cr.begin_key.c_str();
|
|
|
|
bool match=true;
|
|
|
|
for(int k=0;k<lr;k++) {
|
|
if (kc[k]!=str[i+k]) {
|
|
match=false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (match) {
|
|
|
|
ColorRegionInfo cri;
|
|
cri.end=false;
|
|
cri.region=j;
|
|
text[p_line].region_info[i]=cri;
|
|
i+=lr-1;
|
|
break;
|
|
}
|
|
|
|
/* END */
|
|
|
|
lr=cr.end_key.length();
|
|
if (lr==0 || lr>left)
|
|
continue;
|
|
|
|
kc = cr.end_key.c_str();
|
|
|
|
match=true;
|
|
|
|
for(int k=0;k<lr;k++) {
|
|
if (kc[k]!=str[i+k]) {
|
|
match=false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (match) {
|
|
|
|
ColorRegionInfo cri;
|
|
cri.end=true;
|
|
cri.region=j;
|
|
text[p_line].region_info[i]=cri;
|
|
i+=lr-1;
|
|
break;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
const Map<int,TextEdit::Text::ColorRegionInfo>& TextEdit::Text::get_color_region_info(int p_line) {
|
|
|
|
Map<int,ColorRegionInfo> *cri=NULL;
|
|
ERR_FAIL_INDEX_V(p_line,text.size(),*cri); //enjoy your crash
|
|
|
|
if (text[p_line].width_cache==-1) {
|
|
_update_line_cache(p_line);
|
|
}
|
|
|
|
return text[p_line].region_info;
|
|
}
|
|
|
|
int TextEdit::Text::get_line_width(int p_line) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_line,text.size(),-1);
|
|
|
|
if (text[p_line].width_cache==-1) {
|
|
_update_line_cache(p_line);
|
|
}
|
|
|
|
return text[p_line].width_cache;
|
|
}
|
|
|
|
void TextEdit::Text::clear_caches() {
|
|
|
|
for(int i=0;i<text.size();i++)
|
|
text[i].width_cache=-1;
|
|
|
|
}
|
|
|
|
void TextEdit::Text::clear() {
|
|
|
|
|
|
text.clear();;
|
|
insert(0,"");
|
|
}
|
|
|
|
int TextEdit::Text::get_max_width() const {
|
|
//quite some work.. but should be fast enough.
|
|
|
|
int max = 0;
|
|
|
|
for(int i=0;i<text.size();i++)
|
|
max=MAX(max,get_line_width(i));
|
|
return max;
|
|
|
|
}
|
|
|
|
void TextEdit::Text::set(int p_line,const String& p_text) {
|
|
|
|
ERR_FAIL_INDEX(p_line,text.size());
|
|
|
|
text[p_line].width_cache=-1;
|
|
text[p_line].data=p_text;
|
|
}
|
|
|
|
|
|
void TextEdit::Text::insert(int p_at,const String& p_text) {
|
|
|
|
Line line;
|
|
line.marked=false;
|
|
line.breakpoint=false;
|
|
line.width_cache=-1;
|
|
line.data=p_text;
|
|
text.insert(p_at,line);
|
|
}
|
|
void TextEdit::Text::remove(int p_at) {
|
|
|
|
text.remove(p_at);
|
|
}
|
|
|
|
void TextEdit::_update_scrollbars() {
|
|
|
|
|
|
Size2 size = get_size();
|
|
Size2 hmin = h_scroll->get_combined_minimum_size();
|
|
Size2 vmin = v_scroll->get_combined_minimum_size();
|
|
|
|
|
|
|
|
v_scroll->set_begin( Point2(size.width - vmin.width, cache.style_normal->get_margin(MARGIN_TOP)) );
|
|
v_scroll->set_end( Point2(size.width, size.height - cache.style_normal->get_margin(MARGIN_TOP) - cache.style_normal->get_margin(MARGIN_BOTTOM)) );
|
|
|
|
h_scroll->set_begin( Point2( 0, size.height - hmin.height) );
|
|
h_scroll->set_end( Point2(size.width-vmin.width, size.height) );
|
|
|
|
|
|
int hscroll_rows = ((hmin.height-1)/get_row_height())+1;
|
|
int visible_rows = get_visible_rows();
|
|
int total_rows = text.size();
|
|
if (scroll_past_end_of_file_enabled) {
|
|
total_rows += get_visible_rows() - 1;
|
|
}
|
|
|
|
int vscroll_pixels = v_scroll->get_combined_minimum_size().width;
|
|
int visible_width = size.width - cache.style_normal->get_minimum_size().width;
|
|
int total_width = text.get_max_width() + vmin.x;
|
|
|
|
if (line_numbers)
|
|
total_width += cache.line_number_w;
|
|
|
|
if (draw_breakpoint_gutter) {
|
|
total_width += cache.breakpoint_gutter_width;
|
|
}
|
|
|
|
bool use_hscroll=true;
|
|
bool use_vscroll=true;
|
|
|
|
if (total_rows <= visible_rows && total_width <= visible_width) {
|
|
//thanks yessopie for this clever bit of logic
|
|
use_hscroll=false;
|
|
use_vscroll=false;
|
|
|
|
} else {
|
|
|
|
if (total_rows > visible_rows && total_width <= visible_width - vscroll_pixels) {
|
|
//thanks yessopie for this clever bit of logic
|
|
use_hscroll=false;
|
|
}
|
|
|
|
if (total_rows <= visible_rows - hscroll_rows && total_width > visible_width) {
|
|
//thanks yessopie for this clever bit of logic
|
|
use_vscroll=false;
|
|
}
|
|
}
|
|
|
|
updating_scrolls=true;
|
|
|
|
if (use_vscroll) {
|
|
|
|
v_scroll->show();
|
|
v_scroll->set_max(total_rows);
|
|
v_scroll->set_page(visible_rows);
|
|
v_scroll->set_val(cursor.line_ofs);
|
|
|
|
} else {
|
|
cursor.line_ofs = 0;
|
|
v_scroll->hide();
|
|
}
|
|
|
|
if (use_hscroll) {
|
|
|
|
h_scroll->show();
|
|
h_scroll->set_max(total_width);
|
|
h_scroll->set_page(visible_width);
|
|
h_scroll->set_val(cursor.x_ofs);
|
|
|
|
} else {
|
|
|
|
h_scroll->hide();
|
|
}
|
|
|
|
|
|
|
|
updating_scrolls=false;
|
|
}
|
|
|
|
void TextEdit::_click_selection_held() {
|
|
|
|
if (Input::get_singleton()->is_mouse_button_pressed(BUTTON_LEFT) && selection.selecting_mode!=Selection::MODE_NONE) {
|
|
|
|
Point2 mp = Input::get_singleton()->get_mouse_pos()-get_global_pos();
|
|
|
|
int row,col;
|
|
_get_mouse_pos(Point2i(mp.x,mp.y), row,col);
|
|
|
|
select(selection.selecting_line,selection.selecting_column,row,col);
|
|
|
|
cursor_set_line( row );
|
|
cursor_set_column( col );
|
|
update();
|
|
|
|
click_select_held->start();
|
|
|
|
} else {
|
|
|
|
click_select_held->stop();
|
|
}
|
|
}
|
|
|
|
|
|
void TextEdit::_notification(int p_what) {
|
|
|
|
switch(p_what) {
|
|
case NOTIFICATION_ENTER_TREE: {
|
|
|
|
_update_caches();
|
|
if (cursor_changed_dirty)
|
|
MessageQueue::get_singleton()->push_call(this,"_cursor_changed_emit");
|
|
if (text_changed_dirty)
|
|
MessageQueue::get_singleton()->push_call(this,"_text_changed_emit");
|
|
|
|
} break;
|
|
case NOTIFICATION_RESIZED: {
|
|
|
|
cache.size=get_size();
|
|
adjust_viewport_to_cursor();
|
|
|
|
|
|
} break;
|
|
case NOTIFICATION_THEME_CHANGED: {
|
|
|
|
_update_caches();
|
|
} break;
|
|
case MainLoop::NOTIFICATION_WM_FOCUS_IN: {
|
|
window_has_focus = true;
|
|
draw_caret = true;
|
|
update();
|
|
} break;
|
|
case MainLoop::NOTIFICATION_WM_FOCUS_OUT: {
|
|
window_has_focus = false;
|
|
draw_caret = false;
|
|
update();
|
|
} break;
|
|
case NOTIFICATION_DRAW: {
|
|
|
|
if ((!has_focus() && !menu->has_focus()) || !window_has_focus) {
|
|
draw_caret = false;
|
|
}
|
|
|
|
if (draw_breakpoint_gutter) {
|
|
breakpoint_gutter_width = (get_row_height() * 55) / 100;
|
|
cache.breakpoint_gutter_width = breakpoint_gutter_width;
|
|
} else {
|
|
cache.breakpoint_gutter_width = 0;
|
|
}
|
|
|
|
int line_number_char_count=0;
|
|
|
|
{
|
|
int lc=text.size()+1;
|
|
cache.line_number_w=0;
|
|
while(lc) {
|
|
cache.line_number_w+=1;
|
|
lc/=10;
|
|
};
|
|
|
|
if (line_numbers) {
|
|
|
|
line_number_char_count=cache.line_number_w;
|
|
cache.line_number_w=(cache.line_number_w+1)*cache.font->get_char_size('0').width;
|
|
} else {
|
|
cache.line_number_w=0;
|
|
}
|
|
|
|
|
|
}
|
|
_update_scrollbars();
|
|
|
|
|
|
RID ci = get_canvas_item();
|
|
int xmargin_beg=cache.style_normal->get_margin(MARGIN_LEFT)+cache.line_number_w+cache.breakpoint_gutter_width;
|
|
int xmargin_end=cache.size.width-cache.style_normal->get_margin(MARGIN_RIGHT);
|
|
//let's do it easy for now:
|
|
cache.style_normal->draw(ci,Rect2(Point2(),cache.size));
|
|
if (has_focus())
|
|
cache.style_focus->draw(ci,Rect2(Point2(),cache.size));
|
|
|
|
|
|
int ascent=cache.font->get_ascent();
|
|
|
|
int visible_rows = get_visible_rows();
|
|
|
|
int tab_w = cache.font->get_char_size(' ').width*tab_size;
|
|
|
|
Color color = cache.font_color;
|
|
int in_region=-1;
|
|
|
|
if (syntax_coloring) {
|
|
|
|
if (custom_bg_color.a>0.01) {
|
|
|
|
Point2i ofs = Point2i(cache.style_normal->get_offset())/2.0;
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(ofs, get_size()-cache.style_normal->get_minimum_size()+ofs),custom_bg_color);
|
|
}
|
|
//compute actual region to start (may be inside say, a comment).
|
|
//slow in very large documments :( but ok for source!
|
|
|
|
for(int i=0;i<cursor.line_ofs;i++) {
|
|
|
|
const Map<int,Text::ColorRegionInfo>& cri_map=text.get_color_region_info(i);
|
|
|
|
if (in_region>=0 && color_regions[in_region].line_only) {
|
|
in_region=-1; //reset regions that end at end of line
|
|
}
|
|
|
|
for( const Map<int,Text::ColorRegionInfo>::Element* E= cri_map.front();E;E=E->next() ) {
|
|
|
|
const Text::ColorRegionInfo &cri=E->get();
|
|
|
|
if (in_region==-1) {
|
|
|
|
if (!cri.end) {
|
|
|
|
in_region=cri.region;
|
|
}
|
|
} else if (in_region==cri.region && !color_regions[cri.region].line_only) { //ignore otherwise
|
|
|
|
if (cri.end || color_regions[cri.region].eq) {
|
|
|
|
in_region=-1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
int brace_open_match_line=-1;
|
|
int brace_open_match_column=-1;
|
|
bool brace_open_matching=false;
|
|
bool brace_open_mismatch=false;
|
|
int brace_close_match_line=-1;
|
|
int brace_close_match_column=-1;
|
|
bool brace_close_matching=false;
|
|
bool brace_close_mismatch=false;
|
|
|
|
|
|
if (brace_matching_enabled) {
|
|
|
|
if (cursor.column<text[cursor.line].length()) {
|
|
//check for open
|
|
CharType c = text[cursor.line][cursor.column];
|
|
CharType closec=0;
|
|
|
|
if (c=='[') {
|
|
closec=']';
|
|
} else if (c=='{') {
|
|
closec='}';
|
|
} else if (c=='(') {
|
|
closec=')';
|
|
}
|
|
|
|
if (closec!=0) {
|
|
|
|
int stack=1;
|
|
|
|
|
|
for(int i=cursor.line;i<text.size();i++) {
|
|
|
|
int from = i==cursor.line?cursor.column+1:0;
|
|
for(int j=from;j<text[i].length();j++) {
|
|
|
|
CharType cc = text[i][j];
|
|
//ignore any brackets inside a string
|
|
if (cc== '"' || cc == '\'') {
|
|
CharType quotation = cc;
|
|
do {
|
|
j++;
|
|
if (!(j<text[i].length())) {
|
|
break;
|
|
}
|
|
cc=text[i][j];
|
|
//skip over escaped quotation marks inside strings
|
|
if (cc=='\\') {
|
|
bool escaped = true;
|
|
while (j+1<text[i].length() && text[i][j+1]=='\\') {
|
|
escaped=!escaped;
|
|
j++;
|
|
}
|
|
if (escaped) {
|
|
j++;
|
|
continue;
|
|
}
|
|
}
|
|
} while (cc!= quotation);
|
|
} else if (cc==c)
|
|
stack++;
|
|
else if (cc==closec)
|
|
stack--;
|
|
|
|
if (stack==0) {
|
|
brace_open_match_line=i;
|
|
brace_open_match_column=j;
|
|
brace_open_matching=true;
|
|
|
|
break;
|
|
}
|
|
}
|
|
if (brace_open_match_line!=-1)
|
|
break;
|
|
}
|
|
|
|
if (!brace_open_matching)
|
|
brace_open_mismatch=true;
|
|
|
|
|
|
}
|
|
}
|
|
|
|
if (cursor.column>0) {
|
|
CharType c = text[cursor.line][cursor.column-1];
|
|
CharType closec=0;
|
|
|
|
|
|
|
|
if (c==']') {
|
|
closec='[';
|
|
} else if (c=='}') {
|
|
closec='{';
|
|
} else if (c==')') {
|
|
closec='(';
|
|
}
|
|
|
|
if (closec!=0) {
|
|
|
|
int stack=1;
|
|
|
|
|
|
for(int i=cursor.line;i>=0;i--) {
|
|
|
|
int from = i==cursor.line?cursor.column-2:text[i].length()-1;
|
|
for(int j=from;j>=0;j--) {
|
|
|
|
CharType cc = text[i][j];
|
|
//ignore any brackets inside a string
|
|
if (cc== '"' || cc == '\'') {
|
|
CharType quotation = cc;
|
|
do {
|
|
j--;
|
|
if (!(j>=0)) {
|
|
break;
|
|
}
|
|
cc=text[i][j];
|
|
//skip over escaped quotation marks inside strings
|
|
if (cc==quotation) {
|
|
bool escaped = false;
|
|
while (j-1>=0 && text[i][j-1]=='\\') {
|
|
escaped=!escaped;
|
|
j--;
|
|
}
|
|
if (escaped) {
|
|
j--;
|
|
cc='\\';
|
|
continue;
|
|
}
|
|
}
|
|
} while (cc!= quotation);
|
|
} else if (cc==c)
|
|
stack++;
|
|
else if (cc==closec)
|
|
stack--;
|
|
|
|
if (stack==0) {
|
|
brace_close_match_line=i;
|
|
brace_close_match_column=j;
|
|
brace_close_matching=true;
|
|
|
|
break;
|
|
}
|
|
}
|
|
if (brace_close_match_line!=-1)
|
|
break;
|
|
}
|
|
|
|
if (!brace_close_matching)
|
|
brace_close_mismatch=true;
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|
|
|
|
|
|
int deregion=0; //force it to clear inrgion
|
|
Point2 cursor_pos;
|
|
|
|
// get the highlighted words
|
|
String highlighted_text = get_selection_text();
|
|
|
|
for (int i=0;i<visible_rows;i++) {
|
|
|
|
int line=i+cursor.line_ofs;
|
|
|
|
if (line<0 || line>=(int)text.size())
|
|
continue;
|
|
|
|
const String &str=text[line];
|
|
|
|
int char_margin=xmargin_beg-cursor.x_ofs;
|
|
int char_ofs=0;
|
|
int ofs_y=i*get_row_height()+cache.line_spacing/2;
|
|
bool prev_is_char=false;
|
|
bool prev_is_number = false;
|
|
bool in_keyword=false;
|
|
bool in_word = false;
|
|
bool in_function_name = false;
|
|
bool in_member_variable = false;
|
|
bool is_hex_notation = false;
|
|
Color keyword_color;
|
|
|
|
// check if line contains highlighted word
|
|
int highlighted_text_col = -1;
|
|
int search_text_col = -1;
|
|
|
|
if (!search_text.empty())
|
|
search_text_col = _get_column_pos_of_word(search_text, str, search_flags, 0);
|
|
|
|
if (highlighted_text.length() != 0 && highlighted_text != search_text)
|
|
highlighted_text_col = _get_column_pos_of_word(highlighted_text, str, SEARCH_MATCH_CASE|SEARCH_WHOLE_WORDS, 0);
|
|
|
|
const Map<int,Text::ColorRegionInfo>& cri_map=text.get_color_region_info(line);
|
|
|
|
|
|
if (text.is_marked(line)) {
|
|
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(xmargin_beg, ofs_y,xmargin_end-xmargin_beg,get_row_height()),cache.mark_color);
|
|
}
|
|
|
|
if (text.is_breakpoint(line)) {
|
|
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(xmargin_beg, ofs_y,xmargin_end-xmargin_beg,get_row_height()),cache.breakpoint_color);
|
|
}
|
|
|
|
if (line==cursor.line) {
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(0, ofs_y,xmargin_end,get_row_height()),cache.current_line_color);
|
|
}
|
|
|
|
// draw breakpoint marker
|
|
if (text.is_breakpoint(line)) {
|
|
if (draw_breakpoint_gutter) {
|
|
int vertical_gap = (get_row_height() * 40) / 100;
|
|
int horizontal_gap = (cache.breakpoint_gutter_width * 30) / 100;
|
|
int marker_height = get_row_height() - (vertical_gap * 2);
|
|
int marker_width = cache.breakpoint_gutter_width - (horizontal_gap * 2);
|
|
// no transparency on marker
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(cache.style_normal->get_margin(MARGIN_LEFT) + horizontal_gap - 2, ofs_y + vertical_gap ,marker_width, marker_height),Color(cache.breakpoint_color.r, cache.breakpoint_color.g, cache.breakpoint_color.b));
|
|
}
|
|
}
|
|
|
|
|
|
if (cache.line_number_w) {
|
|
String fc = String::num(line+1);
|
|
while (fc.length() < line_number_char_count) {
|
|
fc="0"+fc;
|
|
}
|
|
|
|
cache.font->draw(ci,Point2(cache.style_normal->get_margin(MARGIN_LEFT)+cache.breakpoint_gutter_width,ofs_y+cache.font->get_ascent()),fc,cache.line_number_color);
|
|
}
|
|
for (int j=0;j<str.length();j++) {
|
|
|
|
//look for keyword
|
|
|
|
if (deregion>0) {
|
|
deregion--;
|
|
if (deregion==0)
|
|
in_region=-1;
|
|
}
|
|
if (syntax_coloring && deregion==0) {
|
|
|
|
|
|
color = cache.font_color; //reset
|
|
//find keyword
|
|
bool is_char = _is_text_char(str[j]);
|
|
bool is_symbol = _is_symbol(str[j]);
|
|
bool is_number = _is_number(str[j]);
|
|
|
|
if (j==0 && in_region>=0 && color_regions[in_region].line_only) {
|
|
in_region=-1; //reset regions that end at end of line
|
|
}
|
|
|
|
// allow ABCDEF in hex notation
|
|
if (is_hex_notation && (_is_hex_symbol(str[j]) || is_number)) {
|
|
is_number = true;
|
|
} else {
|
|
is_hex_notation = false;
|
|
}
|
|
|
|
// check for dot or 'x' for hex notation in floating point number
|
|
if ((str[j] == '.' || str[j] == 'x') && !in_word && prev_is_number && !is_number) {
|
|
is_number = true;
|
|
is_symbol = false;
|
|
|
|
if (str[j] == 'x' && str[j-1] == '0') {
|
|
is_hex_notation = true;
|
|
}
|
|
}
|
|
|
|
if (!in_word && _is_char(str[j])) {
|
|
in_word = true;
|
|
}
|
|
|
|
if ((in_keyword || in_word) && !is_hex_notation) {
|
|
is_number = false;
|
|
}
|
|
|
|
if (is_symbol && str[j] != '.' && in_word) {
|
|
in_word = false;
|
|
}
|
|
|
|
if (is_symbol && cri_map.has(j)) {
|
|
|
|
|
|
const Text::ColorRegionInfo &cri=cri_map[j];
|
|
|
|
if (in_region==-1) {
|
|
|
|
if (!cri.end) {
|
|
|
|
in_region=cri.region;
|
|
}
|
|
} else if (in_region==cri.region && !color_regions[cri.region].line_only) { //ignore otherwise
|
|
|
|
if (cri.end || color_regions[cri.region].eq) {
|
|
|
|
deregion=color_regions[cri.region].eq?color_regions[cri.region].begin_key.length():color_regions[cri.region].end_key.length();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!is_char)
|
|
in_keyword=false;
|
|
|
|
if (in_region==-1 && !in_keyword && is_char && !prev_is_char) {
|
|
|
|
int to=j;
|
|
while(to<str.length() && _is_text_char(str[to]))
|
|
to++;
|
|
|
|
uint32_t hash = String::hash(&str[j],to-j);
|
|
StrRange range(&str[j],to-j);
|
|
|
|
const Color *col=keywords.custom_getptr(range,hash);
|
|
|
|
if (col) {
|
|
|
|
in_keyword=true;
|
|
keyword_color=*col;
|
|
}
|
|
}
|
|
|
|
if (!in_function_name && in_word && !in_keyword) {
|
|
|
|
int k = j;
|
|
while(k < str.length() && !_is_symbol(str[k]) && str[k] != '\t' && str[k] != ' ') {
|
|
k++;
|
|
}
|
|
|
|
// check for space between name and bracket
|
|
while (k < str.length() && (str[k] == '\t' || str[k] == ' ')) {
|
|
k++;
|
|
}
|
|
|
|
if (str[k] == '(') {
|
|
in_function_name = true;
|
|
}
|
|
}
|
|
|
|
if (!in_function_name && !in_member_variable && !in_keyword && !is_number && in_word) {
|
|
int k = j;
|
|
while(k > 0 && !_is_symbol(str[k]) && str[k] != '\t' && str[k] != ' ') {
|
|
k--;
|
|
}
|
|
|
|
if (str[k] == '.') {
|
|
in_member_variable = true;
|
|
}
|
|
}
|
|
|
|
if (is_symbol) {
|
|
in_function_name = false;
|
|
in_member_variable = false;
|
|
}
|
|
|
|
if (in_region>=0)
|
|
color=color_regions[in_region].color;
|
|
else if (in_keyword)
|
|
color=keyword_color;
|
|
else if (in_member_variable)
|
|
color=cache.member_variable_color;
|
|
else if (in_function_name)
|
|
color=cache.function_color;
|
|
else if (is_symbol)
|
|
color=symbol_color;
|
|
else if (is_number)
|
|
color=cache.number_color;
|
|
|
|
prev_is_char=is_char;
|
|
prev_is_number=is_number;
|
|
|
|
}
|
|
int char_w;
|
|
|
|
//handle tabulator
|
|
|
|
|
|
if (str[j]=='\t') {
|
|
int left = char_ofs%tab_w;
|
|
if (left==0)
|
|
char_w=tab_w;
|
|
else
|
|
char_w=tab_w-char_ofs%tab_w; // is right...
|
|
|
|
} else {
|
|
char_w=cache.font->get_char_size(str[j],str[j+1]).width;
|
|
}
|
|
|
|
if ( (char_ofs+char_margin)<xmargin_beg) {
|
|
char_ofs+=char_w;
|
|
continue;
|
|
}
|
|
|
|
if ( (char_ofs+char_margin+char_w)>=xmargin_end) {
|
|
if (syntax_coloring)
|
|
continue;
|
|
else
|
|
break;
|
|
}
|
|
|
|
bool in_search_result=false;
|
|
|
|
if (search_text_col != -1) {
|
|
// if we are at the end check for new search result on same line
|
|
if (j >= search_text_col+search_text.length())
|
|
search_text_col = _get_column_pos_of_word(search_text, str, search_flags, j);
|
|
|
|
in_search_result = j >= search_text_col && j < search_text_col+search_text.length();
|
|
|
|
if (in_search_result) {
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2i( char_ofs+char_margin, ofs_y ), Size2i(char_w, get_row_height())),cache.search_result_color);
|
|
}
|
|
}
|
|
|
|
bool in_selection = (selection.active && line>=selection.from_line && line<=selection.to_line && (line>selection.from_line || j>=selection.from_column) && (line<selection.to_line || j<selection.to_column));
|
|
|
|
if (in_selection) {
|
|
//inside selection!
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2i( char_ofs+char_margin, ofs_y ), Size2i(char_w,get_row_height())),cache.selection_color);
|
|
}
|
|
|
|
if (in_search_result) {
|
|
Color border_color=(line==search_result_line && j>=search_result_col && j<search_result_col+search_text.length())?cache.font_color:cache.search_result_border_color;
|
|
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2i( char_ofs+char_margin, ofs_y ), Size2i(char_w,1)),border_color);
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2i( char_ofs+char_margin, ofs_y+get_row_height()-1 ), Size2i(char_w,1)),border_color);
|
|
|
|
if (j==search_text_col)
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2i( char_ofs+char_margin, ofs_y ), Size2i(1,get_row_height())),border_color);
|
|
if (j==search_text_col+search_text.length()-1)
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2i( char_ofs+char_margin+char_w-1, ofs_y ), Size2i(1,get_row_height())),border_color);
|
|
}
|
|
|
|
if (highlight_all_occurrences) {
|
|
if (highlighted_text_col != -1) {
|
|
|
|
// if we are at the end check for new word on same line
|
|
if (j > highlighted_text_col+highlighted_text.length()) {
|
|
highlighted_text_col = _get_column_pos_of_word(highlighted_text, str, SEARCH_MATCH_CASE|SEARCH_WHOLE_WORDS, j);
|
|
}
|
|
|
|
bool in_highlighted_word = (j >= highlighted_text_col && j < highlighted_text_col+highlighted_text.length());
|
|
|
|
/* if this is the original highlighted text we don't want to highlight it again */
|
|
if (cursor.line==line && (cursor.column >= highlighted_text_col && cursor.column <= highlighted_text_col+highlighted_text.length())) {
|
|
in_highlighted_word = false;
|
|
}
|
|
|
|
if (in_highlighted_word) {
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2i( char_ofs+char_margin, ofs_y ), Size2i(char_w, get_row_height())),cache.word_highlighted_color);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (brace_matching_enabled) {
|
|
if ( (brace_open_match_line==line && brace_open_match_column==j) ||
|
|
(cursor.column==j && cursor.line==line && (brace_open_matching||brace_open_mismatch))) {
|
|
|
|
if (brace_open_mismatch)
|
|
color=cache.brace_mismatch_color;
|
|
cache.font->draw_char(ci,Point2i( char_ofs+char_margin, ofs_y+ascent),'_',str[j+1],in_selection?cache.font_selected_color:color);
|
|
|
|
}
|
|
|
|
if (
|
|
(brace_close_match_line==line && brace_close_match_column==j) ||
|
|
(cursor.column==j+1 && cursor.line==line && (brace_close_matching||brace_close_mismatch))) {
|
|
|
|
|
|
if (brace_close_mismatch)
|
|
color=cache.brace_mismatch_color;
|
|
cache.font->draw_char(ci,Point2i( char_ofs+char_margin, ofs_y+ascent),'_',str[j+1],in_selection?cache.font_selected_color:color);
|
|
|
|
}
|
|
}
|
|
|
|
if (cursor.column==j && cursor.line==line) {
|
|
|
|
cursor_pos = Point2i( char_ofs+char_margin, ofs_y );
|
|
|
|
if (insert_mode) {
|
|
cursor_pos.y += (get_row_height() - 3);
|
|
}
|
|
|
|
int caret_w = (str[j]=='\t') ? cache.font->get_char_size(' ').width : char_w;
|
|
if (draw_caret) {
|
|
if (insert_mode) {
|
|
int caret_h = (block_caret) ? 4 : 1;
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(cursor_pos, Size2i(caret_w,caret_h)),cache.caret_color);
|
|
} else {
|
|
caret_w = (block_caret) ? caret_w : 1;
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(cursor_pos, Size2i(caret_w,get_row_height())),cache.caret_color);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (cursor.column==j && cursor.line==line && block_caret && draw_caret && !insert_mode) {
|
|
color = cache.caret_background_color;
|
|
}
|
|
|
|
if (str[j]>=32)
|
|
cache.font->draw_char(ci,Point2i( char_ofs+char_margin, ofs_y+ascent),str[j],str[j+1],in_selection?cache.font_selected_color:color);
|
|
|
|
else if (draw_tabs && str[j]=='\t') {
|
|
int yofs= (get_row_height() - cache.tab_icon->get_height())/2;
|
|
cache.tab_icon->draw(ci, Point2(char_ofs+char_margin,ofs_y+yofs),in_selection?cache.font_selected_color:color);
|
|
}
|
|
|
|
char_ofs+=char_w;
|
|
}
|
|
|
|
if (cursor.column==str.length() && cursor.line==line && (char_ofs+char_margin)>=xmargin_beg) {
|
|
|
|
cursor_pos=Point2i( char_ofs+char_margin, ofs_y );
|
|
|
|
if (insert_mode) {
|
|
cursor_pos.y += (get_row_height() - 3);
|
|
}
|
|
|
|
if (draw_caret) {
|
|
if (insert_mode) {
|
|
int char_w = cache.font->get_char_size(' ').width;
|
|
int caret_h = (block_caret) ? 4 : 1;
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(cursor_pos, Size2i(char_w,caret_h)),cache.caret_color);
|
|
} else {
|
|
int char_w = cache.font->get_char_size(' ').width;
|
|
int caret_w = (block_caret) ? char_w : 1;
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(cursor_pos, Size2i(caret_w,get_row_height())),cache.caret_color);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool completion_below = false;
|
|
if (completion_active) {
|
|
// code completion box
|
|
Ref<StyleBox> csb = get_stylebox("completion");
|
|
int maxlines = get_constant("completion_lines");
|
|
int cmax_width = get_constant("completion_max_width")*cache.font->get_char_size('x').x;
|
|
int scrollw = get_constant("completion_scroll_width");
|
|
Color scrollc = get_color("completion_scroll_color");
|
|
|
|
|
|
|
|
int lines = MIN(completion_options.size(),maxlines);
|
|
int w=0;
|
|
int h=lines*get_row_height();
|
|
int nofs = cache.font->get_string_size(completion_base).width;
|
|
|
|
|
|
if (completion_options.size() < 50) {
|
|
for(int i=0;i<completion_options.size();i++) {
|
|
int w2=MIN(cache.font->get_string_size(completion_options[i]).x,cmax_width);
|
|
if (w2>w)
|
|
w=w2;
|
|
}
|
|
} else {
|
|
w=cmax_width;
|
|
}
|
|
|
|
int th = h + csb->get_minimum_size().y;
|
|
|
|
if (cursor_pos.y+get_row_height()+th > get_size().height) {
|
|
completion_rect.pos.y=cursor_pos.y-th;
|
|
} else {
|
|
completion_rect.pos.y=cursor_pos.y+get_row_height()+csb->get_offset().y;
|
|
completion_below = true;
|
|
}
|
|
|
|
if (cursor_pos.x-nofs+w+scrollw > get_size().width) {
|
|
completion_rect.pos.x=get_size().width-w-scrollw;
|
|
} else {
|
|
completion_rect.pos.x=cursor_pos.x-nofs;
|
|
}
|
|
|
|
completion_rect.size.width=w+2;
|
|
completion_rect.size.height=h;
|
|
if (completion_options.size()<=maxlines)
|
|
scrollw=0;
|
|
|
|
draw_style_box(csb,Rect2(completion_rect.pos-csb->get_offset(),completion_rect.size+csb->get_minimum_size()+Size2(scrollw,0)));
|
|
|
|
if (cache.completion_background_color.a>0.01) {
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(completion_rect.pos,completion_rect.size+Size2(scrollw,0)),cache.completion_background_color);
|
|
}
|
|
int line_from = CLAMP(completion_index - lines/2, 0, completion_options.size() - lines);
|
|
VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(Point2(completion_rect.pos.x,completion_rect.pos.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.pos,Size2(nofs,completion_rect.size.height)),cache.completion_existing_color);
|
|
|
|
|
|
|
|
|
|
for(int i=0;i<lines;i++) {
|
|
|
|
int l = line_from + i;
|
|
ERR_CONTINUE( l < 0 || l>= completion_options.size());
|
|
Color text_color = cache.completion_font_color;
|
|
for(int j=0;j<color_regions.size();j++) {
|
|
if (completion_options[l].begins_with(color_regions[j].begin_key)) {
|
|
text_color=color_regions[j].color;
|
|
}
|
|
}
|
|
draw_string(cache.font,Point2(completion_rect.pos.x,completion_rect.pos.y+i*get_row_height()+cache.font->get_ascent()),completion_options[l],text_color,completion_rect.size.width);
|
|
}
|
|
|
|
if (scrollw) {
|
|
//draw a small scroll rectangle to show a position in the options
|
|
float r = maxlines / (float)completion_options.size();
|
|
float o = line_from / (float)completion_options.size();
|
|
draw_rect(Rect2(completion_rect.pos.x+completion_rect.size.width,completion_rect.pos.y+o*completion_rect.size.y,scrollw,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 (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_stylebox("panel","TooltipPanel");
|
|
Ref<Font> font = cache.font;
|
|
Color font_color = get_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).x;
|
|
max_w = MAX(len,max_w);
|
|
if (i==0) {
|
|
offset = font->get_string_size(l.substr(0,l.find(String::chr(0xFFFF)))).x;
|
|
} else {
|
|
spacing+=cache.line_spacing;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
Size2 size = Size2(max_w,sc*font->get_height()+spacing);
|
|
Size2 minsize = size+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 += get_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)))).x;
|
|
end = font->get_string_size(l.substr(0,l.rfind(String::chr(0xFFFF)))).x;
|
|
}
|
|
|
|
draw_string(font,hint_ofs+sb->get_offset()+Vector2(0,font->get_ascent()+font->get_height()*i+spacing),l.replace(String::chr(0xFFFF),""),font_color);
|
|
if (end>0) {
|
|
Vector2 b = hint_ofs+sb->get_offset()+Vector2(begin,font->get_height()+font->get_height()*i+spacing-1);
|
|
draw_line(b,b+Vector2(end-begin,0),font_color);
|
|
}
|
|
spacing+=cache.line_spacing;
|
|
}
|
|
}
|
|
|
|
|
|
} break;
|
|
case NOTIFICATION_FOCUS_ENTER: {
|
|
|
|
if (!caret_blink_enabled) {
|
|
draw_caret = true;
|
|
}
|
|
if (OS::get_singleton()->has_virtual_keyboard())
|
|
OS::get_singleton()->show_virtual_keyboard(get_text(),get_global_rect());
|
|
|
|
} break;
|
|
case NOTIFICATION_FOCUS_EXIT: {
|
|
|
|
if (OS::get_singleton()->has_virtual_keyboard())
|
|
OS::get_singleton()->hide_virtual_keyboard();
|
|
|
|
} break;
|
|
|
|
}
|
|
}
|
|
|
|
void TextEdit::_consume_pair_symbol(CharType ch) {
|
|
|
|
int cursor_position_to_move = cursor_get_column() + 1;
|
|
|
|
CharType ch_single[2] = {ch, 0};
|
|
CharType ch_single_pair[2] = {_get_right_pair_symbol(ch), 0};
|
|
CharType ch_pair[3] = {ch, _get_right_pair_symbol(ch), 0};
|
|
|
|
if(is_selection_active()) {
|
|
|
|
int new_column,new_line;
|
|
|
|
begin_complex_operation();
|
|
_insert_text(get_selection_from_line(), get_selection_from_column(),
|
|
ch_single,
|
|
&new_line, &new_column);
|
|
|
|
int to_col_offset = 0;
|
|
if(get_selection_from_line() == get_selection_to_line())
|
|
to_col_offset = 1;
|
|
|
|
_insert_text(get_selection_to_line(),
|
|
get_selection_to_column() + to_col_offset,
|
|
ch_single_pair,
|
|
&new_line,&new_column);
|
|
end_complex_operation();
|
|
|
|
cursor_set_line(get_selection_to_line());
|
|
cursor_set_column(get_selection_to_column() + to_col_offset);
|
|
|
|
deselect();
|
|
update();
|
|
return;
|
|
}
|
|
|
|
if( (ch == '\'' || ch == '"') &&
|
|
cursor_get_column() > 0 &&
|
|
_is_text_char(text[cursor.line][cursor_get_column() - 1])
|
|
) {
|
|
insert_text_at_cursor(ch_single);
|
|
cursor_set_column(cursor_position_to_move);
|
|
return;
|
|
}
|
|
|
|
if(cursor_get_column() < text[cursor.line].length()) {
|
|
if(_is_text_char(text[cursor.line][cursor_get_column()])) {
|
|
insert_text_at_cursor(ch_single);
|
|
cursor_set_column(cursor_position_to_move);
|
|
return;
|
|
}
|
|
if( _is_pair_right_symbol(ch) &&
|
|
text[cursor.line][cursor_get_column()] == ch
|
|
) {
|
|
cursor_set_column(cursor_position_to_move);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
insert_text_at_cursor(ch_pair);
|
|
cursor_set_column(cursor_position_to_move);
|
|
return;
|
|
|
|
}
|
|
|
|
void TextEdit::_consume_backspace_for_pair_symbol(int prev_line, int prev_column) {
|
|
|
|
bool remove_right_symbol = false;
|
|
|
|
if(cursor.column < text[cursor.line].length() && cursor.column > 0) {
|
|
|
|
CharType left_char = text[cursor.line][cursor.column - 1];
|
|
CharType right_char = text[cursor.line][cursor.column];
|
|
|
|
if(right_char == _get_right_pair_symbol(left_char)) {
|
|
remove_right_symbol = true;
|
|
}
|
|
|
|
}
|
|
if(remove_right_symbol) {
|
|
_remove_text(prev_line,prev_column,cursor.line,cursor.column + 1);
|
|
} else {
|
|
_remove_text(prev_line,prev_column,cursor.line,cursor.column);
|
|
}
|
|
|
|
}
|
|
|
|
void TextEdit::backspace_at_cursor() {
|
|
if (readonly)
|
|
return;
|
|
|
|
if (cursor.column==0 && cursor.line==0)
|
|
return;
|
|
|
|
int prev_line = cursor.column?cursor.line:cursor.line-1;
|
|
int prev_column = cursor.column?(cursor.column-1):(text[cursor.line-1].length());
|
|
if(auto_brace_completion_enabled &&
|
|
cursor.column > 0 &&
|
|
_is_pair_left_symbol(text[cursor.line][cursor.column - 1])) {
|
|
_consume_backspace_for_pair_symbol(prev_line, prev_column);
|
|
} else {
|
|
_remove_text(prev_line,prev_column,cursor.line,cursor.column);
|
|
}
|
|
|
|
cursor_set_line(prev_line);
|
|
cursor_set_column(prev_column);
|
|
|
|
}
|
|
|
|
void TextEdit::indent_selection_right() {
|
|
|
|
if (!is_selection_active()) {
|
|
return;
|
|
}
|
|
begin_complex_operation();
|
|
int start_line = get_selection_from_line();
|
|
int end_line = get_selection_to_line();
|
|
|
|
// ignore if the cursor is not past the first column
|
|
if (get_selection_to_column() == 0) {
|
|
end_line--;
|
|
}
|
|
|
|
for (int i = start_line; i <= end_line; i++) {
|
|
String line_text = get_line(i);
|
|
line_text = '\t' + line_text;
|
|
set_line(i, line_text);
|
|
}
|
|
|
|
// fix selection being off by one on the last line
|
|
selection.to_column++;
|
|
end_complex_operation();
|
|
update();
|
|
}
|
|
|
|
void TextEdit::indent_selection_left() {
|
|
|
|
if (!is_selection_active()) {
|
|
return;
|
|
}
|
|
begin_complex_operation();
|
|
int start_line = get_selection_from_line();
|
|
int end_line = get_selection_to_line();
|
|
|
|
// ignore if the cursor is not past the first column
|
|
if (get_selection_to_column() == 0) {
|
|
end_line--;
|
|
}
|
|
String last_line_text = get_line(end_line);
|
|
|
|
for (int i = start_line; i <= end_line; i++) {
|
|
String line_text = get_line(i);
|
|
|
|
if (line_text.begins_with("\t")) {
|
|
line_text = line_text.substr(1, line_text.length());
|
|
set_line(i, line_text);
|
|
} else if (line_text.begins_with(" ")) {
|
|
line_text = line_text.substr(4, line_text.length());
|
|
set_line(i, line_text);
|
|
}
|
|
}
|
|
|
|
// fix selection being off by one on the last line
|
|
if (last_line_text != get_line(end_line) && selection.to_column > 0) {
|
|
selection.to_column--;
|
|
}
|
|
end_complex_operation();
|
|
update();
|
|
}
|
|
|
|
void TextEdit::_get_mouse_pos(const Point2i& p_mouse, int &r_row, int &r_col) const {
|
|
|
|
float rows=p_mouse.y;
|
|
rows-=cache.style_normal->get_margin(MARGIN_TOP);
|
|
rows/=get_row_height();
|
|
int row=cursor.line_ofs+rows;
|
|
|
|
if (row<0)
|
|
row=0;
|
|
|
|
int col=0;
|
|
|
|
if (row>=text.size()) {
|
|
|
|
row=text.size()-1;
|
|
col=text[row].size();
|
|
} else {
|
|
|
|
col=p_mouse.x-(cache.style_normal->get_margin(MARGIN_LEFT)+cache.line_number_w+cache.breakpoint_gutter_width);
|
|
col+=cursor.x_ofs;
|
|
col=get_char_pos_for( col, get_line(row) );
|
|
}
|
|
|
|
r_row=row;
|
|
r_col=col;
|
|
}
|
|
|
|
void TextEdit::_input_event(const InputEvent& p_input_event) {
|
|
|
|
switch(p_input_event.type) {
|
|
|
|
case InputEvent::MOUSE_BUTTON: {
|
|
|
|
const InputEventMouseButton &mb=p_input_event.mouse_button;
|
|
|
|
if (completion_active && completion_rect.has_point(Point2(mb.x,mb.y))) {
|
|
|
|
if (!mb.pressed)
|
|
return;
|
|
|
|
if (mb.button_index==BUTTON_WHEEL_UP) {
|
|
if (completion_index>0) {
|
|
completion_index--;
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
}
|
|
|
|
}
|
|
if (mb.button_index==BUTTON_WHEEL_DOWN) {
|
|
|
|
if (completion_index<completion_options.size()-1) {
|
|
completion_index++;
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
}
|
|
}
|
|
|
|
if (mb.button_index==BUTTON_LEFT) {
|
|
|
|
completion_index=CLAMP(completion_line_ofs+(mb.y-completion_rect.pos.y)/get_row_height(),0,completion_options.size()-1);
|
|
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
if (mb.doubleclick)
|
|
_confirm_completion();
|
|
}
|
|
return;
|
|
} else {
|
|
_cancel_completion();
|
|
_cancel_code_hint();
|
|
}
|
|
|
|
if (mb.pressed) {
|
|
if (mb.button_index==BUTTON_WHEEL_UP && !mb.mod.command) {
|
|
v_scroll->set_val( v_scroll->get_val() -3 );
|
|
}
|
|
if (mb.button_index==BUTTON_WHEEL_DOWN && !mb.mod.command) {
|
|
v_scroll->set_val( v_scroll->get_val() +3 );
|
|
}
|
|
if (mb.button_index==BUTTON_WHEEL_LEFT) {
|
|
h_scroll->set_val( h_scroll->get_val() -3 );
|
|
}
|
|
if (mb.button_index==BUTTON_WHEEL_RIGHT) {
|
|
h_scroll->set_val( h_scroll->get_val() +3 );
|
|
}
|
|
if (mb.button_index==BUTTON_LEFT) {
|
|
|
|
_reset_caret_blink_timer();
|
|
|
|
int row,col;
|
|
_get_mouse_pos(Point2i(mb.x,mb.y), row,col);
|
|
|
|
// toggle breakpoint on gutter click
|
|
if (draw_breakpoint_gutter) {
|
|
int gutter=cache.style_normal->get_margin(MARGIN_LEFT);
|
|
if (mb.x > gutter && mb.x <= gutter + cache.breakpoint_gutter_width + 3) {
|
|
set_line_as_breakpoint(row, !is_line_set_as_breakpoint(row));
|
|
emit_signal("breakpoint_toggled", row);
|
|
return;
|
|
}
|
|
}
|
|
|
|
int prev_col=cursor.column;
|
|
int prev_line=cursor.line;
|
|
|
|
|
|
|
|
cursor_set_line( row );
|
|
cursor_set_column( col );
|
|
|
|
if (mb.mod.shift && (cursor.column!=prev_col || cursor.line!=prev_line)) {
|
|
|
|
if (!selection.active) {
|
|
selection.active=true;
|
|
selection.selecting_mode=Selection::MODE_POINTER;
|
|
selection.from_column=prev_col;
|
|
selection.from_line=prev_line;
|
|
selection.to_column=cursor.column;
|
|
selection.to_line=cursor.line;
|
|
|
|
if (selection.from_line>selection.to_line || (selection.from_line==selection.to_line && selection.from_column>selection.to_column)) {
|
|
SWAP(selection.from_column,selection.to_column);
|
|
SWAP(selection.from_line,selection.to_line);
|
|
selection.shiftclick_left=false;
|
|
} else {
|
|
selection.shiftclick_left=true;
|
|
}
|
|
selection.selecting_line=prev_line;
|
|
selection.selecting_column=prev_col;
|
|
update();
|
|
} else {
|
|
|
|
if (cursor.line<selection.selecting_line || (cursor.line==selection.selecting_line && cursor.column<selection.selecting_column)) {
|
|
|
|
if (selection.shiftclick_left) {
|
|
SWAP(selection.from_column,selection.to_column);
|
|
SWAP(selection.from_line,selection.to_line);
|
|
selection.shiftclick_left = !selection.shiftclick_left;
|
|
}
|
|
selection.from_column=cursor.column;
|
|
selection.from_line=cursor.line;
|
|
|
|
} else if (cursor.line>selection.selecting_line || (cursor.line==selection.selecting_line && cursor.column>selection.selecting_column)) {
|
|
|
|
if (!selection.shiftclick_left) {
|
|
SWAP(selection.from_column,selection.to_column);
|
|
SWAP(selection.from_line,selection.to_line);
|
|
selection.shiftclick_left = !selection.shiftclick_left;
|
|
}
|
|
selection.to_column=cursor.column;
|
|
selection.to_line=cursor.line;
|
|
|
|
} else {
|
|
selection.active=false;
|
|
}
|
|
|
|
update();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} else {
|
|
|
|
//if sel active and dblick last time < something
|
|
|
|
//else
|
|
selection.active=false;
|
|
selection.selecting_mode=Selection::MODE_POINTER;
|
|
selection.selecting_line=row;
|
|
selection.selecting_column=col;
|
|
}
|
|
|
|
|
|
if (!mb.doubleclick && (OS::get_singleton()->get_ticks_msec()-last_dblclk)<600 && cursor.line==prev_line) {
|
|
//tripleclick select line
|
|
select(cursor.line,0,cursor.line,text[cursor.line].length());
|
|
selection.selecting_column=0;
|
|
last_dblclk=0;
|
|
|
|
} else if (mb.doubleclick && text[cursor.line].length()) {
|
|
|
|
//doubleclick select world
|
|
String s = text[cursor.line];
|
|
int beg=CLAMP(cursor.column,0,s.length());
|
|
int end=beg;
|
|
|
|
if (s[beg]>32 || beg==s.length()) {
|
|
|
|
bool symbol = beg < s.length() && _is_symbol(s[beg]); //not sure if right but most editors behave like this
|
|
|
|
while(beg>0 && s[beg-1]>32 && (symbol==_is_symbol(s[beg-1]))) {
|
|
beg--;
|
|
}
|
|
while(end<s.length() && s[end+1]>32 && (symbol==_is_symbol(s[end+1]))) {
|
|
end++;
|
|
}
|
|
|
|
if (end<s.length())
|
|
end+=1;
|
|
|
|
select(cursor.line,beg,cursor.line,end);
|
|
|
|
selection.selecting_column=beg;
|
|
}
|
|
|
|
last_dblclk = OS::get_singleton()->get_ticks_msec();
|
|
|
|
}
|
|
|
|
update();
|
|
}
|
|
|
|
if (mb.button_index==BUTTON_RIGHT) {
|
|
|
|
menu->set_pos(get_global_transform().xform(get_local_mouse_pos()));
|
|
menu->set_size(Vector2(1,1));
|
|
menu->popup();
|
|
grab_focus();
|
|
|
|
}
|
|
} else {
|
|
|
|
if (mb.button_index==BUTTON_LEFT)
|
|
click_select_held->stop();
|
|
|
|
// notify to show soft keyboard
|
|
notification(NOTIFICATION_FOCUS_ENTER);
|
|
}
|
|
|
|
} break;
|
|
case InputEvent::MOUSE_MOTION: {
|
|
|
|
const InputEventMouseMotion &mm=p_input_event.mouse_motion;
|
|
|
|
if (mm.button_mask&BUTTON_MASK_LEFT) {
|
|
|
|
if (selection.selecting_mode!=Selection::MODE_NONE) {
|
|
|
|
_reset_caret_blink_timer();
|
|
|
|
int row,col;
|
|
_get_mouse_pos(Point2i(mm.x,mm.y), row,col);
|
|
|
|
select(selection.selecting_line,selection.selecting_column,row,col);
|
|
|
|
cursor_set_line( row );
|
|
cursor_set_column( col );
|
|
update();
|
|
|
|
click_select_held->start();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case InputEvent::KEY: {
|
|
|
|
InputEventKey k=p_input_event.key;
|
|
|
|
if (!k.pressed)
|
|
return;
|
|
|
|
if (completion_active) {
|
|
if (readonly)
|
|
break;
|
|
|
|
bool valid=true;
|
|
if (k.mod.command || k.mod.meta)
|
|
valid=false;
|
|
|
|
if (valid) {
|
|
|
|
if (!k.mod.alt) {
|
|
if (k.scancode==KEY_UP) {
|
|
|
|
if (completion_index>0) {
|
|
completion_index--;
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
}
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
|
|
if (k.scancode==KEY_DOWN) {
|
|
|
|
if (completion_index<completion_options.size()-1) {
|
|
completion_index++;
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
}
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (k.scancode==KEY_PAGEUP) {
|
|
|
|
completion_index-=get_constant("completion_lines");
|
|
if (completion_index<0)
|
|
completion_index=0;
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
|
|
if (k.scancode==KEY_PAGEDOWN) {
|
|
|
|
completion_index+=get_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.scancode==KEY_HOME && completion_index>0) {
|
|
|
|
completion_index=0;
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (k.scancode==KEY_END && completion_index<completion_options.size()-1) {
|
|
|
|
completion_index=completion_options.size()-1;
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
|
|
if (k.scancode==KEY_DOWN) {
|
|
|
|
if (completion_index<completion_options.size()-1) {
|
|
completion_index++;
|
|
completion_current=completion_options[completion_index];
|
|
update();
|
|
}
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (k.scancode==KEY_ENTER || k.scancode==KEY_RETURN || k.scancode==KEY_TAB) {
|
|
|
|
_confirm_completion();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (k.scancode==KEY_BACKSPACE) {
|
|
|
|
_reset_caret_blink_timer();
|
|
|
|
backspace_at_cursor();
|
|
_update_completion_candidates();
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
|
|
if (k.scancode==KEY_SHIFT) {
|
|
accept_event();
|
|
return;
|
|
}
|
|
}
|
|
|
|
if (k.unicode>32) {
|
|
|
|
_reset_caret_blink_timer();
|
|
|
|
const CharType chr[2] = {(CharType)k.unicode, 0};
|
|
if(auto_brace_completion_enabled && _is_pair_symbol(chr[0])) {
|
|
_consume_pair_symbol(chr[0]);
|
|
} else {
|
|
|
|
// remove the old character if in insert mode
|
|
if (insert_mode) {
|
|
begin_complex_operation();
|
|
|
|
// make sure we don't try and remove empty space
|
|
if (cursor.column < get_line(cursor.line).length()) {
|
|
_remove_text(cursor.line, cursor.column, cursor.line, cursor.column + 1);
|
|
}
|
|
}
|
|
|
|
_insert_text_at_cursor(chr);
|
|
|
|
if (insert_mode) {
|
|
end_complex_operation();
|
|
}
|
|
}
|
|
_update_completion_candidates();
|
|
accept_event();
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
_cancel_completion();
|
|
|
|
}
|
|
|
|
/* TEST CONTROL FIRST!! */
|
|
|
|
// some remaps for duplicate functions..
|
|
if (k.mod.command && !k.mod.shift && !k.mod.alt && !k.mod.meta && k.scancode==KEY_INSERT) {
|
|
|
|
k.scancode=KEY_C;
|
|
}
|
|
if (!k.mod.command && k.mod.shift && !k.mod.alt && !k.mod.meta && k.scancode==KEY_INSERT) {
|
|
|
|
k.scancode=KEY_V;
|
|
k.mod.command=true;
|
|
k.mod.shift=false;
|
|
}
|
|
|
|
if (!k.mod.command) {
|
|
_reset_caret_blink_timer();
|
|
}
|
|
// save here for insert mode, just in case it is cleared in the following section
|
|
bool had_selection = selection.active;
|
|
|
|
// stuff to do when selection is active..
|
|
if (selection.active) {
|
|
|
|
if (readonly)
|
|
break;
|
|
|
|
bool clear=false;
|
|
bool unselect=false;
|
|
bool dobreak=false;
|
|
|
|
switch(k.scancode) {
|
|
|
|
case KEY_TAB: {
|
|
if (k.mod.shift) {
|
|
indent_selection_left();
|
|
} else {
|
|
indent_selection_right();
|
|
}
|
|
dobreak=true;
|
|
accept_event();
|
|
} break;
|
|
case KEY_X:
|
|
case KEY_C:
|
|
//special keys often used with control, wait...
|
|
clear=(!k.mod.command || k.mod.shift || k.mod.alt );
|
|
break;
|
|
case KEY_DELETE:
|
|
if (!k.mod.shift) {
|
|
accept_event();
|
|
clear=true; dobreak=true;
|
|
} else if (k.mod.command || k.mod.alt) {
|
|
dobreak=true;
|
|
}
|
|
break;
|
|
case KEY_BACKSPACE:
|
|
accept_event();
|
|
clear=true; dobreak=true;
|
|
break;
|
|
case KEY_LEFT:
|
|
case KEY_RIGHT:
|
|
case KEY_UP:
|
|
case KEY_DOWN:
|
|
case KEY_PAGEUP:
|
|
case KEY_PAGEDOWN:
|
|
case KEY_HOME:
|
|
case KEY_END:
|
|
// ignore arrows if any modifiers are held (shift = selecting, others may be used for editor hotkeys)
|
|
if (k.mod.command || k.mod.shift || k.mod.alt)
|
|
break;
|
|
unselect=true;
|
|
break;
|
|
|
|
default:
|
|
if (k.unicode>=32 && !k.mod.command && !k.mod.alt && !k.mod.meta)
|
|
clear=true;
|
|
if (auto_brace_completion_enabled && _is_pair_left_symbol(k.unicode))
|
|
clear=false;
|
|
}
|
|
|
|
if (unselect) {
|
|
selection.active=false;
|
|
selection.selecting_mode=Selection::MODE_NONE;
|
|
update();
|
|
}
|
|
if (clear) {
|
|
|
|
if (!dobreak) {
|
|
begin_complex_operation();
|
|
}
|
|
selection.active=false;
|
|
update();
|
|
_remove_text(selection.from_line,selection.from_column,selection.to_line,selection.to_column);
|
|
cursor_set_line(selection.from_line);
|
|
cursor_set_column(selection.from_column);
|
|
update();
|
|
}
|
|
if (dobreak)
|
|
break;
|
|
}
|
|
|
|
selection.selecting_text=false;
|
|
|
|
bool scancode_handled=true;
|
|
|
|
// special scancode test...
|
|
|
|
switch (k.scancode) {
|
|
|
|
case KEY_ENTER:
|
|
case KEY_RETURN: {
|
|
|
|
if (readonly)
|
|
break;
|
|
|
|
String ins="\n";
|
|
|
|
//keep indentation
|
|
for(int i=0;i<text[cursor.line].length();i++) {
|
|
if (text[cursor.line][i]=='\t')
|
|
ins+="\t";
|
|
else
|
|
break;
|
|
}
|
|
if(auto_indent){
|
|
// indent once again if previous line will end with ':'
|
|
// (i.e. colon precedes current cursor position)
|
|
if(cursor.column>0 && text[cursor.line][cursor.column-1]==':') {
|
|
ins+="\t";
|
|
}
|
|
}
|
|
|
|
bool first_line = false;
|
|
if (k.mod.command) {
|
|
if (k.mod.shift) {
|
|
if (cursor.line > 0) {
|
|
cursor_set_line(cursor.line - 1);
|
|
cursor_set_column(text[cursor.line].length());
|
|
}
|
|
else {
|
|
cursor_set_column(0);
|
|
first_line = true;
|
|
}
|
|
}
|
|
else {
|
|
cursor_set_column(text[cursor.line].length());
|
|
}
|
|
}
|
|
|
|
_insert_text_at_cursor(ins);
|
|
_push_current_op();
|
|
|
|
if (first_line) {
|
|
cursor_set_line(0);
|
|
}
|
|
|
|
} break;
|
|
case KEY_ESCAPE: {
|
|
if (completion_hint!="") {
|
|
completion_hint="";
|
|
update();
|
|
} else {
|
|
scancode_handled=false;
|
|
}
|
|
} break;
|
|
case KEY_TAB: {
|
|
if (k.mod.command) break; // avoid tab when command
|
|
|
|
if (readonly)
|
|
break;
|
|
|
|
if (selection.active) {
|
|
|
|
|
|
} else {
|
|
if (k.mod.shift) {
|
|
|
|
int cc = cursor.column;
|
|
if (cc>0 && cc<=text[cursor.line].length() && text[cursor.line][cursor.column-1]=='\t') {
|
|
//simple unindent
|
|
|
|
backspace_at_cursor();
|
|
}
|
|
} else {
|
|
//simple indent
|
|
_insert_text_at_cursor("\t");
|
|
}
|
|
}
|
|
|
|
} break;
|
|
case KEY_BACKSPACE: {
|
|
if (readonly)
|
|
break;
|
|
|
|
#ifdef APPLE_STYLE_KEYS
|
|
if (k.mod.alt) {
|
|
#else
|
|
if (k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
} else if (k.mod.command) {
|
|
#endif
|
|
int line=cursor.line;
|
|
int column=cursor.column;
|
|
|
|
bool prev_char=false;
|
|
bool only_whitespace=true;
|
|
|
|
while (only_whitespace && line > 0) {
|
|
|
|
while (column>0) {
|
|
CharType c=text[line][column-1];
|
|
|
|
if (c != '\t' && c != ' ') {
|
|
only_whitespace=false;
|
|
break;
|
|
}
|
|
|
|
column--;
|
|
}
|
|
|
|
if (only_whitespace) {
|
|
line--;
|
|
column=text[line].length();
|
|
}
|
|
}
|
|
|
|
while (column>0) {
|
|
bool ischar=_is_text_char(text[line][column-1]);
|
|
|
|
if (prev_char && !ischar)
|
|
break;
|
|
|
|
prev_char=ischar;
|
|
column--;
|
|
|
|
}
|
|
|
|
_remove_text(line, column, cursor.line, cursor.column);
|
|
|
|
cursor_set_line(line);
|
|
cursor_set_column(column);
|
|
|
|
} else {
|
|
backspace_at_cursor();
|
|
}
|
|
|
|
} break;
|
|
case KEY_KP_4: {
|
|
if (k.unicode != 0) {
|
|
scancode_handled = false;
|
|
break;
|
|
}
|
|
// numlock disabled. fallthrough to key_left
|
|
}
|
|
case KEY_LEFT: {
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
#ifdef APPLE_STYLE_KEYS
|
|
else
|
|
#else
|
|
else if (!k.mod.alt)
|
|
#endif
|
|
deselect();
|
|
|
|
#ifdef APPLE_STYLE_KEYS
|
|
if (k.mod.command) {
|
|
cursor_set_column(0);
|
|
} else if (k.mod.alt) {
|
|
|
|
#else
|
|
if (k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
} else if (k.mod.command) {
|
|
#endif
|
|
bool prev_char=false;
|
|
int cc=cursor.column;
|
|
while (cc>0) {
|
|
|
|
bool ischar=_is_text_char(text[cursor.line][cc-1]);
|
|
|
|
if (prev_char && !ischar)
|
|
break;
|
|
|
|
prev_char=ischar;
|
|
cc--;
|
|
|
|
}
|
|
|
|
cursor_set_column(cc);
|
|
|
|
} else if (cursor.column==0) {
|
|
|
|
if (cursor.line>0) {
|
|
cursor_set_line(cursor.line-1);
|
|
cursor_set_column(text[cursor.line].length());
|
|
}
|
|
} else {
|
|
cursor_set_column(cursor_get_column()-1);
|
|
}
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
|
|
} break;
|
|
case KEY_KP_6: {
|
|
if (k.unicode != 0) {
|
|
scancode_handled = false;
|
|
break;
|
|
}
|
|
// numlock disabled. fallthrough to key_right
|
|
}
|
|
case KEY_RIGHT: {
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
#ifdef APPLE_STYLE_KEYS
|
|
else
|
|
#else
|
|
else if (!k.mod.alt)
|
|
#endif
|
|
deselect();
|
|
|
|
#ifdef APPLE_STYLE_KEYS
|
|
if (k.mod.command) {
|
|
cursor_set_column(text[cursor.line].length());
|
|
} else if (k.mod.alt) {
|
|
#else
|
|
if (k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
} else if (k.mod.command) {
|
|
#endif
|
|
bool prev_char=false;
|
|
int cc=cursor.column;
|
|
while (cc<text[cursor.line].length()) {
|
|
|
|
bool ischar=_is_text_char(text[cursor.line][cc]);
|
|
|
|
if (prev_char && !ischar)
|
|
break;
|
|
prev_char=ischar;
|
|
cc++;
|
|
}
|
|
|
|
cursor_set_column(cc);
|
|
|
|
} else if (cursor.column==text[cursor.line].length()) {
|
|
|
|
if (cursor.line<text.size()-1) {
|
|
cursor_set_line(cursor.line+1);
|
|
cursor_set_column(0);
|
|
}
|
|
} else {
|
|
cursor_set_column(cursor_get_column()+1);
|
|
}
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
|
|
} break;
|
|
case KEY_KP_8: {
|
|
if (k.unicode != 0) {
|
|
scancode_handled = false;
|
|
break;
|
|
}
|
|
// numlock disabled. fallthrough to key_up
|
|
}
|
|
case KEY_UP: {
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
if (k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
}
|
|
#ifndef APPLE_STYLE_KEYS
|
|
if (k.mod.command) {
|
|
_scroll_lines_up();
|
|
break;
|
|
}
|
|
#else
|
|
if (k.mod.command && k.mod.alt) {
|
|
_scroll_lines_up();
|
|
break;
|
|
}
|
|
|
|
if (k.mod.command)
|
|
cursor_set_line(0);
|
|
else
|
|
#endif
|
|
cursor_set_line(cursor_get_line()-1);
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
_cancel_code_hint();
|
|
|
|
} break;
|
|
case KEY_KP_2: {
|
|
if (k.unicode != 0) {
|
|
scancode_handled = false;
|
|
break;
|
|
}
|
|
// numlock disabled. fallthrough to key_down
|
|
}
|
|
case KEY_DOWN: {
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
if (k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
}
|
|
#ifndef APPLE_STYLE_KEYS
|
|
if (k.mod.command) {
|
|
_scroll_lines_down();
|
|
break;
|
|
}
|
|
#else
|
|
if (k.mod.command && k.mod.alt) {
|
|
_scroll_lines_down();
|
|
break;
|
|
}
|
|
|
|
if (k.mod.command)
|
|
cursor_set_line(text.size()-1);
|
|
else
|
|
#endif
|
|
cursor_set_line(cursor_get_line()+1);
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
_cancel_code_hint();
|
|
|
|
} break;
|
|
|
|
case KEY_DELETE: {
|
|
|
|
if (readonly)
|
|
break;
|
|
|
|
if (k.mod.shift && !k.mod.command && !k.mod.alt) {
|
|
cut();
|
|
break;
|
|
}
|
|
|
|
int curline_len = text[cursor.line].length();
|
|
|
|
if (cursor.line==text.size()-1 && cursor.column==curline_len)
|
|
break; //nothing to do
|
|
|
|
int next_line=cursor.column<curline_len?cursor.line:cursor.line+1;
|
|
int next_column;
|
|
|
|
#ifdef APPLE_STYLE_KEYS
|
|
if (k.mod.alt) {
|
|
#else
|
|
if (k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
} else if (k.mod.command) {
|
|
#endif
|
|
int last_line=text.size()-1;
|
|
|
|
int line=cursor.line;
|
|
int column=cursor.column;
|
|
|
|
bool prev_char=false;
|
|
bool only_whitespace=true;
|
|
|
|
while (only_whitespace && line < last_line) {
|
|
|
|
while (column<text[line].length()) {
|
|
CharType c=text[line][column];
|
|
|
|
if (c != '\t' && c != ' ') {
|
|
only_whitespace=false;
|
|
break;
|
|
}
|
|
|
|
column++;
|
|
}
|
|
|
|
if (only_whitespace) {
|
|
line++;
|
|
column=0;
|
|
}
|
|
}
|
|
|
|
while (column<text[line].length()) {
|
|
|
|
bool ischar=_is_text_char(text[line][column]);
|
|
|
|
if (prev_char && !ischar)
|
|
break;
|
|
prev_char=ischar;
|
|
column++;
|
|
}
|
|
|
|
next_line=line;
|
|
next_column=column;
|
|
} else {
|
|
next_column=cursor.column<curline_len?(cursor.column+1):0;
|
|
}
|
|
|
|
_remove_text(cursor.line,cursor.column,next_line,next_column);
|
|
update();
|
|
|
|
} break;
|
|
case KEY_KP_7: {
|
|
if (k.unicode != 0) {
|
|
scancode_handled = false;
|
|
break;
|
|
}
|
|
// numlock disabled. fallthrough to key_home
|
|
}
|
|
#ifdef APPLE_STYLE_KEYS
|
|
case KEY_HOME: {
|
|
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
|
|
cursor_set_line(0);
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
|
|
} break;
|
|
#else
|
|
case KEY_HOME: {
|
|
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
|
|
// compute whitespace symbols seq length
|
|
int current_line_whitespace_len = 0;
|
|
while(current_line_whitespace_len < text[cursor.line].length()) {
|
|
CharType c = text[cursor.line][current_line_whitespace_len];
|
|
if(c != '\t' && c != ' ')
|
|
break;
|
|
current_line_whitespace_len++;
|
|
}
|
|
|
|
if(cursor_get_column() == current_line_whitespace_len)
|
|
cursor_set_column(0);
|
|
else
|
|
cursor_set_column(current_line_whitespace_len);
|
|
|
|
if (k.mod.command)
|
|
cursor_set_line(0);
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
_cancel_completion();
|
|
completion_hint="";
|
|
|
|
} break;
|
|
#endif
|
|
case KEY_KP_1: {
|
|
if (k.unicode != 0) {
|
|
scancode_handled = false;
|
|
break;
|
|
}
|
|
// numlock disabled. fallthrough to key_end
|
|
}
|
|
#ifdef APPLE_STYLE_KEYS
|
|
case KEY_END: {
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
|
|
cursor_set_line(text.size()-1);
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
|
|
} break;
|
|
#else
|
|
case KEY_END: {
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
|
|
if (k.mod.command)
|
|
cursor_set_line(text.size()-1);
|
|
cursor_set_column(text[cursor.line].length());
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
|
|
_cancel_completion();
|
|
completion_hint="";
|
|
|
|
} break;
|
|
#endif
|
|
case KEY_KP_9: {
|
|
if (k.unicode != 0) {
|
|
scancode_handled = false;
|
|
break;
|
|
}
|
|
// numlock disabled. fallthrough to key_pageup
|
|
}
|
|
case KEY_PAGEUP: {
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
|
|
cursor_set_line(cursor_get_line()-get_visible_rows());
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
|
|
_cancel_completion();
|
|
completion_hint="";
|
|
|
|
|
|
} break;
|
|
case KEY_KP_3: {
|
|
if (k.unicode != 0) {
|
|
scancode_handled = false;
|
|
break;
|
|
}
|
|
// numlock disabled. fallthrough to key_pageup
|
|
}
|
|
case KEY_PAGEDOWN: {
|
|
|
|
if (k.mod.shift)
|
|
_pre_shift_selection();
|
|
|
|
cursor_set_line(cursor_get_line()+get_visible_rows());
|
|
|
|
if (k.mod.shift)
|
|
_post_shift_selection();
|
|
|
|
_cancel_completion();
|
|
completion_hint="";
|
|
|
|
|
|
} break;
|
|
case KEY_A: {
|
|
|
|
if (!k.mod.command || k.mod.shift || k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
}
|
|
|
|
select_all();
|
|
|
|
} break;
|
|
case KEY_X: {
|
|
if (readonly) {
|
|
break;
|
|
}
|
|
if (!k.mod.command || k.mod.shift || k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
}
|
|
|
|
cut();
|
|
|
|
} break;
|
|
case KEY_C: {
|
|
|
|
if (!k.mod.command || k.mod.shift || k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
}
|
|
|
|
copy();
|
|
|
|
} break;
|
|
case KEY_Z: {
|
|
|
|
if (!k.mod.command) {
|
|
scancode_handled=false;
|
|
break;
|
|
}
|
|
|
|
if (k.mod.shift)
|
|
redo();
|
|
else
|
|
undo();
|
|
} break;
|
|
case KEY_V: {
|
|
if (readonly) {
|
|
break;
|
|
}
|
|
if (!k.mod.command || k.mod.shift || k.mod.alt) {
|
|
scancode_handled=false;
|
|
break;
|
|
}
|
|
|
|
paste();
|
|
|
|
} break;
|
|
case KEY_SPACE: {
|
|
#ifdef OSX_ENABLED
|
|
if (completion_enabled && k.mod.meta) { //cmd-space is spotlight shortcut in OSX
|
|
#else
|
|
if (completion_enabled && k.mod.command) {
|
|
#endif
|
|
|
|
query_code_comple();
|
|
scancode_handled=true;
|
|
} else {
|
|
scancode_handled=false;
|
|
}
|
|
|
|
} break;
|
|
|
|
case KEY_U:{
|
|
if (!k.mod.command || k.mod.shift) {
|
|
scancode_handled=false;
|
|
break;
|
|
}
|
|
else {
|
|
if (selection.active) {
|
|
int ini = selection.from_line;
|
|
int end = selection.to_line;
|
|
for (int i=ini; i<= end; i++)
|
|
{
|
|
if (text[i][0] == '#')
|
|
_remove_text(i,0,i,1);
|
|
}
|
|
}
|
|
else{
|
|
if (text[cursor.line][0] == '#')
|
|
_remove_text(cursor.line,0,cursor.line,1);
|
|
}
|
|
update();
|
|
}
|
|
break;}
|
|
|
|
default: {
|
|
|
|
scancode_handled=false;
|
|
} break;
|
|
|
|
}
|
|
|
|
if (scancode_handled)
|
|
accept_event();
|
|
/*
|
|
if (!scancode_handled && !k.mod.command && !k.mod.alt) {
|
|
|
|
if (k.unicode>=32) {
|
|
|
|
if (readonly)
|
|
break;
|
|
|
|
accept_event();
|
|
} else {
|
|
|
|
break;
|
|
}
|
|
}
|
|
*/
|
|
if (k.scancode==KEY_INSERT) {
|
|
set_insert_mode(!insert_mode);
|
|
accept_event();
|
|
return;
|
|
}
|
|
|
|
if (!scancode_handled && !k.mod.command) { //for german kbds
|
|
|
|
if (k.unicode>=32) {
|
|
|
|
if (readonly)
|
|
break;
|
|
|
|
// remove the old character if in insert mode and no selection
|
|
if (insert_mode && !had_selection) {
|
|
begin_complex_operation();
|
|
|
|
// make sure we don't try and remove empty space
|
|
if (cursor.column < get_line(cursor.line).length()) {
|
|
_remove_text(cursor.line, cursor.column, cursor.line, cursor.column + 1);
|
|
}
|
|
}
|
|
|
|
const CharType chr[2] = {(CharType)k.unicode, 0};
|
|
|
|
if (completion_hint!="" && k.unicode==')') {
|
|
completion_hint="";
|
|
}
|
|
if(auto_brace_completion_enabled && _is_pair_symbol(chr[0])) {
|
|
_consume_pair_symbol(chr[0]);
|
|
} else {
|
|
_insert_text_at_cursor(chr);
|
|
}
|
|
|
|
if (insert_mode && !had_selection) {
|
|
end_complex_operation();
|
|
}
|
|
|
|
if (selection.active != had_selection) {
|
|
end_complex_operation();
|
|
}
|
|
accept_event();
|
|
} else {
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
return;
|
|
} break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void TextEdit::_pre_shift_selection() {
|
|
|
|
|
|
if (!selection.active || selection.selecting_mode==Selection::MODE_NONE) {
|
|
|
|
selection.selecting_line=cursor.line;
|
|
selection.selecting_column=cursor.column;
|
|
selection.active=true;
|
|
}
|
|
|
|
selection.selecting_mode=Selection::MODE_SHIFT;
|
|
}
|
|
|
|
void TextEdit::_post_shift_selection() {
|
|
|
|
|
|
if (selection.active && selection.selecting_mode==Selection::MODE_SHIFT) {
|
|
|
|
select(selection.selecting_line,selection.selecting_column,cursor.line,cursor.column);
|
|
update();
|
|
}
|
|
|
|
|
|
selection.selecting_text=true;
|
|
}
|
|
|
|
void TextEdit::_scroll_lines_up() {
|
|
// adjust the vertical scroll
|
|
if (get_v_scroll() > 0) {
|
|
set_v_scroll(get_v_scroll() - 1);
|
|
}
|
|
|
|
// adjust the cursor
|
|
if (cursor_get_line() >= (get_visible_rows() + get_v_scroll()) && !selection.active) {
|
|
cursor_set_line((get_visible_rows() + get_v_scroll()) - 1, false);
|
|
}
|
|
}
|
|
|
|
void TextEdit::_scroll_lines_down() {
|
|
// calculate the maximum vertical scroll position
|
|
int max_v_scroll = get_line_count() - 1;
|
|
if (!scroll_past_end_of_file_enabled) {
|
|
max_v_scroll -= get_visible_rows() - 1;
|
|
}
|
|
|
|
// adjust the vertical scroll
|
|
if (get_v_scroll() < max_v_scroll) {
|
|
set_v_scroll(get_v_scroll() + 1);
|
|
}
|
|
|
|
// adjust the cursor
|
|
if ((cursor_get_line()) <= get_v_scroll() - 1 && !selection.active) {
|
|
cursor_set_line(get_v_scroll(), false);
|
|
}
|
|
}
|
|
|
|
/**** TEXT EDIT CORE API ****/
|
|
|
|
void TextEdit::_base_insert_text(int p_line, int p_char,const String& p_text,int &r_end_line,int &r_end_column) {
|
|
|
|
//save for undo...
|
|
ERR_FAIL_INDEX(p_line,text.size());
|
|
ERR_FAIL_COND(p_char<0);
|
|
|
|
/* STEP 1 add spaces if the char is greater than the end of the line */
|
|
while(p_char>text[p_line].length()) {
|
|
|
|
text.set(p_line,text[p_line]+String::chr(' '));
|
|
}
|
|
|
|
/* STEP 2 separate dest string in pre and post text */
|
|
|
|
String preinsert_text = text[p_line].substr(0,p_char);
|
|
String postinsert_text = text[p_line].substr(p_char,text[p_line].size());
|
|
|
|
/* STEP 3 remove \r from source text and separate in substrings */
|
|
|
|
//buh bye \r and split
|
|
Vector<String> substrings = p_text.replace("\r","").split("\n");
|
|
|
|
|
|
for(int i=0;i<substrings.size();i++) {
|
|
//insert the substrings
|
|
|
|
if (i==0) {
|
|
|
|
text.set(p_line,preinsert_text+substrings[i]);
|
|
} else {
|
|
|
|
text.insert(p_line+i,substrings[i]);
|
|
}
|
|
|
|
if (i==substrings.size()-1){
|
|
|
|
text.set(p_line+i,text[p_line+i]+postinsert_text);
|
|
}
|
|
}
|
|
|
|
r_end_line=p_line+substrings.size()-1;
|
|
r_end_column=text[r_end_line].length()-postinsert_text.length();
|
|
|
|
if (!text_changed_dirty && !setting_text) {
|
|
if (is_inside_tree())
|
|
MessageQueue::get_singleton()->push_call(this,"_text_changed_emit");
|
|
text_changed_dirty=true;
|
|
}
|
|
|
|
}
|
|
|
|
String TextEdit::_base_get_text(int p_from_line, int p_from_column,int p_to_line,int p_to_column) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_from_line,text.size(),String());
|
|
ERR_FAIL_INDEX_V(p_from_column,text[p_from_line].length()+1,String());
|
|
ERR_FAIL_INDEX_V(p_to_line,text.size(),String());
|
|
ERR_FAIL_INDEX_V(p_to_column,text[p_to_line].length()+1,String());
|
|
ERR_FAIL_COND_V(p_to_line < p_from_line ,String()); // from > to
|
|
ERR_FAIL_COND_V(p_to_line == p_from_line && p_to_column<p_from_column,String()); // from > to
|
|
|
|
String ret;
|
|
|
|
for(int i=p_from_line;i<=p_to_line;i++) {
|
|
|
|
int begin = (i==p_from_line)?p_from_column:0;
|
|
int end = (i==p_to_line)?p_to_column:text[i].length();
|
|
|
|
if (i>p_from_line)
|
|
ret+="\n";
|
|
ret+=text[i].substr(begin,end-begin);
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
void TextEdit::_base_remove_text(int p_from_line, int p_from_column,int p_to_line,int p_to_column) {
|
|
|
|
ERR_FAIL_INDEX(p_from_line,text.size());
|
|
ERR_FAIL_INDEX(p_from_column,text[p_from_line].length()+1);
|
|
ERR_FAIL_INDEX(p_to_line,text.size());
|
|
ERR_FAIL_INDEX(p_to_column,text[p_to_line].length()+1);
|
|
ERR_FAIL_COND(p_to_line < p_from_line ); // from > to
|
|
ERR_FAIL_COND(p_to_line == p_from_line && p_to_column<p_from_column); // from > to
|
|
|
|
|
|
String pre_text = text[p_from_line].substr(0,p_from_column);
|
|
String post_text = text[p_to_line].substr(p_to_column,text[p_to_line].length());
|
|
|
|
for(int i=p_from_line;i<p_to_line;i++) {
|
|
|
|
text.remove(p_from_line+1);
|
|
}
|
|
|
|
text.set(p_from_line,pre_text+post_text);
|
|
|
|
if (!text_changed_dirty && !setting_text) {
|
|
if (is_inside_tree())
|
|
MessageQueue::get_singleton()->push_call(this,"_text_changed_emit");
|
|
text_changed_dirty=true;
|
|
}
|
|
}
|
|
|
|
void TextEdit::_insert_text(int p_line, int p_char,const String& p_text,int *r_end_line,int *r_end_column) {
|
|
|
|
if (!setting_text)
|
|
idle_detect->start();
|
|
|
|
if (undo_enabled) {
|
|
_clear_redo();
|
|
}
|
|
|
|
int retline,retchar;
|
|
_base_insert_text(p_line,p_char,p_text,retline,retchar);
|
|
if (r_end_line)
|
|
*r_end_line=retline;
|
|
if (r_end_column)
|
|
*r_end_column=retchar;
|
|
|
|
if (!undo_enabled)
|
|
return;
|
|
|
|
/* UNDO!! */
|
|
TextOperation op;
|
|
op.type=TextOperation::TYPE_INSERT;
|
|
op.from_line=p_line;
|
|
op.from_column=p_char;
|
|
op.to_line=retline;
|
|
op.to_column=retchar;
|
|
op.text=p_text;
|
|
op.version=++version;
|
|
op.chain_forward=false;
|
|
op.chain_backward=false;
|
|
|
|
//see if it shold just be set as current op
|
|
if (current_op.type!=op.type) {
|
|
op.prev_version = get_version();
|
|
_push_current_op();
|
|
current_op=op;
|
|
|
|
return; //set as current op, return
|
|
}
|
|
//see if it can be merged
|
|
if (current_op.to_line!=p_line || current_op.to_column!=p_char) {
|
|
op.prev_version = get_version();
|
|
_push_current_op();
|
|
current_op=op;
|
|
return; //set as current op, return
|
|
}
|
|
//merge current op
|
|
|
|
current_op.text+=p_text;
|
|
current_op.to_column=retchar;
|
|
current_op.to_line=retline;
|
|
current_op.version=op.version;
|
|
|
|
}
|
|
|
|
void TextEdit::_remove_text(int p_from_line, int p_from_column,int p_to_line,int p_to_column) {
|
|
|
|
if (!setting_text)
|
|
idle_detect->start();
|
|
|
|
String text;
|
|
if (undo_enabled) {
|
|
_clear_redo();
|
|
text=_base_get_text(p_from_line,p_from_column,p_to_line,p_to_column);
|
|
}
|
|
|
|
_base_remove_text(p_from_line,p_from_column,p_to_line,p_to_column);
|
|
|
|
if (!undo_enabled)
|
|
return;
|
|
|
|
/* UNDO!! */
|
|
TextOperation op;
|
|
op.type=TextOperation::TYPE_REMOVE;
|
|
op.from_line=p_from_line;
|
|
op.from_column=p_from_column;
|
|
op.to_line=p_to_line;
|
|
op.to_column=p_to_column;
|
|
op.text=text;
|
|
op.version=++version;
|
|
op.chain_forward=false;
|
|
op.chain_backward=false;
|
|
|
|
//see if it shold just be set as current op
|
|
if (current_op.type!=op.type) {
|
|
op.prev_version = get_version();
|
|
_push_current_op();
|
|
current_op=op;
|
|
return; //set as current op, return
|
|
}
|
|
//see if it can be merged
|
|
if (current_op.from_line==p_to_line && current_op.from_column==p_to_column) {
|
|
//basckace or similar
|
|
current_op.text=text+current_op.text;
|
|
current_op.from_line=p_from_line;
|
|
current_op.from_column=p_from_column;
|
|
return; //update current op
|
|
}
|
|
if (current_op.from_line==p_from_line && current_op.from_column==p_from_column) {
|
|
|
|
//current_op.text=text+current_op.text;
|
|
//current_op.from_line=p_from_line;
|
|
//current_op.from_column=p_from_column;
|
|
//return; //update current op
|
|
}
|
|
|
|
op.prev_version = get_version();
|
|
_push_current_op();
|
|
current_op=op;
|
|
|
|
}
|
|
|
|
|
|
void TextEdit::_insert_text_at_cursor(const String& p_text) {
|
|
|
|
int new_column,new_line;
|
|
_insert_text(cursor.line,cursor.column,p_text,&new_line,&new_column);
|
|
cursor_set_line(new_line);
|
|
cursor_set_column(new_column);
|
|
|
|
update();
|
|
}
|
|
|
|
|
|
|
|
|
|
int TextEdit::get_char_count() {
|
|
|
|
int totalsize=0;
|
|
|
|
for (int i=0;i<text.size();i++) {
|
|
|
|
if (i>0)
|
|
totalsize++; // incliude \n
|
|
totalsize+=text[i].length();
|
|
}
|
|
|
|
return totalsize; // omit last \n
|
|
}
|
|
|
|
Size2 TextEdit::get_minimum_size() const {
|
|
|
|
return cache.style_normal->get_minimum_size();
|
|
}
|
|
int TextEdit::get_visible_rows() const {
|
|
|
|
int total=cache.size.height;
|
|
total-=cache.style_normal->get_minimum_size().height;
|
|
total/=get_row_height();
|
|
return total;
|
|
}
|
|
void TextEdit::adjust_viewport_to_cursor() {
|
|
|
|
if (cursor.line_ofs>cursor.line)
|
|
cursor.line_ofs=cursor.line;
|
|
|
|
int visible_width=cache.size.width-cache.style_normal->get_minimum_size().width-cache.line_number_w-cache.breakpoint_gutter_width;
|
|
if (v_scroll->is_visible())
|
|
visible_width-=v_scroll->get_combined_minimum_size().width;
|
|
visible_width-=20; // give it a little more space
|
|
|
|
|
|
//printf("rowofs %i, visrows %i, cursor.line %i\n",cursor.line_ofs,get_visible_rows(),cursor.line);
|
|
|
|
int visible_rows = get_visible_rows();
|
|
if (h_scroll->is_visible())
|
|
visible_rows-=((h_scroll->get_combined_minimum_size().height-1)/get_row_height());
|
|
|
|
if (cursor.line>=(cursor.line_ofs+visible_rows))
|
|
cursor.line_ofs=cursor.line-visible_rows+1;
|
|
if (cursor.line<cursor.line_ofs)
|
|
cursor.line_ofs=cursor.line;
|
|
|
|
int cursor_x = get_column_x_offset( cursor.column, text[cursor.line] );
|
|
|
|
if (cursor_x>(cursor.x_ofs+visible_width))
|
|
cursor.x_ofs=cursor_x-visible_width+1;
|
|
|
|
if (cursor_x < cursor.x_ofs)
|
|
cursor.x_ofs=cursor_x;
|
|
|
|
update();
|
|
/*
|
|
get_range()->set_max(text.size());
|
|
|
|
get_range()->set_page(get_visible_rows());
|
|
|
|
get_range()->set((int)cursor.line_ofs);
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
void TextEdit::center_viewport_to_cursor() {
|
|
|
|
if (cursor.line_ofs>cursor.line)
|
|
cursor.line_ofs=cursor.line;
|
|
|
|
int visible_width=cache.size.width-cache.style_normal->get_minimum_size().width-cache.line_number_w-cache.breakpoint_gutter_width;
|
|
if (v_scroll->is_visible())
|
|
visible_width-=v_scroll->get_combined_minimum_size().width;
|
|
visible_width-=20; // give it a little more space
|
|
|
|
int visible_rows = get_visible_rows();
|
|
if (h_scroll->is_visible())
|
|
visible_rows-=((h_scroll->get_combined_minimum_size().height-1)/get_row_height());
|
|
|
|
int max_ofs = text.size()-(scroll_past_end_of_file_enabled?1:visible_rows);
|
|
cursor.line_ofs=CLAMP(cursor.line-(visible_rows/2),0,max_ofs);
|
|
|
|
int cursor_x = get_column_x_offset( cursor.column, text[cursor.line] );
|
|
|
|
if (cursor_x>(cursor.x_ofs+visible_width))
|
|
cursor.x_ofs=cursor_x-visible_width+1;
|
|
|
|
if (cursor_x < cursor.x_ofs)
|
|
cursor.x_ofs=cursor_x;
|
|
|
|
update();
|
|
}
|
|
|
|
void TextEdit::cursor_set_column(int p_col, bool p_adjust_viewport) {
|
|
|
|
if (p_col<0)
|
|
p_col=0;
|
|
|
|
cursor.column=p_col;
|
|
if (cursor.column > get_line( cursor.line ).length())
|
|
cursor.column=get_line( cursor.line ).length();
|
|
|
|
cursor.last_fit_x=get_column_x_offset(cursor.column,get_line(cursor.line));
|
|
|
|
if (p_adjust_viewport)
|
|
adjust_viewport_to_cursor();
|
|
|
|
if (!cursor_changed_dirty) {
|
|
if (is_inside_tree())
|
|
MessageQueue::get_singleton()->push_call(this,"_cursor_changed_emit");
|
|
cursor_changed_dirty=true;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void TextEdit::cursor_set_line(int p_row, bool p_adjust_viewport) {
|
|
|
|
if (setting_row)
|
|
return;
|
|
|
|
setting_row=true;
|
|
if (p_row<0)
|
|
p_row=0;
|
|
|
|
|
|
if (p_row>=(int)text.size())
|
|
p_row=(int)text.size()-1;
|
|
|
|
cursor.line=p_row;
|
|
cursor.column=get_char_pos_for( cursor.last_fit_x, get_line( cursor.line) );
|
|
|
|
if (p_adjust_viewport)
|
|
adjust_viewport_to_cursor();
|
|
|
|
setting_row=false;
|
|
|
|
|
|
if (!cursor_changed_dirty) {
|
|
if (is_inside_tree())
|
|
MessageQueue::get_singleton()->push_call(this,"_cursor_changed_emit");
|
|
cursor_changed_dirty=true;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
int TextEdit::cursor_get_column() const {
|
|
|
|
return cursor.column;
|
|
}
|
|
|
|
|
|
int TextEdit::cursor_get_line() const {
|
|
|
|
return cursor.line;
|
|
}
|
|
|
|
bool TextEdit::cursor_get_blink_enabled() const {
|
|
return caret_blink_enabled;
|
|
}
|
|
|
|
void TextEdit::cursor_set_blink_enabled(const bool p_enabled) {
|
|
caret_blink_enabled = p_enabled;
|
|
|
|
if (p_enabled) {
|
|
caret_blink_timer->start();
|
|
} else {
|
|
caret_blink_timer->stop();
|
|
}
|
|
draw_caret = true;
|
|
}
|
|
|
|
|
|
float TextEdit::cursor_get_blink_speed() const {
|
|
return caret_blink_timer->get_wait_time();
|
|
}
|
|
|
|
void TextEdit::cursor_set_blink_speed(const float p_speed) {
|
|
ERR_FAIL_COND(p_speed <= 0);
|
|
caret_blink_timer->set_wait_time(p_speed);
|
|
}
|
|
|
|
void TextEdit::cursor_set_block_mode(const bool p_enable){
|
|
block_caret = p_enable;
|
|
update();
|
|
}
|
|
|
|
bool TextEdit::cursor_is_block_mode() const {
|
|
return block_caret;
|
|
}
|
|
|
|
|
|
void TextEdit::_scroll_moved(double p_to_val) {
|
|
|
|
if (updating_scrolls)
|
|
return;
|
|
|
|
if (h_scroll->is_visible())
|
|
cursor.x_ofs=h_scroll->get_val();
|
|
if (v_scroll->is_visible())
|
|
cursor.line_ofs=v_scroll->get_val();
|
|
update();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int TextEdit::get_row_height() const {
|
|
|
|
return cache.font->get_height()+cache.line_spacing;
|
|
}
|
|
|
|
int TextEdit::get_char_pos_for(int p_px,String p_str) const {
|
|
|
|
int px=0;
|
|
int c=0;
|
|
|
|
int tab_w = cache.font->get_char_size(' ').width*tab_size;
|
|
|
|
while (c<p_str.length()) {
|
|
|
|
int w=0;
|
|
|
|
if (p_str[c]=='\t') {
|
|
|
|
int left = px%tab_w;
|
|
if (left==0)
|
|
w=tab_w;
|
|
else
|
|
w=tab_w-px%tab_w; // is right...
|
|
|
|
} else {
|
|
|
|
w=cache.font->get_char_size(p_str[c],p_str[c+1]).width;
|
|
}
|
|
|
|
if (p_px<(px+w/2))
|
|
break;
|
|
px+=w;
|
|
c++;
|
|
}
|
|
|
|
return c;
|
|
}
|
|
|
|
int TextEdit::get_column_x_offset(int p_char,String p_str) {
|
|
|
|
int px=0;
|
|
|
|
int tab_w = cache.font->get_char_size(' ').width*tab_size;
|
|
|
|
for (int i=0;i<p_char;i++) {
|
|
|
|
if (i>=p_str.length())
|
|
break;
|
|
|
|
if (p_str[i]=='\t') {
|
|
|
|
int left = px%tab_w;
|
|
if (left==0)
|
|
px+=tab_w;
|
|
else
|
|
px+=tab_w-px%tab_w; // is right...
|
|
|
|
} else {
|
|
px+=cache.font->get_char_size(p_str[i],p_str[i+1]).width;
|
|
}
|
|
}
|
|
|
|
return px;
|
|
|
|
}
|
|
|
|
void TextEdit::insert_text_at_cursor(const String& p_text) {
|
|
|
|
if (selection.active) {
|
|
|
|
cursor_set_line(selection.from_line);
|
|
cursor_set_column(selection.from_column);
|
|
|
|
_remove_text(selection.from_line,selection.from_column,selection.to_line,selection.to_column);
|
|
selection.active=false;
|
|
selection.selecting_mode=Selection::MODE_NONE;
|
|
|
|
}
|
|
|
|
_insert_text_at_cursor(p_text);
|
|
update();
|
|
|
|
}
|
|
|
|
Control::CursorShape TextEdit::get_cursor_shape(const Point2& p_pos) const {
|
|
int gutter=cache.style_normal->get_margin(MARGIN_LEFT)+cache.line_number_w+cache.breakpoint_gutter_width;
|
|
if((completion_active && completion_rect.has_point(p_pos)) || p_pos.x < gutter) {
|
|
return CURSOR_ARROW;
|
|
}
|
|
return CURSOR_IBEAM;
|
|
}
|
|
|
|
|
|
void TextEdit::set_text(String p_text){
|
|
|
|
setting_text=true;
|
|
clear();
|
|
_insert_text_at_cursor(p_text);
|
|
clear_undo_history();
|
|
cursor.column=0;
|
|
cursor.line=0;
|
|
cursor.x_ofs=0;
|
|
cursor.line_ofs=0;
|
|
cursor.last_fit_x=0;
|
|
cursor_set_line(0);
|
|
cursor_set_column(0);
|
|
update();
|
|
setting_text=false;
|
|
|
|
//get_range()->set(0);
|
|
};
|
|
|
|
String TextEdit::get_text() {
|
|
String longthing;
|
|
int len = text.size();
|
|
for (int i=0;i<len;i++) {
|
|
|
|
|
|
longthing+=text[i];
|
|
if (i!=len-1)
|
|
longthing+="\n";
|
|
}
|
|
|
|
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 "";
|
|
|
|
return text[line];
|
|
|
|
};
|
|
|
|
void TextEdit::_clear() {
|
|
|
|
clear_undo_history();
|
|
text.clear();
|
|
cursor.column=0;
|
|
cursor.line=0;
|
|
cursor.x_ofs=0;
|
|
cursor.line_ofs=0;
|
|
cursor.last_fit_x=0;
|
|
}
|
|
|
|
|
|
|
|
void TextEdit::clear() {
|
|
|
|
setting_text=true;
|
|
_clear();
|
|
setting_text=false;
|
|
|
|
};
|
|
|
|
void TextEdit::set_readonly(bool p_readonly) {
|
|
|
|
|
|
readonly=p_readonly;
|
|
}
|
|
|
|
void TextEdit::set_wrap(bool p_wrap) {
|
|
|
|
wrap=p_wrap;
|
|
}
|
|
|
|
void TextEdit::set_max_chars(int p_max_chars) {
|
|
|
|
max_chars=p_max_chars;
|
|
}
|
|
|
|
void TextEdit::_reset_caret_blink_timer() {
|
|
if (caret_blink_enabled) {
|
|
caret_blink_timer->stop();
|
|
caret_blink_timer->start();
|
|
draw_caret = true;
|
|
update();
|
|
}
|
|
}
|
|
|
|
void TextEdit::_toggle_draw_caret() {
|
|
draw_caret = !draw_caret;
|
|
if (is_visible() && has_focus() && window_has_focus) {
|
|
update();
|
|
}
|
|
}
|
|
|
|
void TextEdit::_update_caches() {
|
|
|
|
cache.style_normal=get_stylebox("normal");
|
|
cache.style_focus=get_stylebox("focus");
|
|
cache.completion_background_color=get_color("completion_background_color");
|
|
cache.completion_selected_color=get_color("completion_selected_color");
|
|
cache.completion_existing_color=get_color("completion_existing_color");
|
|
cache.completion_font_color=get_color("completion_font_color");
|
|
cache.font=get_font("font");
|
|
cache.caret_color=get_color("caret_color");
|
|
cache.caret_background_color=get_color("caret_background_color");
|
|
cache.line_number_color=get_color("line_number_color");
|
|
cache.font_color=get_color("font_color");
|
|
cache.font_selected_color=get_color("font_selected_color");
|
|
cache.keyword_color=get_color("keyword_color");
|
|
cache.function_color=get_color("function_color");
|
|
cache.member_variable_color=get_color("member_variable_color");
|
|
cache.number_color=get_color("number_color");
|
|
cache.selection_color=get_color("selection_color");
|
|
cache.mark_color=get_color("mark_color");
|
|
cache.current_line_color=get_color("current_line_color");
|
|
cache.breakpoint_color=get_color("breakpoint_color");
|
|
cache.brace_mismatch_color=get_color("brace_mismatch_color");
|
|
cache.word_highlighted_color=get_color("word_highlighted_color");
|
|
cache.search_result_color=get_color("search_result_color");
|
|
cache.search_result_border_color=get_color("search_result_border_color");
|
|
cache.line_spacing=get_constant("line_spacing");
|
|
cache.row_height = cache.font->get_height() + cache.line_spacing;
|
|
cache.tab_icon=get_icon("tab");
|
|
text.set_font(cache.font);
|
|
|
|
}
|
|
|
|
|
|
void TextEdit::clear_colors() {
|
|
|
|
keywords.clear();
|
|
color_regions.clear();;
|
|
text.clear_caches();
|
|
custom_bg_color=Color(0,0,0,0);
|
|
}
|
|
|
|
void TextEdit::set_custom_bg_color(const Color& p_color) {
|
|
|
|
custom_bg_color=p_color;
|
|
update();
|
|
}
|
|
|
|
void TextEdit::add_keyword_color(const String& p_keyword,const Color& p_color) {
|
|
|
|
keywords[p_keyword]=p_color;
|
|
update();
|
|
|
|
}
|
|
|
|
void TextEdit::add_color_region(const String& p_begin_key,const String& p_end_key,const Color &p_color,bool p_line_only) {
|
|
|
|
color_regions.push_back(ColorRegion(p_begin_key,p_end_key,p_color,p_line_only));
|
|
text.clear_caches();
|
|
update();
|
|
|
|
}
|
|
|
|
void TextEdit::set_symbol_color(const Color& p_color) {
|
|
|
|
symbol_color=p_color;
|
|
update();
|
|
}
|
|
|
|
void TextEdit::set_syntax_coloring(bool p_enabled) {
|
|
|
|
syntax_coloring=p_enabled;
|
|
update();
|
|
}
|
|
|
|
bool TextEdit::is_syntax_coloring_enabled() const {
|
|
|
|
return syntax_coloring;
|
|
}
|
|
|
|
void TextEdit::set_auto_indent(bool p_auto_indent) {
|
|
auto_indent = p_auto_indent;
|
|
}
|
|
|
|
void TextEdit::cut() {
|
|
|
|
if (!selection.active) {
|
|
|
|
String clipboard = text[cursor.line];
|
|
OS::get_singleton()->set_clipboard(clipboard);
|
|
cursor_set_line(cursor.line);
|
|
cursor_set_column(0);
|
|
_remove_text(cursor.line,0,cursor.line,text[cursor.line].length());
|
|
|
|
backspace_at_cursor();
|
|
update();
|
|
cursor_set_line(cursor.line+1);
|
|
cut_copy_line = true;
|
|
|
|
} else {
|
|
|
|
String clipboard = _base_get_text(selection.from_line,selection.from_column,selection.to_line,selection.to_column);
|
|
OS::get_singleton()->set_clipboard(clipboard);
|
|
|
|
cursor_set_line(selection.from_line);
|
|
cursor_set_column(selection.from_column);
|
|
|
|
_remove_text(selection.from_line,selection.from_column,selection.to_line,selection.to_column);
|
|
selection.active=false;
|
|
selection.selecting_mode=Selection::MODE_NONE;
|
|
update();
|
|
cut_copy_line = false;
|
|
}
|
|
}
|
|
|
|
void TextEdit::copy() {
|
|
|
|
if (!selection.active)
|
|
return;
|
|
|
|
if (!selection.active) {
|
|
String clipboard = _base_get_text(cursor.line,0,cursor.line,text[cursor.line].length());
|
|
OS::get_singleton()->set_clipboard(clipboard);
|
|
cut_copy_line = true;
|
|
} else {
|
|
String clipboard = _base_get_text(selection.from_line,selection.from_column,selection.to_line,selection.to_column);
|
|
OS::get_singleton()->set_clipboard(clipboard);
|
|
cut_copy_line = false;
|
|
}
|
|
}
|
|
|
|
void TextEdit::paste() {
|
|
|
|
String clipboard = OS::get_singleton()->get_clipboard();
|
|
|
|
if (selection.active) {
|
|
|
|
selection.active=false;
|
|
selection.selecting_mode=Selection::MODE_NONE;
|
|
_remove_text(selection.from_line,selection.from_column,selection.to_line,selection.to_column);
|
|
cursor_set_line(selection.from_line);
|
|
cursor_set_column(selection.from_column);
|
|
|
|
} else if (cut_copy_line) {
|
|
|
|
cursor_set_column(0);
|
|
String ins="\n";
|
|
clipboard += ins;
|
|
}
|
|
|
|
_insert_text_at_cursor(clipboard);
|
|
update();
|
|
}
|
|
|
|
void TextEdit::select_all() {
|
|
|
|
if (text.size()==1 && text[0].length()==0)
|
|
return;
|
|
selection.active=true;
|
|
selection.from_line=0;
|
|
selection.from_column=0;
|
|
selection.selecting_line=0;
|
|
selection.selecting_column=0;
|
|
selection.to_line=text.size()-1;
|
|
selection.to_column=text[selection.to_line].length();
|
|
selection.selecting_mode=Selection::MODE_SHIFT;
|
|
selection.shiftclick_left=true;
|
|
cursor_set_line( selection.to_line, false );
|
|
cursor_set_column( selection.to_column, false );
|
|
update();
|
|
|
|
}
|
|
|
|
|
|
void TextEdit::deselect() {
|
|
|
|
selection.active=false;
|
|
update();
|
|
}
|
|
|
|
void TextEdit::select(int p_from_line,int p_from_column,int p_to_line,int p_to_column) {
|
|
|
|
if (p_from_line>=text.size())
|
|
p_from_line=text.size()-1;
|
|
if (p_from_column>=text[p_from_line].length())
|
|
p_from_column=text[p_from_line].length();
|
|
|
|
if (p_to_line>=text.size())
|
|
p_to_line=text.size()-1;
|
|
if (p_to_column>=text[p_to_line].length())
|
|
p_to_column=text[p_to_line].length();
|
|
|
|
selection.from_line=p_from_line;
|
|
selection.from_column=p_from_column;
|
|
selection.to_line=p_to_line;
|
|
selection.to_column=p_to_column;
|
|
|
|
selection.active=true;
|
|
|
|
if (selection.from_line==selection.to_line) {
|
|
|
|
if (selection.from_column==selection.to_column) {
|
|
|
|
selection.active=false;
|
|
|
|
} else if (selection.from_column>selection.to_column) {
|
|
|
|
selection.shiftclick_left = false;
|
|
SWAP( selection.from_column, selection.to_column );
|
|
} else {
|
|
|
|
selection.shiftclick_left = true;
|
|
}
|
|
} else if (selection.from_line>selection.to_line) {
|
|
|
|
selection.shiftclick_left = false;
|
|
SWAP( selection.from_line, selection.to_line );
|
|
SWAP( selection.from_column, selection.to_column );
|
|
} else {
|
|
|
|
selection.shiftclick_left = true;
|
|
}
|
|
|
|
|
|
update();
|
|
}
|
|
|
|
bool TextEdit::is_selection_active() const {
|
|
|
|
return selection.active;
|
|
}
|
|
int TextEdit::get_selection_from_line() const {
|
|
|
|
ERR_FAIL_COND_V(!selection.active,-1);
|
|
return selection.from_line;
|
|
|
|
}
|
|
int TextEdit::get_selection_from_column() const {
|
|
|
|
ERR_FAIL_COND_V(!selection.active,-1);
|
|
return selection.from_column;
|
|
|
|
}
|
|
int TextEdit::get_selection_to_line() const {
|
|
|
|
ERR_FAIL_COND_V(!selection.active,-1);
|
|
return selection.to_line;
|
|
|
|
}
|
|
int TextEdit::get_selection_to_column() const {
|
|
|
|
ERR_FAIL_COND_V(!selection.active,-1);
|
|
return selection.to_column;
|
|
|
|
}
|
|
|
|
String TextEdit::get_selection_text() const {
|
|
|
|
if (!selection.active)
|
|
return "";
|
|
|
|
return _base_get_text(selection.from_line,selection.from_column,selection.to_line,selection.to_column);
|
|
|
|
}
|
|
|
|
String TextEdit::get_word_under_cursor() const {
|
|
|
|
int prev_cc = cursor.column;
|
|
while(prev_cc >0) {
|
|
bool is_char = _is_text_char(text[cursor.line][prev_cc-1]);
|
|
if (!is_char)
|
|
break;
|
|
--prev_cc;
|
|
}
|
|
|
|
int next_cc = cursor.column;
|
|
while(next_cc<text[cursor.line].length()) {
|
|
bool is_char = _is_text_char(text[cursor.line][next_cc]);
|
|
if(!is_char)
|
|
break;
|
|
++ next_cc;
|
|
}
|
|
if (prev_cc == cursor.column || next_cc == cursor.column)
|
|
return "";
|
|
return text[cursor.line].substr(prev_cc, next_cc-prev_cc);
|
|
}
|
|
|
|
void TextEdit::set_search_text(const String &p_search_text) {
|
|
search_text = p_search_text;
|
|
}
|
|
|
|
void TextEdit::set_search_flags(uint32_t p_flags) {
|
|
search_flags = p_flags;
|
|
}
|
|
|
|
void TextEdit::set_current_search_result(int line, int col) {
|
|
search_result_line = line;
|
|
search_result_col = col;
|
|
update();
|
|
}
|
|
|
|
void TextEdit::set_highlight_all_occurrences(const bool p_enabled) {
|
|
highlight_all_occurrences = p_enabled;
|
|
update();
|
|
}
|
|
|
|
bool TextEdit::is_highlight_all_occurrences_enabled() const {
|
|
return highlight_all_occurrences;
|
|
}
|
|
|
|
int TextEdit::_get_column_pos_of_word(const String &p_key, const String &p_search, uint32_t p_search_flags, int p_from_column) {
|
|
int col = -1;
|
|
|
|
if (p_key.length() > 0 && p_search.length() > 0) {
|
|
if (p_from_column < 0 || p_from_column > p_search.length()) {
|
|
p_from_column = 0;
|
|
}
|
|
|
|
while (col == -1 && p_from_column <= p_search.length()) {
|
|
if (p_search_flags&SEARCH_MATCH_CASE) {
|
|
col = p_search.find(p_key,p_from_column);
|
|
} else {
|
|
col = p_search.findn(p_key,p_from_column);
|
|
}
|
|
|
|
// whole words only
|
|
if (col != -1 && p_search_flags&SEARCH_WHOLE_WORDS) {
|
|
p_from_column=col;
|
|
|
|
if (col > 0 && _is_text_char(p_search[col-1])) {
|
|
col = -1;
|
|
} else if (_is_text_char(p_search[col+p_key.length()])) {
|
|
col = -1;
|
|
}
|
|
}
|
|
|
|
p_from_column+=1;
|
|
}
|
|
}
|
|
return col;
|
|
}
|
|
|
|
DVector<int> TextEdit::_search_bind(const String &p_key,uint32_t p_search_flags, int p_from_line,int p_from_column) const {
|
|
|
|
int col,line;
|
|
if (search(p_key,p_search_flags,p_from_line,p_from_column,col,line)) {
|
|
DVector<int> result;
|
|
result.resize(2);
|
|
result.set(0,line);
|
|
result.set(1,col);
|
|
return result;
|
|
|
|
} else {
|
|
|
|
return DVector<int>();
|
|
}
|
|
}
|
|
|
|
bool TextEdit::search(const String &p_key,uint32_t p_search_flags, int p_from_line, int p_from_column,int &r_line,int &r_column) const {
|
|
|
|
if (p_key.length()==0)
|
|
return false;
|
|
ERR_FAIL_INDEX_V(p_from_line,text.size(),false);
|
|
ERR_FAIL_INDEX_V(p_from_column,text[p_from_line].length()+1,false);
|
|
|
|
//search through the whole documment, but start by current line
|
|
|
|
int line=-1;
|
|
int pos=-1;
|
|
|
|
line=p_from_line;
|
|
|
|
for(int i=0;i<text.size()+1;i++) {
|
|
//backwards is broken...
|
|
//int idx=(p_search_flags&SEARCH_BACKWARDS)?(text.size()-i):i; //do backwards seearch
|
|
|
|
|
|
if (line<0) {
|
|
line=text.size()-1;
|
|
}
|
|
if (line==text.size()) {
|
|
line=0;
|
|
}
|
|
|
|
String text_line = text[line];
|
|
int from_column=0;
|
|
if (line==p_from_line) {
|
|
|
|
if (i==text.size()) {
|
|
//wrapped
|
|
|
|
if (p_search_flags&SEARCH_BACKWARDS) {
|
|
from_column=text_line.length();
|
|
} else {
|
|
from_column=0;
|
|
}
|
|
|
|
} else {
|
|
|
|
from_column=p_from_column;
|
|
}
|
|
|
|
|
|
} else {
|
|
if (p_search_flags&SEARCH_BACKWARDS)
|
|
from_column=text_line.length()-1;
|
|
else
|
|
from_column=0;
|
|
}
|
|
|
|
pos=-1;
|
|
|
|
int pos_from=0;
|
|
int last_pos=-1;
|
|
while ((last_pos=(p_search_flags&SEARCH_MATCH_CASE)?text_line.find(p_key,pos_from):text_line.findn(p_key,pos_from))!=-1) {
|
|
|
|
if (p_search_flags&SEARCH_BACKWARDS) {
|
|
|
|
if (last_pos>from_column)
|
|
break;
|
|
pos=last_pos;
|
|
|
|
} else {
|
|
|
|
if (last_pos>=from_column) {
|
|
pos=last_pos;
|
|
break;
|
|
}
|
|
}
|
|
|
|
pos_from=last_pos+p_key.length();
|
|
}
|
|
|
|
if (pos!=-1 && (p_search_flags&SEARCH_WHOLE_WORDS)) {
|
|
//validate for whole words
|
|
if (pos>0 && _is_text_char(text_line[pos-1]))
|
|
pos=-1;
|
|
else if (_is_text_char(text_line[pos+p_key.length()]))
|
|
pos=-1;
|
|
}
|
|
|
|
if (pos!=-1)
|
|
break;
|
|
|
|
if (p_search_flags&SEARCH_BACKWARDS)
|
|
line--;
|
|
else
|
|
line++;
|
|
|
|
}
|
|
|
|
if (pos==-1) {
|
|
r_line=-1;
|
|
r_column=-1;
|
|
return false;
|
|
}
|
|
|
|
r_line=line;
|
|
r_column=pos;
|
|
|
|
|
|
return true;
|
|
}
|
|
|
|
void TextEdit::_cursor_changed_emit() {
|
|
|
|
emit_signal("cursor_changed");
|
|
cursor_changed_dirty=false;
|
|
}
|
|
|
|
void TextEdit::_text_changed_emit() {
|
|
|
|
emit_signal("text_changed");
|
|
text_changed_dirty=false;
|
|
}
|
|
|
|
void TextEdit::set_line_as_marked(int p_line,bool p_marked) {
|
|
|
|
ERR_FAIL_INDEX(p_line,text.size());
|
|
text.set_marked(p_line,p_marked);
|
|
update();
|
|
}
|
|
|
|
bool TextEdit::is_line_set_as_breakpoint(int p_line) const {
|
|
|
|
ERR_FAIL_INDEX_V(p_line,text.size(),false);
|
|
return text.is_breakpoint(p_line);
|
|
|
|
}
|
|
|
|
void TextEdit::set_line_as_breakpoint(int p_line,bool p_breakpoint) {
|
|
|
|
|
|
ERR_FAIL_INDEX(p_line,text.size());
|
|
text.set_breakpoint(p_line,p_breakpoint);
|
|
update();
|
|
}
|
|
|
|
void TextEdit::get_breakpoints(List<int> *p_breakpoints) const {
|
|
|
|
for(int i=0;i<text.size();i++) {
|
|
if (text.is_breakpoint(i))
|
|
p_breakpoints->push_back(i);
|
|
}
|
|
}
|
|
|
|
int TextEdit::get_line_count() const {
|
|
|
|
return text.size();
|
|
}
|
|
|
|
void TextEdit::_do_text_op(const TextOperation& p_op, bool p_reverse) {
|
|
|
|
ERR_FAIL_COND(p_op.type==TextOperation::TYPE_NONE);
|
|
|
|
bool insert = p_op.type==TextOperation::TYPE_INSERT;
|
|
if (p_reverse)
|
|
insert=!insert;
|
|
|
|
if (insert) {
|
|
|
|
int check_line;
|
|
int check_column;
|
|
_base_insert_text(p_op.from_line,p_op.from_column,p_op.text,check_line,check_column);
|
|
ERR_FAIL_COND( check_line != p_op.to_line ); // BUG
|
|
ERR_FAIL_COND( check_column != p_op.to_column ); // BUG
|
|
} else {
|
|
|
|
_base_remove_text(p_op.from_line,p_op.from_column,p_op.to_line,p_op.to_column);
|
|
}
|
|
|
|
}
|
|
|
|
void TextEdit::_clear_redo() {
|
|
|
|
if (undo_stack_pos==NULL)
|
|
return; //nothing to clear
|
|
|
|
_push_current_op();
|
|
|
|
while (undo_stack_pos) {
|
|
List<TextOperation>::Element *elem = undo_stack_pos;
|
|
undo_stack_pos=undo_stack_pos->next();
|
|
undo_stack.erase(elem);
|
|
}
|
|
}
|
|
|
|
|
|
void TextEdit::undo() {
|
|
|
|
_push_current_op();
|
|
|
|
if (undo_stack_pos==NULL) {
|
|
|
|
if (!undo_stack.size())
|
|
return; //nothing to undo
|
|
|
|
undo_stack_pos=undo_stack.back();
|
|
|
|
} else if (undo_stack_pos==undo_stack.front())
|
|
return; // at the bottom of the undo stack
|
|
else
|
|
undo_stack_pos=undo_stack_pos->prev();
|
|
|
|
TextOperation op = undo_stack_pos->get();
|
|
_do_text_op(op, true);
|
|
current_op.version=op.prev_version;
|
|
if(undo_stack_pos->get().chain_backward) {
|
|
while(true) {
|
|
ERR_BREAK(!undo_stack_pos->prev());
|
|
undo_stack_pos = undo_stack_pos->prev();
|
|
op = undo_stack_pos->get();
|
|
_do_text_op(op, true);
|
|
current_op.version = op.prev_version;
|
|
if (undo_stack_pos->get().chain_forward) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (undo_stack_pos->get().type == TextOperation::TYPE_REMOVE) {
|
|
cursor_set_line(undo_stack_pos->get().to_line);
|
|
cursor_set_column(undo_stack_pos->get().to_column);
|
|
_cancel_code_hint();
|
|
} else {
|
|
cursor_set_line(undo_stack_pos->get().from_line);
|
|
cursor_set_column(undo_stack_pos->get().from_column);
|
|
}
|
|
update();
|
|
}
|
|
|
|
void TextEdit::redo() {
|
|
|
|
_push_current_op();
|
|
|
|
if (undo_stack_pos==NULL)
|
|
return; //nothing to do.
|
|
|
|
TextOperation op = undo_stack_pos->get();
|
|
_do_text_op(op, false);
|
|
current_op.version = op.version;
|
|
if(undo_stack_pos->get().chain_forward) {
|
|
|
|
while(true) {
|
|
ERR_BREAK(!undo_stack_pos->next());
|
|
undo_stack_pos=undo_stack_pos->next();
|
|
op = undo_stack_pos->get();
|
|
_do_text_op(op, false);
|
|
current_op.version = op.version;
|
|
if (undo_stack_pos->get().chain_backward)
|
|
break;
|
|
}
|
|
}
|
|
cursor_set_line(undo_stack_pos->get().to_line);
|
|
cursor_set_column(undo_stack_pos->get().to_column);
|
|
undo_stack_pos=undo_stack_pos->next();
|
|
update();
|
|
}
|
|
|
|
void TextEdit::clear_undo_history() {
|
|
|
|
saved_version=0;
|
|
current_op.type=TextOperation::TYPE_NONE;
|
|
undo_stack_pos=NULL;
|
|
undo_stack.clear();
|
|
|
|
}
|
|
|
|
void TextEdit::begin_complex_operation() {
|
|
_push_current_op();
|
|
next_operation_is_complex=true;
|
|
}
|
|
|
|
void TextEdit::end_complex_operation() {
|
|
|
|
_push_current_op();
|
|
ERR_FAIL_COND(undo_stack.size() == 0);
|
|
|
|
if(undo_stack.back()->get().chain_forward) {
|
|
undo_stack.back()->get().chain_forward=false;
|
|
return;
|
|
}
|
|
|
|
undo_stack.back()->get().chain_backward=true;
|
|
}
|
|
|
|
void TextEdit::_push_current_op() {
|
|
|
|
if (current_op.type==TextOperation::TYPE_NONE)
|
|
return; // do nothing
|
|
|
|
if(next_operation_is_complex) {
|
|
current_op.chain_forward=true;
|
|
next_operation_is_complex=false;
|
|
}
|
|
|
|
undo_stack.push_back(current_op);
|
|
current_op.type=TextOperation::TYPE_NONE;
|
|
current_op.text="";
|
|
current_op.chain_forward=false;
|
|
|
|
}
|
|
|
|
void TextEdit::set_tab_size(const int p_size) {
|
|
ERR_FAIL_COND(p_size <= 0);
|
|
tab_size = p_size;
|
|
text.set_tab_size(p_size);
|
|
update();
|
|
}
|
|
|
|
void TextEdit::set_draw_tabs(bool p_draw) {
|
|
|
|
draw_tabs=p_draw;
|
|
}
|
|
|
|
bool TextEdit::is_drawing_tabs() const{
|
|
|
|
return draw_tabs;
|
|
}
|
|
|
|
void TextEdit::set_insert_mode(bool p_enabled) {
|
|
insert_mode = p_enabled;
|
|
update();
|
|
}
|
|
|
|
bool TextEdit::is_insert_mode() const {
|
|
return insert_mode;
|
|
}
|
|
|
|
uint32_t TextEdit::get_version() const {
|
|
return current_op.version;
|
|
}
|
|
uint32_t TextEdit::get_saved_version() const {
|
|
|
|
return saved_version;
|
|
}
|
|
void TextEdit::tag_saved_version() {
|
|
|
|
saved_version=get_version();
|
|
}
|
|
|
|
int TextEdit::get_v_scroll() const {
|
|
|
|
return v_scroll->get_val();
|
|
}
|
|
void TextEdit::set_v_scroll(int p_scroll) {
|
|
|
|
v_scroll->set_val(p_scroll);
|
|
cursor.line_ofs=p_scroll;
|
|
}
|
|
|
|
int TextEdit::get_h_scroll() const {
|
|
|
|
return h_scroll->get_val();
|
|
}
|
|
void TextEdit::set_h_scroll(int p_scroll) {
|
|
|
|
h_scroll->set_val(p_scroll);
|
|
}
|
|
|
|
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);
|
|
|
|
if (completion_current.ends_with("(") && auto_brace_completion_enabled) {
|
|
insert_text_at_cursor(")");
|
|
cursor.column--;
|
|
}
|
|
|
|
end_complex_operation();
|
|
|
|
_cancel_completion();
|
|
}
|
|
|
|
|
|
void TextEdit::_cancel_code_hint() {
|
|
|
|
VisualServer::get_singleton()->canvas_item_set_z(get_canvas_item(), 0);
|
|
completion_hint="";
|
|
update();
|
|
}
|
|
|
|
void TextEdit::_cancel_completion() {
|
|
|
|
VisualServer::get_singleton()->canvas_item_set_z(get_canvas_item(), 0);
|
|
if (!completion_active)
|
|
return;
|
|
|
|
completion_active=false;
|
|
update();
|
|
|
|
}
|
|
|
|
static bool _is_completable(CharType 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 c=cofs-1;
|
|
while(c>=0) {
|
|
if (l[c]=='"' || l[c]=='\'') {
|
|
inquote=!inquote;
|
|
if (first_quote==-1)
|
|
first_quote=c;
|
|
}
|
|
c--;
|
|
}
|
|
|
|
bool pre_keyword=false;
|
|
bool cancel=false;
|
|
|
|
//print_line("inquote: "+itos(inquote)+"first quote "+itos(first_quote)+" cofs-1 "+itos(cofs-1));
|
|
if (!inquote && first_quote==cofs-1) {
|
|
//no completion here
|
|
//print_line("cancel!");
|
|
cancel=true;
|
|
} if (inquote && first_quote!=-1) {
|
|
|
|
s=l.substr(first_quote,cofs-first_quote);
|
|
//print_line("s: 1"+s);
|
|
} 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);
|
|
//print_line("KW "+kw+"? "+itos(pre_keyword));
|
|
|
|
} else {
|
|
|
|
|
|
while(cofs>0 && l[cofs-1]>32 && _is_completable(l[cofs-1])) {
|
|
s=String::chr(l[cofs-1])+s;
|
|
if (l[cofs-1]=='\'' || l[cofs-1]=='"')
|
|
break;
|
|
|
|
cofs--;
|
|
}
|
|
}
|
|
|
|
if (cursor.column > 0 && l[cursor.column - 1] == '(' && !pre_keyword && !completion_strings[0].begins_with("\"")) {
|
|
cancel = true;
|
|
}
|
|
|
|
update();
|
|
|
|
if (cancel || (!pre_keyword && s=="" && (cofs==0 || !completion_prefixes.has(String::chr(l[cofs-1]))))) {
|
|
//none to complete, cancel
|
|
_cancel_completion();
|
|
return;
|
|
}
|
|
|
|
completion_options.clear();
|
|
completion_index=0;
|
|
completion_base=s;
|
|
Vector<float> sim_cache;
|
|
for(int i=0;i<completion_strings.size();i++) {
|
|
if (s == completion_strings[i]) {
|
|
// A perfect match, stop completion
|
|
_cancel_completion();
|
|
return;
|
|
}
|
|
if (s.is_subsequence_ofi(completion_strings[i])) {
|
|
// don't remove duplicates if no input is provided
|
|
if (s != "" && completion_options.find(completion_strings[i]) != -1) {
|
|
continue;
|
|
}
|
|
// Calculate the similarity to keep completions in good order
|
|
float similarity;
|
|
if (completion_strings[i].to_lower().begins_with(s.to_lower())) {
|
|
// Substrings are the best candidates
|
|
similarity = 1.1;
|
|
} else {
|
|
// Otherwise compute the similarity
|
|
similarity = s.to_lower().similarity(completion_strings[i].to_lower());
|
|
}
|
|
|
|
int comp_size = completion_options.size();
|
|
if (comp_size == 0) {
|
|
completion_options.push_back(completion_strings[i]);
|
|
sim_cache.push_back(similarity);
|
|
} else {
|
|
float comp_sim;
|
|
int pos = 0;
|
|
do {
|
|
comp_sim = sim_cache[pos++];
|
|
} while(pos < comp_size && similarity < comp_sim);
|
|
pos = similarity > comp_sim ? pos - 1 : pos; // Pos will be off by one
|
|
completion_options.insert(pos, completion_strings[i]);
|
|
sim_cache.insert(pos, similarity);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (completion_options.size()==0) {
|
|
//no options to complete, cancel
|
|
_cancel_completion();
|
|
return;
|
|
|
|
}
|
|
|
|
// The top of the list is the best match
|
|
completion_current=completion_options[0];
|
|
|
|
#if 0 // even there's only one option, user still get the chance to choose using it or not
|
|
if (completion_options.size()==1) {
|
|
//one option to complete, just complete it automagically
|
|
_confirm_completion();
|
|
// insert_text_at_cursor(completion_options[0].substr(s.length(),completion_options[0].length()-s.length()));
|
|
_cancel_completion();
|
|
return;
|
|
|
|
}
|
|
#endif
|
|
|
|
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--;
|
|
}
|
|
|
|
if (ofs>0 && (inquote || _is_completable(l[ofs-1]) || completion_prefixes.has(String::chr(l[ofs-1]))))
|
|
emit_signal("request_completion");
|
|
|
|
}
|
|
|
|
|
|
void TextEdit::set_code_hint(const String& p_hint) {
|
|
|
|
VisualServer::get_singleton()->canvas_item_set_z(get_canvas_item(), 1);
|
|
completion_hint=p_hint;
|
|
completion_hint_offset=-0xFFFF;
|
|
update();
|
|
}
|
|
|
|
void TextEdit::code_complete(const Vector<String> &p_strings) {
|
|
|
|
VisualServer::get_singleton()->canvas_item_set_z(get_canvas_item(), 1);
|
|
completion_strings=p_strings;
|
|
completion_active=true;
|
|
completion_current="";
|
|
completion_index=0;
|
|
_update_completion_candidates();
|
|
//
|
|
}
|
|
|
|
|
|
String TextEdit::get_tooltip(const Point2& p_pos) const {
|
|
|
|
if (!tooltip_obj)
|
|
return Control::get_tooltip(p_pos);
|
|
int row,col;
|
|
_get_mouse_pos(p_pos, row, col);
|
|
|
|
String s = text[row];
|
|
if (s.length()==0)
|
|
return Control::get_tooltip(p_pos);
|
|
int beg=CLAMP(col,0,s.length());
|
|
int end=beg;
|
|
|
|
|
|
if (s[beg]>32 || beg==s.length()) {
|
|
|
|
bool symbol = beg < s.length() && _is_symbol(s[beg]); //not sure if right but most editors behave like this
|
|
|
|
while(beg>0 && s[beg-1]>32 && (symbol==_is_symbol(s[beg-1]))) {
|
|
beg--;
|
|
}
|
|
while(end<s.length() && s[end+1]>32 && (symbol==_is_symbol(s[end+1]))) {
|
|
end++;
|
|
}
|
|
|
|
if (end<s.length())
|
|
end+=1;
|
|
|
|
String tt = tooltip_obj->call(tooltip_func,s.substr(beg,end-beg),tooltip_ud);
|
|
|
|
return tt;
|
|
|
|
}
|
|
|
|
return Control::get_tooltip(p_pos);
|
|
|
|
}
|
|
|
|
void TextEdit::set_tooltip_request_func(Object *p_obj, const StringName& p_function,const Variant& p_udata) {
|
|
|
|
tooltip_obj=p_obj;
|
|
tooltip_func=p_function;
|
|
tooltip_ud=p_udata;
|
|
}
|
|
|
|
void TextEdit::set_line(int line, String new_text)
|
|
{
|
|
if (line < 0 || line > text.size())
|
|
return;
|
|
_remove_text(line, 0, line, text[line].length());
|
|
_insert_text(line, 0, new_text);
|
|
if (cursor.line==line) {
|
|
cursor.column=MIN(cursor.column,new_text.length());
|
|
}
|
|
}
|
|
|
|
void TextEdit::insert_at(const String &p_text, int at)
|
|
{
|
|
cursor_set_column(0);
|
|
cursor_set_line(at);
|
|
_insert_text(at, 0, p_text+"\n");
|
|
}
|
|
|
|
void TextEdit::set_show_line_numbers(bool p_show) {
|
|
|
|
line_numbers=p_show;
|
|
update();
|
|
}
|
|
|
|
bool TextEdit::is_show_line_numbers_enabled() const {
|
|
return line_numbers;
|
|
}
|
|
|
|
void TextEdit::set_draw_breakpoint_gutter(bool p_draw) {
|
|
draw_breakpoint_gutter = p_draw;
|
|
update();
|
|
}
|
|
|
|
bool TextEdit::is_drawing_breakpoint_gutter() const {
|
|
return draw_breakpoint_gutter;
|
|
}
|
|
|
|
void TextEdit::set_breakpoint_gutter_width(int p_gutter_width) {
|
|
breakpoint_gutter_width = p_gutter_width;
|
|
update();
|
|
}
|
|
|
|
int TextEdit::get_breakpoint_gutter_width() const {
|
|
return cache.breakpoint_gutter_width;
|
|
}
|
|
|
|
bool TextEdit::is_text_field() const {
|
|
|
|
return true;
|
|
}
|
|
|
|
void TextEdit::menu_option(int p_option) {
|
|
|
|
switch( p_option ) {
|
|
case MENU_CUT: {
|
|
if (!readonly) {
|
|
cut();
|
|
}
|
|
} break;
|
|
case MENU_COPY: {
|
|
copy();
|
|
} break;
|
|
case MENU_PASTE: {
|
|
if (!readonly) {
|
|
paste();
|
|
}
|
|
} break;
|
|
case MENU_CLEAR: {
|
|
if (!readonly) {
|
|
clear();
|
|
}
|
|
} break;
|
|
case MENU_SELECT_ALL: {
|
|
select_all();
|
|
} break;
|
|
case MENU_UNDO: {
|
|
undo();
|
|
} break;
|
|
|
|
};
|
|
}
|
|
|
|
PopupMenu *TextEdit::get_menu() const {
|
|
return menu;
|
|
}
|
|
|
|
void TextEdit::_bind_methods() {
|
|
|
|
|
|
ObjectTypeDB::bind_method(_MD("_input_event"),&TextEdit::_input_event);
|
|
ObjectTypeDB::bind_method(_MD("_scroll_moved"),&TextEdit::_scroll_moved);
|
|
ObjectTypeDB::bind_method(_MD("_cursor_changed_emit"),&TextEdit::_cursor_changed_emit);
|
|
ObjectTypeDB::bind_method(_MD("_text_changed_emit"),&TextEdit::_text_changed_emit);
|
|
ObjectTypeDB::bind_method(_MD("_push_current_op"),&TextEdit::_push_current_op);
|
|
ObjectTypeDB::bind_method(_MD("_click_selection_held"),&TextEdit::_click_selection_held);
|
|
ObjectTypeDB::bind_method(_MD("_toggle_draw_caret"),&TextEdit::_toggle_draw_caret);
|
|
|
|
BIND_CONSTANT( SEARCH_MATCH_CASE );
|
|
BIND_CONSTANT( SEARCH_WHOLE_WORDS );
|
|
BIND_CONSTANT( SEARCH_BACKWARDS );
|
|
|
|
/*
|
|
ObjectTypeDB::bind_method(_MD("delete_char"),&TextEdit::delete_char);
|
|
ObjectTypeDB::bind_method(_MD("delete_line"),&TextEdit::delete_line);
|
|
*/
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_text","text"),&TextEdit::set_text);
|
|
ObjectTypeDB::bind_method(_MD("insert_text_at_cursor","text"),&TextEdit::insert_text_at_cursor);
|
|
|
|
ObjectTypeDB::bind_method(_MD("get_line_count"),&TextEdit::get_line_count);
|
|
ObjectTypeDB::bind_method(_MD("get_text"),&TextEdit::get_text);
|
|
ObjectTypeDB::bind_method(_MD("get_line","line"),&TextEdit::get_line);
|
|
|
|
ObjectTypeDB::bind_method(_MD("cursor_set_column","column","adjust_viewport"),&TextEdit::cursor_set_column,DEFVAL(false));
|
|
ObjectTypeDB::bind_method(_MD("cursor_set_line","line","adjust_viewport"),&TextEdit::cursor_set_line,DEFVAL(false));
|
|
|
|
ObjectTypeDB::bind_method(_MD("cursor_get_column"),&TextEdit::cursor_get_column);
|
|
ObjectTypeDB::bind_method(_MD("cursor_get_line"),&TextEdit::cursor_get_line);
|
|
ObjectTypeDB::bind_method(_MD("cursor_set_blink_enabled", "enable"),&TextEdit::cursor_set_blink_enabled);
|
|
ObjectTypeDB::bind_method(_MD("cursor_get_blink_enabled"),&TextEdit::cursor_get_blink_enabled);
|
|
ObjectTypeDB::bind_method(_MD("cursor_set_blink_speed", "blink_speed"),&TextEdit::cursor_set_blink_speed);
|
|
ObjectTypeDB::bind_method(_MD("cursor_get_blink_speed"),&TextEdit::cursor_get_blink_speed);
|
|
ObjectTypeDB::bind_method(_MD("cursor_set_block_mode", "enable"), &TextEdit::cursor_set_block_mode);
|
|
ObjectTypeDB::bind_method(_MD("cursor_is_block_mode"), &TextEdit::cursor_is_block_mode);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_readonly","enable"),&TextEdit::set_readonly);
|
|
ObjectTypeDB::bind_method(_MD("set_wrap","enable"),&TextEdit::set_wrap);
|
|
ObjectTypeDB::bind_method(_MD("set_max_chars","amount"),&TextEdit::set_max_chars);
|
|
|
|
ObjectTypeDB::bind_method(_MD("cut"),&TextEdit::cut);
|
|
ObjectTypeDB::bind_method(_MD("copy"),&TextEdit::copy);
|
|
ObjectTypeDB::bind_method(_MD("paste"),&TextEdit::paste);
|
|
ObjectTypeDB::bind_method(_MD("select_all"),&TextEdit::select_all);
|
|
ObjectTypeDB::bind_method(_MD("select","from_line","from_column","to_line","to_column"),&TextEdit::select);
|
|
|
|
ObjectTypeDB::bind_method(_MD("is_selection_active"),&TextEdit::is_selection_active);
|
|
ObjectTypeDB::bind_method(_MD("get_selection_from_line"),&TextEdit::get_selection_from_line);
|
|
ObjectTypeDB::bind_method(_MD("get_selection_from_column"),&TextEdit::get_selection_from_column);
|
|
ObjectTypeDB::bind_method(_MD("get_selection_to_line"),&TextEdit::get_selection_to_line);
|
|
ObjectTypeDB::bind_method(_MD("get_selection_to_column"),&TextEdit::get_selection_to_column);
|
|
ObjectTypeDB::bind_method(_MD("get_selection_text"),&TextEdit::get_selection_text);
|
|
ObjectTypeDB::bind_method(_MD("get_word_under_cursor"),&TextEdit::get_word_under_cursor);
|
|
ObjectTypeDB::bind_method(_MD("search","flags","from_line","from_column","to_line","to_column"),&TextEdit::_search_bind);
|
|
|
|
ObjectTypeDB::bind_method(_MD("undo"),&TextEdit::undo);
|
|
ObjectTypeDB::bind_method(_MD("redo"),&TextEdit::redo);
|
|
ObjectTypeDB::bind_method(_MD("clear_undo_history"),&TextEdit::clear_undo_history);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_show_line_numbers", "enable"), &TextEdit::set_show_line_numbers);
|
|
ObjectTypeDB::bind_method(_MD("is_show_line_numbers_enabled"), &TextEdit::is_show_line_numbers_enabled);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_highlight_all_occurrences", "enable"), &TextEdit::set_highlight_all_occurrences);
|
|
ObjectTypeDB::bind_method(_MD("is_highlight_all_occurrences_enabled"), &TextEdit::is_highlight_all_occurrences_enabled);
|
|
|
|
ObjectTypeDB::bind_method(_MD("set_syntax_coloring","enable"),&TextEdit::set_syntax_coloring);
|
|
ObjectTypeDB::bind_method(_MD("is_syntax_coloring_enabled"),&TextEdit::is_syntax_coloring_enabled);
|
|
|
|
|
|
ObjectTypeDB::bind_method(_MD("add_keyword_color","keyword","color"),&TextEdit::add_keyword_color);
|
|
ObjectTypeDB::bind_method(_MD("add_color_region","begin_key","end_key","color","line_only"),&TextEdit::add_color_region,DEFVAL(false));
|
|
ObjectTypeDB::bind_method(_MD("set_symbol_color","color"),&TextEdit::set_symbol_color);
|
|
ObjectTypeDB::bind_method(_MD("set_custom_bg_color","color"),&TextEdit::set_custom_bg_color);
|
|
ObjectTypeDB::bind_method(_MD("clear_colors"),&TextEdit::clear_colors);
|
|
ObjectTypeDB::bind_method(_MD("menu_option"),&TextEdit::menu_option);
|
|
ObjectTypeDB::bind_method(_MD("get_menu:PopupMenu"),&TextEdit::get_menu);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "syntax_highlighting"), _SCS("set_syntax_coloring"), _SCS("is_syntax_coloring_enabled"));
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "show_line_numbers"), _SCS("set_show_line_numbers"), _SCS("is_show_line_numbers_enabled"));
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "highlight_all_occurrences"), _SCS("set_highlight_all_occurrences"), _SCS("is_highlight_all_occurrences_enabled"));
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "caret/block_caret"), _SCS("cursor_set_block_mode"), _SCS("cursor_is_block_mode"));
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "caret/caret_blink"), _SCS("cursor_set_blink_enabled"), _SCS("cursor_get_blink_enabled"));
|
|
ADD_PROPERTYNZ(PropertyInfo(Variant::REAL, "caret/caret_blink_speed",PROPERTY_HINT_RANGE,"0.1,10,0.1"), _SCS("cursor_set_blink_speed"),_SCS("cursor_get_blink_speed") );
|
|
|
|
ADD_SIGNAL(MethodInfo("cursor_changed"));
|
|
ADD_SIGNAL(MethodInfo("text_changed"));
|
|
ADD_SIGNAL(MethodInfo("request_completion"));
|
|
ADD_SIGNAL(MethodInfo("breakpoint_toggled", PropertyInfo( Variant::INT, "row")));
|
|
|
|
BIND_CONSTANT( MENU_CUT );
|
|
BIND_CONSTANT( MENU_COPY );
|
|
BIND_CONSTANT( MENU_PASTE );
|
|
BIND_CONSTANT( MENU_CLEAR );
|
|
BIND_CONSTANT( MENU_SELECT_ALL );
|
|
BIND_CONSTANT( MENU_UNDO );
|
|
BIND_CONSTANT( MENU_MAX );
|
|
|
|
|
|
}
|
|
|
|
TextEdit::TextEdit() {
|
|
|
|
readonly=false;
|
|
setting_row=false;
|
|
draw_tabs=false;
|
|
draw_caret=true;
|
|
max_chars=0;
|
|
clear();
|
|
wrap=false;
|
|
set_focus_mode(FOCUS_ALL);
|
|
_update_caches();
|
|
cache.size=Size2(1,1);
|
|
cache.row_height=1;
|
|
cache.line_spacing=1;
|
|
cache.line_number_w=1;
|
|
cache.breakpoint_gutter_width=0;
|
|
breakpoint_gutter_width = 0;
|
|
|
|
tab_size=4;
|
|
text.set_tab_size(tab_size);
|
|
text.clear();
|
|
// text.insert(1,"Mongolia..");
|
|
// text.insert(2,"PAIS GENEROSO!!");
|
|
text.set_color_regions(&color_regions);
|
|
|
|
h_scroll = memnew( HScrollBar );
|
|
v_scroll = memnew( VScrollBar );
|
|
|
|
add_child(h_scroll);
|
|
add_child(v_scroll);
|
|
|
|
updating_scrolls=false;
|
|
selection.active=false;
|
|
|
|
h_scroll->connect("value_changed", this,"_scroll_moved");
|
|
v_scroll->connect("value_changed", this,"_scroll_moved");
|
|
|
|
cursor_changed_dirty=false;
|
|
text_changed_dirty=false;
|
|
|
|
selection.selecting_mode=Selection::MODE_NONE;
|
|
selection.selecting_line=0;
|
|
selection.selecting_column=0;
|
|
selection.selecting_text=false;
|
|
selection.active=false;
|
|
syntax_coloring=false;
|
|
|
|
block_caret=false;
|
|
caret_blink_enabled=false;
|
|
caret_blink_timer = memnew(Timer);
|
|
add_child(caret_blink_timer);
|
|
caret_blink_timer->set_wait_time(0.65);
|
|
caret_blink_timer->connect("timeout", this,"_toggle_draw_caret");
|
|
cursor_set_blink_enabled(false);
|
|
|
|
custom_bg_color=Color(0,0,0,0);
|
|
idle_detect = memnew( Timer );
|
|
add_child(idle_detect);
|
|
idle_detect->set_one_shot(true);
|
|
idle_detect->set_wait_time(GLOBAL_DEF("display/text_edit_idle_detect_sec",3));
|
|
idle_detect->connect("timeout", this,"_push_current_op");
|
|
|
|
click_select_held = memnew( Timer );
|
|
add_child(click_select_held);
|
|
click_select_held->set_wait_time(0.05);
|
|
click_select_held->connect("timeout", this,"_click_selection_held");
|
|
|
|
#if 0
|
|
syntax_coloring=true;
|
|
keywords["void"]=Color(0.3,0.0,0.1);
|
|
keywords["int"]=Color(0.3,0.0,0.1);
|
|
keywords["function"]=Color(0.3,0.0,0.1);
|
|
keywords["class"]=Color(0.3,0.0,0.1);
|
|
keywords["extends"]=Color(0.3,0.0,0.1);
|
|
keywords["constructor"]=Color(0.3,0.0,0.1);
|
|
symbol_color=Color(0.1,0.0,0.3,1.0);
|
|
|
|
color_regions.push_back(ColorRegion("/*","*/",Color(0.4,0.6,0,4)));
|
|
color_regions.push_back(ColorRegion("//","",Color(0.6,0.6,0.4)));
|
|
color_regions.push_back(ColorRegion("\"","\"",Color(0.4,0.7,0.7)));
|
|
color_regions.push_back(ColorRegion("'","'",Color(0.4,0.8,0.8)));
|
|
color_regions.push_back(ColorRegion("#","",Color(0.2,1.0,0.2)));
|
|
|
|
#endif
|
|
|
|
current_op.type=TextOperation::TYPE_NONE;
|
|
undo_enabled=true;
|
|
undo_stack_pos=NULL;
|
|
setting_text=false;
|
|
last_dblclk=0;
|
|
current_op.version=0;
|
|
version=0;
|
|
saved_version=0;
|
|
|
|
completion_enabled=false;
|
|
completion_active=false;
|
|
completion_line_ofs=0;
|
|
tooltip_obj=NULL;
|
|
line_numbers=false;
|
|
draw_breakpoint_gutter=false;
|
|
next_operation_is_complex=false;
|
|
scroll_past_end_of_file_enabled=false;
|
|
auto_brace_completion_enabled=false;
|
|
brace_matching_enabled=false;
|
|
highlight_all_occurrences=false;
|
|
auto_indent=false;
|
|
insert_mode = false;
|
|
window_has_focus=true;
|
|
|
|
menu = memnew( PopupMenu );
|
|
add_child(menu);
|
|
menu->add_item(TTR("Cut"),MENU_CUT,KEY_MASK_CMD|KEY_X);
|
|
menu->add_item(TTR("Copy"),MENU_COPY,KEY_MASK_CMD|KEY_C);
|
|
menu->add_item(TTR("Paste"),MENU_PASTE,KEY_MASK_CMD|KEY_V);
|
|
menu->add_separator();
|
|
menu->add_item(TTR("Select All"),MENU_SELECT_ALL,KEY_MASK_CMD|KEY_A);
|
|
menu->add_item(TTR("Clear"),MENU_CLEAR);
|
|
menu->add_separator();
|
|
menu->add_item(TTR("Undo"),MENU_UNDO,KEY_MASK_CMD|KEY_Z);
|
|
menu->connect("item_pressed",this,"menu_option");
|
|
|
|
|
|
}
|
|
|
|
TextEdit::~TextEdit()
|
|
{
|
|
}
|