2324 lines
71 KiB
C++
2324 lines
71 KiB
C++
/*************************************************************************/
|
|
/* 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_node.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<StyleBox> 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<Font> &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<Font> 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<ItemText *>(it);
|
|
|
|
Ref<Font> 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;
|
|
|
|
if (p_mode == PROCESS_DRAW) {
|
|
color = _find_color(text, p_base_color);
|
|
font_color_shadow = _find_color(text, p_font_color_shadow);
|
|
underline = _find_underline(text);
|
|
if (_find_meta(text, &meta) && underline_meta) {
|
|
|
|
underline = 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);
|
|
}
|
|
}
|
|
|
|
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<ItemImage *>(it);
|
|
|
|
Ref<Font> 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<ItemTable *>(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<Item *>::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<ItemFrame *>(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<Item *>::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<ItemFrame *>(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<Item *>::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<ItemFrame *>(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<Font> 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"));
|
|
|
|
float x_ofs = 0;
|
|
|
|
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<Font> 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<InputEvent> p_event) {
|
|
|
|
Ref<InputEventMouseButton> 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<ItemText *>(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<InputEventPanGesture> 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<InputEventKey> 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<InputEventMouseMotion> 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<ItemMeta *>(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<Font> RichTextLabel::_find_font(Item *p_item) {
|
|
|
|
Item *fontitem = p_item;
|
|
|
|
while (fontitem) {
|
|
|
|
if (fontitem->type == ITEM_FONT) {
|
|
|
|
ItemFont *fi = static_cast<ItemFont *>(fontitem);
|
|
return fi->font;
|
|
}
|
|
|
|
fontitem = fontitem->parent;
|
|
}
|
|
|
|
return Ref<Font>();
|
|
}
|
|
|
|
int RichTextLabel::_find_margin(Item *p_item, const Ref<Font> &p_base_font) {
|
|
|
|
Item *item = p_item;
|
|
|
|
int margin = 0;
|
|
|
|
while (item) {
|
|
|
|
if (item->type == ITEM_INDENT) {
|
|
|
|
Ref<Font> font = _find_font(item);
|
|
if (font.is_null())
|
|
font = p_base_font;
|
|
|
|
ItemIndent *indent = static_cast<ItemIndent *>(item);
|
|
|
|
margin += indent->level * tab_size * font->get_char_size(' ').width;
|
|
|
|
} else if (item->type == ITEM_LIST) {
|
|
|
|
Ref<Font> 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<ItemAlign *>(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<ItemColor *>(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_meta(Item *p_item, Variant *r_meta) {
|
|
|
|
Item *item = p_item;
|
|
|
|
while (item) {
|
|
|
|
if (item->type == ITEM_META) {
|
|
|
|
ItemMeta *meta = static_cast<ItemMeta *>(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<Font> 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<ItemText *>(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<Texture> &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<Font> &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_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<ItemTable *>(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<ItemTable *>(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<ItemFrame *>(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<String> tag_stack;
|
|
Ref<Font> normal_font = get_font("normal_font");
|
|
Ref<Font> bold_font = get_font("bold_font");
|
|
Ref<Font> italics_font = get_font("italics_font");
|
|
Ref<Font> bold_italics_font = get_font("bold_italics_font");
|
|
Ref<Font> 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 o 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;
|
|
//use monospace font
|
|
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;
|
|
//use monospace font
|
|
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 (not supported underline instead)
|
|
push_underline();
|
|
pos = brk_end + 1;
|
|
tag_stack.push_front(tag);
|
|
} else if (tag == "center") {
|
|
|
|
//use underline
|
|
push_align(ALIGN_CENTER);
|
|
pos = brk_end + 1;
|
|
tag_stack.push_front(tag);
|
|
} else if (tag == "fill") {
|
|
|
|
//use underline
|
|
push_align(ALIGN_FILL);
|
|
pos = brk_end + 1;
|
|
tag_stack.push_front(tag);
|
|
} else if (tag == "right") {
|
|
|
|
//use underline
|
|
push_align(ALIGN_RIGHT);
|
|
pos = brk_end + 1;
|
|
tag_stack.push_front(tag);
|
|
} else if (tag == "ul") {
|
|
|
|
//use underline
|
|
push_list(LIST_DOTS);
|
|
pos = brk_end + 1;
|
|
tag_stack.push_front(tag);
|
|
} else if (tag == "ol") {
|
|
|
|
//use underline
|
|
push_list(LIST_NUMBERS);
|
|
pos = brk_end + 1;
|
|
tag_stack.push_front(tag);
|
|
} else if (tag == "indent") {
|
|
|
|
//use underline
|
|
indent_level++;
|
|
push_indent(indent_level);
|
|
pos = brk_end + 1;
|
|
tag_stack.push_front(tag);
|
|
|
|
} else if (tag == "url") {
|
|
|
|
//use strikethrough (not supported underline instead)
|
|
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") {
|
|
|
|
//use strikethrough (not supported underline instead)
|
|
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> 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> 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<ItemText *>(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<ItemFrame *>(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<ItemText *>(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<ItemText *>(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_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"), "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_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<RichTextLabel *>(this)->_validate_line_caches(main);
|
|
return Size2(fixed_width, const_cast<RichTextLabel *>(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_slave(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);
|
|
}
|