text: /*************************************************************************/
  /*  rich_text_label.cpp                                                  */
  /*************************************************************************/
  /*                       This file is part of:                           */
  /*                           GODOT ENGINE                                */
  /*                    http://www.godotengine.org                         */
  /*************************************************************************/
  /* Copyright (c) 2007-2016 Juan Linietsky, Ariel Manzur.                 */
  /*                                                                       */
  /* Permission is hereby granted, free of charge, to any person obtaining */
  /* a copy of this software and associated documentation files (the       */
  /* "Software"), to deal in the Software without restriction, including   */
  /* without limitation the rights to use, copy, modify, merge, publish,   */
  /* distribute, sublicense, and/or sell copies of the Software, and to    */
  /* permit persons to whom the Software is furnished to do so, subject to */
  /* the following conditions:                                             */
  /*                                                                       */
  /* The above copyright notice and this permission notice shall be        */
  /* included in all copies or substantial portions of the Software.       */
  /*                                                                       */
  /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
  /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
  /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
  /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
  /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
  /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
  /*************************************************************************/
  #include "rich_text_label.h"
  #include "scene/scene_string_names.h"
  #include "os/keyboard.h"
  #include "os/os.h"
  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;
  
  }
  
  
  void 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 Point2i& p_click_pos,Item **r_click_item,int *r_click_char,bool *r_outside,int p_char_count) {
  
  	RID ci;
  	if (r_outside)
  		*r_outside=false;
  	if (p_mode==PROCESS_DRAW) {
  		ci=get_canvas_item();
  
  		if (r_click_item)
  			*r_click_item=NULL;
  
  	}
  	Line &l = p_frame->lines[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;
  
  
  	if (p_mode!=PROCESS_CACHE) {
  
  		ERR_FAIL_INDEX(line,l.offset_caches.size());
  		line_ofs = l.offset_caches[line];
  	}
  
  	if (p_mode==PROCESS_CACHE) {
  		l.offset_caches.clear();
  		l.height_caches.clear();
  		l.char_count=0;
  		l.minimum_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 succesive newlines are displayed
  	int line_height=cfont->get_height();
  
  	Variant meta;
  
  #define NEW_LINE \
  {\
  	if (p_mode!=PROCESS_CACHE) {\
  		line++;\
  		if (line < l.offset_caches.size())\
  			line_ofs=l.offset_caches[line];\
  		wofs=margin;\
  		if (align!=ALIGN_FILL)\
  			wofs+=line_ofs;\
  	} else {\
  		int used=wofs-margin;\
  		switch(align) {\
  			case ALIGN_LEFT: l.offset_caches.push_back(0); break;\
  			case ALIGN_CENTER: l.offset_caches.push_back(((p_width-margin)-used)/2); break;\
  			case ALIGN_RIGHT: l.offset_caches.push_back(((p_width-margin)-used)); break;\
  			case ALIGN_FILL: l.offset_caches.push_back((p_width-margin)-used/*+spaces_size*/); break;\
  		}\
  		l.height_caches.push_back(line_height);\
  		l.space_caches.push_back(spaces);\
  	}\
  	y+=line_height+get_constant(SceneStringNames::get_singleton()->line_separation);\
  	line_height=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;\
  	}\
  	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.minimum_width=MAX(l.minimum_width,wofs+m_width);\
  	}\
  	if (wofs + m_width > p_width) {\
  		if (p_mode==PROCESS_CACHE) {\
  			if (spaces>0)	\
  				spaces-=1;\
  		}\
  		if (p_mode==PROCESS_POINTER && r_click_item && p_click_pos.y>=p_ofs.y+y && p_click_pos.y<=p_ofs.y+y+lh && p_click_pos.x>p_ofs.x+wofs) {\
  			if (r_outside) *r_outside=true;	\
  			*r_click_item=it;\
  			*r_click_char=rchar;\
  			return;\
  		}\
  		NEW_LINE\
  	}
  
  
  #define ADVANCE(m_width) \
  {\
  	if (p_mode==PROCESS_POINTER && r_click_item && p_click_pos.y>=p_ofs.y+y && p_click_pos.y<=p_ofs.y+y+lh && p_click_pos.x>=p_ofs.x+wofs && p_click_pos.x<p_ofs.x+wofs+m_width) {\
  		if (r_outside) *r_outside=false;	\
  		*r_click_item=it;\
  		*r_click_char=rchar;\
  		return;\
  	}\
  	wofs+=m_width;\
  }
  
  #define CHECK_HEIGHT( m_height ) \
  if (m_height > line_height) {\
  	line_height=m_height;\
  }
  
  	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;
  
  	while (it) {
  
  		switch(it->type) {
  
  			case ITEM_TEXT: {
  
  				ItemText *text = static_cast<ItemText*>(it);
  
  				Ref<Font> font=_find_font(it);
  				if (font.is_null())
  					font=p_base_font;
  
  				const CharType *c = text->text.c_str();				
  				const CharType *cf=c;
  				int fh=font->get_height();
  				int ascent = font->get_ascent();
  				Color color;
  				bool underline=false;
  
  				if (p_mode==PROCESS_DRAW) {
  					color=_find_color(text,p_base_color);
  					underline=_find_underline(text);
  					if (_find_meta(text,&meta)) {
  
  						underline=true;
  					}
  
  
  				} else if (p_mode==PROCESS_CACHE) {
  					l.char_count+=text->text.length();
  
  				}
  
  				rchar=0;
  
  				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;
  					}
  					bool found_space=false;
  
  					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;
  						}
  						w+=cw;
  
  						if (c[end]==' ') {
  
  							fw+=cw;
  							/*
  							if (p_mode==PROCESS_CACHE) {
  								fw+=cw;
  							} else if (align==ALIGN_FILL && line<l.space_caches.size() && l.space_caches[line]>0) {
  								//print_line(String(c,end)+": "+itos(l.offset_caches[line])+"/"+itos(l.space_caches[line]));
  								//sub_space=cw;
  								found_space=true;
  							} else {
  								fw+=cw;
  							}*/
  						} else {
  							fw+=cw;
  						}
  
  						end++;						
  					}
  
  					ENSURE_WIDTH(w);
  
  					//print_line("END: "+String::chr(c[end])+".");
  					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++;
  
  						/*
  						if (found_space) {
  							int ln = MIN(l.offset_caches.size()-1,line);
  
  							fw+=l.offset_caches[ln]/l.space_caches[ln];
  						}*/
  
  					}
  
  
  					{
  
  
  						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);
  									//print_line("GOT: "+itos(rchar));
  
  
  									//if (i==end-1 && p_click_pos.x+cw/2 > pofs)
  									//	rchar++;
  									//int o = (wofs+w)-p_click_pos.x;
  
  								//	if (o>cw/2)
  								//		rchar++;
  								}
  
  
  								ofs+=cw;
  							} else if (p_mode==PROCESS_DRAW) {
  
  								bool selected=false;
  								if (selection.active) {
  
  									int cofs = (&c[i])-cf;
  									if ((text->index > selection.from->index || (text->index == selection.from->index && cofs >=selection.from_char)) && (text->index < selection.to->index || (text->index == selection.to->index && cofs <=selection.to_char))) {
  										selected=true;
  									}
  								}
  
  								int cw=0;
  
  								bool visible = visible_characters<0 || p_char_count<visible_characters;
  
  								if (selected) {
  
  									cw = font->get_char_size(c[i],c[i+1]).x;
  									draw_rect(Rect2(p_ofs.x+pofs,p_ofs.y+y,cw,lh),selection_bg);
  									if (visible)
  										font->draw_char(ci,p_ofs+Point2(align_ofs+pofs,y+lh-(fh-ascent)),c[i],c[i+1],selection_fg);
  
  								} else {
  									if (visible)
  										cw=font->draw_char(ci,p_ofs+Point2(align_ofs+pofs,y+lh-(fh-ascent)),c[i],c[i+1],color);
  								}
  
  								p_char_count++;
  								if (c[i]=='\t') {
  									cw=tab_size*font->get_char_size(' ').width;
  								}
  
  
  								//print_line("draw char: "+String::chr(c[i]));
  
  								if (underline) {
  									Color uc=color;
  									uc.a*=0.5;
  									//VS::get_singleton()->canvas_item_add_line(ci,Point2(pofs,y+ascent+2),Point2(pofs+cw,y+ascent+2),uc);
  									int uy = y+lh-fh+ascent+2;
  									VS::get_singleton()->canvas_item_add_line(ci,p_ofs+Point2(align_ofs+pofs,uy),p_ofs+Point2(align_ofs+pofs+cw,uy),uc);
  								}
  								ofs+=cw;
  							}
  
  						}
  					}
  
  
  					ADVANCE(fw);
  					CHECK_HEIGHT(fh); //must be done somewhere
  					c=&c[end];
  				}
  
  
  			} break;
  			case ITEM_IMAGE: {
  
  				lh=0;
  				if (p_mode!=PROCESS_CACHE)
  					lh = line<l.height_caches.size()?l.height_caches[line]:1;
  				else
  					l.char_count+=1; //images count as chars too
  
  				ItemImage *img = static_cast<ItemImage*>(it);
  
  				Ref<Font> font=_find_font(it);
  				if (font.is_null())
  					font=p_base_font;
  
  				if (p_mode==PROCESS_POINTER && r_click_char)
  					*r_click_char=0;
  
  				ENSURE_WIDTH( img->image->get_width() );
  
  				bool visible = visible_characters<0 || p_char_count<visible_characters;
  
  				if (p_mode==PROCESS_DRAW && visible) {
  					img->image->draw(ci,p_ofs+Point2(align_ofs+wofs,y+lh-font->get_descent()-img->image->get_height()));
  				}
  				p_char_count++;
  
  				ADVANCE( img->image->get_width() );
  				CHECK_HEIGHT( (img->image->get_height()+font->get_descent()) );
  
  			} break;
  			case ITEM_NEWLINE: {
  
  
  				lh=0;
  				if (p_mode!=PROCESS_CACHE)
  					lh = line<l.height_caches.size()?l.height_caches[line]:1;
  
  
  #if 0
  				if (p_mode==PROCESS_POINTER && r_click_item ) {
  					//previous last "wrapped" line
  					int pl = line-1;
  					if (pl<0 || lines[pl].height_caches.size()==0)
  						break;
  					int py=lines[pl].offset_caches[ lines[pl].offset_caches.size() -1 ];
  					int ph=lines[pl].height_caches[ lines[pl].height_caches.size() -1 ];
  					print_line("py: "+itos(py));
  					print_line("ph: "+itos(ph));
  
  					rchar=0;
  					if (p_click_pos.y>=py && p_click_pos.y<=py+ph) {
  						if (r_outside) *r_outside=true;
  						*r_click_item=it;
  						*r_click_char=rchar;
  						return;
  					}
  				}
  
  #endif
  			} 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);
  				int max_y=get_size().height;
  
  				if (p_mode==PROCESS_CACHE) {
  
  					int idx=0;
  					//set minimums to zero
  					for(int i=0;i<table->columns.size();i++) {
  						table->columns[i].min_width=0;
  						table->columns[i].width=0;
  					}
  					//compute minimum width for each cell
  					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,p_width,i,PROCESS_CACHE,cfont,Color());
  							table->columns[column].min_width=MAX( table->columns[i].min_width, frame->lines[i].minimum_width );
  						}
  						idx++;
  					}
  
  					//compute available width and total radio (for expanders)
  
  
  					int total_ratio=0;
  					int available_width=p_width - hseparation * (table->columns.size() -1);
  					table->total_width=hseparation;
  
  					for(int i=0;i<table->columns.size();i++) {
  						available_width-=table->columns[i].min_width;
  						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[i].width = table->columns[i].min_width;
  						if (table->columns[i].expand)
  							table->columns[i].width+=table->columns[i].expand_ratio*available_width/total_ratio;
  						table->total_width+=table->columns[i].width+hseparation;
  					}
  
  					//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());
  							frame->lines[i].height_cache=ly; //actual height
  							frame->lines[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;
  
  					for(int i=0;i<frame->lines.size();i++) {
  
  
  						if (visible) {
  							if (p_mode==PROCESS_DRAW) {
  								_process_line(frame,p_ofs+offset+draw_ofs+Vector2(0,yofs),ly,table->columns[column].width,i,PROCESS_DRAW,cfont,ccolor);
  							} 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,p_click_pos,r_click_item,r_click_char,r_outside);
  							}
  						}
  
  						yofs+=frame->lines[i].height_cache;
  						if (p_mode==PROCESS_CACHE) {
  							frame->lines[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 (p_mode == PROCESS_POINTER && r_click_item && itp && !it && p_click_pos.y>p_ofs.y+y+lh) {
  			//at the end of all, return this
  			if (r_outside) *r_outside=true;
  			*r_click_item=itp;
  			*r_click_char=rchar;
  			return;
  		}
  
  		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;
  
  #undef NEW_LINE
  #undef ENSURE_WIDTH
  #undef ADVANCE
  #undef CHECK_HEIGHT
  
  }
  
  void RichTextLabel::_scroll_changed(double) {
  
  	if (updating_scroll)
  		return;
  
  	if (scroll_follow && vscroll->get_val()>=(vscroll->get_max()-vscroll->get_page()))
  		scroll_following=true;
  	else
  		scroll_following=false;
  
  	update();
  
  }
  
  void RichTextLabel::_update_scroll() {
  
  	int total_height=0;
  	if (main->lines.size())
  		total_height=main->lines[main->lines.size()-1].height_accum_cache;
  
  	bool exceeds = total_height > get_size().height && scroll_active;
  
  
  	if (exceeds!=scroll_visible) {
  
  		if (exceeds) {
  			scroll_visible=true;
  			main->first_invalid_line=0;
  			scroll_w=vscroll->get_combined_minimum_size().width;
  			vscroll->show();
  			vscroll->set_anchor_and_margin( MARGIN_LEFT, ANCHOR_END,scroll_w);
  			_validate_line_caches(main);
  
  		} else {
  
  			scroll_visible=false;
  			vscroll->hide();
  			scroll_w=0;
  			_validate_line_caches(main);
  		}
  
  	}
  
  }
  
  void RichTextLabel::_notification(int p_what) {
  
  	switch (p_what) {
  
  		case NOTIFICATION_RESIZED: {
  
  			main->first_invalid_line=0; //invalidate ALL
  			update();
  
  		} break;
  		case NOTIFICATION_ENTER_TREE: {
  
  			if (use_bbcode)
  				parse_bbcode(bbcode);
  			main->first_invalid_line=0; //invalidate ALL
  			update();
  
  		} break;
  		case NOTIFICATION_THEME_CHANGED: {
  
  			if (is_inside_tree() && use_bbcode) {
  				parse_bbcode(bbcode);
  				//first_invalid_line=0; //invalidate ALL
  				//update();
  			}
  
  		} break;
  		case NOTIFICATION_DRAW: {
  
  			_validate_line_caches(main);
  			_update_scroll();
  
  
  			RID ci=get_canvas_item();
  			Size2 size = get_size();
  
  			VisualServer::get_singleton()->canvas_item_set_clip(ci,true);
  
  			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_val();
  
  			//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>=ofs)
  					break;
  				from_line++;
  				total_chars+=main->lines[from_line].char_count;
  			}
  
  			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");
  
  			while (y<size.height && from_line<main->lines.size()) {
  
  				_process_line(main,Point2(),y,size.width-scroll_w,from_line,PROCESS_DRAW,base_font,base_color,Point2i(),NULL,NULL,NULL,total_chars);
  				total_chars+=main->lines[from_line].char_count;
  				from_line++;
  			}
  		}
  	}
  }
  
  
  void RichTextLabel::_find_click(ItemFrame* p_frame,const Point2i& p_click,Item **r_click_item,int *r_click_char,bool *r_outside) {
  
  	if (r_click_item)
  		*r_click_item=NULL;
  
  	Size2 size = get_size();
  
  	int ofs = vscroll->get_val();
  
  	//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<size.height && from_line<p_frame->lines.size()) {
  
  		_process_line(p_frame,Point2(),y,size.width-scroll_w,from_line,PROCESS_POINTER,base_font,base_color,p_click,r_click_item,r_click_char,r_outside);
  		if (r_click_item && *r_click_item)
  			return;
  		from_line++;
  	}
  
  
  }
  
  
  Control::CursorShape RichTextLabel::get_cursor_shape(const Point2& p_pos) const {
  
  	if (!underline_meta || selection.click)
  		return CURSOR_ARROW;
  
  	if (main->first_invalid_line<main->lines.size())
  		return CURSOR_ARROW; //invalid
  
  	int line=0;
  	Item *item=NULL;
  
  	((RichTextLabel*)(this))->_find_click(main,p_pos,&item,&line);
  
  
  	if (item && ((RichTextLabel*)(this))->_find_meta(item,NULL))
  		return CURSOR_POINTING_HAND;
  
  	return CURSOR_ARROW;
  }
  
  
  void RichTextLabel::_input_event(InputEvent p_event) {
  
  	switch(p_event.type) {
  
  		case InputEvent::MOUSE_BUTTON: {
  
  			if (main->first_invalid_line<main->lines.size())
  				return;
  
  			const InputEventMouseButton& b = p_event.mouse_button;
  
  			if (b.button_index==BUTTON_LEFT) {
  
  				if (true) {
  
  
  					if (b.pressed && !b.doubleclick) {
  						int line=0;
  						Item *item=NULL;
  
  						bool outside;
  						_find_click(main,Point2i(b.x,b.y),&item,&line,&outside);
  
  						if (item) {
  
  							Variant meta;
  							if (!outside && _find_meta(item,&meta)) {
  								//meta clicked
  
  								emit_signal("meta_clicked",meta);
  							} else if (selection.enabled) {
  
  								selection.click=item;
  								selection.click_char=line;
  
  							}
  
  						}
  
  					} else if (!b.pressed) {
  
  						selection.click=NULL;
  					}
  				}
  			}
  
  			if (b.button_index==BUTTON_WHEEL_UP) {
  
  				if (scroll_active)
  					vscroll->set_val( vscroll->get_val()-vscroll->get_page()/8 );
  			}
  			if (b.button_index==BUTTON_WHEEL_DOWN) {
  
  				if (scroll_active)
  					vscroll->set_val( vscroll->get_val()+vscroll->get_page()/8 );
  			}
  		} break;
  		case InputEvent::KEY: {
  
  			const InputEventKey &k=p_event.key;
  			if (k.pressed && !k.mod.alt && !k.mod.shift && !k.mod.meta) {
  				bool handled=true;
  				switch(k.scancode) {
  					case KEY_PAGEUP: {
  
  						if (vscroll->is_visible())
  							vscroll->set_val( vscroll->get_val() - vscroll->get_page() );
  					} break;
  					case KEY_PAGEDOWN: {
  
  						if (vscroll->is_visible())
  							vscroll->set_val( vscroll->get_val() + vscroll->get_page() );
  					} break;
  					case KEY_UP: {
  
  						if (vscroll->is_visible())
  							vscroll->set_val( vscroll->get_val() - get_font("normal_font")->get_height() );
  					} break;
  					case KEY_DOWN: {
  
  						if (vscroll->is_visible())
  							vscroll->set_val( vscroll->get_val() + get_font("normal_font")->get_height() );
  					} break;
  					case KEY_HOME: {
  
  						if (vscroll->is_visible())
  							vscroll->set_val( 0 );
  					} break;
  					case KEY_END: {
  
  						if (vscroll->is_visible())
  							vscroll->set_val( vscroll->get_max() );
  					} break;
  					case KEY_INSERT:
  					case KEY_C: {
  
  						if (k.mod.command) {
  							selection_copy();
  						} else {
  							handled=false;
  						}
  
  					} break;
  					default: handled=false;
  				}
  
  
  				if (handled)
  					accept_event();
  			}
  
  		} break;
  		case InputEvent::MOUSE_MOTION: {
  
  			if (main->first_invalid_line<main->lines.size())
  				return;
  
  			const InputEventMouseMotion& m = p_event.mouse_motion;
  
  			if (selection.click) {
  
  				int line=0;
  				Item *item=NULL;
  				_find_click(main,Point2i(m.x,m.y),&item,&line);
  				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();
  
  			}
  
  		} break;
  	}
  
  }
  
  Ref<Font> RichTextLabel::_find_font(Item *p_item) {
  
  	Item *fontitem=p_item;
  
  	while(fontitem) {
  
  		if (fontitem->type==ITEM_FONT) {
  
  			ItemFont *fi = static_cast<ItemFont*>(fontitem);
  			return fi->font;
  		}
  
  		fontitem=fontitem->parent;
  	}
  
  	return Ref<Font>();
  }
  
  int RichTextLabel::_find_margin(Item *p_item,const Ref<Font>& p_base_font) {
  
  	Item *item=p_item;
  
  	int margin=0;
  
  	while(item) {
  
  		if (item->type==ITEM_INDENT) {
  
  			Ref<Font> font=_find_font(item);
  			if (font.is_null())
  				font=p_base_font;
  
  			ItemIndent *indent = static_cast<ItemIndent*>(item);
  
  			margin+=indent->level*tab_size*font->get_char_size(' ').width;
  
  		} else if (item->type==ITEM_LIST) {
  
  			Ref<Font> font=_find_font(item);
  			if (font.is_null())
  				font=p_base_font;
  
  		}
  
  		item=item->parent;
  	}
  
  	return margin;
  }
  
  
  RichTextLabel::Align RichTextLabel::_find_align(Item *p_item) {
  
  	Item *item=p_item;
  
  	while(item) {
  
  		if (item->type==ITEM_ALIGN) {
  
  			ItemAlign *align = static_cast<ItemAlign*>(item);
  			return align->align;
  
  		}
  
  		item=item->parent;
  	}
  
  	return default_align;
  }
  
  Color RichTextLabel::_find_color(Item *p_item,const Color& p_default_color) {
  
  	Item *item=p_item;
  
  	while(item) {
  
  		if (item->type==ITEM_COLOR) {
  
  			ItemColor *color = static_cast<ItemColor*>(item);
  			return color->color;
  
  		}
  
  		item=item->parent;
  	}
  
  	return p_default_color;
  }
  
  bool RichTextLabel::_find_underline(Item *p_item) {
  
  	Item *item=p_item;
  
  	while(item) {
  
  		if (item->type==ITEM_UNDERLINE) {
  
  			return true;
  
  		}
  
  		item=item->parent;
  	}
  
  	return false;
  }
  
  bool RichTextLabel::_find_meta(Item *p_item,Variant *r_meta) {
  
  	Item *item=p_item;
  
  	while(item) {
  
  		if (item->type==ITEM_META) {
  
  			ItemMeta *meta = static_cast<ItemMeta*>(item);
  			if (r_meta)
  				*r_meta=meta->meta;
  			return true;
  
  		}
  
  		item=item->parent;
  	}
  
  	return false;
  
  }
  
  void RichTextLabel::_validate_line_caches(ItemFrame* p_frame) {
  
  	if (p_frame->first_invalid_line==p_frame->lines.size())
  		return;
  
  	//validate invalid lines!s
  	Size2 size = get_size();
  
  	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,Point2(),y,size.width-scroll_w,i,PROCESS_CACHE,base_font,Color());
  		p_frame->lines[i].height_cache=y;
  		p_frame->lines[i].height_accum_cache=y;
  
  		if (i>0)
  			p_frame->lines[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;
  
  	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_val(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);
  			current_frame->lines[current_frame->lines.size()-1].from=item;
  			_invalidate_current_line(current_frame);
  
  		}
  
  		pos=end+1;
  	}
  }
  
  void RichTextLabel::_add_item(Item *p_item, bool p_enter, bool p_ensure_newline) {
  
  
  
  	p_item->parent=current;
  	p_item->E=current->subitems.push_back(p_item);
  	p_item->index=current_idx++;
  
  
  	if (p_enter)
  		current=p_item;
  
  	if (p_ensure_newline && current_frame->lines[current_frame->lines.size()-1].from) {
  		_invalidate_current_line(current_frame);
  		current_frame->lines.resize( current_frame->lines.size() +1 );
  
  	}
  
  	if (current_frame->lines[current_frame->lines.size()-1].from==NULL) {
  		current_frame->lines[current_frame->lines.size()-1].from=p_item;
  	}
  	p_item->line=current_frame->lines.size()-1;
  
  	_invalidate_current_line(current_frame);
  
  }
  
  void RichTextLabel::add_image(const Ref<Texture>& p_image) {
  
  	if (current->type==ITEM_TABLE)
  		return;
  
  	ERR_FAIL_COND(p_image.is_null());
  	ItemImage *item = memnew( ItemImage );
  
  	item->image=p_image;
  	_add_item(item,false);
  
  }
  
  void RichTextLabel::add_newline() {
  
  	if (current->type==ITEM_TABLE)
  		return;
  	ItemNewline *item = memnew( ItemNewline );
  	item->line=current_frame->lines.size();
  	current_frame->lines.resize(current_frame->lines.size()+1);
  	_add_item(item,false);
  
  }
  
  void RichTextLabel::push_font(const Ref<Font>& p_font) {
  
  	ERR_FAIL_COND(current->type==ITEM_TABLE);
  	ERR_FAIL_COND(p_font.is_null());
  	ItemFont *item = memnew( ItemFont );
  
  	item->font=p_font;
  	_add_item(item,true);
  
  }
  void RichTextLabel::push_color(const Color& p_color) {
  
  	ERR_FAIL_COND(current->type==ITEM_TABLE);
  	ItemColor *item = memnew( ItemColor );
  
  	item->color=p_color;
  	_add_item(item,true);
  
  }
  void RichTextLabel::push_underline() {
  
  	ERR_FAIL_COND(current->type==ITEM_TABLE);
  	ItemUnderline *item = memnew( ItemUnderline );
  
  	_add_item(item,true);
  
  }
  
  void RichTextLabel::push_align(Align p_align) {
  
  	ERR_FAIL_COND(current->type==ITEM_TABLE);
  
  	ItemAlign *item = memnew( ItemAlign );
  	item->align=p_align;
  	_add_item(item,true,true);
  
  }
  
  void RichTextLabel::push_indent(int p_level) {
  
  	ERR_FAIL_COND(current->type==ITEM_TABLE);
  	ERR_FAIL_COND(p_level<0);
  
  	ItemIndent *item = memnew( ItemIndent );
  	item->level=p_level;
  	_add_item(item,true,true);
  
  }
  
  void RichTextLabel::push_list(ListType p_list) {
  
  	ERR_FAIL_COND(current->type==ITEM_TABLE);
  	ERR_FAIL_INDEX(p_list,3);
  
  	ItemList *item = memnew( ItemList );
  
  	item->list_type=p_list;
  	_add_item(item,true,true);
  
  }
  
  void RichTextLabel::push_meta(const Variant& p_meta) {
  
  	ERR_FAIL_COND(current->type==ITEM_TABLE);
  	ItemMeta *item = memnew( ItemMeta );
  
  	item->meta=p_meta;
  	_add_item(item,true);
  
  }
  
  void RichTextLabel::push_table(int p_columns) {
  
  	ERR_FAIL_COND( p_columns < 1);
  	ItemTable *item = memnew( ItemTable );
  
  	item->columns.resize(p_columns);
  	item->total_width=0;
  	for(int i=0;i<item->columns.size();i++) {
  		item->columns[i].expand=false;
  		item->columns[i].expand_ratio=1;
  	}
  	_add_item(item,true,true);
  
  }
  
  void RichTextLabel::set_table_column_expand(int p_column,bool p_expand,int p_ratio) {
  
  	ERR_FAIL_COND(current->type!=ITEM_TABLE);
  	ItemTable *table = static_cast<ItemTable*>(current);
  	ERR_FAIL_INDEX(p_column,table->columns.size());
  	table->columns[p_column].expand=p_expand;
  	table->columns[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[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_offset(int p_pixel) {
  
  	vscroll->set_val(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() || vscroll->get_val()>=(vscroll->get_max()-vscroll->get_page()))
  		scroll_following=true;
  }
  
  bool RichTextLabel::is_scroll_following() const {
  
  	return scroll_follow;
  }
  
  Error RichTextLabel::parse_bbcode(const String& p_bbcode) {
  
  
  	clear();
  	return append_bbcode(p_bbcode);
  }
  
  Error RichTextLabel::append_bbcode(const String& p_bbcode) {
  
  	int pos = 0;
  
  	List<String> tag_stack;
  	Ref<Font> normal_font=get_font("normal_font");
  	Ref<Font> bold_font=get_font("bold_font");
  	Ref<Font> italics_font=get_font("italics_font");
  	Ref<Font> bold_italics_font=get_font("bold_italics_font");
  	Ref<Font> mono_font=get_font("mono_font");
  
  	Color base_color=get_color("default_color");
  
  	int indent_level=0;
  
  	bool in_bold=false;
  	bool in_italics=false;
  
  	while(pos < p_bbcode.length()) {
  
  
  		int brk_pos = p_bbcode.find("[",pos);
  
  		if (brk_pos<0)
  			brk_pos=p_bbcode.length();
  
  		if (brk_pos > pos) {
  			add_text(p_bbcode.substr(pos,brk_pos-pos));
  		}
  
  		if (brk_pos==p_bbcode.length())
  			break; //nothing else o add
  
  		int brk_end = p_bbcode.find("]",brk_pos+1);
  
  		if (brk_end==-1) {
  			//no close, add the rest
  			add_text(p_bbcode.substr(brk_pos,p_bbcode.length()-brk_pos));
  			break;
  		}
  
  
  		String tag = p_bbcode.substr(brk_pos+1,brk_end-brk_pos-1);
  
  
  		if (tag.begins_with("/") && tag_stack.size()) {
  
  			bool tag_ok = tag_stack.size() && tag_stack.front()->get()==tag.substr(1,tag.length());
  
  
  
  			if (tag_stack.front()->get()=="b")
  				in_bold=false;
  			if (tag_stack.front()->get()=="i")
  				in_italics=false;
  			if (tag_stack.front()->get()=="indent")
  				indent_level--;
  
  
  			if (!tag_ok) {
  
  				add_text("[");
  				pos++;
  				continue;
  			}
  
  			tag_stack.pop_front();
  			pos=brk_end+1;
  			if (tag!="/img")
  				pop();
  
  		} else if (tag=="b") {
  
  			//use bold font
  			in_bold=true;
  			if (in_italics)
  				push_font(bold_italics_font);
  			else
  				push_font(bold_font);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="i") {
  
  			//use italics font
  			in_italics=true;
  			if (in_bold)
  				push_font(bold_italics_font);
  			else
  				push_font(italics_font);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="code") {
  
  			//use monospace font
  			push_font(mono_font);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag.begins_with("table=")) {
  
  			int columns = tag.substr(6,tag.length()).to_int();
  			if (columns<1)
  				columns=1;
  			//use monospace font
  			push_table(columns);
  			pos=brk_end+1;
  			tag_stack.push_front("table");
  		} else if (tag=="cell") {
  
  			push_cell();
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag.begins_with("cell=")) {
  
  			int ratio = tag.substr(6,tag.length()).to_int();
  			if (ratio<1)
  				ratio=1;
  			//use monospace font
  			set_table_column_expand(get_current_table_column(),true,ratio);
  			push_cell();
  			pos=brk_end+1;
  			tag_stack.push_front("cell");
  		} else if (tag=="u") {
  
  			//use underline
  			push_underline();
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="s") {
  
  			//use strikethrough (not supported underline instead)
  			push_underline();
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="center") {
  
  			//use underline
  			push_align(ALIGN_CENTER);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="fill") {
  
  			//use underline
  			push_align(ALIGN_FILL);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="right") {
  
  			//use underline
  			push_align(ALIGN_RIGHT);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="ul") {
  
  			//use underline
  			push_list(LIST_DOTS);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="ol") {
  
  			//use underline
  			push_list(LIST_NUMBERS);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  		} else if (tag=="indent") {
  
  			//use underline
  			indent_level++;
  			push_indent(indent_level);
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  
  		} else if (tag=="url") {
  
  			//use strikethrough (not supported underline instead)
  			int end=p_bbcode.find("[",brk_end);
  			if (end==-1)
  				end=p_bbcode.length();
  			String url = p_bbcode.substr(brk_end+1,end-brk_end-1);
  			push_meta(url);
  
  			pos=brk_end+1;
  			tag_stack.push_front(tag);
  
  		} else if (tag.begins_with("url=")) {
  
  			String url = tag.substr(4,tag.length());
  			push_meta(url);
  			pos=brk_end+1;
  			tag_stack.push_front("url");
  		} else if (tag=="img") {
  
  			//use strikethrough (not supported underline instead)
  			int end=p_bbcode.find("[",brk_end);
  			if (end==-1)
  				end=p_bbcode.length();
  			String image = p_bbcode.substr(brk_end+1,end-brk_end-1);
  
  			Ref<Texture> texture = ResourceLoader::load(image,"Texture");
  			if (texture.is_valid())
  				add_image(texture);
  
  			pos=end;
  			tag_stack.push_front(tag);
  		} else if (tag.begins_with("color=")) {
  
  			String col = tag.substr(6,tag.length());
  			Color color;
  
  			if (col.begins_with("#"))
  				color=Color::html(col);
  			else if (col=="aqua")
  				color=Color::html("#00FFFF");
  			else if (col=="black")
  				color=Color::html("#000000");
  			else if (col=="blue")
  				color=Color::html("#0000FF");
  			else if (col=="fuchsia")
  				color=Color::html("#FF00FF");
  			else if (col=="gray" || col=="grey")
  				color=Color::html("#808080");
  			else if (col=="green")
  				color=Color::html("#008000");
  			else if (col=="lime")
  				color=Color::html("#00FF00");
  			else if (col=="maroon")
  				color=Color::html("#800000");
  			else if (col=="navy")
  				color=Color::html("#000080");
  			else if (col=="olive")
  				color=Color::html("#808000");
  			else if (col=="purple")
  				color=Color::html("#800080");
  			else if (col=="red")
  				color=Color::html("#FF0000");
  			else if (col=="silver")
  				color=Color::html("#C0C0C0");
  			else if (col=="teal")
  				color=Color::html("#008008");
  			else if (col=="white")
  				color=Color::html("#FFFFFF");
  			else if (col=="yellow")
  				color=Color::html("#FFFF00");
  			else
  				color=base_color;
  
  
  
  			push_color(color);
  			pos=brk_end+1;
  			tag_stack.push_front("color");
  
  		} else if (tag.begins_with("font=")) {
  
  			String fnt = tag.substr(5,tag.length());
  
  
  			Ref<Font> font = ResourceLoader::load(fnt,"Font");
  			if (font.is_valid())
  				push_font(font);
  			else
  				push_font(normal_font);
  
  			pos=brk_end+1;
  			tag_stack.push_front("font");
  
  
  		} else {
  
  			add_text("["); //ignore
  			pos=brk_pos+1;
  
  		}
  	}
  
  	return OK;
  }
  
  
  void RichTextLabel::scroll_to_line(int p_line) {
  
  	ERR_FAIL_INDEX(p_line,main->lines.size());
  	_validate_line_caches(main);
  	vscroll->set_val(main->lines[p_line].height_accum_cache-main->lines[p_line].height_cache);
  
  }
  
  int RichTextLabel::get_line_count() const {
  
  	return current_frame->lines.size();
  }
  
  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) {
  
  	ERR_FAIL_COND_V(!selection.enabled,false);
  	Item *it=main;
  	int charidx=0;
  
  	if (p_from_selection && selection.active && selection.enabled) {
  		it=selection.to;
  		charidx=selection.to_char+1;
  	}
  
  	int line=-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_val(offset-fh);
  
  				return true;
  			}
  		}
  
  		it=_get_next_item(it,true);
  		charidx=0;
  
  	}
  
  	return false;
  
  }
  
  void RichTextLabel::selection_copy() {
  
  	if (!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);
  		//print_line("COPY: "+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);
  }
  
  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;
  	if (is_inside_tree() && use_bbcode)
  		parse_bbcode(bbcode);
  }
  
  bool RichTextLabel::is_using_bbcode() const {
  
  	return use_bbcode;
  }
  void RichTextLabel::_bind_methods() {
  
  
  	ObjectTypeDB::bind_method(_MD("_input_event"),&RichTextLabel::_input_event);
  	ObjectTypeDB::bind_method(_MD("_scroll_changed"),&RichTextLabel::_scroll_changed);
  	ObjectTypeDB::bind_method(_MD("add_text","text"),&RichTextLabel::add_text);
  	ObjectTypeDB::bind_method(_MD("add_image","image:Texture"),&RichTextLabel::add_image);
  	ObjectTypeDB::bind_method(_MD("newline"),&RichTextLabel::add_newline);
  	ObjectTypeDB::bind_method(_MD("push_font","font"),&RichTextLabel::push_font);
  	ObjectTypeDB::bind_method(_MD("push_color","color"),&RichTextLabel::push_color);
  	ObjectTypeDB::bind_method(_MD("push_align","align"),&RichTextLabel::push_align);
  	ObjectTypeDB::bind_method(_MD("push_indent","level"),&RichTextLabel::push_indent);
  	ObjectTypeDB::bind_method(_MD("push_list","type"),&RichTextLabel::push_list);
  	ObjectTypeDB::bind_method(_MD("push_meta","data"),&RichTextLabel::push_meta);
  	ObjectTypeDB::bind_method(_MD("push_underline"),&RichTextLabel::push_underline);
  	ObjectTypeDB::bind_method(_MD("push_table","columns"),&RichTextLabel::push_table);
  	ObjectTypeDB::bind_method(_MD("set_table_column_expand","column","expand","ratio"),&RichTextLabel::set_table_column_expand);
  	ObjectTypeDB::bind_method(_MD("push_cell"),&RichTextLabel::push_cell);
  	ObjectTypeDB::bind_method(_MD("pop"),&RichTextLabel::pop);
  
  	ObjectTypeDB::bind_method(_MD("clear"),&RichTextLabel::clear);
  
  	ObjectTypeDB::bind_method(_MD("set_meta_underline","enable"),&RichTextLabel::set_meta_underline);
  	ObjectTypeDB::bind_method(_MD("is_meta_underlined"),&RichTextLabel::is_meta_underlined);
  
  	ObjectTypeDB::bind_method(_MD("set_scroll_active","active"),&RichTextLabel::set_scroll_active);
  	ObjectTypeDB::bind_method(_MD("is_scroll_active"),&RichTextLabel::is_scroll_active);
  
  	ObjectTypeDB::bind_method(_MD("set_scroll_follow","follow"),&RichTextLabel::set_scroll_follow);
  	ObjectTypeDB::bind_method(_MD("is_scroll_following"),&RichTextLabel::is_scroll_following);
  
  	ObjectTypeDB::bind_method(_MD("get_v_scroll"),&RichTextLabel::get_v_scroll);
  
  	ObjectTypeDB::bind_method(_MD("scroll_to_line","line"),&RichTextLabel::scroll_to_line);
  
  	ObjectTypeDB::bind_method(_MD("set_tab_size","spaces"),&RichTextLabel::set_tab_size);
  	ObjectTypeDB::bind_method(_MD("get_tab_size"),&RichTextLabel::get_tab_size);
  
  	ObjectTypeDB::bind_method(_MD("set_selection_enabled","enabled"),&RichTextLabel::set_selection_enabled);
  	ObjectTypeDB::bind_method(_MD("is_selection_enabled"),&RichTextLabel::is_selection_enabled);
  
  	ObjectTypeDB::bind_method(_MD("parse_bbcode", "bbcode"),&RichTextLabel::parse_bbcode);
  	ObjectTypeDB::bind_method(_MD("append_bbcode", "bbcode"),&RichTextLabel::append_bbcode);
  
  	ObjectTypeDB::bind_method(_MD("set_bbcode","text"),&RichTextLabel::set_bbcode);
  	ObjectTypeDB::bind_method(_MD("get_bbcode"),&RichTextLabel::get_bbcode);
  
  	ObjectTypeDB::bind_method(_MD("set_visible_characters","amount"),&RichTextLabel::set_visible_characters);
  	ObjectTypeDB::bind_method(_MD("get_visible_characters"),&RichTextLabel::get_visible_characters);
  
  	ObjectTypeDB::bind_method(_MD("get_total_character_count"),&RichTextLabel::get_total_character_count);
  
  	ObjectTypeDB::bind_method(_MD("set_use_bbcode","enable"),&RichTextLabel::set_use_bbcode);
  	ObjectTypeDB::bind_method(_MD("is_using_bbcode"),&RichTextLabel::is_using_bbcode);
  
  	ADD_PROPERTY(PropertyInfo(Variant::BOOL,"bbcode/enabled"),_SCS("set_use_bbcode"),_SCS("is_using_bbcode"));
  	ADD_PROPERTY(PropertyInfo(Variant::STRING,"bbcode/bbcode",PROPERTY_HINT_MULTILINE_TEXT),_SCS("set_bbcode"),_SCS("get_bbcode"));
  	ADD_PROPERTY(PropertyInfo(Variant::INT,"visible_characters",PROPERTY_HINT_RANGE,"-1,128000,1"),_SCS("set_visible_characters"),_SCS("get_visible_characters"));
  
  	ADD_SIGNAL( MethodInfo("meta_clicked",PropertyInfo(Variant::NIL,"meta")));
  
  	BIND_CONSTANT( ALIGN_LEFT );
  	BIND_CONSTANT( ALIGN_CENTER );
  	BIND_CONSTANT( ALIGN_RIGHT );
  	BIND_CONSTANT( ALIGN_FILL );
  
  	BIND_CONSTANT( LIST_NUMBERS );
  	BIND_CONSTANT( LIST_LETTERS );
  	BIND_CONSTANT( LIST_DOTS );
  
  	BIND_CONSTANT( ITEM_FRAME );
  	BIND_CONSTANT( ITEM_TEXT );
  	BIND_CONSTANT( ITEM_IMAGE );
  	BIND_CONSTANT( ITEM_NEWLINE );
  	BIND_CONSTANT( ITEM_FONT );
  	BIND_CONSTANT( ITEM_COLOR );
  	BIND_CONSTANT( ITEM_UNDERLINE );
  	BIND_CONSTANT( ITEM_ALIGN );
  	BIND_CONSTANT( ITEM_INDENT );
  	BIND_CONSTANT( ITEM_LIST );
  	BIND_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;
  }
  
  
  RichTextLabel::RichTextLabel() {
  
  
  	main = memnew( ItemFrame );
  	main->index=0;
  	current=main;
  	main->lines.resize(1);
  	main->lines[0].from=main;
  	main->first_invalid_line=0;
  	current_frame=main;
  	tab_size=4;
  	default_align=ALIGN_LEFT;
  	underline_meta=true;
  
  	scroll_visible=false;
  	scroll_follow=false;
  	scroll_following=false;
  	updating_scroll=false;
  	scroll_active=true;
  	scroll_w=0;
  
  	vscroll = memnew( VScrollBar );	
  	add_child(vscroll);
  	vscroll->set_drag_slave(String(".."));
  	vscroll->set_step(1);
  	vscroll->set_anchor_and_margin( MARGIN_TOP, ANCHOR_BEGIN, 0);
  	vscroll->set_anchor_and_margin( MARGIN_BOTTOM, ANCHOR_END, 0);
  	vscroll->set_anchor_and_margin( MARGIN_RIGHT, ANCHOR_END, 0);
  	vscroll->connect("value_changed",this,"_scroll_changed");
  	vscroll->set_step(1);
  	vscroll->hide();
  	current_idx=1;
  	use_bbcode=false;
  
  	selection.click=NULL;
  	selection.active=false;
  	selection.enabled=false;
  
  	visible_characters=-1;
  
  }
  
  RichTextLabel::~RichTextLabel() {
  
  	memdelete( main );
  }
  