/*************************************************************************/ /* rich_text_label.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2018 Godot Engine contributors (cf. AUTHORS.md) */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "rich_text_label.h" #include "core/os/keyboard.h" #include "core/os/os.h" #include "scene/scene_string_names.h" #ifdef TOOLS_ENABLED #include "editor/editor_scale.h" #endif RichTextLabel::Item *RichTextLabel::_get_next_item(Item *p_item, bool p_free) { if (p_free) { if (p_item->subitems.size()) { return p_item->subitems.front()->get(); } else if (!p_item->parent) { return NULL; } else if (p_item->E->next()) { return p_item->E->next()->get(); } else { //go up until something with a next is found while (p_item->parent && !p_item->E->next()) { p_item = p_item->parent; } if (p_item->parent) return p_item->E->next()->get(); else return NULL; } } else { if (p_item->subitems.size() && p_item->type != ITEM_TABLE) { return p_item->subitems.front()->get(); } else if (p_item->type == ITEM_FRAME) { return NULL; } else if (p_item->E->next()) { return p_item->E->next()->get(); } else { //go up until something with a next is found while (p_item->type != ITEM_FRAME && !p_item->E->next()) { p_item = p_item->parent; } if (p_item->type != ITEM_FRAME) return p_item->E->next()->get(); else return NULL; } } return NULL; } RichTextLabel::Item *RichTextLabel::_get_prev_item(Item *p_item, bool p_free) { if (p_free) { if (p_item->subitems.size()) { return p_item->subitems.back()->get(); } else if (!p_item->parent) { return NULL; } else if (p_item->E->prev()) { return p_item->E->prev()->get(); } else { //go back until something with a prev is found while (p_item->parent && !p_item->E->prev()) { p_item = p_item->parent; } if (p_item->parent) return p_item->E->prev()->get(); else return NULL; } } else { if (p_item->subitems.size() && p_item->type != ITEM_TABLE) { return p_item->subitems.back()->get(); } else if (p_item->type == ITEM_FRAME) { return NULL; } else if (p_item->E->prev()) { return p_item->E->prev()->get(); } else { //go back until something with a prev is found while (p_item->type != ITEM_FRAME && !p_item->E->prev()) { p_item = p_item->parent; } if (p_item->type != ITEM_FRAME) return p_item->E->prev()->get(); else return NULL; } } return NULL; } Rect2 RichTextLabel::_get_text_rect() { Ref style = get_stylebox("normal"); return Rect2(style->get_offset(), get_size() - style->get_minimum_size()); } int RichTextLabel::_process_line(ItemFrame *p_frame, const Vector2 &p_ofs, int &y, int p_width, int p_line, ProcessMode p_mode, const Ref &p_base_font, const Color &p_base_color, const Color &p_font_color_shadow, bool p_shadow_as_outline, const Point2 &shadow_ofs, const Point2i &p_click_pos, Item **r_click_item, int *r_click_char, bool *r_outside, int p_char_count) { RID ci; if (r_outside) *r_outside = false; if (p_mode == PROCESS_DRAW) { ci = get_canvas_item(); if (r_click_item) *r_click_item = NULL; } Line &l = p_frame->lines.write[p_line]; Item *it = l.from; int line_ofs = 0; int margin = _find_margin(it, p_base_font); Align align = _find_align(it); int line = 0; int spaces = 0; int height = get_size().y; if (p_mode != PROCESS_CACHE) { ERR_FAIL_INDEX_V(line, l.offset_caches.size(), 0); line_ofs = l.offset_caches[line]; } if (p_mode == PROCESS_CACHE) { l.offset_caches.clear(); l.height_caches.clear(); l.ascent_caches.clear(); l.descent_caches.clear(); l.char_count = 0; l.minimum_width = 0; l.maximum_width = 0; } int wofs = margin; int spaces_size = 0; int align_ofs = 0; if (p_mode != PROCESS_CACHE && align != ALIGN_FILL) wofs += line_ofs; int begin = wofs; Ref cfont = _find_font(it); if (cfont.is_null()) cfont = p_base_font; //line height should be the font height for the first time, this ensures that an empty line will never have zero height and successive newlines are displayed int line_height = cfont->get_height(); int line_ascent = cfont->get_ascent(); int line_descent = cfont->get_descent(); int nonblank_line_count = 0; //number of nonblank lines as counted during PROCESS_DRAW Variant meta; #define RETURN return nonblank_line_count #define NEW_LINE \ { \ if (p_mode != PROCESS_CACHE) { \ line++; \ if (!line_is_blank) { \ nonblank_line_count++; \ } \ line_is_blank = true; \ if (line < l.offset_caches.size()) \ line_ofs = l.offset_caches[line]; \ wofs = margin; \ if (align != ALIGN_FILL) \ wofs += line_ofs; \ } else { \ int used = wofs - margin; \ switch (align) { \ case ALIGN_LEFT: l.offset_caches.push_back(0); break; \ case ALIGN_CENTER: l.offset_caches.push_back(((p_width - margin) - used) / 2); break; \ case ALIGN_RIGHT: l.offset_caches.push_back(((p_width - margin) - used)); break; \ case ALIGN_FILL: l.offset_caches.push_back((p_width - margin) - used /*+spaces_size*/); break; \ } \ l.height_caches.push_back(line_height); \ l.ascent_caches.push_back(line_ascent); \ l.descent_caches.push_back(line_descent); \ l.space_caches.push_back(spaces); \ } \ y += line_height + get_constant(SceneStringNames::get_singleton()->line_separation); \ line_height = 0; \ line_ascent = 0; \ line_descent = 0; \ spaces = 0; \ spaces_size = 0; \ wofs = begin; \ align_ofs = 0; \ if (p_mode != PROCESS_CACHE) { \ lh = line < l.height_caches.size() ? l.height_caches[line] : 1; \ line_ascent = line < l.ascent_caches.size() ? l.ascent_caches[line] : 1; \ line_descent = line < l.descent_caches.size() ? l.descent_caches[line] : 1; \ } \ if (p_mode == PROCESS_POINTER && r_click_item && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh && p_click_pos.x < p_ofs.x + wofs) { \ if (r_outside) *r_outside = true; \ *r_click_item = it; \ *r_click_char = rchar; \ RETURN; \ } \ } #define ENSURE_WIDTH(m_width) \ if (p_mode == PROCESS_CACHE) { \ l.maximum_width = MAX(l.maximum_width, MIN(p_width, wofs + m_width)); \ l.minimum_width = MAX(l.minimum_width, m_width); \ } \ if (wofs + m_width > p_width) { \ if (p_mode == PROCESS_CACHE) { \ if (spaces > 0) \ spaces -= 1; \ } \ if (p_mode == PROCESS_POINTER && r_click_item && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh && p_click_pos.x > p_ofs.x + wofs) { \ if (r_outside) *r_outside = true; \ *r_click_item = it; \ *r_click_char = rchar; \ RETURN; \ } \ NEW_LINE \ } #define ADVANCE(m_width) \ { \ if (p_mode == PROCESS_POINTER && r_click_item && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh && p_click_pos.x >= p_ofs.x + wofs && p_click_pos.x < p_ofs.x + wofs + m_width) { \ if (r_outside) *r_outside = false; \ *r_click_item = it; \ *r_click_char = rchar; \ RETURN; \ } \ wofs += m_width; \ } #define CHECK_HEIGHT(m_height) \ if (m_height > line_height) { \ line_height = m_height; \ } #define YRANGE_VISIBLE(m_top, m_height) \ (m_height > 0 && ((m_top >= 0 && m_top < height) || ((m_top + m_height - 1) >= 0 && (m_top + m_height - 1) < height))) Color selection_fg; Color selection_bg; if (p_mode == PROCESS_DRAW) { selection_fg = get_color("font_color_selected"); selection_bg = get_color("selection_color"); } int rchar = 0; int lh = 0; bool line_is_blank = true; int fh = 0; while (it) { switch (it->type) { case ITEM_TEXT: { ItemText *text = static_cast(it); Ref font = _find_font(it); if (font.is_null()) font = p_base_font; const CharType *c = text->text.c_str(); const CharType *cf = c; int ascent = font->get_ascent(); int descent = font->get_descent(); Color color; Color font_color_shadow; bool underline = false; bool strikethrough = false; if (p_mode == PROCESS_DRAW) { color = _find_color(text, p_base_color); font_color_shadow = _find_color(text, p_font_color_shadow); if (_find_underline(text) || (_find_meta(text, &meta) && underline_meta)) { underline = true; } else if (_find_strikethrough(text)) { strikethrough = true; } } else if (p_mode == PROCESS_CACHE) { l.char_count += text->text.length(); } rchar = 0; FontDrawer drawer(font, Color(1, 1, 1)); while (*c) { int end = 0; int w = 0; int fw = 0; lh = 0; if (p_mode != PROCESS_CACHE) { lh = line < l.height_caches.size() ? l.height_caches[line] : 1; line_ascent = line < l.ascent_caches.size() ? l.ascent_caches[line] : 1; line_descent = line < l.descent_caches.size() ? l.descent_caches[line] : 1; } while (c[end] != 0 && !(end && c[end - 1] == ' ' && c[end] != ' ')) { int cw = font->get_char_size(c[end], c[end + 1]).width; if (c[end] == '\t') { cw = tab_size * font->get_char_size(' ').width; } if (end > 0 && w + cw + begin > p_width) { break; //don't allow lines longer than assigned width } w += cw; fw += cw; end++; } CHECK_HEIGHT(fh); ENSURE_WIDTH(w); line_ascent = MAX(line_ascent, ascent); line_descent = MAX(line_descent, descent); fh = line_ascent + line_descent; if (end && c[end - 1] == ' ') { if (p_mode == PROCESS_CACHE) { spaces_size += font->get_char_size(' ').width; } else if (align == ALIGN_FILL) { int ln = MIN(l.offset_caches.size() - 1, line); if (l.space_caches[ln]) { align_ofs = spaces * l.offset_caches[ln] / l.space_caches[ln]; } } spaces++; } { int ofs = 0; for (int i = 0; i < end; i++) { int pofs = wofs + ofs; if (p_mode == PROCESS_POINTER && r_click_char && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh) { //int o = (wofs+w)-p_click_pos.x; int cw = font->get_char_size(c[i], c[i + 1]).x; if (c[i] == '\t') { cw = tab_size * font->get_char_size(' ').width; } if (p_click_pos.x - cw / 2 > p_ofs.x + align_ofs + pofs) { rchar = int((&c[i]) - cf); } ofs += cw; } else if (p_mode == PROCESS_DRAW) { bool selected = false; if (selection.active) { int cofs = (&c[i]) - cf; if ((text->index > selection.from->index || (text->index == selection.from->index && cofs >= selection.from_char)) && (text->index < selection.to->index || (text->index == selection.to->index && cofs <= selection.to_char))) { selected = true; } } int cw = 0; bool visible = visible_characters < 0 || (p_char_count < visible_characters && YRANGE_VISIBLE(y + lh - line_descent - line_ascent, line_ascent + line_descent)); if (visible) line_is_blank = false; if (c[i] == '\t') visible = false; if (visible) { if (selected) { cw = font->get_char_size(c[i], c[i + 1]).x; draw_rect(Rect2(p_ofs.x + pofs, p_ofs.y + y, cw, lh), selection_bg); } if (p_font_color_shadow.a > 0) { float x_ofs_shadow = align_ofs + pofs; float y_ofs_shadow = y + lh - line_descent; float move = font->draw_char(ci, Point2(x_ofs_shadow, y_ofs_shadow) + shadow_ofs, c[i], c[i + 1], p_font_color_shadow); if (p_shadow_as_outline) { font->draw_char(ci, Point2(x_ofs_shadow, y_ofs_shadow) + Vector2(-shadow_ofs.x, shadow_ofs.y), c[i], c[i + 1], p_font_color_shadow); font->draw_char(ci, Point2(x_ofs_shadow, y_ofs_shadow) + Vector2(shadow_ofs.x, -shadow_ofs.y), c[i], c[i + 1], p_font_color_shadow); font->draw_char(ci, Point2(x_ofs_shadow, y_ofs_shadow) + Vector2(-shadow_ofs.x, -shadow_ofs.y), c[i], c[i + 1], p_font_color_shadow); } x_ofs_shadow += move; } if (selected) { drawer.draw_char(ci, p_ofs + Point2(align_ofs + pofs, y + lh - line_descent), c[i], c[i + 1], override_selected_font_color ? selection_fg : color); } else { cw = drawer.draw_char(ci, p_ofs + Point2(align_ofs + pofs, y + lh - line_descent), c[i], c[i + 1], color); } } p_char_count++; if (c[i] == '\t') { cw = tab_size * font->get_char_size(' ').width; } ofs += cw; } } if (underline) { Color uc = color; uc.a *= 0.5; int uy = y + lh - line_descent + 2; float underline_width = 1.0; #ifdef TOOLS_ENABLED underline_width *= EDSCALE; #endif VS::get_singleton()->canvas_item_add_line(ci, p_ofs + Point2(align_ofs + wofs, uy), p_ofs + Point2(align_ofs + wofs + w, uy), uc, underline_width); } else if (strikethrough) { Color uc = color; uc.a *= 0.5; int uy = y + lh / 2 - line_descent + 2; float strikethrough_width = 1.0; #ifdef TOOLS_ENABLED strikethrough_width *= EDSCALE; #endif VS::get_singleton()->canvas_item_add_line(ci, p_ofs + Point2(align_ofs + wofs, uy), p_ofs + Point2(align_ofs + wofs + w, uy), uc, strikethrough_width); } } ADVANCE(fw); CHECK_HEIGHT(fh); //must be done somewhere c = &c[end]; } } break; case ITEM_IMAGE: { lh = 0; if (p_mode != PROCESS_CACHE) lh = line < l.height_caches.size() ? l.height_caches[line] : 1; else l.char_count += 1; //images count as chars too ItemImage *img = static_cast(it); Ref font = _find_font(it); if (font.is_null()) font = p_base_font; if (p_mode == PROCESS_POINTER && r_click_char) *r_click_char = 0; ENSURE_WIDTH(img->image->get_width()); bool visible = visible_characters < 0 || (p_char_count < visible_characters && YRANGE_VISIBLE(y + lh - font->get_descent() - img->image->get_height(), img->image->get_height())); if (visible) line_is_blank = false; if (p_mode == PROCESS_DRAW && visible) { img->image->draw(ci, p_ofs + Point2(align_ofs + wofs, y + lh - font->get_descent() - img->image->get_height())); } p_char_count++; ADVANCE(img->image->get_width()); CHECK_HEIGHT((img->image->get_height() + font->get_descent())); } break; case ITEM_NEWLINE: { lh = 0; if (p_mode != PROCESS_CACHE) { lh = line < l.height_caches.size() ? l.height_caches[line] : 1; line_is_blank = true; } } break; case ITEM_TABLE: { lh = 0; ItemTable *table = static_cast(it); int hseparation = get_constant("table_hseparation"); int vseparation = get_constant("table_vseparation"); Color ccolor = _find_color(table, p_base_color); Vector2 draw_ofs = Point2(wofs, y); Color font_color_shadow = get_color("font_color_shadow"); bool use_outline = get_constant("shadow_as_outline"); Point2 shadow_ofs(get_constant("shadow_offset_x"), get_constant("shadow_offset_y")); if (p_mode == PROCESS_CACHE) { int idx = 0; //set minimums to zero for (int i = 0; i < table->columns.size(); i++) { table->columns.write[i].min_width = 0; table->columns.write[i].max_width = 0; table->columns.write[i].width = 0; } //compute minimum width for each cell const int available_width = p_width - hseparation * (table->columns.size() - 1) - wofs; for (List::Element *E = table->subitems.front(); E; E = E->next()) { ERR_CONTINUE(E->get()->type != ITEM_FRAME); //children should all be frames ItemFrame *frame = static_cast(E->get()); int column = idx % table->columns.size(); int ly = 0; for (int i = 0; i < frame->lines.size(); i++) { _process_line(frame, Point2(), ly, available_width, i, PROCESS_CACHE, cfont, Color(), font_color_shadow, use_outline, shadow_ofs); table->columns.write[column].min_width = MAX(table->columns[column].min_width, frame->lines[i].minimum_width); table->columns.write[column].max_width = MAX(table->columns[column].max_width, frame->lines[i].maximum_width); } idx++; } //compute available width and total ratio (for expanders) int total_ratio = 0; int remaining_width = available_width; table->total_width = hseparation; for (int i = 0; i < table->columns.size(); i++) { remaining_width -= table->columns[i].min_width; if (table->columns[i].max_width > table->columns[i].min_width) table->columns.write[i].expand = true; if (table->columns[i].expand) total_ratio += table->columns[i].expand_ratio; } //assign actual widths for (int i = 0; i < table->columns.size(); i++) { table->columns.write[i].width = table->columns[i].min_width; if (table->columns[i].expand) table->columns.write[i].width += table->columns[i].expand_ratio * remaining_width / total_ratio; table->total_width += table->columns[i].width + hseparation; } //resize to max_width if needed and distribute the remaining space bool table_need_fit = true; while (table_need_fit) { table_need_fit = false; //fit slim for (int i = 0; i < table->columns.size(); i++) { if (!table->columns[i].expand) continue; int dif = table->columns[i].width - table->columns[i].max_width; if (dif > 0) { table_need_fit = true; table->columns.write[i].width = table->columns[i].max_width; table->total_width -= dif; total_ratio -= table->columns[i].expand_ratio; } } //grow remaining_width = available_width - table->total_width; if (remaining_width > 0 && total_ratio > 0) { for (int i = 0; i < table->columns.size(); i++) { if (table->columns[i].expand) { int dif = table->columns[i].max_width - table->columns[i].width; if (dif > 0) { int slice = table->columns[i].expand_ratio * remaining_width / total_ratio; int incr = MIN(dif, slice); table->columns.write[i].width += incr; table->total_width += incr; } } } } } //compute caches properly again with the right width idx = 0; for (List::Element *E = table->subitems.front(); E; E = E->next()) { ERR_CONTINUE(E->get()->type != ITEM_FRAME); //children should all be frames ItemFrame *frame = static_cast(E->get()); int column = idx % table->columns.size(); for (int i = 0; i < frame->lines.size(); i++) { int ly = 0; _process_line(frame, Point2(), ly, table->columns[column].width, i, PROCESS_CACHE, cfont, Color(), font_color_shadow, use_outline, shadow_ofs); frame->lines.write[i].height_cache = ly; //actual height frame->lines.write[i].height_accum_cache = ly; //actual height } idx++; } } Point2 offset(align_ofs + hseparation, vseparation); int row_height = 0; //draw using computed caches int idx = 0; for (List::Element *E = table->subitems.front(); E; E = E->next()) { ERR_CONTINUE(E->get()->type != ITEM_FRAME); //children should all be frames ItemFrame *frame = static_cast(E->get()); int column = idx % table->columns.size(); int ly = 0; int yofs = 0; int lines_h = frame->lines[frame->lines.size() - 1].height_accum_cache - (frame->lines[0].height_accum_cache - frame->lines[0].height_cache); int lines_ofs = p_ofs.y + offset.y + draw_ofs.y; bool visible = lines_ofs < get_size().height && lines_ofs + lines_h >= 0; if (visible) line_is_blank = false; for (int i = 0; i < frame->lines.size(); i++) { if (visible) { if (p_mode == PROCESS_DRAW) { nonblank_line_count += _process_line(frame, p_ofs + offset + draw_ofs + Vector2(0, yofs), ly, table->columns[column].width, i, PROCESS_DRAW, cfont, ccolor, font_color_shadow, use_outline, shadow_ofs); } else if (p_mode == PROCESS_POINTER) { _process_line(frame, p_ofs + offset + draw_ofs + Vector2(0, yofs), ly, table->columns[column].width, i, PROCESS_POINTER, cfont, ccolor, font_color_shadow, use_outline, shadow_ofs, p_click_pos, r_click_item, r_click_char, r_outside); if (r_click_item && *r_click_item) { RETURN; // exit early } } } yofs += frame->lines[i].height_cache; if (p_mode == PROCESS_CACHE) { frame->lines.write[i].height_accum_cache = offset.y + draw_ofs.y + frame->lines[i].height_cache; } } row_height = MAX(yofs, row_height); offset.x += table->columns[column].width + hseparation; if (column == table->columns.size() - 1) { offset.y += row_height + vseparation; offset.x = hseparation; row_height = 0; } idx++; } int total_height = offset.y; if (row_height) { total_height = row_height + vseparation; } ADVANCE(table->total_width); CHECK_HEIGHT(total_height); } break; default: {} } Item *itp = it; it = _get_next_item(it); if (it && (p_line + 1 < p_frame->lines.size()) && p_frame->lines[p_line + 1].from == it) { if (p_mode == PROCESS_POINTER && r_click_item && p_click_pos.y >= p_ofs.y + y && p_click_pos.y <= p_ofs.y + y + lh) { //went to next line, but pointer was on the previous one if (r_outside) *r_outside = true; *r_click_item = itp; *r_click_char = rchar; RETURN; } break; } } NEW_LINE; RETURN; #undef RETURN #undef NEW_LINE #undef ENSURE_WIDTH #undef ADVANCE #undef CHECK_HEIGHT } void RichTextLabel::_scroll_changed(double) { if (updating_scroll) return; if (scroll_follow && vscroll->get_value() >= (vscroll->get_max() - vscroll->get_page())) scroll_following = true; else scroll_following = false; update(); } void RichTextLabel::_update_scroll() { int total_height = get_content_height(); bool exceeds = total_height > get_size().height && scroll_active; if (exceeds != scroll_visible) { if (exceeds) { scroll_visible = true; main->first_invalid_line = 0; scroll_w = vscroll->get_combined_minimum_size().width; vscroll->show(); vscroll->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_END, -scroll_w); _validate_line_caches(main); } else { scroll_visible = false; vscroll->hide(); scroll_w = 0; _validate_line_caches(main); } } } void RichTextLabel::_notification(int p_what) { switch (p_what) { case NOTIFICATION_RESIZED: { main->first_invalid_line = 0; //invalidate ALL update(); } break; case NOTIFICATION_ENTER_TREE: { if (bbcode != "") set_bbcode(bbcode); main->first_invalid_line = 0; //invalidate ALL update(); } break; case NOTIFICATION_THEME_CHANGED: { if (is_inside_tree() && use_bbcode) { parse_bbcode(bbcode); //first_invalid_line=0; //invalidate ALL //update(); } } break; case NOTIFICATION_DRAW: { _validate_line_caches(main); _update_scroll(); RID ci = get_canvas_item(); Size2 size = get_size(); Rect2 text_rect = _get_text_rect(); draw_style_box(get_stylebox("normal"), Rect2(Point2(), size)); if (has_focus()) { VisualServer::get_singleton()->canvas_item_add_clip_ignore(ci, true); draw_style_box(get_stylebox("focus"), Rect2(Point2(), size)); VisualServer::get_singleton()->canvas_item_add_clip_ignore(ci, false); } int ofs = vscroll->get_value(); //todo, change to binary search int from_line = 0; int total_chars = 0; while (from_line < main->lines.size()) { if (main->lines[from_line].height_accum_cache + _get_text_rect().get_position().y >= ofs) break; total_chars += main->lines[from_line].char_count; from_line++; } if (from_line >= main->lines.size()) break; //nothing to draw int y = (main->lines[from_line].height_accum_cache - main->lines[from_line].height_cache) - ofs; Ref base_font = get_font("normal_font"); Color base_color = get_color("default_color"); Color font_color_shadow = get_color("font_color_shadow"); bool use_outline = get_constant("shadow_as_outline"); Point2 shadow_ofs(get_constant("shadow_offset_x"), get_constant("shadow_offset_y")); visible_line_count = 0; while (y < size.height && from_line < main->lines.size()) { visible_line_count += _process_line(main, text_rect.get_position(), y, text_rect.get_size().width - scroll_w, from_line, PROCESS_DRAW, base_font, base_color, font_color_shadow, use_outline, shadow_ofs, Point2i(), NULL, NULL, NULL, total_chars); total_chars += main->lines[from_line].char_count; from_line++; } } } } void RichTextLabel::_find_click(ItemFrame *p_frame, const Point2i &p_click, Item **r_click_item, int *r_click_char, bool *r_outside) { if (r_click_item) *r_click_item = NULL; Size2 size = get_size(); Rect2 text_rect = _get_text_rect(); int ofs = vscroll->get_value(); Color font_color_shadow = get_color("font_color_shadow"); bool use_outline = get_constant("shadow_as_outline"); Point2 shadow_ofs(get_constant("shadow_offset_x"), get_constant("shadow_offset_y")); //todo, change to binary search int from_line = 0; while (from_line < p_frame->lines.size()) { if (p_frame->lines[from_line].height_accum_cache >= ofs) break; from_line++; } if (from_line >= p_frame->lines.size()) return; int y = (p_frame->lines[from_line].height_accum_cache - p_frame->lines[from_line].height_cache) - ofs; Ref base_font = get_font("normal_font"); Color base_color = get_color("default_color"); while (y < text_rect.get_size().height && from_line < p_frame->lines.size()) { _process_line(p_frame, text_rect.get_position(), y, text_rect.get_size().width - scroll_w, from_line, PROCESS_POINTER, base_font, base_color, font_color_shadow, use_outline, shadow_ofs, p_click, r_click_item, r_click_char, r_outside); if (r_click_item && *r_click_item) return; from_line++; } } Control::CursorShape RichTextLabel::get_cursor_shape(const Point2 &p_pos) const { if (!underline_meta || selection.click) return CURSOR_ARROW; if (main->first_invalid_line < main->lines.size()) return CURSOR_ARROW; //invalid int line = 0; Item *item = NULL; ((RichTextLabel *)(this))->_find_click(main, p_pos, &item, &line); if (item && ((RichTextLabel *)(this))->_find_meta(item, NULL)) return CURSOR_POINTING_HAND; return CURSOR_ARROW; } void RichTextLabel::_gui_input(Ref p_event) { Ref b = p_event; if (b.is_valid()) { if (main->first_invalid_line < main->lines.size()) return; if (b->get_button_index() == BUTTON_LEFT) { if (true) { if (b->is_pressed() && !b->is_doubleclick()) { int line = 0; Item *item = NULL; bool outside; _find_click(main, b->get_position(), &item, &line, &outside); if (item) { Variant meta; if (!outside && _find_meta(item, &meta)) { //meta clicked emit_signal("meta_clicked", meta); } else if (selection.enabled) { selection.click = item; selection.click_char = line; // Erase previous selection. if (selection.active) { selection.from = NULL; selection.from_char = '\0'; selection.to = NULL; selection.to_char = '\0'; selection.active = false; update(); } } } } else if (b->is_pressed() && b->is_doubleclick() && selection.enabled) { //doubleclick: select word int line = 0; Item *item = NULL; bool outside; _find_click(main, b->get_position(), &item, &line, &outside); while (item && item->type != ITEM_TEXT) { item = _get_next_item(item, true); } if (item && item->type == ITEM_TEXT) { String itext = static_cast(item)->text; int beg, end; if (select_word(itext, line, beg, end)) { selection.from = item; selection.to = item; selection.from_char = beg; selection.to_char = end - 1; selection.active = true; update(); } } } else if (!b->is_pressed()) { selection.click = NULL; } } } if (b->get_button_index() == BUTTON_WHEEL_UP) { if (scroll_active) vscroll->set_value(vscroll->get_value() - vscroll->get_page() * b->get_factor() * 0.5 / 8); } if (b->get_button_index() == BUTTON_WHEEL_DOWN) { if (scroll_active) vscroll->set_value(vscroll->get_value() + vscroll->get_page() * b->get_factor() * 0.5 / 8); } } Ref pan_gesture = p_event; if (pan_gesture.is_valid()) { if (scroll_active) vscroll->set_value(vscroll->get_value() + vscroll->get_page() * pan_gesture->get_delta().y * 0.5 / 8); return; } Ref k = p_event; if (k.is_valid()) { if (k->is_pressed() && !k->get_alt() && !k->get_shift()) { bool handled = true; switch (k->get_scancode()) { case KEY_PAGEUP: { if (vscroll->is_visible_in_tree()) vscroll->set_value(vscroll->get_value() - vscroll->get_page()); } break; case KEY_PAGEDOWN: { if (vscroll->is_visible_in_tree()) vscroll->set_value(vscroll->get_value() + vscroll->get_page()); } break; case KEY_UP: { if (vscroll->is_visible_in_tree()) vscroll->set_value(vscroll->get_value() - get_font("normal_font")->get_height()); } break; case KEY_DOWN: { if (vscroll->is_visible_in_tree()) vscroll->set_value(vscroll->get_value() + get_font("normal_font")->get_height()); } break; case KEY_HOME: { if (vscroll->is_visible_in_tree()) vscroll->set_value(0); } break; case KEY_END: { if (vscroll->is_visible_in_tree()) vscroll->set_value(vscroll->get_max()); } break; case KEY_INSERT: case KEY_C: { if (k->get_command()) { selection_copy(); } else { handled = false; } } break; default: handled = false; } if (handled) accept_event(); } } Ref m = p_event; if (m.is_valid()) { if (main->first_invalid_line < main->lines.size()) return; int line = 0; Item *item = NULL; bool outside; _find_click(main, m->get_position(), &item, &line, &outside); if (selection.click) { if (!item) return; // do not update selection.from = selection.click; selection.from_char = selection.click_char; selection.to = item; selection.to_char = line; bool swap = false; if (selection.from->index > selection.to->index) swap = true; else if (selection.from->index == selection.to->index) { if (selection.from_char > selection.to_char) swap = true; else if (selection.from_char == selection.to_char) { selection.active = false; return; } } if (swap) { SWAP(selection.from, selection.to); SWAP(selection.from_char, selection.to_char); } selection.active = true; update(); } Variant meta; if (item && !outside && _find_meta(item, &meta)) { if (meta_hovering != item) { if (meta_hovering) { emit_signal("meta_hover_ended", current_meta); } meta_hovering = static_cast(item); current_meta = meta; emit_signal("meta_hover_started", meta); } } else if (meta_hovering) { emit_signal("meta_hover_ended", current_meta); meta_hovering = NULL; current_meta = false; } } } Ref RichTextLabel::_find_font(Item *p_item) { Item *fontitem = p_item; while (fontitem) { if (fontitem->type == ITEM_FONT) { ItemFont *fi = static_cast(fontitem); return fi->font; } fontitem = fontitem->parent; } return Ref(); } int RichTextLabel::_find_margin(Item *p_item, const Ref &p_base_font) { Item *item = p_item; int margin = 0; while (item) { if (item->type == ITEM_INDENT) { Ref font = _find_font(item); if (font.is_null()) font = p_base_font; ItemIndent *indent = static_cast(item); margin += indent->level * tab_size * font->get_char_size(' ').width; } else if (item->type == ITEM_LIST) { Ref font = _find_font(item); if (font.is_null()) font = p_base_font; } item = item->parent; } return margin; } RichTextLabel::Align RichTextLabel::_find_align(Item *p_item) { Item *item = p_item; while (item) { if (item->type == ITEM_ALIGN) { ItemAlign *align = static_cast(item); return align->align; } item = item->parent; } return default_align; } Color RichTextLabel::_find_color(Item *p_item, const Color &p_default_color) { Item *item = p_item; while (item) { if (item->type == ITEM_COLOR) { ItemColor *color = static_cast(item); return color->color; } item = item->parent; } return p_default_color; } bool RichTextLabel::_find_underline(Item *p_item) { Item *item = p_item; while (item) { if (item->type == ITEM_UNDERLINE) { return true; } item = item->parent; } return false; } bool RichTextLabel::_find_strikethrough(Item *p_item) { Item *item = p_item; while (item) { if (item->type == ITEM_STRIKETHROUGH) { return true; } item = item->parent; } return false; } bool RichTextLabel::_find_meta(Item *p_item, Variant *r_meta) { Item *item = p_item; while (item) { if (item->type == ITEM_META) { ItemMeta *meta = static_cast(item); if (r_meta) *r_meta = meta->meta; return true; } item = item->parent; } return false; } void RichTextLabel::_validate_line_caches(ItemFrame *p_frame) { if (p_frame->first_invalid_line == p_frame->lines.size()) return; //validate invalid lines Size2 size = get_size(); if (fixed_width != -1) { size.width = fixed_width; } Rect2 text_rect = _get_text_rect(); Color font_color_shadow = get_color("font_color_shadow"); bool use_outline = get_constant("shadow_as_outline"); Point2 shadow_ofs(get_constant("shadow_offset_x"), get_constant("shadow_offset_y")); Ref base_font = get_font("normal_font"); for (int i = p_frame->first_invalid_line; i < p_frame->lines.size(); i++) { int y = 0; _process_line(p_frame, text_rect.get_position(), y, text_rect.get_size().width - scroll_w, i, PROCESS_CACHE, base_font, Color(), font_color_shadow, use_outline, shadow_ofs); p_frame->lines.write[i].height_cache = y; p_frame->lines.write[i].height_accum_cache = y; if (i > 0) p_frame->lines.write[i].height_accum_cache += p_frame->lines[i - 1].height_accum_cache; } int total_height = 0; if (p_frame->lines.size()) total_height = p_frame->lines[p_frame->lines.size() - 1].height_accum_cache + get_stylebox("normal")->get_minimum_size().height; main->first_invalid_line = p_frame->lines.size(); updating_scroll = true; vscroll->set_max(total_height); vscroll->set_page(size.height); if (scroll_follow && scroll_following) vscroll->set_value(total_height - size.height); updating_scroll = false; } void RichTextLabel::_invalidate_current_line(ItemFrame *p_frame) { if (p_frame->lines.size() - 1 <= p_frame->first_invalid_line) { p_frame->first_invalid_line = p_frame->lines.size() - 1; update(); } } void RichTextLabel::add_text(const String &p_text) { if (current->type == ITEM_TABLE) return; //can't add anything here int pos = 0; while (pos < p_text.length()) { int end = p_text.find("\n", pos); String line; bool eol = false; if (end == -1) { end = p_text.length(); } else { eol = true; } if (pos == 0 && end == p_text.length()) line = p_text; else line = p_text.substr(pos, end - pos); if (line.length() > 0) { if (current->subitems.size() && current->subitems.back()->get()->type == ITEM_TEXT) { //append text condition! ItemText *ti = static_cast(current->subitems.back()->get()); ti->text += line; _invalidate_current_line(main); } else { //append item condition ItemText *item = memnew(ItemText); item->text = line; _add_item(item, false); } } if (eol) { ItemNewline *item = memnew(ItemNewline); item->line = current_frame->lines.size(); _add_item(item, false); current_frame->lines.resize(current_frame->lines.size() + 1); if (item->type != ITEM_NEWLINE) current_frame->lines.write[current_frame->lines.size() - 1].from = item; _invalidate_current_line(current_frame); } pos = end + 1; } } void RichTextLabel::_add_item(Item *p_item, bool p_enter, bool p_ensure_newline) { p_item->parent = current; p_item->E = current->subitems.push_back(p_item); p_item->index = current_idx++; if (p_enter) current = p_item; if (p_ensure_newline && current_frame->lines[current_frame->lines.size() - 1].from) { _invalidate_current_line(current_frame); current_frame->lines.resize(current_frame->lines.size() + 1); } if (current_frame->lines[current_frame->lines.size() - 1].from == NULL) { current_frame->lines.write[current_frame->lines.size() - 1].from = p_item; } p_item->line = current_frame->lines.size() - 1; _invalidate_current_line(current_frame); } void RichTextLabel::_remove_item(Item *p_item, const int p_line, const int p_subitem_line) { int size = p_item->subitems.size(); if (size == 0) { p_item->parent->subitems.erase(p_item); if (p_item->type == ITEM_NEWLINE) { current_frame->lines.remove(p_line); for (int i = p_subitem_line; i < current->subitems.size(); i++) { if (current->subitems[i]->line > 0) current->subitems[i]->line--; } } } else { for (int i = 0; i < size; i++) { _remove_item(p_item->subitems.front()->get(), p_line, p_subitem_line); } } } void RichTextLabel::add_image(const Ref &p_image) { if (current->type == ITEM_TABLE) return; ERR_FAIL_COND(p_image.is_null()); ItemImage *item = memnew(ItemImage); item->image = p_image; _add_item(item, false); } void RichTextLabel::add_newline() { if (current->type == ITEM_TABLE) return; ItemNewline *item = memnew(ItemNewline); item->line = current_frame->lines.size(); _add_item(item, false); current_frame->lines.resize(current_frame->lines.size() + 1); _invalidate_current_line(current_frame); } bool RichTextLabel::remove_line(const int p_line) { if (p_line >= current_frame->lines.size() || p_line < 0) return false; int i = 0; while (i < current->subitems.size() && current->subitems[i]->line < p_line) { i++; } bool was_newline = false; while (i < current->subitems.size()) { was_newline = current->subitems[i]->type == ITEM_NEWLINE; _remove_item(current->subitems[i], current->subitems[i]->line, p_line); if (was_newline) break; } if (!was_newline) { current_frame->lines.remove(p_line); } if (p_line == 0 && current->subitems.size() > 0) main->lines.write[0].from = main; main->first_invalid_line = 0; return true; } void RichTextLabel::push_font(const Ref &p_font) { ERR_FAIL_COND(current->type == ITEM_TABLE); ERR_FAIL_COND(p_font.is_null()); ItemFont *item = memnew(ItemFont); item->font = p_font; _add_item(item, true); } void RichTextLabel::push_color(const Color &p_color) { ERR_FAIL_COND(current->type == ITEM_TABLE); ItemColor *item = memnew(ItemColor); item->color = p_color; _add_item(item, true); } void RichTextLabel::push_underline() { ERR_FAIL_COND(current->type == ITEM_TABLE); ItemUnderline *item = memnew(ItemUnderline); _add_item(item, true); } void RichTextLabel::push_strikethrough() { ERR_FAIL_COND(current->type == ITEM_TABLE); ItemStrikethrough *item = memnew(ItemStrikethrough); _add_item(item, true); } void RichTextLabel::push_align(Align p_align) { ERR_FAIL_COND(current->type == ITEM_TABLE); ItemAlign *item = memnew(ItemAlign); item->align = p_align; _add_item(item, true, true); } void RichTextLabel::push_indent(int p_level) { ERR_FAIL_COND(current->type == ITEM_TABLE); ERR_FAIL_COND(p_level < 0); ItemIndent *item = memnew(ItemIndent); item->level = p_level; _add_item(item, true, true); } void RichTextLabel::push_list(ListType p_list) { ERR_FAIL_COND(current->type == ITEM_TABLE); ERR_FAIL_INDEX(p_list, 3); ItemList *item = memnew(ItemList); item->list_type = p_list; _add_item(item, true, true); } void RichTextLabel::push_meta(const Variant &p_meta) { ERR_FAIL_COND(current->type == ITEM_TABLE); ItemMeta *item = memnew(ItemMeta); item->meta = p_meta; _add_item(item, true); } void RichTextLabel::push_table(int p_columns) { ERR_FAIL_COND(p_columns < 1); ItemTable *item = memnew(ItemTable); item->columns.resize(p_columns); item->total_width = 0; for (int i = 0; i < item->columns.size(); i++) { item->columns.write[i].expand = false; item->columns.write[i].expand_ratio = 1; } _add_item(item, true, true); } void RichTextLabel::set_table_column_expand(int p_column, bool p_expand, int p_ratio) { ERR_FAIL_COND(current->type != ITEM_TABLE); ItemTable *table = static_cast(current); ERR_FAIL_INDEX(p_column, table->columns.size()); table->columns.write[p_column].expand = p_expand; table->columns.write[p_column].expand_ratio = p_ratio; } void RichTextLabel::push_cell() { ERR_FAIL_COND(current->type != ITEM_TABLE); ItemFrame *item = memnew(ItemFrame); item->parent_frame = current_frame; _add_item(item, true); current_frame = item; item->cell = true; item->parent_line = item->parent_frame->lines.size() - 1; item->lines.resize(1); item->lines.write[0].from = NULL; item->first_invalid_line = 0; } int RichTextLabel::get_current_table_column() const { ERR_FAIL_COND_V(current->type != ITEM_TABLE, -1); ItemTable *table = static_cast(current); return table->subitems.size() % table->columns.size(); } void RichTextLabel::pop() { ERR_FAIL_COND(!current->parent); if (current->type == ITEM_FRAME) { current_frame = static_cast(current)->parent_frame; } current = current->parent; } void RichTextLabel::clear() { main->_clear_children(); current = main; current_frame = main; main->lines.clear(); main->lines.resize(1); main->first_invalid_line = 0; update(); selection.click = NULL; selection.active = false; current_idx = 1; } void RichTextLabel::set_tab_size(int p_spaces) { tab_size = p_spaces; main->first_invalid_line = 0; update(); } int RichTextLabel::get_tab_size() const { return tab_size; } void RichTextLabel::set_meta_underline(bool p_underline) { underline_meta = p_underline; update(); } bool RichTextLabel::is_meta_underlined() const { return underline_meta; } void RichTextLabel::set_override_selected_font_color(bool p_override_selected_font_color) { override_selected_font_color = p_override_selected_font_color; } bool RichTextLabel::is_overriding_selected_font_color() const { return override_selected_font_color; } void RichTextLabel::set_offset(int p_pixel) { vscroll->set_value(p_pixel); } void RichTextLabel::set_scroll_active(bool p_active) { if (scroll_active == p_active) return; scroll_active = p_active; update(); } bool RichTextLabel::is_scroll_active() const { return scroll_active; } void RichTextLabel::set_scroll_follow(bool p_follow) { scroll_follow = p_follow; if (!vscroll->is_visible_in_tree() || vscroll->get_value() >= (vscroll->get_max() - vscroll->get_page())) scroll_following = true; } bool RichTextLabel::is_scroll_following() const { return scroll_follow; } Error RichTextLabel::parse_bbcode(const String &p_bbcode) { clear(); return append_bbcode(p_bbcode); } Error RichTextLabel::append_bbcode(const String &p_bbcode) { int pos = 0; List tag_stack; Ref normal_font = get_font("normal_font"); Ref bold_font = get_font("bold_font"); Ref italics_font = get_font("italics_font"); Ref bold_italics_font = get_font("bold_italics_font"); Ref mono_font = get_font("mono_font"); Color base_color = get_color("default_color"); int indent_level = 0; bool in_bold = false; bool in_italics = false; while (pos < p_bbcode.length()) { int brk_pos = p_bbcode.find("[", pos); if (brk_pos < 0) brk_pos = p_bbcode.length(); if (brk_pos > pos) { add_text(p_bbcode.substr(pos, brk_pos - pos)); } if (brk_pos == p_bbcode.length()) break; //nothing else to add int brk_end = p_bbcode.find("]", brk_pos + 1); if (brk_end == -1) { //no close, add the rest add_text(p_bbcode.substr(brk_pos, p_bbcode.length() - brk_pos)); break; } String tag = p_bbcode.substr(brk_pos + 1, brk_end - brk_pos - 1); if (tag.begins_with("/") && tag_stack.size()) { bool tag_ok = tag_stack.size() && tag_stack.front()->get() == tag.substr(1, tag.length()); if (tag_stack.front()->get() == "b") in_bold = false; if (tag_stack.front()->get() == "i") in_italics = false; if (tag_stack.front()->get() == "indent") indent_level--; if (!tag_ok) { add_text("["); pos++; continue; } tag_stack.pop_front(); pos = brk_end + 1; if (tag != "/img") pop(); } else if (tag == "b") { //use bold font in_bold = true; if (in_italics) push_font(bold_italics_font); else push_font(bold_font); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "i") { //use italics font in_italics = true; if (in_bold) push_font(bold_italics_font); else push_font(italics_font); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "code") { //use monospace font push_font(mono_font); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag.begins_with("table=")) { int columns = tag.substr(6, tag.length()).to_int(); if (columns < 1) columns = 1; push_table(columns); pos = brk_end + 1; tag_stack.push_front("table"); } else if (tag == "cell") { push_cell(); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag.begins_with("cell=")) { int ratio = tag.substr(5, tag.length()).to_int(); if (ratio < 1) ratio = 1; set_table_column_expand(get_current_table_column(), true, ratio); push_cell(); pos = brk_end + 1; tag_stack.push_front("cell"); } else if (tag == "u") { //use underline push_underline(); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "s") { //use strikethrough push_strikethrough(); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "center") { push_align(ALIGN_CENTER); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "fill") { push_align(ALIGN_FILL); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "right") { push_align(ALIGN_RIGHT); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "ul") { push_list(LIST_DOTS); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "ol") { push_list(LIST_NUMBERS); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "indent") { indent_level++; push_indent(indent_level); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag == "url") { int end = p_bbcode.find("[", brk_end); if (end == -1) end = p_bbcode.length(); String url = p_bbcode.substr(brk_end + 1, end - brk_end - 1); push_meta(url); pos = brk_end + 1; tag_stack.push_front(tag); } else if (tag.begins_with("url=")) { String url = tag.substr(4, tag.length()); push_meta(url); pos = brk_end + 1; tag_stack.push_front("url"); } else if (tag == "img") { int end = p_bbcode.find("[", brk_end); if (end == -1) end = p_bbcode.length(); String image = p_bbcode.substr(brk_end + 1, end - brk_end - 1); Ref texture = ResourceLoader::load(image, "Texture"); if (texture.is_valid()) add_image(texture); pos = end; tag_stack.push_front(tag); } else if (tag.begins_with("color=")) { String col = tag.substr(6, tag.length()); Color color; if (col.begins_with("#")) color = Color::html(col); else if (col == "aqua") color = Color::html("#00FFFF"); else if (col == "black") color = Color::html("#000000"); else if (col == "blue") color = Color::html("#0000FF"); else if (col == "fuchsia") color = Color::html("#FF00FF"); else if (col == "gray" || col == "grey") color = Color::html("#808080"); else if (col == "green") color = Color::html("#008000"); else if (col == "lime") color = Color::html("#00FF00"); else if (col == "maroon") color = Color::html("#800000"); else if (col == "navy") color = Color::html("#000080"); else if (col == "olive") color = Color::html("#808000"); else if (col == "purple") color = Color::html("#800080"); else if (col == "red") color = Color::html("#FF0000"); else if (col == "silver") color = Color::html("#C0C0C0"); else if (col == "teal") color = Color::html("#008008"); else if (col == "white") color = Color::html("#FFFFFF"); else if (col == "yellow") color = Color::html("#FFFF00"); else color = base_color; push_color(color); pos = brk_end + 1; tag_stack.push_front("color"); } else if (tag.begins_with("font=")) { String fnt = tag.substr(5, tag.length()); Ref font = ResourceLoader::load(fnt, "Font"); if (font.is_valid()) push_font(font); else push_font(normal_font); pos = brk_end + 1; tag_stack.push_front("font"); } else { add_text("["); //ignore pos = brk_pos + 1; } } return OK; } void RichTextLabel::scroll_to_line(int p_line) { ERR_FAIL_INDEX(p_line, main->lines.size()); _validate_line_caches(main); vscroll->set_value(main->lines[p_line].height_accum_cache - main->lines[p_line].height_cache); } int RichTextLabel::get_line_count() const { return current_frame->lines.size(); } int RichTextLabel::get_visible_line_count() const { if (!is_visible()) return 0; return visible_line_count; } void RichTextLabel::set_selection_enabled(bool p_enabled) { selection.enabled = p_enabled; if (!p_enabled) { if (selection.active) { selection.active = false; update(); } set_focus_mode(FOCUS_NONE); } else { set_focus_mode(FOCUS_ALL); } } bool RichTextLabel::search(const String &p_string, bool p_from_selection, bool p_search_previous) { ERR_FAIL_COND_V(!selection.enabled, false); Item *it = main; int charidx = 0; if (p_from_selection && selection.active && selection.enabled) { it = selection.to; charidx = selection.to_char + 1; } while (it) { if (it->type == ITEM_TEXT) { ItemText *t = static_cast(it); int sp = t->text.find(p_string, charidx); if (sp != -1) { selection.from = it; selection.from_char = sp; selection.to = it; selection.to_char = sp + p_string.length() - 1; selection.active = true; update(); _validate_line_caches(main); int fh = _find_font(t).is_valid() ? _find_font(t)->get_height() : get_font("normal_font")->get_height(); float offset = 0; int line = t->line; Item *item = t; while (item) { if (item->type == ITEM_FRAME) { ItemFrame *frame = static_cast(item); if (line >= 0 && line < frame->lines.size()) { offset += frame->lines[line].height_accum_cache - frame->lines[line].height_cache; line = frame->line; } } item = item->parent; } vscroll->set_value(offset - fh); return true; } } if (p_search_previous) it = _get_prev_item(it, true); else it = _get_next_item(it, true); charidx = 0; } return false; } void RichTextLabel::selection_copy() { if (!selection.active || !selection.enabled) return; String text; RichTextLabel::Item *item = selection.from; while (item) { if (item->type == ITEM_TEXT) { String itext = static_cast(item)->text; if (item == selection.from && item == selection.to) { text += itext.substr(selection.from_char, selection.to_char - selection.from_char + 1); } else if (item == selection.from) { text += itext.substr(selection.from_char, itext.size()); } else if (item == selection.to) { text += itext.substr(0, selection.to_char + 1); } else { text += itext; } } else if (item->type == ITEM_NEWLINE) { text += "\n"; } if (item == selection.to) break; item = _get_next_item(item, true); } if (text != "") { OS::get_singleton()->set_clipboard(text); } } bool RichTextLabel::is_selection_enabled() const { return selection.enabled; } void RichTextLabel::set_bbcode(const String &p_bbcode) { bbcode = p_bbcode; if (is_inside_tree() && use_bbcode) parse_bbcode(p_bbcode); else { // raw text clear(); add_text(p_bbcode); } } String RichTextLabel::get_bbcode() const { return bbcode; } void RichTextLabel::set_use_bbcode(bool p_enable) { if (use_bbcode == p_enable) return; use_bbcode = p_enable; set_bbcode(bbcode); } bool RichTextLabel::is_using_bbcode() const { return use_bbcode; } String RichTextLabel::get_text() { String text = ""; Item *it = main; while (it) { if (it->type == ITEM_TEXT) { ItemText *t = static_cast(it); text += t->text; } else if (it->type == ITEM_NEWLINE) { text += "\n"; } else if (it->type == ITEM_INDENT) { text += "\t"; } it = _get_next_item(it, true); } return text; } void RichTextLabel::set_text(const String &p_string) { clear(); add_text(p_string); } void RichTextLabel::set_percent_visible(float p_percent) { if (p_percent < 0 || p_percent >= 1) { visible_characters = -1; percent_visible = 1; } else { visible_characters = get_total_character_count() * p_percent; percent_visible = p_percent; } update(); } float RichTextLabel::get_percent_visible() const { return percent_visible; } int RichTextLabel::get_content_height() { int total_height = 0; if (main->lines.size()) total_height = main->lines[main->lines.size() - 1].height_accum_cache + get_stylebox("normal")->get_minimum_size().height; return total_height; } void RichTextLabel::_bind_methods() { ClassDB::bind_method(D_METHOD("_gui_input"), &RichTextLabel::_gui_input); ClassDB::bind_method(D_METHOD("_scroll_changed"), &RichTextLabel::_scroll_changed); ClassDB::bind_method(D_METHOD("get_text"), &RichTextLabel::get_text); ClassDB::bind_method(D_METHOD("add_text", "text"), &RichTextLabel::add_text); ClassDB::bind_method(D_METHOD("set_text", "text"), &RichTextLabel::set_text); ClassDB::bind_method(D_METHOD("add_image", "image"), &RichTextLabel::add_image); ClassDB::bind_method(D_METHOD("newline"), &RichTextLabel::add_newline); ClassDB::bind_method(D_METHOD("remove_line", "line"), &RichTextLabel::remove_line); ClassDB::bind_method(D_METHOD("push_font", "font"), &RichTextLabel::push_font); ClassDB::bind_method(D_METHOD("push_color", "color"), &RichTextLabel::push_color); ClassDB::bind_method(D_METHOD("push_align", "align"), &RichTextLabel::push_align); ClassDB::bind_method(D_METHOD("push_indent", "level"), &RichTextLabel::push_indent); ClassDB::bind_method(D_METHOD("push_list", "type"), &RichTextLabel::push_list); ClassDB::bind_method(D_METHOD("push_meta", "data"), &RichTextLabel::push_meta); ClassDB::bind_method(D_METHOD("push_underline"), &RichTextLabel::push_underline); ClassDB::bind_method(D_METHOD("push_strikethrough"), &RichTextLabel::push_strikethrough); ClassDB::bind_method(D_METHOD("push_table", "columns"), &RichTextLabel::push_table); ClassDB::bind_method(D_METHOD("set_table_column_expand", "column", "expand", "ratio"), &RichTextLabel::set_table_column_expand); ClassDB::bind_method(D_METHOD("push_cell"), &RichTextLabel::push_cell); ClassDB::bind_method(D_METHOD("pop"), &RichTextLabel::pop); ClassDB::bind_method(D_METHOD("clear"), &RichTextLabel::clear); ClassDB::bind_method(D_METHOD("set_meta_underline", "enable"), &RichTextLabel::set_meta_underline); ClassDB::bind_method(D_METHOD("is_meta_underlined"), &RichTextLabel::is_meta_underlined); ClassDB::bind_method(D_METHOD("set_override_selected_font_color", "override"), &RichTextLabel::set_override_selected_font_color); ClassDB::bind_method(D_METHOD("is_overriding_selected_font_color"), &RichTextLabel::is_overriding_selected_font_color); ClassDB::bind_method(D_METHOD("set_scroll_active", "active"), &RichTextLabel::set_scroll_active); ClassDB::bind_method(D_METHOD("is_scroll_active"), &RichTextLabel::is_scroll_active); ClassDB::bind_method(D_METHOD("set_scroll_follow", "follow"), &RichTextLabel::set_scroll_follow); ClassDB::bind_method(D_METHOD("is_scroll_following"), &RichTextLabel::is_scroll_following); ClassDB::bind_method(D_METHOD("get_v_scroll"), &RichTextLabel::get_v_scroll); ClassDB::bind_method(D_METHOD("scroll_to_line", "line"), &RichTextLabel::scroll_to_line); ClassDB::bind_method(D_METHOD("set_tab_size", "spaces"), &RichTextLabel::set_tab_size); ClassDB::bind_method(D_METHOD("get_tab_size"), &RichTextLabel::get_tab_size); ClassDB::bind_method(D_METHOD("set_selection_enabled", "enabled"), &RichTextLabel::set_selection_enabled); ClassDB::bind_method(D_METHOD("is_selection_enabled"), &RichTextLabel::is_selection_enabled); ClassDB::bind_method(D_METHOD("parse_bbcode", "bbcode"), &RichTextLabel::parse_bbcode); ClassDB::bind_method(D_METHOD("append_bbcode", "bbcode"), &RichTextLabel::append_bbcode); ClassDB::bind_method(D_METHOD("set_bbcode", "text"), &RichTextLabel::set_bbcode); ClassDB::bind_method(D_METHOD("get_bbcode"), &RichTextLabel::get_bbcode); ClassDB::bind_method(D_METHOD("set_visible_characters", "amount"), &RichTextLabel::set_visible_characters); ClassDB::bind_method(D_METHOD("get_visible_characters"), &RichTextLabel::get_visible_characters); ClassDB::bind_method(D_METHOD("set_percent_visible", "percent_visible"), &RichTextLabel::set_percent_visible); ClassDB::bind_method(D_METHOD("get_percent_visible"), &RichTextLabel::get_percent_visible); ClassDB::bind_method(D_METHOD("get_total_character_count"), &RichTextLabel::get_total_character_count); ClassDB::bind_method(D_METHOD("set_use_bbcode", "enable"), &RichTextLabel::set_use_bbcode); ClassDB::bind_method(D_METHOD("is_using_bbcode"), &RichTextLabel::is_using_bbcode); ClassDB::bind_method(D_METHOD("get_line_count"), &RichTextLabel::get_line_count); ClassDB::bind_method(D_METHOD("get_visible_line_count"), &RichTextLabel::get_visible_line_count); ClassDB::bind_method(D_METHOD("get_content_height"), &RichTextLabel::get_content_height); ADD_GROUP("BBCode", "bbcode_"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "bbcode_enabled"), "set_use_bbcode", "is_using_bbcode"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "bbcode_text", PROPERTY_HINT_MULTILINE_TEXT), "set_bbcode", "get_bbcode"); ADD_PROPERTY(PropertyInfo(Variant::INT, "visible_characters", PROPERTY_HINT_RANGE, "-1,128000,1"), "set_visible_characters", "get_visible_characters"); ADD_PROPERTY(PropertyInfo(Variant::REAL, "percent_visible", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_percent_visible", "get_percent_visible"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "meta_underlined"), "set_meta_underline", "is_meta_underlined"); ADD_PROPERTY(PropertyInfo(Variant::INT, "tab_size", PROPERTY_HINT_RANGE, "0,24,1"), "set_tab_size", "get_tab_size"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "text", PROPERTY_HINT_MULTILINE_TEXT), "set_text", "get_text"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "scroll_active"), "set_scroll_active", "is_scroll_active"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "scroll_following"), "set_scroll_follow", "is_scroll_following"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "selection_enabled"), "set_selection_enabled", "is_selection_enabled"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "override_selected_font_color"), "set_override_selected_font_color", "is_overriding_selected_font_color"); ADD_SIGNAL(MethodInfo("meta_clicked", PropertyInfo(Variant::NIL, "meta", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT))); ADD_SIGNAL(MethodInfo("meta_hover_started", PropertyInfo(Variant::NIL, "meta", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT))); ADD_SIGNAL(MethodInfo("meta_hover_ended", PropertyInfo(Variant::NIL, "meta", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NIL_IS_VARIANT))); BIND_ENUM_CONSTANT(ALIGN_LEFT); BIND_ENUM_CONSTANT(ALIGN_CENTER); BIND_ENUM_CONSTANT(ALIGN_RIGHT); BIND_ENUM_CONSTANT(ALIGN_FILL); BIND_ENUM_CONSTANT(LIST_NUMBERS); BIND_ENUM_CONSTANT(LIST_LETTERS); BIND_ENUM_CONSTANT(LIST_DOTS); BIND_ENUM_CONSTANT(ITEM_FRAME); BIND_ENUM_CONSTANT(ITEM_TEXT); BIND_ENUM_CONSTANT(ITEM_IMAGE); BIND_ENUM_CONSTANT(ITEM_NEWLINE); BIND_ENUM_CONSTANT(ITEM_FONT); BIND_ENUM_CONSTANT(ITEM_COLOR); BIND_ENUM_CONSTANT(ITEM_UNDERLINE); BIND_ENUM_CONSTANT(ITEM_STRIKETHROUGH); BIND_ENUM_CONSTANT(ITEM_ALIGN); BIND_ENUM_CONSTANT(ITEM_INDENT); BIND_ENUM_CONSTANT(ITEM_LIST); BIND_ENUM_CONSTANT(ITEM_TABLE); BIND_ENUM_CONSTANT(ITEM_META); } void RichTextLabel::set_visible_characters(int p_visible) { visible_characters = p_visible; update(); } int RichTextLabel::get_visible_characters() const { return visible_characters; } int RichTextLabel::get_total_character_count() const { int tc = 0; for (int i = 0; i < current_frame->lines.size(); i++) tc += current_frame->lines[i].char_count; return tc; } void RichTextLabel::set_fixed_size_to_width(int p_width) { fixed_width = p_width; minimum_size_changed(); } Size2 RichTextLabel::get_minimum_size() const { if (fixed_width != -1) { const_cast(this)->_validate_line_caches(main); return Size2(fixed_width, const_cast(this)->get_content_height()); } return Size2(); } RichTextLabel::RichTextLabel() { main = memnew(ItemFrame); main->index = 0; current = main; main->lines.resize(1); main->lines.write[0].from = main; main->first_invalid_line = 0; current_frame = main; tab_size = 4; default_align = ALIGN_LEFT; underline_meta = true; override_selected_font_color = false; scroll_visible = false; scroll_follow = false; scroll_following = false; updating_scroll = false; scroll_active = true; scroll_w = 0; vscroll = memnew(VScrollBar); add_child(vscroll); vscroll->set_drag_node(String("..")); vscroll->set_step(1); vscroll->set_anchor_and_margin(MARGIN_TOP, ANCHOR_BEGIN, 0); vscroll->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 0); vscroll->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 0); vscroll->connect("value_changed", this, "_scroll_changed"); vscroll->set_step(1); vscroll->hide(); current_idx = 1; use_bbcode = false; selection.click = NULL; selection.active = false; selection.enabled = false; visible_characters = -1; percent_visible = 1; visible_line_count = 0; fixed_width = -1; set_clip_contents(true); } RichTextLabel::~RichTextLabel() { memdelete(main); }