/*************************************************************************/
/*  rich_text_label.cpp                                                  */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2020 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/math/math_defs.h"
#include "core/os/keyboard.h"
#include "core/os/os.h"
#include "scene/scene_string_names.h"

#include "modules/modules_enabled.gen.h"
#ifdef MODULE_REGEX_ENABLED
#include "modules/regex/regex.h"
#endif

#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<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) {

	ERR_FAIL_INDEX_V((int)p_mode, 3, 0);

	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(line_wrapped ? ((p_width - margin) - used) : 0); 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);                                                                                                                   \
		}                                                                                                                                                       \
		line_wrapped = false;                                                                                                                                   \
		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) {                                                                                                         \
		line_wrapped = true;                                                                                                                \
		if (p_mode == PROCESS_CACHE) {                                                                                                      \
			if (spaces > 0)                                                                                                                 \
				spaces -= 1;                                                                                                                \
		}                                                                                                                                   \
		const bool x_in_range = (p_click_pos.x > p_ofs.x + wofs) && (!p_frame->cell || p_click_pos.x < p_ofs.x + p_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 && x_in_range) { \
			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;
	bool line_wrapped = false;
	int fh = 0;

	while (it) {

		switch (it->type) {

			case ITEM_ALIGN: {

				ItemAlign *align_it = static_cast<ItemAlign *>(it);

				align = align_it->align;

			} break;
			case ITEM_INDENT: {

				if (it != l.from) {
					ItemIndent *indent_it = static_cast<ItemIndent *>(it);

					int indent = indent_it->level * tab_size * cfont->get_char_size(' ').width;
					margin += indent;
					begin += indent;
					wofs += indent;
				}

			} break;
			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;
				bool strikethrough = false;
				ItemFade *fade = NULL;
				int it_char_start = p_char_count;

				Vector<ItemFX *> fx_stack = Vector<ItemFX *>();
				_fetch_item_fx_stack(text, fx_stack);
				bool custom_fx_ok = true;

				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;
					}

					Item *fade_item = it;
					while (fade_item) {
						if (fade_item->type == ITEM_FADE) {
							fade = static_cast<ItemFade *>(fade_item);
							break;
						}
						fade_item = fade_item->parent;
					}

				} 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;
								Color fx_color = Color(color);
								Point2 fx_offset;
								CharType fx_char = c[i];

								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;
								int c_item_offset = p_char_count - it_char_start;

								float faded_visibility = 1.0f;
								if (fade) {
									if (c_item_offset >= fade->starting_index) {
										faded_visibility -= (float)(c_item_offset - fade->starting_index) / (float)fade->length;
										faded_visibility = faded_visibility < 0.0f ? 0.0f : faded_visibility;
									}
									fx_color.a = faded_visibility;
								}

								bool visible = visible_characters < 0 || ((p_char_count < visible_characters && YRANGE_VISIBLE(y + lh - line_descent - line_ascent, line_ascent + line_descent)) &&
																				 faded_visibility > 0.0f);

								for (int j = 0; j < fx_stack.size(); j++) {
									ItemFX *item_fx = fx_stack[j];

									if (item_fx->type == ITEM_CUSTOMFX && custom_fx_ok) {
										ItemCustomFX *item_custom = static_cast<ItemCustomFX *>(item_fx);

										Ref<CharFXTransform> charfx = item_custom->char_fx_transform;
										Ref<RichTextEffect> custom_effect = item_custom->custom_effect;

										if (!custom_effect.is_null()) {
											charfx->elapsed_time = item_custom->elapsed_time;
											charfx->relative_index = c_item_offset;
											charfx->absolute_index = p_char_count;
											charfx->visibility = visible;
											charfx->offset = fx_offset;
											charfx->color = fx_color;
											charfx->character = fx_char;

											bool effect_status = custom_effect->_process_effect_impl(charfx);
											custom_fx_ok = effect_status;

											fx_offset += charfx->offset;
											fx_color = charfx->color;
											visible &= charfx->visibility;
											fx_char = charfx->character;
										}
									} else if (item_fx->type == ITEM_SHAKE) {
										ItemShake *item_shake = static_cast<ItemShake *>(item_fx);

										uint64_t char_current_rand = item_shake->offset_random(c_item_offset);
										uint64_t char_previous_rand = item_shake->offset_previous_random(c_item_offset);
										uint64_t max_rand = 2147483647;
										double current_offset = Math::range_lerp(char_current_rand % max_rand, 0, max_rand, 0.0f, 2.f * (float)Math_PI);
										double previous_offset = Math::range_lerp(char_previous_rand % max_rand, 0, max_rand, 0.0f, 2.f * (float)Math_PI);
										double n_time = (double)(item_shake->elapsed_time / (0.5f / item_shake->rate));
										n_time = (n_time > 1.0) ? 1.0 : n_time;
										fx_offset += Point2(Math::lerp(Math::sin(previous_offset),
																	Math::sin(current_offset),
																	n_time),
															 Math::lerp(Math::cos(previous_offset),
																	 Math::cos(current_offset),
																	 n_time)) *
													 (float)item_shake->strength / 10.0f;
									} else if (item_fx->type == ITEM_WAVE) {
										ItemWave *item_wave = static_cast<ItemWave *>(item_fx);

										double value = Math::sin(item_wave->frequency * item_wave->elapsed_time + ((p_ofs.x + pofs) / 50)) * (item_wave->amplitude / 10.0f);
										fx_offset += Point2(0, 1) * value;
									} else if (item_fx->type == ITEM_TORNADO) {
										ItemTornado *item_tornado = static_cast<ItemTornado *>(item_fx);

										double torn_x = Math::sin(item_tornado->frequency * item_tornado->elapsed_time + ((p_ofs.x + pofs) / 50)) * (item_tornado->radius);
										double torn_y = Math::cos(item_tornado->frequency * item_tornado->elapsed_time + ((p_ofs.x + pofs) / 50)) * (item_tornado->radius);
										fx_offset += Point2(torn_x, torn_y);
									} else if (item_fx->type == ITEM_RAINBOW) {
										ItemRainbow *item_rainbow = static_cast<ItemRainbow *>(item_fx);

										fx_color = fx_color.from_hsv(item_rainbow->frequency * (item_rainbow->elapsed_time + ((p_ofs.x + pofs) / 50)),
												item_rainbow->saturation,
												item_rainbow->value,
												fx_color.a);
									}
								}

								if (visible)
									line_is_blank = false;

								if (c[i] == '\t')
									visible = false;

								if (visible) {

									if (selected) {
										cw = font->get_char_size(fx_char, 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;
										font->draw_char(ci, Point2(x_ofs_shadow, y_ofs_shadow) + shadow_ofs + fx_offset, fx_char, 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) + fx_offset, fx_char, 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) + fx_offset, fx_char, 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) + fx_offset, fx_char, c[i + 1], p_font_color_shadow);
										}
									}

									if (selected) {
										drawer.draw_char(ci, p_ofs + Point2(align_ofs + pofs, y + lh - line_descent), fx_char, c[i + 1], override_selected_font_color ? selection_fg : fx_color);
									} else {
										cw = drawer.draw_char(ci, p_ofs + Point2(align_ofs + pofs, y + lh - line_descent) + fx_offset, fx_char, c[i + 1], fx_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<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->size.width);

				bool visible = visible_characters < 0 || (p_char_count < visible_characters && YRANGE_VISIBLE(y + lh - font->get_descent() - img->size.height, img->size.height));
				if (visible)
					line_is_blank = false;

				if (p_mode == PROCESS_DRAW && visible) {
					img->image->draw_rect(ci, Rect2(p_ofs + Point2(align_ofs + wofs, y + lh - font->get_descent() - img->size.height), img->size));
				}
				p_char_count++;

				ADVANCE(img->size.width);
				CHECK_HEIGHT((img->size.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_ofs2(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_ofs2);
							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 && total_ratio > 0)
							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_ofs2);
							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_ofs2);
							} 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_ofs2, 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 || !scroll_active)
		return;

	if (scroll_follow && vscroll->get_value() >= (vscroll->get_max() - vscroll->get_page()))
		scroll_following = true;
	else
		scroll_following = false;

	scroll_updated = true;

	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;
			scroll_w = vscroll->get_combined_minimum_size().width;
			vscroll->show();
			vscroll->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_END, -scroll_w);
		} else {
			scroll_visible = false;
			scroll_w = 0;
			vscroll->hide();
		}

		main->first_invalid_line = 0; //invalidate ALL
		_validate_line_caches(main);
	}
}

void RichTextLabel::_update_fx(RichTextLabel::ItemFrame *p_frame, float p_delta_time) {
	Item *it = p_frame;
	while (it) {
		ItemFX *ifx = NULL;

		if (it->type == ITEM_CUSTOMFX || it->type == ITEM_SHAKE || it->type == ITEM_WAVE || it->type == ITEM_TORNADO || it->type == ITEM_RAINBOW) {
			ifx = static_cast<ItemFX *>(it);
		}

		if (!ifx) {
			it = _get_next_item(it, true);
			continue;
		}

		ifx->elapsed_time += p_delta_time;

		ItemShake *shake = NULL;

		if (it->type == ITEM_SHAKE) {
			shake = static_cast<ItemShake *>(it);
		}

		if (shake) {
			bool cycle = (shake->elapsed_time > (1.0f / shake->rate));
			if (cycle) {
				shake->elapsed_time -= (1.0f / shake->rate);
				shake->reroll_random();
			}
		}

		it = _get_next_item(it, true);
	}
}

void RichTextLabel::_notification(int p_what) {

	switch (p_what) {

		case NOTIFICATION_MOUSE_EXIT: {
			if (meta_hovering) {
				meta_hovering = NULL;
				emit_signal("meta_hover_ended", current_meta);
				current_meta = false;
				update();
			}
		} break;
		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: {

			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"));

			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++;
			}
		} break;
		case NOTIFICATION_INTERNAL_PROCESS: {
			float dt = get_process_delta_time();

			_update_fx(main, dt);
			update();
		}
	}
}

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;

	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)
		return CURSOR_ARROW;

	if (selection.click)
		return CURSOR_IBEAM;

	if (main->first_invalid_line < main->lines.size())
		return CURSOR_ARROW; //invalid

	int line = 0;
	Item *item = NULL;
	bool outside;
	((RichTextLabel *)(this))->_find_click(main, p_pos, &item, &line, &outside);

	if (item && !outside && ((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 (b->is_pressed() && !b->is_doubleclick()) {
				scroll_updated = false;
				int line = 0;
				Item *item = NULL;

				bool outside;
				_find_click(main, b->get_position(), &item, &line, &outside);

				if (item) {

					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->is_doubleclick() && !scroll_updated) {
					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);
						}
					}
				}
			}
		}

		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;
		ItemMeta *item_meta;
		if (item && !outside && _find_meta(item, &meta, &item_meta)) {
			if (meta_hovering != item_meta) {
				if (meta_hovering) {
					emit_signal("meta_hover_ended", current_meta);
				}
				meta_hovering = item_meta;
				current_meta = meta;
				emit_signal("meta_hover_started", meta);
			}
		} else if (meta_hovering) {
			meta_hovering = NULL;
			emit_signal("meta_hover_ended", current_meta);
			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_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_by_type(Item *p_item, ItemType p_type) {

	ERR_FAIL_INDEX_V((int)p_type, 19, false);

	Item *item = p_item;

	while (item) {
		if (item->type == p_type) {
			return true;
		}
		item = item->parent;
	}
	return false;
}

void RichTextLabel::_fetch_item_fx_stack(Item *p_item, Vector<ItemFX *> &r_stack) {
	Item *item = p_item;
	while (item) {
		if (item->type == ITEM_CUSTOMFX || item->type == ITEM_SHAKE || item->type == ITEM_WAVE || item->type == ITEM_TORNADO || item->type == ITEM_RAINBOW) {
			r_stack.push_back(static_cast<ItemFX *>(item));
		}

		item = item->parent;
	}
}

bool RichTextLabel::_find_meta(Item *p_item, Variant *r_meta, ItemMeta **r_item) {
	Item *item = p_item;

	while (item) {

		if (item->type == ITEM_META) {

			ItemMeta *meta = static_cast<ItemMeta *>(item);
			if (r_meta)
				*r_meta = meta->meta;
			if (r_item)
				*r_item = meta;
			return true;
		}

		item = item->parent;
	}

	return false;
}

bool RichTextLabel::_find_layout_subitem(Item *from, Item *to) {

	if (from && from != to) {
		if (from->type != ITEM_FONT && from->type != ITEM_COLOR && from->type != ITEM_UNDERLINE && from->type != ITEM_STRIKETHROUGH)
			return true;

		for (List<Item *>::Element *E = from->subitems.front(); E; E = E->next()) {
			bool layout = _find_layout_subitem(E->get(), to);

			if (layout)
				return true;
		}
	}

	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) {
		Item *from = current_frame->lines[current_frame->lines.size() - 1].from;
		// only create a new line for Item types that generate content/layout, ignore those that represent formatting/styling
		if (_find_layout_subitem(from, p_item)) {
			_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, const int p_width, const int p_height) {

	if (current->type == ITEM_TABLE)
		return;

	ERR_FAIL_COND(p_image.is_null());
	ItemImage *item = memnew(ItemImage);

	item->image = p_image;

	if (p_width > 0) {
		// custom width
		item->size.width = p_width;
		if (p_height > 0) {
			// custom height
			item->size.height = p_height;
		} else {
			// calculate height to keep aspect ratio
			item->size.height = p_image->get_height() * p_width / p_image->get_width();
		}
	} else {
		if (p_height > 0) {
			// custom height
			item->size.height = p_height;
			// calculate width to keep aspect ratio
			item->size.width = p_image->get_width() * p_height / p_image->get_height();
		} else {
			// keep original width and height
			item->size.height = p_image->get_height();
			item->size.width = p_image->get_width();
		}
	}

	_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 (current_frame->lines.size() == 0) {
			current_frame->lines.resize(1);
		}
	}

	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_normal() {
	Ref<Font> normal_font = get_font("normal_font");
	ERR_FAIL_COND(normal_font.is_null());

	push_font(normal_font);
}

void RichTextLabel::push_bold() {
	Ref<Font> bold_font = get_font("bold_font");
	ERR_FAIL_COND(bold_font.is_null());

	push_font(bold_font);
}

void RichTextLabel::push_bold_italics() {
	Ref<Font> bold_italics_font = get_font("bold_italics_font");
	ERR_FAIL_COND(bold_italics_font.is_null());

	push_font(bold_italics_font);
}

void RichTextLabel::push_italics() {
	Ref<Font> italics_font = get_font("italics_font");
	ERR_FAIL_COND(italics_font.is_null());

	push_font(italics_font);
}

void RichTextLabel::push_mono() {
	Ref<Font> mono_font = get_font("mono_font");
	ERR_FAIL_COND(mono_font.is_null());

	push_font(mono_font);
}

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::push_fade(int p_start_index, int p_length) {
	ItemFade *item = memnew(ItemFade);
	item->starting_index = p_start_index;
	item->length = p_length;
	_add_item(item, true);
}

void RichTextLabel::push_shake(int p_strength = 10, float p_rate = 24.0f) {
	ItemShake *item = memnew(ItemShake);
	item->strength = p_strength;
	item->rate = p_rate;
	_add_item(item, true);
}

void RichTextLabel::push_wave(float p_frequency = 1.0f, float p_amplitude = 10.0f) {
	ItemWave *item = memnew(ItemWave);
	item->frequency = p_frequency;
	item->amplitude = p_amplitude;
	_add_item(item, true);
}

void RichTextLabel::push_tornado(float p_frequency = 1.0f, float p_radius = 10.0f) {
	ItemTornado *item = memnew(ItemTornado);
	item->frequency = p_frequency;
	item->radius = p_radius;
	_add_item(item, true);
}

void RichTextLabel::push_rainbow(float p_saturation, float p_value, float p_frequency) {
	ItemRainbow *item = memnew(ItemRainbow);
	item->frequency = p_frequency;
	item->saturation = p_saturation;
	item->value = p_value;
	_add_item(item, true);
}

void RichTextLabel::push_customfx(Ref<RichTextEffect> p_custom_effect, Dictionary p_environment) {
	ItemCustomFX *item = memnew(ItemCustomFX);
	item->custom_effect = p_custom_effect;
	item->char_fx_transform->environment = p_environment;
	_add_item(item, 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;

	set_process_internal(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("[" + tag);
				pos = brk_end;
				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> texture = ResourceLoader::load(image, "Texture");
			if (texture.is_valid())
				add_image(texture);

			pos = end;
			tag_stack.push_front(tag);
		} else if (tag.begins_with("img=")) {

			int width = 0;
			int height = 0;

			String params = tag.substr(4, tag.length());
			int sep = params.find("x");
			if (sep == -1) {
				width = params.to_int();
			} else {
				width = params.substr(0, sep).to_int();
				height = params.substr(sep + 1, params.length()).to_int();
			}

			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, width, height);

			pos = end;
			tag_stack.push_front("img");
		} 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(0, 1, 1);
			else if (col == "black")
				color = Color(0, 0, 0);
			else if (col == "blue")
				color = Color(0, 0, 1);
			else if (col == "fuchsia")
				color = Color(1, 0, 1);
			else if (col == "gray" || col == "grey")
				color = Color(0.5, 0.5, 0.5);
			else if (col == "green")
				color = Color(0, 0.5, 0);
			else if (col == "lime")
				color = Color(0, 1, 0);
			else if (col == "maroon")
				color = Color(0.5, 0, 0);
			else if (col == "navy")
				color = Color(0, 0, 0.5);
			else if (col == "olive")
				color = Color(0.5, 0.5, 0);
			else if (col == "purple")
				color = Color(0.5, 0, 0.5);
			else if (col == "red")
				color = Color(1, 0, 0);
			else if (col == "silver")
				color = Color(0.75, 0.75, 0.75);
			else if (col == "teal")
				color = Color(0, 0.5, 0.5);
			else if (col == "white")
				color = Color(1, 1, 1);
			else if (col == "yellow")
				color = Color(1, 1, 0);
			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 if (tag.begins_with("fade")) {
			Vector<String> tags = tag.split(" ", false);
			int startIndex = 0;
			int length = 10;

			if (tags.size() > 1) {
				tags.remove(0);
				for (int i = 0; i < tags.size(); i++) {
					String expr = tags[i];
					if (expr.begins_with("start=")) {
						String start_str = expr.substr(6, expr.length());
						startIndex = start_str.to_int();
					} else if (expr.begins_with("length=")) {
						String end_str = expr.substr(7, expr.length());
						length = end_str.to_int();
					}
				}
			}

			push_fade(startIndex, length);
			pos = brk_end + 1;
			tag_stack.push_front("fade");
		} else if (tag.begins_with("shake")) {
			Vector<String> tags = tag.split(" ", false);
			int strength = 5;
			float rate = 20.0f;

			if (tags.size() > 1) {
				tags.remove(0);
				for (int i = 0; i < tags.size(); i++) {
					String expr = tags[i];
					if (expr.begins_with("level=")) {
						String str_str = expr.substr(6, expr.length());
						strength = str_str.to_int();
					} else if (expr.begins_with("rate=")) {
						String rate_str = expr.substr(5, expr.length());
						rate = rate_str.to_float();
					}
				}
			}

			push_shake(strength, rate);
			pos = brk_end + 1;
			tag_stack.push_front("shake");
			set_process_internal(true);
		} else if (tag.begins_with("wave")) {
			Vector<String> tags = tag.split(" ", false);
			float amplitude = 20.0f;
			float period = 5.0f;

			if (tags.size() > 1) {
				tags.remove(0);
				for (int i = 0; i < tags.size(); i++) {
					String expr = tags[i];
					if (expr.begins_with("amp=")) {
						String amp_str = expr.substr(4, expr.length());
						amplitude = amp_str.to_float();
					} else if (expr.begins_with("freq=")) {
						String period_str = expr.substr(5, expr.length());
						period = period_str.to_float();
					}
				}
			}

			push_wave(period, amplitude);
			pos = brk_end + 1;
			tag_stack.push_front("wave");
			set_process_internal(true);
		} else if (tag.begins_with("tornado")) {
			Vector<String> tags = tag.split(" ", false);
			float radius = 10.0f;
			float frequency = 1.0f;

			if (tags.size() > 1) {
				tags.remove(0);
				for (int i = 0; i < tags.size(); i++) {
					String expr = tags[i];
					if (expr.begins_with("radius=")) {
						String amp_str = expr.substr(7, expr.length());
						radius = amp_str.to_float();
					} else if (expr.begins_with("freq=")) {
						String period_str = expr.substr(5, expr.length());
						frequency = period_str.to_float();
					}
				}
			}

			push_tornado(frequency, radius);
			pos = brk_end + 1;
			tag_stack.push_front("tornado");
			set_process_internal(true);
		} else if (tag.begins_with("rainbow")) {
			Vector<String> tags = tag.split(" ", false);
			float saturation = 0.8f;
			float value = 0.8f;
			float frequency = 1.0f;

			if (tags.size() > 1) {
				tags.remove(0);
				for (int i = 0; i < tags.size(); i++) {
					String expr = tags[i];
					if (expr.begins_with("sat=")) {
						String sat_str = expr.substr(4, expr.length());
						saturation = sat_str.to_float();
					} else if (expr.begins_with("val=")) {
						String val_str = expr.substr(4, expr.length());
						value = val_str.to_float();
					} else if (expr.begins_with("freq=")) {
						String freq_str = expr.substr(5, expr.length());
						frequency = freq_str.to_float();
					}
				}
			}

			push_rainbow(saturation, value, frequency);
			pos = brk_end + 1;
			tag_stack.push_front("rainbow");
			set_process_internal(true);
		} else {
			Vector<String> expr = tag.split(" ", false);
			if (expr.size() < 1) {
				add_text("[");
				pos = brk_pos + 1;
			} else {
				String identifier = expr[0];
				expr.remove(0);
				Dictionary properties = parse_expressions_for_values(expr);
				Ref<RichTextEffect> effect = _get_custom_effect_by_code(identifier);

				if (!effect.is_null()) {
					push_customfx(effect, properties);
					pos = brk_end + 1;
					tag_stack.push_front(identifier);
					set_process_internal(true);
				} 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) {
		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;
}

void RichTextLabel::set_effects(const Vector<Variant> &effects) {
	custom_effects.clear();
	for (int i = 0; i < effects.size(); i++) {
		Ref<RichTextEffect> effect = Ref<RichTextEffect>(effects[i]);
		custom_effects.push_back(effect);
	}

	parse_bbcode(bbcode);
}

Vector<Variant> RichTextLabel::get_effects() {
	Vector<Variant> r;
	for (int i = 0; i < custom_effects.size(); i++) {
		r.push_back(custom_effects[i].get_ref_ptr());
	}
	return r;
}

void RichTextLabel::install_effect(const Variant effect) {
	Ref<RichTextEffect> rteffect;
	rteffect = effect;

	if (rteffect.is_valid()) {
		custom_effects.push_back(effect);
		parse_bbcode(bbcode);
	}
}

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", "width", "height"), &RichTextLabel::add_image, DEFVAL(0), DEFVAL(0));
	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_normal"), &RichTextLabel::push_normal);
	ClassDB::bind_method(D_METHOD("push_bold"), &RichTextLabel::push_bold);
	ClassDB::bind_method(D_METHOD("push_bold_italics"), &RichTextLabel::push_bold_italics);
	ClassDB::bind_method(D_METHOD("push_italics"), &RichTextLabel::push_italics);
	ClassDB::bind_method(D_METHOD("push_mono"), &RichTextLabel::push_mono);
	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);

	ClassDB::bind_method(D_METHOD("parse_expressions_for_values", "expressions"), &RichTextLabel::parse_expressions_for_values);

	ClassDB::bind_method(D_METHOD("set_effects", "effects"), &RichTextLabel::set_effects);
	ClassDB::bind_method(D_METHOD("get_effects"), &RichTextLabel::get_effects);
	ClassDB::bind_method(D_METHOD("install_effect", "effect"), &RichTextLabel::install_effect);

	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_PROPERTY(PropertyInfo(Variant::ARRAY, "custom_effects", PROPERTY_HINT_RESOURCE_TYPE, "17/17:RichTextEffect", (PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_SCRIPT_VARIABLE), "RichTextEffect"), "set_effects", "get_effects");

	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_FADE);
	BIND_ENUM_CONSTANT(ITEM_SHAKE);
	BIND_ENUM_CONSTANT(ITEM_WAVE);
	BIND_ENUM_CONSTANT(ITEM_TORNADO);
	BIND_ENUM_CONSTANT(ITEM_RAINBOW);
	BIND_ENUM_CONSTANT(ITEM_CUSTOMFX);
	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();
}

Ref<RichTextEffect> RichTextLabel::_get_custom_effect_by_code(String p_bbcode_identifier) {
	for (int i = 0; i < custom_effects.size(); i++) {
		if (!custom_effects[i].is_valid())
			continue;

		if (custom_effects[i]->get_bbcode() == p_bbcode_identifier) {
			return custom_effects[i];
		}
	}

	return Ref<RichTextEffect>();
}

Dictionary RichTextLabel::parse_expressions_for_values(Vector<String> p_expressions) {
	Dictionary d = Dictionary();
	for (int i = 0; i < p_expressions.size(); i++) {
		String expression = p_expressions[i];

		Array a = Array();
		Vector<String> parts = expression.split("=", true);
		String key = parts[0];
		if (parts.size() != 2) {
			return d;
		}

		Vector<String> values = parts[1].split(",", false);

#ifdef MODULE_REGEX_ENABLED
		RegEx color = RegEx();
		color.compile("^#([A-Fa-f0-9]{6}|[A-Fa-f0-9]{3})$");
		RegEx nodepath = RegEx();
		nodepath.compile("^\\$");
		RegEx boolean = RegEx();
		boolean.compile("^(true|false)$");
		RegEx decimal = RegEx();
		decimal.compile("^-?^.?\\d+(\\.\\d+?)?$");
		RegEx numerical = RegEx();
		numerical.compile("^\\d+$");

		for (int j = 0; j < values.size(); j++) {
			if (!color.search(values[j]).is_null()) {
				a.append(Color::html(values[j]));
			} else if (!nodepath.search(values[j]).is_null()) {
				if (values[j].begins_with("$")) {
					String v = values[j].substr(1, values[j].length());
					a.append(NodePath(v));
				}
			} else if (!boolean.search(values[j]).is_null()) {
				if (values[j] == "true") {
					a.append(true);
				} else if (values[j] == "false") {
					a.append(false);
				}
			} else if (!decimal.search(values[j]).is_null()) {
				a.append(values[j].to_double());
			} else if (!numerical.search(values[j]).is_null()) {
				a.append(values[j].to_int());
			} else {
				a.append(values[j]);
			}
		}
#endif

		if (values.size() > 1) {
			d[key] = a;
		} else if (values.size() == 1) {
			d[key] = a[0];
		}
	}
	return d;
}

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;
	meta_hovering = NULL;
	override_selected_font_color = false;

	scroll_visible = false;
	scroll_follow = false;
	scroll_following = false;
	updating_scroll = false;
	scroll_active = true;
	scroll_w = 0;
	scroll_updated = false;

	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);
}