diff --git a/code/nel/include/nel/gui/css_parser.h b/code/nel/include/nel/gui/css_parser.h
index cb4cea62e..cfaf03caa 100644
--- a/code/nel/include/nel/gui/css_parser.h
+++ b/code/nel/include/nel/gui/css_parser.h
@@ -19,6 +19,7 @@
 
 #include "nel/misc/types_nl.h"
 #include "nel/gui/css_style.h"
+#include "nel/gui/css_selector.h"
 
 namespace NLGUI
 {
@@ -31,8 +32,118 @@ namespace NLGUI
 	public:
 		// parse style declaration, eg "color: red; font-size: 10px;"
 		static TStyle parseDecls(const std::string &styleString);
-	};
 
+		// parse css stylesheet
+		void parseStylesheet(const std::string &cssString, std::vector<CCssStyle::SStyleRule> &rules);
+
+	private:
+		// stylesheet currently parsed
+		ucstring _Style;
+		// keep track of current position in _Style
+		size_t _Position;
+
+		std::vector<CCssStyle::SStyleRule> _Rules;
+
+	private:
+		// @media ( .. ) { .. }
+		void readAtRule();
+
+		// a#id.class[attr=val] { .. }
+		void readRule();
+
+		// move past whitespace
+		void skipWhitespace();
+
+		// skip valid IDENT
+		bool skipIdentifier();
+
+		// skip over {}, (), or [] block
+		void skipBlock();
+
+		// skip over string quoted with ' or "
+		void skipString();
+
+		// backslash escape
+		void escape();
+
+		// normalize newline chars and remove comments
+		void preprocess();
+
+		// parse selectors + combinators
+		std::vector<CCssSelector> parse_selector(const ucstring &sel, std::string &pseudoElement) const;
+
+		// parse selector and style
+		void parseRule(const ucstring &selectorString, const ucstring &styleString);
+
+		inline bool is_eof() const
+		{
+			return _Position >= _Style.size();
+		}
+
+		inline bool is_whitespace(ucchar ch) const
+		{
+			return (ch == (ucchar)' ' || ch == (ucchar)'\t' || ch == (ucchar)'\n');
+		}
+
+		inline bool is_hex(ucchar ch) const
+		{
+			return ((ch >= (ucchar)'0' && ch <= (ucchar)'9') ||
+					(ch >= (ucchar)'a' && ch <= (ucchar)'f') ||
+					(ch >= (ucchar)'A' && ch <= (ucchar)'F'));
+		}
+
+		inline bool maybe_escape() const
+		{
+			// escaping newline (\n) only allowed inside strings
+			return (_Style.size() - _Position) >= 1 && _Style[_Position] == (ucchar)'\\' && _Style[_Position+1] != '\n';
+		}
+
+		inline bool is_quote(ucchar ch) const
+		{
+			return	ch== (ucchar)'"' || ch == (ucchar)'\'';
+		}
+
+		inline bool is_block_open(ucchar ch) const
+		{
+			return	ch == (ucchar)'{' || ch == (ucchar)'[' || ch == (ucchar)'(';
+		}
+
+		inline bool is_block_close(ucchar ch, ucchar open) const
+		{
+			return ((open == '{' && ch == (ucchar)'}') ||
+					(open == '[' && ch == (ucchar)']') ||
+					(open == '(' && ch == (ucchar)')'));
+		}
+
+		inline bool is_comment_open() const
+		{
+			if (_Position+1 > _Style.size())
+				return false;
+
+			return _Style[_Position] == (ucchar)'/' && _Style[_Position+1] == (ucchar)'*';
+		}
+
+		inline bool is_nonascii(ucchar ch) const
+		{
+			return ch >= 0x80 /*&&  ch <= 255*/;
+		}
+
+		inline bool is_alpha(ucchar ch) const
+		{
+			return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
+		}
+
+		inline bool is_digit(ucchar ch) const
+		{
+			return ch >= '0' && ch <= '9';
+		}
+
+		inline bool is_nmchar(ucchar ch) const
+		{
+			// checking escape here does not check if next char is '\n' or not
+			return ch == '_' || ch == '-' || is_alpha(ch) || is_digit(ch) || is_nonascii(ch) || ch == '\\'/*is_escape(ch)*/;
+		}
+	};
 }//namespace
 
 #endif // CL_CSS_PARSER_H
diff --git a/code/nel/include/nel/gui/css_selector.h b/code/nel/include/nel/gui/css_selector.h
new file mode 100644
index 000000000..84b039089
--- /dev/null
+++ b/code/nel/include/nel/gui/css_selector.h
@@ -0,0 +1,107 @@
+// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
+// Copyright (C) 2010  Winch Gate Property Limited
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef CL_CSS_SELECTOR_H
+#define CL_CSS_SELECTOR_H
+
+#include "nel/misc/types_nl.h"
+
+namespace NLGUI
+{
+	class CHtmlElement;
+
+	/**
+	 * \brief CSS selector
+	 * \date 2019-03-15 10:50 GMT
+	 * \author Meelis Mägi (Nimetu)
+	 */
+	class CCssSelector
+	{
+	public:
+		enum ECombinator {
+			NONE = 0,
+			GENERAL_CHILD,
+			ADJACENT_SIBLING,
+			GENERAL_SIBLING,
+			CHILD_OF
+		};
+
+		struct SAttribute {
+			std::string key;
+			std::string value;
+			char op; // =, ~, |, ^, $, *
+			SAttribute(const std::string &k, const std::string &v, char o)
+				:key(k),value(v),op(o)
+			{}
+		};
+
+		std::string Element;
+		std::string Id;
+		std::vector<std::string> Class;
+		std::vector<SAttribute> Attr;
+		std::vector<std::string> PseudoClass;
+
+		// css combinator or \0 missing (first element)
+		char Combinator;
+
+	public:
+		// TODO: rewrite for ECombinator enum
+		CCssSelector(std::string elm="", std::string id="", std::string cls="", char comb = '\0');
+
+		// helper for sorting
+		uint32 specificity() const;
+
+		// set classes used, eg 'class1 class2'
+		void setClass(const std::string &cls);
+
+		// add attribute to selector
+		// ' ' op means 'key exists, ignore value'
+		void addAttribute(const std::string &key, const std::string &val = "", char op = ' ');
+
+		// add pseudo class to selector, eg 'first-child'
+		void addPseudoClass(const std::string &key);
+
+		// true if no rules have been defined
+		bool empty() const
+		{
+			return Element.empty() && Id.empty() && Class.empty() && Attr.empty() && PseudoClass.empty();
+		}
+
+		// Test current selector to html DOM element
+		// NOTE: Does not check combinator
+		bool match(const CHtmlElement &elm) const;
+
+	private:
+		bool matchClass(const CHtmlElement &elm) const;
+		bool matchAttributes(const CHtmlElement &elm) const;
+		bool matchPseudoClass(const CHtmlElement &elm) const;
+
+		// match An+B rule to child index (1 based)
+		bool matchNth(sint childNr, sint a, sint b) const;
+		
+		// parse nth-child string to 'a' and 'b' components
+		// :nth-child(odd)
+		// :nth-child(even)
+		// :nth-child(An+B)
+		// :nth-child(-An+b)
+		void parseNth(const std::string &pseudo, sint &a, sint &b) const;
+
+	};
+
+}//namespace
+
+#endif // CL_CSS_SELECTOR_H
+
diff --git a/code/nel/include/nel/gui/css_style.h b/code/nel/include/nel/gui/css_style.h
index 2a854a6d9..dea4a1f43 100644
--- a/code/nel/include/nel/gui/css_style.h
+++ b/code/nel/include/nel/gui/css_style.h
@@ -19,9 +19,12 @@
 
 #include "nel/misc/types_nl.h"
 #include "nel/misc/rgba.h"
+#include "nel/gui/css_selector.h"
 
 namespace NLGUI
 {
+	class CHtmlElement;
+
 	typedef std::map<std::string, std::string> TStyle;
 
 	/**
@@ -44,7 +47,7 @@ namespace NLGUI
 			sint32 X;
 			sint32 Y;
 			NLMISC::CRGBA Color;
-		};
+		};		
 	public:
 		CStyleParams () : FontFamily(""), TextColor(255,255,255,255), TextShadow()
 		{
@@ -62,6 +65,19 @@ namespace NLGUI
 			BackgroundColor=NLMISC::CRGBA::Black;
 			BackgroundColorOver=NLMISC::CRGBA::Black;
 		}
+
+		bool hasStyle(const std::string &key) const
+		{
+			return StyleRules.find(key) != StyleRules.end();
+		}
+
+		std::string getStyle(const std::string &key) const
+		{
+			TStyle::const_iterator it = StyleRules.find(key);
+			return (it != StyleRules.end() ? it->second : "");
+		}
+
+	public:
 		uint FontSize;
 		uint FontWeight;
 		bool FontOblique;
@@ -78,11 +94,26 @@ namespace NLGUI
 		sint32 BorderWidth;
 		NLMISC::CRGBA BackgroundColor;
 		NLMISC::CRGBA BackgroundColorOver;
+
+		std::string WhiteSpace;
+		std::string TextAlign;
+		std::string VerticalAlign;
+
+		TStyle StyleRules;
 	};
 
 	class CCssStyle {
 	public:
+		struct SStyleRule {
+			std::vector<CCssSelector> Selector;
+			TStyle Properties;
 
+			// pseudo element like ':before'
+			std::string PseudoElement;
+			
+			// returns selector specificity
+			uint specificity() const;
+		};
 
 		// 'browser' style, overwriten with '<html>'
 		CStyleParams Root;
@@ -90,18 +121,37 @@ namespace NLGUI
 		// current element style
 		CStyleParams Current;
 
+		// known style rules sorted by specificity
+		std::vector<SStyleRule> _StyleRules;
+
 	private:
 		std::vector<CStyleParams> _StyleStack;
 
-		// test if str is one of "thin/medium/thick" and return its pixel value 
+		// test if str is one of "thin/medium/thick" and return its pixel value
 		bool scanCssLength(const std::string& str, uint32 &px) const;
 
 		// read style attribute
 		void getStyleParams(const std::string &styleString, CStyleParams &style, const CStyleParams &current) const;
+		void getStyleParams(const TStyle &styleRules, CStyleParams &style, const CStyleParams &current) const;
+
+		// merge src into dest by overwriting key in dest
+		void merge(TStyle &dst, const TStyle &src) const;
+
+		// match selector to dom path
+		bool match(const std::vector<CCssSelector> &selector, const CHtmlElement &elm) const;
+
+		// parse 'background' into 'background-color', 'background-image', etc
+		void parseBackgroundShorthand(const std::string &value, CStyleParams &style) const;
 
 	public:
 		void reset();
 
+		// parse <style>..</style> tag or css file content
+		void parseStylesheet(const std::string &styleString);
+
+		// set element style from matching css rules
+		void getStyleFor(CHtmlElement &elm) const;
+
 		inline uint getFontSizeSmaller() const
 		{
 			if (Current.FontSize < 5)
@@ -109,15 +159,29 @@ namespace NLGUI
 			return Current.FontSize-2;
 		}
 
+		sint styleStackIndex = 0;
+
 		inline void pushStyle()
 		{
+			styleStackIndex++;
 			_StyleStack.push_back(Current);
+
+			Current.Width=-1;
+			Current.Height=-1;
+			Current.MaxWidth=-1;
+			Current.MaxHeight=-1;
+			Current.BorderWidth=1;
+			
+			Current.StyleRules.clear();
 		}
 
 		inline void popStyle()
 		{
+			styleStackIndex--;
 			if (_StyleStack.empty())
+			{
 				Current = Root;
+			}
 			else
 			{
 				Current = _StyleStack.back();
@@ -125,16 +189,32 @@ namespace NLGUI
 			}
 		}
 
-		// apply style string to this.Root
+		// apply style to this.Root
 		void applyRootStyle(const std::string &styleString);
+		void applyRootStyle(const TStyle &styleRules);
 
-		// apply style string to this.Current
+		// apply style to this.Current
 		void applyStyle(const std::string &styleString);
+		void applyStyle(const TStyle &styleRules);
 
 		void applyCssMinMax(sint32 &width, sint32 &height, sint32 minw=0, sint32 minh=0, sint32 maxw=0, sint32 maxh=0) const;
 
-	};
+		// check if current style property matches value
+		bool checkStyle(const std::string &key, const std::string &val) const
+		{
+			return Current.hasStyle(key) && Current.getStyle(key) == val;
+		}
 
+		bool hasStyle(const std::string &key) const
+		{
+			return Current.hasStyle(key);
+		}
+
+		std::string getStyle(const std::string &key) const
+		{
+			return Current.getStyle(key);
+		}
+	};
 }//namespace
 
 #endif // CL_CSS_STYLE_H
diff --git a/code/nel/include/nel/gui/group_html.h b/code/nel/include/nel/gui/group_html.h
index d8935f431..6a8760533 100644
--- a/code/nel/include/nel/gui/group_html.h
+++ b/code/nel/include/nel/gui/group_html.h
@@ -24,6 +24,7 @@
 #include "nel/gui/ctrl_button.h"
 #include "nel/gui/group_table.h"
 #include "nel/gui/libwww_types.h"
+#include "nel/gui/html_element.h"
 #include "nel/gui/css_style.h"
 
 // forward declaration
@@ -76,7 +77,7 @@ namespace NLGUI
 		static SWebOptions options;
 
 		// ImageDownload system
-		enum TDataType {ImgType= 0, BnpType};
+		enum TDataType {ImgType= 0, BnpType, StylesheetType};
 		enum TImageType {NormalImage=0, OverImage};
 		
 		// Constructor
@@ -97,6 +98,9 @@ namespace NLGUI
 		// Browse
 		virtual void browse (const char *url);
 
+		// load css from local file and insert into active stylesheet collection
+		void parseStylesheetFile(const std::string &fname);
+
 		// parse html string using libxml2 parser
 		bool parseHtml(const std::string &htmlString);
 
@@ -273,16 +277,10 @@ namespace NLGUI
 		virtual void addText (const char * buf, int len);
 
 		// A new begin HTML element has been parsed (<IMG> for exemple)
-		virtual void beginElement (uint element_number, const std::vector<bool> &present, const std::vector<const char *> &value);
+		virtual void beginElement(CHtmlElement &elm);
 
 		// A new end HTML element has been parsed (</IMG> for exemple)
-		virtual void endElement (uint element_number);
-
-		// A new begin unparsed element has been found
-		virtual void beginUnparsedElement(const char *buffer, int length);
-
-		// A new end unparsed element has been found
-		virtual void endUnparsedElement(const char *buffer, int length);
+		virtual void endElement(CHtmlElement &elm);
 
 		// Add GET params to the url
 		virtual void addHTTPGetParams (std::string &url, bool trustedDomain);
@@ -296,6 +294,9 @@ namespace NLGUI
 		// Get Home URL
 		virtual std::string	home();
 
+		// parse dom node and all child nodes recursively
+		void renderDOM(CHtmlElement &elm);
+
 		// Clear style stack and restore default style
 		void resetCssStyle();
 
@@ -326,7 +327,7 @@ namespace NLGUI
 		void addString(const ucstring &str);
 
 		// Add an image in the current paragraph
-		void addImage(const std::string &id, const char *image, bool reloadImg=false, const CStyleParams &style = CStyleParams());
+		void addImage(const std::string &id, const std::string &img, bool reloadImg=false, const CStyleParams &style = CStyleParams());
 
 		// Add a text area in the current paragraph
 		CInterfaceGroup *addTextArea (const std::string &templateName, const char *name, uint rows, uint cols, bool multiLine, const ucstring &content, uint maxlength);
@@ -365,6 +366,14 @@ namespace NLGUI
 		// Current URL
 		std::string		_DocumentUrl;
 		std::string		_DocumentDomain;
+        std::string		_DocumentHtml; // not updated, only set by first render
+		// If true, then render _DocumentHtml on next update (replaces content)
+		bool			_RenderNextTime;
+		// true if renderer is waiting for css files to finish downloading (link rel=stylesheet)
+		bool			_WaitingForStylesheet;
+		// list of css file urls that are queued up for download
+		std::vector<std::string> _StylesheetQueue;
+
 		// Valid base href was found
 		bool            _IgnoreBaseUrlTag;
 		// Fragment from loading url
@@ -484,6 +493,11 @@ namespace NLGUI
 
 		// Keep track of current element style
 		CCssStyle _Style;
+		CHtmlElement _HtmlDOM;
+		CHtmlElement *_CurrentHTMLElement;
+		// Backup of CurrentHTMLElement->nextSibling before ::beginElement() is called
+		// for luaParseHtml() to insert nodes into right place in right order
+		CHtmlElement *_CurrentHTMLNextSibling;
 
 		// Current link
 		std::vector<std::string>	_Link;
@@ -722,6 +736,12 @@ namespace NLGUI
 
 	private:
 		friend class CHtmlParser;
+		// TODO: beginElement is overwritten in client quick help class, merge it here?
+		void beginElementDeprecated(uint element_number, const std::vector<bool> &present, const std::vector<const char *> &value);
+		void endElementDeprecated(uint element_number);
+
+		// move src->Children into CurrentHtmlElement.parent.children element
+		void spliceFragment(std::list<CHtmlElement>::iterator src);
 
 		// decode all HTML entities
 		static ucstring decodeHTMLEntities(const ucstring &str);
@@ -764,6 +784,8 @@ namespace NLGUI
 		int RunningCurls;
 
 		bool startCurlDownload(CDataDownload &download);
+		void finishCurlDownload(CDataDownload &download);
+		void pumpCurlDownloads();
 
 		void initImageDownload();
 		void checkImageDownload();
@@ -782,11 +804,94 @@ namespace NLGUI
 		bool addBnpDownload(std::string url, const std::string &action, const std::string &script, const std::string &md5sum);
 		std::string localBnpName(const std::string &url);
 
+		// add css file from <link href=".." rel="stylesheet"> to download queue
+		void addStylesheetDownload(std::vector<std::string> links);
+
 		void releaseDownloads();
 		void checkDownloads();
 
 		// HtmlType download finished
 		void htmlDownloadFinished(const std::string &content, const std::string &type, long code);
+
+		// stylesheet finished downloading. if local file does not exist, then it failed (404)
+		void cssDownloadFinished(const std::string &url, const std::string &local);
+
+		// read common table/tr/td parameters and push them to _CellParams
+		void getCellsParameters(const CHtmlElement &elm, bool inherit);
+
+		// render _HtmlDOM
+		void renderDocument();
+
+		// :before, :after rendering
+		void renderPseudoElement(const std::string &pseudo, const CHtmlElement &elm);
+
+		// HTML elements
+		void htmlA(const CHtmlElement &elm);
+		void htmlAend(const CHtmlElement &elm);
+		void htmlBASE(const CHtmlElement &elm);
+		void htmlBODY(const CHtmlElement &elm);
+		void htmlBR(const CHtmlElement &elm);
+		void htmlDD(const CHtmlElement &elm);
+		void htmlDDend(const CHtmlElement &elm);
+		//void htmlDEL(const CHtmlElement &elm);
+		void htmlDIV(const CHtmlElement &elm);
+		void htmlDIVend(const CHtmlElement &elm);
+		void htmlDL(const CHtmlElement &elm);
+		void htmlDLend(const CHtmlElement &elm);
+		void htmlDT(const CHtmlElement &elm);
+		void htmlDTend(const CHtmlElement &elm);
+		//void htmlEM(const CHtmlElement &elm);
+		void htmlFONT(const CHtmlElement &elm);
+		void htmlFORM(const CHtmlElement &elm);
+		void htmlH(const CHtmlElement &elm);
+		void htmlHend(const CHtmlElement &elm);
+		void htmlHEAD(const CHtmlElement &elm);
+		void htmlHEADend(const CHtmlElement &elm);
+		void htmlHR(const CHtmlElement &elm);
+		void htmlHTML(const CHtmlElement &elm);
+		void htmlI(const CHtmlElement &elm);
+		void htmlIend(const CHtmlElement &elm);
+		void htmlIMG(const CHtmlElement &elm);
+		void htmlINPUT(const CHtmlElement &elm);
+		void htmlLI(const CHtmlElement &elm);
+		void htmlLIend(const CHtmlElement &elm);
+		void htmlLUA(const CHtmlElement &elm);
+		void htmlLUAend(const CHtmlElement &elm);
+		void htmlMETA(const CHtmlElement &elm);
+		void htmlOBJECT(const CHtmlElement &elm);
+		void htmlOBJECTend(const CHtmlElement &elm);
+		void htmlOL(const CHtmlElement &elm);
+		void htmlOLend(const CHtmlElement &elm);
+		void htmlOPTION(const CHtmlElement &elm);
+		void htmlOPTIONend(const CHtmlElement &elm);
+		void htmlP(const CHtmlElement &elm);
+		void htmlPend(const CHtmlElement &elm);
+		void htmlPRE(const CHtmlElement &elm);
+		void htmlPREend(const CHtmlElement &elm);
+		void htmlSCRIPT(const CHtmlElement &elm);
+		void htmlSCRIPTend(const CHtmlElement &elm);
+		void htmlSELECT(const CHtmlElement &elm);
+		void htmlSELECTend(const CHtmlElement &elm);
+		//void htmlSMALL(const CHtmlElement &elm);
+		//void htmlSPAN(const CHtmlElement &elm);
+		//void htmlSTRONG(const CHtmlElement &elm);
+		void htmlSTYLE(const CHtmlElement &elm);
+		void htmlSTYLEend(const CHtmlElement &elm);
+		void htmlTABLE(const CHtmlElement &elm);
+		void htmlTABLEend(const CHtmlElement &elm);
+		void htmlTD(const CHtmlElement &elm);
+		void htmlTDend(const CHtmlElement &elm);
+		void htmlTEXTAREA(const CHtmlElement &elm);
+		void htmlTEXTAREAend(const CHtmlElement &elm);
+		void htmlTH(const CHtmlElement &elm);
+		void htmlTHend(const CHtmlElement &elm);
+		void htmlTITLE(const CHtmlElement &elm);
+		void htmlTITLEend(const CHtmlElement &elm);
+		void htmlTR(const CHtmlElement &elm);
+		void htmlTRend(const CHtmlElement &elm);
+		//void htmlU(const CHtmlElement &elm);
+		void htmlUL(const CHtmlElement &elm);
+		void htmlULend(const CHtmlElement &elm);
 	};
 
 	// adapter group that store y offset for inputs inside an html form
diff --git a/code/nel/include/nel/gui/html_element.h b/code/nel/include/nel/gui/html_element.h
new file mode 100644
index 000000000..bac681c1c
--- /dev/null
+++ b/code/nel/include/nel/gui/html_element.h
@@ -0,0 +1,86 @@
+// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
+// Copyright (C) 2010  Winch Gate Property Limited
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#ifndef CL_HTML_ELEMENT_H
+#define CL_HTML_ELEMENT_H
+
+#include "nel/misc/types_nl.h"
+#include "nel/gui/css_style.h"
+
+namespace NLGUI
+{
+	/**
+	 * \brief HTML element
+	 * \date 2019-04-25 18:23 GMT
+	 * \author Meelis Mägi (Nimetu)
+	 */
+	class CHtmlElement
+	{
+	public:
+		enum ENodeType {
+			NONE = 0,
+			ELEMENT_NODE = 1,
+			TEXT_NODE = 3,
+		};
+
+		uint ID; // libwww element enum
+		ENodeType Type;
+		std::string Value; // text node value or element node name
+		std::map<std::string, std::string> Attributes;
+		std::list<CHtmlElement> Children;
+
+		// class names for css matching
+		std::set<std::string> ClassNames;
+
+		// defined style and :before/:after pseudo elements
+		TStyle Style;
+		TStyle StyleBefore;
+		TStyle StyleAfter;
+
+		// hierarchy
+		CHtmlElement *parent;
+		CHtmlElement *previousSibling;
+		CHtmlElement *nextSibling;
+
+		// n'th ELEMENT_NODE in parent.Children, for :nth-child() rules
+		uint childIndex;
+
+		CHtmlElement(ENodeType type = NONE, std::string value = "");
+
+		// returns true if rhs is same pointer
+		friend bool operator==(const CHtmlElement &lhs, const CHtmlElement &rhs)
+		{
+			return &lhs == &rhs;
+		}
+
+		bool hasAttribute(const std::string &key) const;
+
+		bool hasNonEmptyAttribute(const std::string &key) const;
+
+		std::string getAttribute(const std::string &key) const;
+
+		bool hasClass(const std::string &key) const;
+
+		// update Children index/parent/next/prevSibling pointers
+		void reindexChilds();
+
+		// debug
+		std::string toString(bool tree = false, uint depth = 0) const;
+	};
+}
+
+#endif
+
diff --git a/code/nel/include/nel/gui/html_parser.h b/code/nel/include/nel/gui/html_parser.h
index 132c4ac88..760640234 100644
--- a/code/nel/include/nel/gui/html_parser.h
+++ b/code/nel/include/nel/gui/html_parser.h
@@ -21,7 +21,7 @@
 
 namespace NLGUI
 {
-	class CGroupHTML;
+	class CHtmlElement;
 
 	/**
 	 * \brief HTML parsing
@@ -31,21 +31,21 @@ namespace NLGUI
 	class CHtmlParser
 	{
 	public:
-		CHtmlParser(CGroupHTML *group) : _GroupHtml(group)
-		{}
+		bool parseHtml(std::string htmlString) const;
 
-		bool parseHtml(std::string htmlString);
+		// parse html string into DOM, extract <style> tags into styleString, <link stylesheet> urls into links
+		void getDOM(std::string htmlString, CHtmlElement &parent, std::string &styleString, std::vector<std::string> &links) const;
 
 	private:
-		// libxml2 html parser functions
-		void htmlElement(xmlNode *node, int element_number);
-		void parseNode(xmlNode *a_node);
+		// iterate over libxml html tree, build DOM, and join all <style> tags together
+		void parseNode(xmlNode *a_node, CHtmlElement &parent, std::string &styleString, std::vector<std::string> &links) const;
 
-	private:
+		// read <style> tag and add its content to styleString
+		void parseStyle(xmlNode *a_node, std::string &styleString) const;
 
-		CGroupHTML *_GroupHtml;
+		// update parent/sibling in elm.Children
+		void reindexChilds(CHtmlElement &elm) const;
 	};
-
 }
 
 #endif
diff --git a/code/nel/include/nel/gui/libwww.h b/code/nel/include/nel/gui/libwww.h
index d7fe1251c..74227305c 100644
--- a/code/nel/include/nel/gui/libwww.h
+++ b/code/nel/include/nel/gui/libwww.h
@@ -297,6 +297,9 @@ namespace NLGUI
 	// Parse a HTML color
 	NLMISC::CRGBA getColor (const char *color);
 
+	// return css color in rgba() format
+	std::string getRGBAString(const NLMISC::CRGBA &color);
+
 	// ***************************************************************************
 
 	const std::string &setCurrentDomain(const std::string &uri);
diff --git a/code/nel/include/nel/misc/common.h b/code/nel/include/nel/misc/common.h
index d5d59b130..a89ff226b 100644
--- a/code/nel/include/nel/misc/common.h
+++ b/code/nel/include/nel/misc/common.h
@@ -276,6 +276,17 @@ template <class T> T trimRightWhiteSpaces (const T &str)
 	return str.substr (0, end);
 }
 
+// if both first and last char are quotes (' or "), then remove them
+template <class T> T trimQuotes (const T&str)
+{
+	typename T::size_type size = str.size();
+	if (size == 0)
+		return str;
+	if (str[0] != str[size-1] && (str[0] != '"' || str[0] != '\''))
+		return str;
+	return str.substr(1, size - 1);
+}
+
 //////////////////////////////////////////////////////////////////////////
 // ****  DEPRECATED *****: PLEASE DON'T USE THESE METHODS BUT FUNCTIONS ABOVE toLower() and toUpper()
 //////////////////////////////////////////////////////////////////////////
diff --git a/code/nel/src/gui/css_parser.cpp b/code/nel/src/gui/css_parser.cpp
index c45121824..0a4288d12 100644
--- a/code/nel/src/gui/css_parser.cpp
+++ b/code/nel/src/gui/css_parser.cpp
@@ -20,6 +20,7 @@
 #include "nel/misc/types_nl.h"
 #include "nel/gui/css_parser.h"
 #include "nel/gui/css_style.h"
+#include "nel/gui/css_selector.h"
 
 using namespace NLMISC;
 
@@ -54,5 +55,662 @@ namespace NLGUI
 
 		return styles;
 	}
+
+	// ***************************************************************************
+	// Parse stylesheet, eg content from main.css file
+	//
+	// Return all found rules
+	void CCssParser::parseStylesheet(const std::string &cssString, std::vector<CCssStyle::SStyleRule> &result)
+	{
+		_Rules.clear();
+		_Style.clear();
+
+		_Style.fromUtf8(cssString);
+		preprocess();
+
+		_Position = 0;
+		while(!is_eof())
+		{
+			skipWhitespace();
+
+			if (_Style[_Position] == (ucchar)'@')
+				readAtRule();
+			else
+				readRule();
+		}
+
+		result.insert(result.end(), _Rules.begin(), _Rules.end());
+		_Rules.clear();
+	}
+
+	// ***************************************************************************
+	// Parse selector with style string
+	// selector: "a#id .class"
+	// style:    "color: red; font-size: 10px;"
+	//
+	// @internal
+	void CCssParser::parseRule(const ucstring &selectorString, const ucstring &styleString)
+	{
+		std::vector<ucstring> selectors;
+		NLMISC::explode(selectorString, ucstring(","), selectors);
+
+		TStyle props;
+		props = parseDecls(styleString.toUtf8());
+
+		// duplicate props to each selector in selector list,
+		// example 'div > p, h1' creates 'div>p' and 'h1'
+		for(uint i=0; i<selectors.size(); ++i)
+		{
+			CCssStyle::SStyleRule rule;
+
+			rule.Selector = parse_selector(trim(selectors[i]), rule.PseudoElement);
+			rule.Properties = props;
+
+			if (!rule.Selector.empty())
+			{
+				_Rules.push_back(rule);
+			}
+		}
+	}
+
+	// ***************************************************************************
+	// Skip over at-rule
+	// @import ... ;
+	// @charset ... ;
+	// @media query { .. }
+	//
+	// @internal
+	void CCssParser::readAtRule()
+	{
+		// skip '@'
+		_Position++;
+
+		// skip 'import', 'media', etc
+		skipIdentifier();
+
+		// skip at-rule statement
+		while(!is_eof() && _Style[_Position] != (ucchar)';')
+		{
+			if (maybe_escape())
+			{
+				escape();
+			}
+			else if (is_quote(_Style[_Position]))
+			{
+				skipString();
+			}
+			else if (is_block_open(_Style[_Position]))
+			{
+				bool mustBreak = (_Style[_Position] == '{');
+				skipBlock();
+
+				if(mustBreak)
+				{
+					break;
+				}
+			}
+			else
+			{
+				_Position++;
+			}
+		}
+
+		// skip ';' or '}'
+		_Position++;
+	}
+
+	// ***************************************************************************
+	// skip over "elm#id.selector[attr]:peseudo, .sel2 { rule }" block
+	// @internal
+	void CCssParser::readRule()
+	{
+		size_t start;
+
+		// selector
+		start = _Position;
+		while(!is_eof())
+		{
+			if (maybe_escape())
+				_Position++;
+			else if (is_quote(_Style[_Position]))
+				skipString();
+			else if (_Style[_Position] == (ucchar)'[')
+				skipBlock();
+			else if (_Style[_Position] == (ucchar)'{')
+				break;
+			else
+				_Position++;
+		}
+
+		if (!is_eof())
+		{
+			ucstring selector;
+			selector.append(_Style, start, _Position - start);
+
+			skipWhitespace();
+
+			// declaration block
+			start = _Position;
+			skipBlock();
+			if (_Position <= _Style.size())
+			{
+				ucstring rules;
+				rules.append(_Style, start + 1, _Position - start - 2);
+
+				parseRule(selector, rules);
+			}
+		}
+	}
+
+	// ***************************************************************************
+	// skip over \abcdef escaped sequence or escaped newline char
+	// @internal
+	void CCssParser::escape()
+	{
+		// skip '\'
+		_Position++;
+		if (is_hex(_Style[_Position]))
+		{
+			// TODO: '\abc def' should be considered one string
+			for(uint i=0; i<6 && is_hex(_Style[_Position]); i++)
+				_Position++;
+
+			if (_Style[_Position] == (ucchar)' ')
+				_Position++;
+		}
+		else if (_Style[_Position] != 0x0A)
+			_Position++;
+	}
+
+	// ***************************************************************************
+	// @internal
+	bool CCssParser::skipIdentifier()
+	{
+		size_t start = _Position;
+		bool valid = true;
+		while(!is_eof() && valid)
+		{
+			if (maybe_escape())
+			{
+				escape();
+				continue;
+			}
+			else if (is_alpha(_Style[_Position]))
+			{
+				// valid
+			}
+			else if (is_digit(_Style[_Position]))
+			{
+				if (_Position == start)
+				{
+					// cannot start with digit
+					valid = false;
+				}
+				else if ((_Position - start) == 0 && _Style[_Position-1] == (ucchar)'-')
+				{
+					// cannot start with -#
+					valid = false;
+				}
+			}
+			else if (_Style[_Position] == (ucchar)'_')
+			{
+				// valid
+			}
+			else if (_Style[_Position] >= 0x0080)
+			{
+				// valid
+			}
+			else if (_Style[_Position] == (ucchar)'-')
+			{
+				if ((_Position - start) == 1 && _Style[_Position-1] == (ucchar)'-')
+				{
+					// cannot start with --
+					valid = false;
+				}
+			}
+			else
+			{
+				// we're done
+				break;
+			}
+
+			_Position++;
+		}
+
+		return valid && !is_eof();
+	}
+
+	// ***************************************************************************
+	// skip over (..), [..], or {..} blocks
+	// @internal
+	void CCssParser::skipBlock()
+	{
+		ucchar startChar = _Style[_Position];
+
+		// block start
+		_Position++;
+		while(!is_eof() && !is_block_close(_Style[_Position], startChar))
+		{
+			if (maybe_escape())
+				// skip backslash and next char
+				_Position += 2;
+			else if (is_quote(_Style[_Position]))
+				skipString();
+			else if (is_block_open(_Style[_Position]))
+				skipBlock();
+			else
+				_Position++;
+		}
+
+		// block end
+		_Position++;
+	}
+
+	// ***************************************************************************
+	// skip over quoted string
+	// @internal
+	void CCssParser::skipString()
+	{
+		ucchar endChar = _Style[_Position];
+
+		// quote start
+		_Position++;
+		while(!is_eof() && _Style[_Position] != endChar)
+		{
+			if (maybe_escape())
+				_Position++;
+
+			_Position++;
+		}
+
+		// quote end
+		_Position++;
+	}
+
+	// ***************************************************************************
+	// @internal
+	void CCssParser::skipWhitespace()
+	{
+		while(!is_eof() && is_whitespace(_Style[_Position]))
+			_Position++;
+	}
+
+	// ***************************************************************************
+	// parse selector list
+	// @internal
+	std::vector<CCssSelector> CCssParser::parse_selector(const ucstring &sel, std::string &pseudoElement) const
+	{
+		std::vector<CCssSelector> result;
+		CCssSelector current;
+
+		pseudoElement.clear();
+
+		bool failed = false;
+		ucstring::size_type start = 0, pos = 0;
+		while(pos < sel.size())
+		{
+			ucstring uc;
+			uc = sel[pos];
+			if (is_nmchar(sel[pos]) && current.empty())
+			{
+				pos++;
+
+				while(pos < sel.size() && is_nmchar(sel[pos]))
+					pos++;
+
+				current.Element = toLower(sel.substr(start, pos - start).toUtf8());
+				start = pos;
+				continue;
+			}
+
+			if(sel[pos] == '#')
+			{
+				pos++;
+				start=pos;
+
+				while(pos < sel.size() && is_nmchar(sel[pos]))
+					pos++;
+
+				current.Id = toLower(sel.substr(start, pos - start).toUtf8());
+				start = pos;
+			}
+			else if (sel[pos] == '.')
+			{
+				pos++;
+				start=pos;
+
+				// .classA.classB
+				while(pos < sel.size() && (is_nmchar(sel[pos]) || sel[pos] == '.'))
+					pos++;
+
+				current.setClass(toLower(sel.substr(start, pos - start).toUtf8()));
+				start = pos;
+			}
+			else if (sel[pos] == '[')
+			{
+				pos++;
+				start = pos;
+
+				if (is_whitespace(sel[pos]))
+				{
+					while(pos < sel.size() && is_whitespace(sel[pos]))
+						pos++;
+
+					start = pos;
+				}
+
+				ucstring key;
+				ucstring value;
+				ucchar op = ' ';
+
+				// key
+				while(pos < sel.size() && is_nmchar(sel[pos]))
+					pos++;
+
+				key = sel.substr(start, pos - start);
+				if (pos == sel.size()) break;
+
+				if (is_whitespace(sel[pos]))
+				{
+					while(pos < sel.size() && is_whitespace(sel[pos]))
+						pos++;
+
+					if (pos == sel.size()) break;
+				}
+
+				if (sel[pos] == ']')
+				{
+					current.addAttribute(key.toUtf8());
+				}
+				else
+				{
+					// operand
+					op = sel[pos];
+					if (op == '~' || op == '|' || op == '^' || op == '$' || op == '*')
+					{
+						pos++;
+						if (pos == sel.size()) break;
+					}
+
+					// invalid rule?, eg [attr^value]
+					if (sel[pos] != '=')
+					{
+						while(pos < sel.size() && sel[pos] != ']')
+							pos++;
+
+						if (pos == sel.size()) break;
+
+						start = pos;
+					}
+					else
+					{
+						// skip '='
+						pos++;
+
+						if (is_whitespace(sel[pos]))
+						{
+							while(pos < sel.size() && is_whitespace(sel[pos]))
+								pos++;
+
+							if (pos == sel.size()) break;
+						}
+
+						// value
+						start = pos;
+						bool quote = false;
+						char quoteOpen;
+						while(pos < sel.size())
+						{
+							if (sel[pos] == '\'' || sel[pos] == '"')
+							{
+								// value is quoted
+								start = pos;
+								pos++;
+								while(pos < sel.size() && sel[pos] != sel[start])
+								{
+									if (sel[pos] == '\\')
+									{
+										pos++;
+									}
+									pos++;
+								}
+
+								if (pos == sel.size()) break;
+
+								value = sel.substr(start + 1, pos - start - 1);
+								break;
+							}
+							else if (sel[pos] == '\\')
+							{
+								pos++;
+							}
+							else if (!quote && sel[pos] == ']')
+							{
+								// unquoted value
+								value = sel.substr(start, pos - start);
+								break;
+							}
+
+							pos++;
+						} // while 'value'
+
+						// TODO: scan for sel[pos] == ']'
+						if (pos == sel.size()) break;
+						// whitespace between quote and ], ie '[ attr $= "val" ]'
+						if (sel[pos] != ']')
+						{
+							while(pos < sel.size() && sel[pos] != ']')
+								pos++;
+						}
+						if (pos == sel.size()) break;
+
+						current.addAttribute(key.toUtf8(), value.toUtf8(), (char)op);
+					} // op error
+				} // no value
+
+				// skip ']'
+				pos++;
+
+				start = pos;
+			}
+			else if (sel[pos] == ':')
+			{
+				pos++;
+				start=pos;
+				// pseudo element, eg '::before'
+				if (pos < sel.size() && sel[pos] == ':')
+				{
+					pos++;
+				}
+				// :first-child
+				// :nth-child(2n+0)
+				// :not(h1, div#main)
+				// :not(:nth-child(2n+0))
+				// has no support for quotes, eg  :not(h1[attr=")"]) fails
+				while(pos < sel.size() && (is_nmchar(sel[pos]) || sel[pos] == '('))
+				{
+					if (sel[pos] == '(')
+					{
+						uint open = 1;
+						pos++;
+						while(pos < sel.size() && open > 0)
+						{
+							if (sel[pos] == ')')
+								open--;
+							else if (sel[pos] == '(')
+								open++;
+
+							pos++;
+						}
+						break;
+					}
+					else
+					{
+						pos++;
+					}
+				}
+
+				std::string key = toLower(sel.substr(start, pos - start).toUtf8());
+				if (key.empty())
+				{
+					failed = true;
+					break;
+				}
+
+				if (key[0] == ':' || key == "after" || key == "before" || key == "cue" || key == "first-letter" || key == "first-line")
+				{
+					if (!pseudoElement.empty())
+					{
+						failed = true;
+						break;
+					}
+					if (key[0] != ':')
+					{
+						pseudoElement = ":" + key;
+					}
+					else
+					{
+						pseudoElement = key;
+					}
+				}
+				else
+				{
+					current.addPseudoClass(key);
+				}
+
+				start = pos;
+			}
+			else if (!current.empty())
+			{
+				// pseudo element like ':before' can only be set on the last selector
+				// user action pseudo classes can be used after pseudo element (ie, :focus, :hover)
+				// there is no support for those and its safe to just fail the selector
+				if (!result.empty() && !pseudoElement.empty())
+				{
+					failed = true;
+					break;
+				}
+
+				// start new selector as combinator is part of next selector
+				result.push_back(current);
+				current = CCssSelector();
+
+				// detect and remove whitespace around combinator, eg ' > '
+				bool isSpace = is_whitespace(sel[pos]);;
+				while(pos < sel.size() && is_whitespace(sel[pos]))
+					pos++;
+
+				if (sel[pos] == '>' || sel[pos] == '+' || sel[pos] == '~')
+				{
+					current.Combinator = sel[pos];
+					pos++;
+
+					while(pos < sel.size() && is_whitespace(sel[pos]))
+						pos++;
+				}
+				else if (isSpace)
+				{
+					current.Combinator = ' ';
+				}
+				else
+				{
+					// unknown
+					current.Combinator = sel[pos];
+					pos++;
+				}
+
+				start = pos;
+			}
+			else
+			{
+				pos++;
+			}
+		}
+
+		if (failed)
+		{
+			result.clear();
+		}
+		else if (result.empty() || !current.empty())
+		{
+			// pseudo element like ':before' can only be set on the last selector
+			if (!result.empty() && !pseudoElement.empty())
+			{
+				// failed
+				result.clear();
+			}
+			else
+			{
+				result.push_back(current);
+			}
+		}
+
+		return result;
+	}
+
+	// ***************************************************************************
+	// @internal
+	void CCssParser::preprocess()
+	{
+		_Position = 0;
+
+		size_t start;
+		size_t charsLeft;
+		bool quote = false;
+		ucchar quoteChar;
+		while(!is_eof())
+		{
+			charsLeft = _Style.size() - _Position - 1;
+
+			// FF, CR
+			if (_Style[_Position] == 0x0C || _Style[_Position] == 0x0D)
+			{
+				uint len = 1;
+				// CR, LF
+				if (charsLeft >= 1 && _Style[_Position] == 0x0D && _Style[_Position+1] == 0x0A)
+					len++;
+
+				ucstring tmp;
+				tmp += 0x000A;
+				_Style.replace(_Position, 1, tmp);
+			}
+			else if (_Style[_Position] == 0x00)
+			{
+				// Unicode replacement character
+				_Style[_Position] = 0xFFFD;
+			}
+			else
+			{
+				// strip comments for easier parsing
+				if (_Style[_Position] == '\\')
+				{
+					_Position++;
+				}
+				else if (is_quote(_Style[_Position]))
+				{
+					if (!quote)
+						quoteChar = _Style[_Position];
+
+					if (quote && _Style[_Position] == quoteChar)
+						quote = !quote;
+				}
+				else if (!quote && is_comment_open())
+				{
+					size_t pos = _Style.find(ucstring("*/"), _Position + 2);
+					if (pos == std::string::npos)
+						pos = _Style.size();
+
+					_Style.erase(_Position, pos - _Position + 2);
+					ucstring uc;
+					uc = _Style[_Position];
+
+					// _Position is already at correct place
+					continue;
+				}
+			}
+
+			_Position++;
+		}
+	}
 } // namespace
 
diff --git a/code/nel/src/gui/css_selector.cpp b/code/nel/src/gui/css_selector.cpp
new file mode 100644
index 000000000..0384f561a
--- /dev/null
+++ b/code/nel/src/gui/css_selector.cpp
@@ -0,0 +1,314 @@
+// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
+// Copyright (C) 2010  Winch Gate Property Limited
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+#include "stdpch.h"
+
+#include <string>
+#include "nel/misc/types_nl.h"
+#include "nel/gui/css_selector.h"
+#include "nel/gui/html_element.h"
+
+using namespace NLMISC;
+
+#ifdef DEBUG_NEW
+#define new DEBUG_NEW
+#endif
+
+namespace NLGUI
+{
+	CCssSelector::CCssSelector(std::string elm, std::string id, std::string cls, char comb)
+		: Element(elm), Id(id), Class(), Attr(), PseudoClass(), Combinator(comb)
+	{
+		if (!cls.empty())
+		{
+			setClass(cls);
+		}
+	}
+
+	uint32 CCssSelector::specificity() const
+	{
+		uint ret = 0;
+
+		if (!Element.empty() && Element != "*") ret += 0x000001;
+		// Pseudo Element is added in CCssStyle
+		//if (!PseudoElement.empty())             ret += 0x000001;
+
+		if (!Class.empty())                     ret += 0x000100 * Class.size();
+		if (!Attr.empty())                      ret += 0x000100 * Attr.size();
+		// TODO: has different cases
+		if (!PseudoClass.empty())               ret += 0x000100 * PseudoClass.size();
+
+		if (!Id.empty())                        ret += 0x010000;
+
+		return ret;
+	}
+
+	void CCssSelector::setClass(const std::string &cls)
+	{
+		std::vector<std::string> parts;
+		NLMISC::splitString(toLower(cls), ".", parts);
+
+		for(uint i = 0; i< parts.size(); i++)
+		{
+			std::string cname = trim(parts[i]);
+			if (!cname.empty())
+			{
+				Class.push_back(cname);
+			}
+		}
+	}
+
+	void CCssSelector::addAttribute(const std::string &key, const std::string &val, char op)
+	{
+		Attr.push_back(SAttribute(key, val, op));
+	}
+
+	void CCssSelector::addPseudoClass(const std::string &key)
+	{
+		if (key.empty()) return;
+
+		PseudoClass.push_back(key);
+	}
+
+	bool CCssSelector::match(const CHtmlElement &elm) const
+	{
+		if (!Element.empty() && Element != "*" && Element != elm.Value)
+		{
+			return false;
+		}
+
+		if (!Id.empty() && Id != elm.getAttribute("id"))
+		{
+			return false;
+		}
+
+		if (!Class.empty() && !matchClass(elm))
+		{
+			return false;
+		}
+
+		if (!Attr.empty() && !matchAttributes(elm))
+		{
+			return false;
+		}
+
+		if (!PseudoClass.empty() && !matchPseudoClass(elm))
+		{
+			return false;
+		}
+
+		return true;
+	}
+
+	bool CCssSelector::matchClass(const CHtmlElement &elm) const
+	{
+		// make sure all class names we have, other has as well
+		for(uint i = 0; i< Class.size(); ++i)
+		{
+			if (!elm.hasClass(Class[i]))
+			{
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	bool CCssSelector::matchAttributes(const CHtmlElement &elm) const
+	{
+		// TODO: refactor into matchAttributeSelector
+		for(uint i = 0; i< Attr.size(); ++i)
+		{
+			if (!elm.hasAttribute(Attr[i].key)) return false;
+
+			std::string value = elm.getAttribute(Attr[i].key);
+			switch(Attr[i].op)
+			{
+				case '=':
+					if (Attr[i].value != value) return false;
+					break;
+				case '~':
+					{
+						// exact match to any of whitespace separated words from element attribute
+						if (Attr[i].value.empty()) return false;
+
+						std::vector<std::string> parts;
+						NLMISC::splitString(value, " ", parts);
+						bool found = false;
+						for(uint j = 0; j < parts.size(); j++)
+						{
+							if (Attr[i].value == parts[j])
+							{
+								found = true;
+								break;
+							}
+						}
+						if (!found) return false;
+					}
+					break;
+				case '|':
+					// exact value, or start with val+'-'
+					if (value != Attr[i].value && value.find(Attr[i].value + "-") == std::string::npos) return false;
+					break;
+				case '^':
+					// prefix, starts with
+					if (Attr[i].value.empty()) return false;
+					if (value.find(Attr[i].value) != 0) return false;
+					break;
+				case '$':
+					// suffic, ends with
+					if (Attr[i].value.empty() || value.size() < Attr[i].value.size()) return false;
+					if (Attr[i].value == value.substr(value.size() - Attr[i].value.size())) return false;
+					break;
+				case '*':
+					if (Attr[i].value.empty()) return false;
+					if (value.find(Attr[i].value) == std::string::npos) return false;
+					break;
+				case ' ':
+					// contains key, ignore value
+					break;
+				default:
+					// unknown comparison
+					return false;
+			}
+		}
+
+		return true;
+	}
+
+	bool CCssSelector::matchPseudoClass(const CHtmlElement &elm) const
+	{
+		for(uint i = 0; i< PseudoClass.size(); i++)
+		{
+			if (PseudoClass[i] == "root")
+			{
+				// ':root' is just 'html' with higher specificity
+				if (elm.Value != "html") return false;
+			}
+			else if (PseudoClass[i] == "only-child")
+			{
+				if (elm.parent && !elm.parent->Children.empty()) return false;
+			}
+			else
+			{
+				if (PseudoClass[i] == "first-child")
+				{
+					if (elm.previousSibling) return false;
+				}
+				else if (PseudoClass[i] == "last-child")
+				{
+					if (elm.nextSibling) return false;
+				}
+				else if (PseudoClass[i].find("nth-child(") != std::string::npos)
+				{
+					sint a, b;
+					// TODO: there might be multiple :nth-child() on single selector, so current can't cache it
+					parseNth(PseudoClass[i], a, b);
+
+					// 1st child should be '1' and not '0'
+					if (!matchNth(elm.childIndex+1, a, b)) return false;
+				}
+				else
+				{
+					return false;
+				}
+			}
+		}
+
+		return true;
+	}
+
+	void CCssSelector::parseNth(const std::string &pseudo, sint &a, sint &b) const
+	{
+		a = 0;
+		b = 0;
+
+		std::string::size_type start = pseudo.find_first_of("(") + 1;
+		std::string::size_type end = pseudo.find_first_of(")");
+
+		if (start == std::string::npos) return;
+
+		std::string expr = toLower(pseudo.substr(start, end - start));
+
+		if (expr.empty()) return;
+
+		if (expr == "even")
+		{
+			// 2n+0
+			a = 2;
+			b = 0;
+		}
+		else if (expr == "odd")
+		{
+			// 2n+1
+			a = 2;
+			b = 1;
+		}
+		else
+		{
+			// -An+B, An+B, An-B
+			std::string::size_type pos;
+
+			start = 0;
+			pos = expr.find_first_of("n", start);
+			if (pos == std::string::npos)
+			{
+				fromString(expr, b);
+			}
+			else if (pos == 0)
+			{
+				// 'n' == '1n'
+				a = 1;
+			}
+			else if (expr[0] == '-' && pos == 1)
+			{
+				// '-n' == '-1n'
+				a = -1;
+			}
+			else
+			{
+				fromString(expr.substr(start, pos - start), a);
+			}
+
+			start = pos;
+			pos = expr.find_first_of("+-", start);
+			if (pos != std::string::npos && (expr[pos] == '+' || expr[pos] == '-'))
+			{
+				// copy with sign char
+				fromString(expr.substr(pos, end - pos), b);
+			}
+		}
+	}
+
+	bool CCssSelector::matchNth(sint childNr, sint a, sint b) const
+	{
+		if (a == 0)
+		{
+			return childNr == b;
+		}
+		else if (a > 0)
+		{
+			return childNr >= b && (childNr - b) % a == 0;
+		}
+		else
+		{
+			// a is negative from '-An+B'
+			return childNr <= b && (b - childNr) % (-a) == 0;
+		}
+	}
+
+} // namespace
+
diff --git a/code/nel/src/gui/css_style.cpp b/code/nel/src/gui/css_style.cpp
index 8fc1207d2..88e438870 100644
--- a/code/nel/src/gui/css_style.cpp
+++ b/code/nel/src/gui/css_style.cpp
@@ -18,6 +18,7 @@
 
 #include <string>
 #include "nel/misc/types_nl.h"
+#include "nel/gui/html_element.h"
 #include "nel/gui/css_style.h"
 #include "nel/gui/css_parser.h"
 #include "nel/gui/libwww.h"
@@ -30,24 +31,236 @@ using namespace NLMISC;
 
 namespace NLGUI
 {
+	uint CCssStyle::SStyleRule::specificity() const
+	{
+		uint count = 0;
+		for(uint i = 0; i < Selector.size(); ++i)
+		{
+			count += Selector[i].specificity();
+		}
+		// counted as element tag like DIV
+		if (!PseudoElement.empty())
+		{
+			count += 0x000001;
+		}
+
+		return count;
+	}
+
 	// ***************************************************************************
 	void CCssStyle::reset()
 	{
+		_StyleRules.clear();
 		_StyleStack.clear();
 
 		Root = CStyleParams();
 		Current = CStyleParams();
 	}
 
+	// ***************************************************************************
+	// Sorting helper
+	struct CCssSpecificityPred
+	{
+		bool operator()(CCssStyle::SStyleRule lhs, CCssStyle::SStyleRule rhs) const
+		{
+			return lhs.specificity() < rhs.specificity();
+		}
+	};
+
+	// ***************************************************************************
+	void CCssStyle::parseStylesheet(const std::string &styleString)
+	{
+		CCssParser parser;
+		parser.parseStylesheet(styleString, _StyleRules);
+
+		// keep the list sorted
+		std::stable_sort(_StyleRules.begin(), _StyleRules.end(), CCssSpecificityPred());
+	}
+
+	void CCssStyle::getStyleFor(CHtmlElement &elm) const
+	{
+		std::vector<SStyleRule> mRules;
+		for (std::vector<SStyleRule>::const_iterator it = _StyleRules.begin(); it != _StyleRules.end(); ++it)
+		{
+			if (match(it->Selector, elm))
+			{
+				mRules.push_back(*it);
+			}
+		}
+
+		elm.Style.clear();
+		elm.StyleBefore.clear();
+		elm.StyleAfter.clear();
+
+		if (!mRules.empty())
+		{
+			// style is sorted by specificity (lowest first), eg. html, .class, html.class, #id, html#id.class
+			for(std::vector<SStyleRule>::const_iterator i = mRules.begin(); i != mRules.end(); ++i)
+			{
+				if (i->PseudoElement.empty())
+				{
+					merge(elm.Style, i->Properties);
+				}
+				else if (i->PseudoElement == ":before")
+				{
+					merge(elm.StyleBefore, i->Properties);
+				}
+				else if (i->PseudoElement == ":after")
+				{
+					merge(elm.StyleAfter, i->Properties);
+				}
+			}
+		}
+
+		// style from "style" attribute overrides <style>
+		if (elm.hasNonEmptyAttribute("style"))
+		{
+			TStyle styles = CCssParser::parseDecls(elm.getAttribute("style"));
+			merge(elm.Style, styles);
+		}
+	}
+
+	void CCssStyle::merge(TStyle &dst, const TStyle &src) const
+	{
+		// TODO: does not use '!important' flag
+		for(TStyle::const_iterator it = src.begin(); it != src.end(); ++it)
+		{
+			dst[it->first] = it->second;
+		}
+	}
+
+	bool CCssStyle::match(const std::vector<CCssSelector> &selector, const CHtmlElement &elm) const
+	{
+		if (selector.empty()) return false;
+
+		// first selector, '>' immediate parent
+		bool matches = false;
+		bool mustMatchNext = true;
+		bool matchGeneralChild = false;
+		bool matchGeneralSibling = false;
+
+		const CHtmlElement *child;
+		child = &elm;
+		std::vector<CCssSelector>::const_reverse_iterator ritSelector = selector.rbegin();
+		char matchCombinator = '\0';
+		while(ritSelector != selector.rend())
+		{
+			if (!child)
+			{
+				return false;
+			}
+
+			matches = ritSelector->match(*child);
+			if (!matches && mustMatchNext)
+			{
+				return false;
+			}
+
+			if (!matches)
+			{
+				if (matchCombinator == ' ')
+				{
+					if (!child->parent)
+					{
+						return false;
+					}
+					child = child->parent;
+					// walk up the tree until there is match for current selector
+					continue;
+				}
+
+				if (matchCombinator == '~')
+				{
+					// any previous sibling must match current selector
+					if (!child->previousSibling)
+					{
+						return false;
+					}
+					child = child->previousSibling;
+
+					// check siblings until there is match for current selector
+					continue;
+				}
+			}
+
+			mustMatchNext = false;
+			switch(ritSelector->Combinator)
+			{
+			case '\0':
+				// default case when single selector
+				break;
+			case ' ':
+				{
+					// general child - match child->parent to current/previous selector
+					if (!child->parent)
+					{
+						return false;
+					}
+					child = child->parent;
+					matchCombinator = ritSelector->Combinator;
+				}
+				break;
+			case '~':
+				{
+					// any previous sibling must match current selector
+					if (!child->previousSibling)
+					{
+						return false;
+					}
+					child = child->previousSibling;
+					matchCombinator = ritSelector->Combinator;
+				}
+				break;
+			case '+':
+				{
+					// adjacent sibling - previous sibling must match previous selector
+					if (!child->previousSibling)
+					{
+						return false;
+					}
+					child = child->previousSibling;
+					mustMatchNext = true;
+				}
+				break;
+			case '>':
+				{
+					// child of - immediate parent must match previous selector
+					if (!child->parent)
+					{
+						return false;					
+					}
+					child = child->parent;
+					mustMatchNext = true;
+				}
+				break;
+			default:
+				// should not reach
+				return false;
+			}
+
+			++ritSelector;
+		}
+
+		return matches;
+	}
+
 	// ***************************************************************************
 	void CCssStyle::applyRootStyle(const std::string &styleString)
 	{
 		getStyleParams(styleString, Root, Root);
 	}
 
+	// ***************************************************************************
+	void CCssStyle::applyRootStyle(const TStyle &styleRules)
+	{
+		getStyleParams(styleRules, Root, Root);
+	}
+
 	// ***************************************************************************
 	void CCssStyle::applyStyle(const std::string &styleString)
 	{
+		if (styleString.empty()) return;
+
 		if (_StyleStack.empty())
 		{
 			getStyleParams(styleString, Current, Root);
@@ -58,6 +271,20 @@ namespace NLGUI
 		}
 	}
 
+	// ***************************************************************************
+	void CCssStyle::applyStyle(const TStyle &styleRules)
+	{
+		if (_StyleStack.empty())
+		{
+			getStyleParams(styleRules, Current, Root);
+		}
+		else
+		{
+			getStyleParams(styleRules, Current, _StyleStack.back());
+		}
+	}
+
+	// ***************************************************************************
 	bool CCssStyle::scanCssLength(const std::string& str, uint32 &px) const
 	{
 		if (fromString(str, px))
@@ -90,14 +317,30 @@ namespace NLGUI
 	// style.StrikeThrough; // text-decoration: line-through;  text-decoration-line: line-through;
 	void CCssStyle::getStyleParams(const std::string &styleString, CStyleParams &style, const CStyleParams &current) const
 	{
-		float tmpf;
 		TStyle styles = CCssParser::parseDecls(styleString);
-		TStyle::iterator it;
 
-		// first pass: get font-size for 'em' sizes
-		// get TextColor value used as 'currentcolor'
-		for (it=styles.begin(); it != styles.end(); ++it)
+		getStyleParams(styles, style, current);
+	}
+
+	void CCssStyle::getStyleParams(const TStyle &styleRules, CStyleParams &style, const CStyleParams &current) const
+	{
+		float tmpf;
+		TStyle::const_iterator it;
+
+		if(styleRules.empty())
 		{
+			return;
+		}
+
+		// first pass:
+		// - get font-size for 'em' sizes
+		// - split shorthand to its parts
+		// - get TextColor value that could be used for 'currentcolor'
+		for (it=styleRules.begin(); it != styleRules.end(); ++it)
+		{
+			// update local copy of applied style
+			style.StyleRules[it->first] = it->second;
+
 			if (it->first == "color")
 			{
 				if (it->second == "inherit")
@@ -180,19 +423,56 @@ namespace NLGUI
 					}
 				}
 			}
+			else
+			if (it->first == "background")
+			{
+				parseBackgroundShorthand(it->second, style);
+			}
 		}
 
 		// second pass: rest of style
-		for (it=styles.begin(); it != styles.end(); ++it)
+		for (it=styleRules.begin(); it != styleRules.end(); ++it)
 		{
-			if (it->first == "border")
+			if (it->first == "border" || it->first == "border-width")
 			{
-				sint32 b;
-				if (it->second == "none")
+				// TODO: border: 1px solid red;
+				if (it->second == "inherit")
+				{
+					style.BorderWidth = current.BorderWidth;
+				}
+				else if (it->second == "none")
+				{
 					style.BorderWidth = 0;
-				else
-				if (fromString(it->second, b))
-					style.BorderWidth = b;
+				}
+				else if (it->second == "thin")
+				{
+					style.BorderWidth = 1;
+				}
+				else if (it->second == "medium")
+				{
+					style.BorderWidth = 3;
+				}
+				else if (it->second == "thick")
+				{
+					style.BorderWidth = 5;
+				}
+				else 
+				{
+					std::string unit;
+					if (getCssLength(tmpf, unit, it->second.c_str()))
+					{
+						if (unit == "rem")
+							style.BorderWidth = Root.FontSize * tmpf;
+						else if (unit == "em")
+							style.BorderWidth = current.FontSize * tmpf;
+						else if (unit == "pt")
+							style.BorderWidth = tmpf / 0.75f;
+						else if (unit == "%")
+							style.BorderWidth = 0; // no support for % in border width
+						else
+							style.BorderWidth = tmpf;
+					}
+				}
 			}
 			else
 			if (it->first == "font-style")
@@ -366,6 +646,30 @@ namespace NLGUI
 				}
 			}
 			else
+			if (it->first == "text-align")
+			{
+				if (it->second == "inherit")
+					style.TextAlign = current.TextAlign;
+				else if (it->second == "left" || it->second == "right" || it->second == "center" || it->second == "justify")
+					style.TextAlign = it->second;
+			}
+			else
+			if (it->first == "vertical-align")
+			{
+				if (it->second == "inherit")
+					style.VerticalAlign = current.VerticalAlign;
+				else if (it->second == "top" || it->second == "middle" || it->second == "bottom")
+					style.VerticalAlign = it->second;
+			}
+			else
+			if (it->first == "white-space")
+			{
+				if (it->second == "inherit")
+					style.WhiteSpace = current.WhiteSpace;
+				else if (it->second == "normal" || it->second == "nowrap" || it->second == "pre")
+					style.WhiteSpace = it->second;
+			}
+			else
 			if (it->first == "width")
 			{
 				std::string unit;
@@ -474,6 +778,172 @@ namespace NLGUI
 			style.StrikeThrough = current.StrikeThrough;
 	}
 
+	void CCssStyle::parseBackgroundShorthand(const std::string &value, CStyleParams &style) const
+	{
+		// background: url(image.jpg) top center / 200px 200px no-repeat fixed padding-box content-box red;
+		// background-image      : url(image.jpg)
+		// background-position   : top center
+		// background-size       : 200px 200px
+		// background-repeat     : no-repeat
+		// background-attachment : fixed
+		// background-origin     : padding-box
+		// background-clip       : content-box
+		// background-color      : red
+
+		const uint nbProps = 8;
+		std::string props[nbProps] = {"background-image", "background-position", "background-size", "background-repeat",
+			"background-attachment", "background-origin", "background-clip", "background-color"};
+		std::string values[nbProps];
+		bool found[nbProps] = {false};
+
+
+		uint partIndex = 0;
+		std::vector<std::string> parts;
+		std::vector<std::string>::iterator it;
+		// FIXME: this will fail if url() contains ' ' chars
+		NLMISC::splitString(value, " ", parts);
+
+		bool failed = false;
+		for(uint index = 0; index < parts.size(); index++)
+		{
+			const std::string val = toLower(trim(parts[index]));
+
+			for(uint i = 0; i < nbProps; i++)
+			{
+				if (found[i])
+				{
+					continue;
+				}
+
+				if (props[i] == "background-image")
+				{
+					if (val.substr(0, 4) == "url(")
+					{
+						// use original value as 'val' is lowercase
+						values[i] = parts[index];
+						found[i] = true;
+					}
+				}
+				else if (props[i] == "background-position")
+				{
+					// TODO:
+				}
+				else if (props[i] == "background-size")
+				{
+					// TODO: [<length-percentage> | auto ]{1,2} cover | contain
+				}
+				else if (props[i] == "background-repeat")
+				{
+					if (val == "repeat-x" || val == "repeat-y" || val == "repeat" || val == "space" || val == "round" || val == "no-repeat")
+					{
+						if (val == "repeat-x")
+						{
+							values[i] = "repeat no-repeat";
+						}
+						else if (val == "repeat-y")
+						{
+							values[i] = "no-repeat repeat";				
+						}
+						else
+						{
+							std::string horiz = val;
+							std::string vert = val;
+							if (index+1 < parts.size())
+							{
+								std::string next = toLower(trim(parts[index+1]));
+								if (next == "repeat" || next == "space" || next == "round" || next == "no-repeat")
+								{
+									vert = next;
+									index++;
+								}
+							}
+							
+							values[i] = horiz + " " + vert;
+						}
+
+						found[i] = true;
+					}
+				}
+				else if (props[i] == "background-attachment")
+				{
+					// TODO: scroll | fixed | local
+				}
+				else if (props[i] == "background-origin" || props[i] == "background-clip")
+				{
+					// same values for both
+					if (val == "padding-box" || val == "border-box" || val == "content-box")
+					{
+						values[i] = val;
+						found[i] = true;
+					}
+				}
+				else if (props[i] == "background-color")
+				{
+					CRGBA color;
+					if (!scanHTMLColor(val.c_str(), color))
+					{
+						failed = true;
+						break;
+					}
+					values[i] = val;
+					// color should come as last item
+					break;
+				}
+			}
+		}
+
+		// invalidate whole rule
+		if (failed)
+		{
+			return;
+		}
+
+		// apply found styles
+		for(uint i = 0; i < nbProps; i++)
+		{
+			if (found[i])
+			{
+				style.StyleRules[props[i]] = values[i];
+			}
+			else
+			{
+				// fill in default if one is set
+				if (props[i] == "background-image")
+				{
+					style.StyleRules[props[i]] = "none";
+				}
+				else if (props[i] == "background-position")
+				{
+					//style.StyleRules[props[i]] = "0% 0%";
+				}
+				else if (props[i] == "background-size")
+				{
+					//style.StyleRules[props[i]] = "auto auto";
+				}
+				else if (props[i] == "background-repeat")
+				{
+					style.StyleRules[props[i]] = "repeat repeat";
+				}
+				else if(props[i] == "background-attachment")
+				{
+					//style.StyleRules[props[i]] = "scroll";
+				}
+				else if(props[i] == "background-origin")
+				{
+					//style.StyleRules[props[i]] = "padding-box";
+				}
+				else if (props[i] == "background-clip")
+				{
+					//style.StyleRules[props[i]] = "border-box";
+				}
+				else if (props[i] == "background-color")
+				{
+					style.StyleRules[props[i]] = "transparent";
+				}
+			}
+		}
+	}
+
 	// ***************************************************************************
 	void CCssStyle::applyCssMinMax(sint32 &width, sint32 &height, sint32 minw, sint32 minh, sint32 maxw, sint32 maxh) const
 	{
diff --git a/code/nel/src/gui/group_html.cpp b/code/nel/src/gui/group_html.cpp
index ba21c6af1..c40617f50 100644
--- a/code/nel/src/gui/group_html.cpp
+++ b/code/nel/src/gui/group_html.cpp
@@ -49,6 +49,9 @@
 #include "nel/gui/http_hsts.h"
 #include "nel/gui/curl_certificates.h"
 #include "nel/gui/html_parser.h"
+#include "nel/gui/html_element.h"
+#include "nel/gui/css_style.h"
+#include "nel/gui/css_parser.h"
 
 #include <curl/curl.h>
 
@@ -69,7 +72,6 @@ using namespace NLMISC;
 
 namespace NLGUI
 {
-
 	// Uncomment to see the log about image download
 	//#define LOG_DL 1
 
@@ -395,22 +397,22 @@ namespace NLGUI
 			setTextStyle(pVT, style);
 		}
 
-		if (style.BackgroundColor.A > 0)
+		if (style.hasStyle("background-color"))
 		{
 			ctrlButton->setColor(style.BackgroundColor);
-			if (style.BackgroundColorOver.A == 0)
+			if (style.hasStyle("-ryzom-background-color-over"))
 			{
-				ctrlButton->setColorOver(style.BackgroundColor);
+				ctrlButton->setColorOver(style.BackgroundColorOver);
 			}
 			else
 			{
-				ctrlButton->setColorOver(style.BackgroundColorOver);
+				ctrlButton->setColorOver(style.BackgroundColor);
 			}
 			ctrlButton->setTexture("", "blank.tga", "", false);
 			ctrlButton->setTextureOver("", "blank.tga", "");
 			ctrlButton->setProperty("force_text_over", "true");
 		}
-		else if (style.BackgroundColorOver.A > 0)
+		else if (style.hasStyle("-ryzom-background-color-over"))
 		{
 			ctrlButton->setColorOver(style.BackgroundColorOver);
 			ctrlButton->setProperty("force_text_over", "true");
@@ -424,7 +426,6 @@ namespace NLGUI
 		{
 			pVT->setFontSize(style.FontSize);
 			pVT->setColor(style.TextColor);
-			pVT->setColor(style.TextColor);
 			pVT->setFontName(style.FontFamily);
 			pVT->setFontSize(style.FontSize);
 			pVT->setEmbolden(style.FontWeight >= FONT_WEIGHT_BOLD);
@@ -450,6 +451,36 @@ namespace NLGUI
 		return dest;
 	}
 
+	void CGroupHTML::pumpCurlDownloads()
+	{
+		if (RunningCurls < options.curlMaxConnections)
+		{
+			for (vector<CDataDownload>::iterator it=Curls.begin(); it<Curls.end(); it++)
+			{
+				if (it->data == NULL)
+				{
+					#ifdef LOG_DL
+					nlwarning("(%s) starting new download '%s'", _Id.c_str(), it->url.c_str());
+					#endif
+					if (!startCurlDownload(*it))
+					{
+						finishCurlDownload(*it);
+						Curls.erase(it);
+						break;
+					}
+
+					RunningCurls++;
+					if (RunningCurls >= options.curlMaxConnections)
+						break;
+				}
+			}
+		}
+		#ifdef LOG_DL
+		if (RunningCurls > 0 || !Curls.empty())
+			nlwarning("(%s) RunningCurls %d, _Curls %d", _Id.c_str(), RunningCurls, Curls.size());
+		#endif
+	}
+
 	// Add url to MultiCurl queue and return cURL handle
 	bool CGroupHTML::startCurlDownload(CDataDownload &download)
 	{
@@ -543,6 +574,86 @@ namespace NLGUI
 		return true;
 	}
 
+	void CGroupHTML::finishCurlDownload(CDataDownload &download)
+	{
+		std::string tmpfile = download.dest + ".tmp";
+
+		if (download.type == ImgType)
+		{
+			// there is race condition if two browser instances are downloading same file
+			// second instance deletes first tmpfile and creates new file for itself.
+			if (CFile::getFileSize(tmpfile) > 0)
+			{
+				try
+				{
+					// verify that image is not corrupted
+					uint32 w, h;
+					CBitmap::loadSize(tmpfile, w, h);
+					if (w != 0 && h != 0)
+					{
+						bool refresh = false;
+						if (CFile::fileExists(download.dest))
+						{
+							CFile::deleteFile(download.dest);
+							refresh = true;
+						}
+
+						// to reload image on page, the easiest seems to be changing texture
+						// to temp file temporarily. that forces driver to reload texture from disk
+						// ITexture::touch() seem not to do this.
+						if (refresh)
+						{
+							// cache was updated, first set texture as temp file
+							for(uint i = 0; i < download.imgs.size(); i++)
+							{
+								setImage(download.imgs[i].Image, tmpfile, download.imgs[i].Type);
+								setImageSize(download.imgs[i].Image, download.imgs[i].Style);
+							}
+						}
+
+						// move temp to correct cache file
+						CFile::moveFile(download.dest, tmpfile);
+						// set image texture as cache file
+						for(uint i = 0; i < download.imgs.size(); i++)
+						{
+							setImage(download.imgs[i].Image, download.dest, download.imgs[i].Type);
+							setImageSize(download.imgs[i].Image, download.imgs[i].Style);
+						}
+
+					}
+				}
+				catch(const NLMISC::Exception &e)
+				{
+					// exception message has .tmp file name, so keep it for further analysis
+					nlwarning("Invalid image (%s): %s", download.url.c_str(), e.what());
+				}
+			}
+
+			return;
+		}
+
+		if (!tmpfile.empty())
+		{
+			CFile::moveFile(download.dest, tmpfile);
+		}
+
+		if (download.type == StylesheetType)
+		{
+			cssDownloadFinished(download.url, download.dest);
+
+			return;
+		}
+
+		if (download.type == BnpType)
+		{
+			CLuaManager::getInstance().executeLuaScript(download.luaScript, true );
+
+			return;
+		}
+
+		nlwarning("Unknown CURL download type (%d) finished '%s'", download.type, download.url.c_str());
+	}
+
 	// Add a image download request in the multi_curl
 	void CGroupHTML::addImageDownload(const string &url, CViewBase *img, const CStyleParams &style, TImageType type)
 	{
@@ -575,22 +686,8 @@ namespace NLGUI
 		}
 
 		Curls.push_back(CDataDownload(finalUrl, dest, ImgType, img, "", "", style, type));
-		if (Curls.size() < options.curlMaxConnections) {
-			if (!startCurlDownload(Curls.back()))
-			{
-				Curls.pop_back();
-				return;
-			}
 
-			RunningCurls++;
-	#ifdef LOG_DL
-			nlwarning("(%s) adding handle %x, %d curls", _Id.c_str(), Curls.back().data->Request, Curls.size());
-		}
-		else
-		{
-			nlwarning("(%s) download queued, %d curls", _Id.c_str(), Curls.size());
-	#endif
-		}
+		pumpCurlDownloads();
 	}
 
 	void CGroupHTML::initImageDownload()
@@ -651,22 +748,8 @@ namespace NLGUI
 		if (action != "delete")
 		{
 			Curls.push_back(CDataDownload(url, dest, BnpType, NULL, script, md5sum));
-			if (Curls.size() < options.curlMaxConnections)
-			{
-				if (!startCurlDownload(Curls.back()))
-				{
-					Curls.pop_back();
-					return false;
-				}
-				RunningCurls++;
-	#ifdef LOG_DL
-				nlwarning("(%s) adding handle %x, %d curls", _Id.c_str(), Curls.back().data->Request, Curls.size());
-			}
-			else
-			{
-				nlwarning("(%s) download queued, %d curls", _Id.c_str(), Curls.size());
-	#endif
-			}
+
+			pumpCurlDownloads();
 		}
 		else
 			return true;
@@ -687,6 +770,25 @@ namespace NLGUI
 			CFile::createDirectory( pathName );
 	}
 
+	void CGroupHTML::addStylesheetDownload(std::vector<std::string> links)
+	{
+		for(uint i = 0; i < links.size(); ++i)
+		{
+			std::string url = getAbsoluteUrl(links[i]);
+			std::string local = localImageName(url);
+
+			// insert only if url not already downloading
+			std::vector<std::string>::const_iterator it = std::find(_StylesheetQueue.begin(), _StylesheetQueue.end(), url);
+			if (it == _StylesheetQueue.end())
+			{
+				_StylesheetQueue.push_back(url);
+				Curls.push_back(CDataDownload(url, local, StylesheetType, NULL, "", ""));
+			}
+		}
+
+		pumpCurlDownloads();
+	}
+
 	// Call this evenly to check if an element is downloaded and then manage it
 	void CGroupHTML::checkDownloads()
 	{
@@ -826,7 +928,7 @@ namespace NLGUI
 								CStrictTransportSecurity::getInstance()->setFromHeader(uri.host, it->data->getHSTSHeader());
 							}
 
-							string tmpfile = it->dest + ".tmp";
+							std::string tmpfile = it->dest + ".tmp";
 							if(res != CURLE_OK || r < 200 || r >= 300 || (!it->md5sum.empty() && (it->md5sum != getMD5(tmpfile).toString())))
 							{
 								if (it->redirects < DEFAULT_RYZOM_REDIRECT_LIMIT && ((r >= 301 && r <= 303) || r == 307 || r == 308))
@@ -863,7 +965,7 @@ namespace NLGUI
 									if (it->redirects >= DEFAULT_RYZOM_REDIRECT_LIMIT)
 										nlwarning("Redirect limit reached for '%s'", it->url.c_str());
 
-									NLMISC::CFile::deleteFile(tmpfile.c_str());
+									CFile::deleteFile(tmpfile);
 
 									// 304 Not Modified
 									if (res == CURLE_OK && r == 304)
@@ -875,6 +977,14 @@ namespace NLGUI
 
 										CHttpCache::getInstance()->store(it->dest, obj);
 									}
+									else
+									{
+										// 404, 500, etc
+										if (CFile::fileExists(it->dest))
+											CFile::deleteFile(it->dest);
+									}
+
+									finishCurlDownload(*it);
 								}
 							}
 							else
@@ -886,46 +996,7 @@ namespace NLGUI
 
 								CHttpCache::getInstance()->store(it->dest, obj);
 
-								string finalUrl;
-								if (it->type == ImgType)
-								{
-									// there is race condition if two browser instances are downloading same file
-									// second instance deletes first tmpfile and creates new file for itself.
-									if (CFile::getFileSize(tmpfile) > 0)
-									{
-										try
-										{
-											// verify that image is not corrupted
-											uint32 w, h;
-											CBitmap::loadSize(tmpfile, w, h);
-											if (w != 0 && h != 0)
-											{
-												if (CFile::fileExists(it->dest))
-													CFile::deleteFile(it->dest);
-
-												CFile::moveFile(it->dest, tmpfile);
-												for(uint i = 0; i < it->imgs.size(); i++)
-												{
-													setImage(it->imgs[i].Image, it->dest, it->imgs[i].Type);
-													setImageSize(it->imgs[i].Image, it->imgs[i].Style);
-												}
-											}
-										}
-										catch(const NLMISC::Exception &e)
-										{
-											// exception message has .tmp file name, so keep it for further analysis
-											nlwarning("Invalid image (%s): %s", it->url.c_str(), e.what());
-										}
-									}
-								}
-								else
-								{
-									CFile::moveFile(it->dest, tmpfile);
-									//if (lookupLocalFile (finalUrl, file.c_str(), false))
-									{
-										CLuaManager::getInstance().executeLuaScript( it->luaScript, true );
-									}
-								}
+								finishCurlDownload(*it);
 							}
 
 							// release CCurlWWWData
@@ -941,31 +1012,7 @@ namespace NLGUI
 
 		RunningCurls = NewRunningCurls;
 
-		if (RunningCurls < options.curlMaxConnections)
-		{
-			for (vector<CDataDownload>::iterator it=Curls.begin(); it<Curls.end(); it++)
-			{
-				if (it->data == NULL) {
-	#ifdef LOG_DL
-					nlwarning("(%s) starting new download '%s'", _Id.c_str(), it->url.c_str());
-	#endif
-					if (!startCurlDownload(*it))
-					{
-						Curls.erase(it);
-						break;
-					}
-
-					RunningCurls++;
-					if (RunningCurls >= options.curlMaxConnections)
-						break;
-				}
-			}
-		}
-
-	#ifdef LOG_DL
-		if (RunningCurls > 0 || !Curls.empty())
-			nlwarning("(%s) RunningCurls %d, _Curls %d", _Id.c_str(), RunningCurls, Curls.size());
-	#endif
+		pumpCurlDownloads();
 	}
 
 
@@ -1117,7 +1164,7 @@ namespace NLGUI
 
 	// ***************************************************************************
 
-	#define getCellsParameters(prefix,inherit) \
+	#define getCellsParameters_DEP(prefix,inherit) \
 	{\
 		CGroupHTML::CCellParams cellParams; \
 		if (!_CellParams.empty() && inherit) \
@@ -1154,8 +1201,310 @@ namespace NLGUI
 	}
 
 	// ***************************************************************************
+	void CGroupHTML::beginElement (CHtmlElement &elm)
+	{
+		_Style.pushStyle();
+		_CurrentHTMLElement = &elm;
+		_CurrentHTMLNextSibling = elm.nextSibling;
 
-	void CGroupHTML::beginElement (uint element_number, const std::vector<bool> &present, const std::vector<const char *> &value)
+		// set element style from css and style attribute
+		_Style.getStyleFor(elm);
+		if (!elm.Style.empty())
+		{
+			_Style.applyStyle(elm.Style);
+		}
+
+		if (elm.hasNonEmptyAttribute("name"))
+		{
+			_AnchorName.push_back(elm.getAttribute("name"));
+		}
+		if (elm.hasNonEmptyAttribute("id"))
+		{
+			_AnchorName.push_back(elm.getAttribute("id"));
+		}
+
+		switch(elm.ID)
+		{
+		case HTML_A:        htmlA(elm); break;
+		case HTML_BASE:     htmlBASE(elm); break;
+		case HTML_BODY:     htmlBODY(elm); break;
+		case HTML_BR:       htmlBR(elm); break;
+		case HTML_DD:       htmlDD(elm); break;
+		case HTML_DEL:      renderPseudoElement(":before", elm); break;
+		case HTML_DIV:      htmlDIV(elm); break;
+		case HTML_DL:       htmlDL(elm); break;
+		case HTML_DT:       htmlDT(elm); break;
+		case HTML_EM:       renderPseudoElement(":before", elm); break;
+		case HTML_FONT:     htmlFONT(elm); break;
+		case HTML_FORM:     htmlFORM(elm); break;
+		case HTML_H1://no-break
+		case HTML_H2://no-break
+		case HTML_H3://no-break
+		case HTML_H4://no-break
+		case HTML_H5://no-break
+		case HTML_H6:		htmlH(elm); break;
+		case HTML_HEAD:     htmlHEAD(elm); break;
+		case HTML_HR:       htmlHR(elm); break;
+		case HTML_HTML:     htmlHTML(elm); break;
+		case HTML_I:        htmlI(elm); break;
+		case HTML_IMG:      htmlIMG(elm); break;
+		case HTML_INPUT:    htmlINPUT(elm); break;
+		case HTML_LI:       htmlLI(elm); break;
+		case HTML_LUA:      htmlLUA(elm); break;
+		case HTML_META:     htmlMETA(elm); break;
+		case HTML_OBJECT:   htmlOBJECT(elm); break;
+		case HTML_OL:       htmlOL(elm); break;
+		case HTML_OPTION:   htmlOPTION(elm); break;
+		case HTML_P:        htmlP(elm); break;
+		case HTML_PRE:      htmlPRE(elm); break;
+		case HTML_SCRIPT:   htmlSCRIPT(elm); break;
+		case HTML_SELECT:   htmlSELECT(elm); break;
+		case HTML_SMALL:    renderPseudoElement(":before", elm); break;
+		case HTML_SPAN:     renderPseudoElement(":before", elm); break;
+		case HTML_STRONG:   renderPseudoElement(":before", elm); break;
+		case HTML_STYLE:    htmlSTYLE(elm); break;
+		case HTML_TABLE:    htmlTABLE(elm); break;
+		case HTML_TD:       htmlTD(elm); break;
+		case HTML_TEXTAREA: htmlTEXTAREA(elm); break;
+		case HTML_TH:       htmlTH(elm); break;
+		case HTML_TITLE:    htmlTITLE(elm); break;
+		case HTML_TR:       htmlTR(elm); break;
+		case HTML_U:        renderPseudoElement(":before", elm); break;
+		case HTML_UL:       htmlUL(elm); break;
+		default:
+			renderPseudoElement(":before", elm);
+			break;
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::endElement(CHtmlElement &elm)
+	{
+		_CurrentHTMLElement = &elm;
+
+		switch(elm.ID)
+		{
+		case HTML_A:        htmlAend(elm); break;
+		case HTML_BASE:     break;
+		case HTML_BODY:     renderPseudoElement(":after", elm); break;
+		case HTML_BR:       break;
+		case HTML_DD:       htmlDDend(elm); break;
+		case HTML_DEL:      renderPseudoElement(":after", elm); break;
+		case HTML_DIV:      htmlDIVend(elm); break;
+		case HTML_DL:       htmlDLend(elm); break;
+		case HTML_DT:       htmlDTend(elm); break;
+		case HTML_EM:       renderPseudoElement(":after", elm);break;
+		case HTML_FONT:     break;
+		case HTML_FORM:     renderPseudoElement(":after", elm);break;
+		case HTML_H1://no-break
+		case HTML_H2://no-break
+		case HTML_H3://no-break
+		case HTML_H4://no-break
+		case HTML_H5://no-break
+		case HTML_H6:		htmlHend(elm); break;
+		case HTML_HEAD:     htmlHEADend(elm); break;
+		case HTML_HR:       break;
+		case HTML_HTML:     break;
+		case HTML_I:        htmlIend(elm); break;
+		case HTML_IMG:      break;
+		case HTML_INPUT:    break;
+		case HTML_LI:       htmlLIend(elm); break;
+		case HTML_LUA:      htmlLUAend(elm); break;
+		case HTML_META:     break;
+		case HTML_OBJECT:   htmlOBJECTend(elm); break;
+		case HTML_OL:       htmlOLend(elm); break;
+		case HTML_OPTION:   htmlOPTIONend(elm); break;
+		case HTML_P:        htmlPend(elm); break;
+		case HTML_PRE:      htmlPREend(elm); break;
+		case HTML_SCRIPT:   htmlSCRIPTend(elm); break;
+		case HTML_SELECT:   htmlSELECTend(elm); break;
+		case HTML_SMALL:    renderPseudoElement(":after", elm);break;
+		case HTML_SPAN:     renderPseudoElement(":after", elm);break;
+		case HTML_STRONG:   renderPseudoElement(":after", elm);break;
+		case HTML_STYLE:    htmlSTYLEend(elm); break;
+		case HTML_TABLE:    htmlTABLEend(elm); break;
+		case HTML_TD:       htmlTDend(elm); break;
+		case HTML_TEXTAREA: htmlTEXTAREAend(elm); break;
+		case HTML_TH:       htmlTHend(elm); break;
+		case HTML_TITLE:    htmlTITLEend(elm); break;
+		case HTML_TR:       htmlTRend(elm); break;
+		case HTML_U:        renderPseudoElement(":after", elm); break;
+		case HTML_UL:       htmlULend(elm); break;
+		default:
+			renderPseudoElement(":after", elm);
+			break;
+		}
+
+
+		_Style.popStyle();
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::renderPseudoElement(const std::string &pseudo, const CHtmlElement &elm)
+	{
+		if (pseudo == ":before" && !elm.StyleBefore.empty())
+		{
+			_Style.pushStyle();
+			_Style.applyStyle(elm.StyleBefore);
+		}
+		else if (pseudo == ":after" && !elm.StyleAfter.empty())
+		{
+			_Style.pushStyle();
+			_Style.applyStyle(elm.StyleAfter);
+		}
+		else
+		{
+			// unknown pseudo element
+			return;
+		}
+
+		// TODO: 'content' should already be tokenized in css parser as it has all the functions for that
+		std::string content = trim(_Style.getStyle("content"));
+		if (toLower(content) == "none" || toLower(content) == "normal")
+		{
+			return;
+		}
+
+		// TODO: use ucstring / ucchar as content is utf8 chars
+		std::string::size_type pos = 0;
+		while(pos < content.size())
+		{
+			std::string::size_type start;
+			std::string token;
+		
+			// not supported
+			// counter, open-quote, close-quote, no-open-quote, no-close-quote
+			if (content[pos] == '"' || content[pos] == '\'')
+			{
+				char quote = content[pos];
+				pos++;
+				start = pos;
+				while(pos < content.size() && content[pos] != quote)
+				{
+					if (content[pos] == '\\') pos++;
+					pos++;
+				}
+				token = content.substr(start, pos - start);
+				addString(ucstring::makeFromUtf8(token));
+
+				// skip closing quote
+				pos++;
+			}
+			else if (content[pos] == 'u' && pos < content.size() - 6 && toLower(content.substr(pos, 4)) == "url(")
+			{
+				// url(/path-to/image.jpg) / "Alt!"
+				// url("/path to/image.jpg") / "Alt!"
+				std::string tooltip;
+
+				start = pos + 4;
+				// fails if url contains ')'
+				pos = content.find(")", start);
+				token = trim(content.substr(start, pos - start));
+				// skip ')'
+				pos++;
+
+				// scan for tooltip
+				start = pos;
+				while(pos < content.size() && content[pos] == ' ' && content[pos] != '/')
+				{
+					pos++;
+				}
+				if (pos < content.size() && content[pos] == '/')
+				{
+					// skip '/'
+					pos++;
+
+					// skip whitespace
+					while(pos < content.size() && content[pos] == ' ')
+					{
+						pos++;
+					}
+					if (pos < content.size() && (content[pos] == '\'' || content[pos] == '"'))
+					{
+						char openQuote =  content[pos];
+						pos++;
+						start = pos;
+						while(pos < content.size() && content[pos] != openQuote)
+						{
+							if (content[pos] == '\\') pos++;
+							pos++;
+						}
+						tooltip = content.substr(start, pos - start);
+
+						// skip closing quote
+						pos++;
+					}
+					else
+					{
+						// tooltip should be quoted
+						pos = start;
+						tooltip.clear();
+					}
+				}
+				else
+				{
+					// no tooltip
+					pos = start;
+				}
+
+				if (tooltip.empty())
+				{
+					addImage(getId() + pseudo, token, false, _Style.Current);
+				}
+				else
+				{
+					tooltip = trimQuotes(tooltip);
+					addButton(CCtrlButton::PushButton, getId() + pseudo, token, token, "", "", "", tooltip.c_str(), _Style.Current);
+				}
+			}
+			else if (content[pos] == 'a' && pos < content.size() - 7)
+			{
+				// attr(title)
+				start = pos + 5;
+				pos = content.find(")", start);
+				token = content.substr(start, pos - start);
+				// skip ')'
+				pos++;
+
+				if (elm.hasAttribute(token))
+				{
+					addString(ucstring::makeFromUtf8(elm.getAttribute(token)));
+				}
+			}
+			else
+			{
+				pos++;
+			}
+		}
+
+		_Style.popStyle();
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::renderDOM(CHtmlElement &elm)
+	{
+		if (elm.Type == CHtmlElement::TEXT_NODE)
+		{
+			addText(elm.Value.c_str(), elm.Value.size());
+		}
+		else
+		{
+			beginElement(elm);
+
+			std::list<CHtmlElement>::iterator it = elm.Children.begin();
+			while(it != elm.Children.end())
+			{
+				renderDOM(*it);
+
+				++it;
+			}
+
+			endElement(elm);
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::beginElementDeprecated(uint element_number, const std::vector<bool> &present, const std::vector<const char *> &value)
 	{
 		if (_Browsing)
 		{
@@ -1229,8 +1578,6 @@ namespace NLGUI
 				_Style.Current.TextColor = LinkColor;
 				_Style.Current.Underlined = true;
 				_Style.Current.GlobalColor = LinkColorGlobalColor;
-				_Style.Current.BackgroundColor.A = 0;
-				_Style.Current.BackgroundColorOver.A = 0;
 				_Style.Current.Width = -1;
 				_Style.Current.Height = -1;
 
@@ -1638,10 +1985,6 @@ namespace NLGUI
 						_Style.Current.TextShadow = CStyleParams::STextShadow(true);
 						_Style.Current.Width = -1;
 						_Style.Current.Height = -1;
-						// by default background texture is transparent,
-						// using alpha value to decide if to change it to 'blank.tga' for coloring
-						_Style.Current.BackgroundColor.A = 0;
-						_Style.Current.BackgroundColorOver.A = 0;
 
 						// Global color flag
 						if (present[MY_HTML_INPUT_GLOBAL_COLOR])
@@ -2024,7 +2367,7 @@ namespace NLGUI
 					registerAnchorName(MY_HTML_TABLE);
 
 					// Get cells parameters
-					getCellsParameters (MY_HTML_TABLE, false);
+					getCellsParameters_DEP (MY_HTML_TABLE, false);
 
 					CGroupTable *table = new CGroupTable(TCtorParam());
 					table->BgColor = _CellParams.back().BgColor;
@@ -2058,7 +2401,7 @@ namespace NLGUI
 			case HTML_TD:
 				{
 					// Get cells parameters
-					getCellsParameters (MY_HTML_TD, true);
+					getCellsParameters_DEP (MY_HTML_TD, true);
 
 					_Style.pushStyle();
 					if (element_number == HTML_TH)
@@ -2162,7 +2505,6 @@ namespace NLGUI
 				_Style.Current.TextShadow = CStyleParams::STextShadow(true);
 				_Style.Current.Width = -1;
 				_Style.Current.Height = -1;
-				_Style.Current.BackgroundColor.A = 0;
 
 				if (present[MY_HTML_TEXTAREA_STYLE] && value[MY_HTML_TEXTAREA_STYLE])
 					_Style.applyStyle(value[MY_HTML_TEXTAREA_STYLE]);
@@ -2213,7 +2555,7 @@ namespace NLGUI
 			case HTML_TR:
 				{
 					// Get cells parameters
-					getCellsParameters (MY_HTML_TR, true);
+					getCellsParameters_DEP (MY_HTML_TR, true);
 
 					// Set TR flag
 					if (!_TR.empty())
@@ -2441,7 +2783,7 @@ namespace NLGUI
 
 	// ***************************************************************************
 
-	void CGroupHTML::endElement (uint element_number)
+	void CGroupHTML::endElementDeprecated(uint element_number)
 	{
 		if (_Browsing)
 		{
@@ -2733,35 +3075,6 @@ namespace NLGUI
 		}
 	}
 
-	// ***************************************************************************
-	void CGroupHTML::beginUnparsedElement(const char *buffer, int length)
-	{
-		string str(buffer, buffer+length);
-		if (stricmp(str.c_str(), "lua") == 0)
-		{
-			// we receive an embeded lua script
-			_ParsingLua = _TrustedDomain; // Only parse lua if TrustedDomain
-			_LuaScript.clear();
-		}
-	}
-
-	// ***************************************************************************
-	void CGroupHTML::endUnparsedElement(const char *buffer, int length)
-	{
-		string str(buffer, buffer+length);
-		if (stricmp(str.c_str(), "lua") == 0)
-		{
-			if (_ParsingLua && _TrustedDomain)
-			{
-				_ParsingLua = false;
-				// execute the embeded lua script
-				_LuaScript = "\nlocal __CURRENT_WINDOW__=\""+this->_Id+"\" \n"+_LuaScript;
-				CLuaManager::getInstance().executeLuaScript(_LuaScript, true);
-			}
-		}
-	}
-
-
 	// ***************************************************************************
 	NLMISC_REGISTER_OBJECT(CViewBase, CGroupHTML, std::string, "html");
 
@@ -2775,7 +3088,8 @@ namespace NLGUI
 	CGroupHTML::CGroupHTML(const TCtorParam &param)
 	:	CGroupScrollText(param),
 		_TimeoutValue(DEFAULT_RYZOM_CONNECTION_TIMEOUT),
-		_RedirectsRemaining(DEFAULT_RYZOM_REDIRECT_LIMIT)
+		_RedirectsRemaining(DEFAULT_RYZOM_REDIRECT_LIMIT),
+		_CurrentHTMLElement(NULL)
 	{
 		// add it to map of group html created
 		_GroupHtmlUID= ++_GroupHtmlUIDPool; // valid assigned Id begin to 1!
@@ -2800,6 +3114,8 @@ namespace NLGUI
 		_RefreshUrl.clear();
 		_NextRefreshTime = 0.0;
 		_LastRefreshTime = 0.0;
+		_RenderNextTime = false;
+		_WaitingForStylesheet = false;
 
 		// Register
 		CWidgetManager::getInstance()->registerClockMsgTarget(this);
@@ -4248,7 +4564,7 @@ namespace NLGUI
 
 	// ***************************************************************************
 
-	void CGroupHTML::addImage(const std::string &id, const char *img, bool reloadImg, const CStyleParams &style)
+	void CGroupHTML::addImage(const std::string &id, const std::string &img, bool reloadImg, const CStyleParams &style)
 	{
 		// In a paragraph ?
 		if (!_Paragraph)
@@ -4377,7 +4693,7 @@ namespace NLGUI
 				if (eb)
 				{
 					eb->setInputString(decodeHTMLEntities(content));
-					if (style.BackgroundColor.A > 0)
+					if (style.hasStyle("background-color"))
 					{
 						CViewBitmap *bg = dynamic_cast<CViewBitmap*>(eb->getView("bg"));
 						if (bg)
@@ -4613,6 +4929,8 @@ namespace NLGUI
 
 	void CGroupHTML::clearContext()
 	{
+		_CurrentHTMLElement = NULL;
+		_CurrentHTMLNextSibling = NULL;
 		_Paragraph = NULL;
 		_PRE.clear();
 		_Indent.clear();
@@ -4959,6 +5277,17 @@ namespace NLGUI
 			}
 		}
 		else
+		if (_RenderNextTime)
+		{
+			_RenderNextTime = false;
+			renderHtmlString(_DocumentHtml);
+		}
+		else
+		if (_WaitingForStylesheet)
+		{
+			renderDocument();
+		}
+		else
 		if (_BrowseNextTime || _PostNextTime)
 		{
 			// Set timeout
@@ -5353,21 +5682,45 @@ namespace NLGUI
 	}
 
 	// ***************************************************************************
-
-	bool CGroupHTML::renderHtmlString(const std::string &html)
+	void CGroupHTML::cssDownloadFinished(const std::string &url, const std::string &local)
 	{
-		bool success;
+		// remove from queue
+		std::vector<std::string>::iterator it = std::find(_StylesheetQueue.begin(), _StylesheetQueue.end(), url);
+		if (it != _StylesheetQueue.end())
+		{
+			_StylesheetQueue.erase(it);
+		}
+
+		if (!CFile::fileExists(local))
+		{
+			return;
+		}
+
+		parseStylesheetFile(local);
+	}
+
+	void CGroupHTML::renderDocument()
+	{
+		if (!_StylesheetQueue.empty())
+		{
+			// waiting for stylesheets to finish downloading
+			return;
+		}
+
+		//TGameTime renderStart = CTime::getLocalTime();
 
-		//
 		_Browsing = true;
-		_DocumentUrl = _URL;
-		_NextRefreshTime = 0;
-		_RefreshUrl.clear();
+		_WaitingForStylesheet = false;
 
-		// clear content
-		beginBuild();
-
-		success = parseHtml(html);
+		// keeps track of currently rendered element
+		_CurrentHTMLElement = NULL;
+		std::list<CHtmlElement>::iterator it = _HtmlDOM.Children.begin();
+		while(it != _HtmlDOM.Children.end())
+		{
+			renderDOM(*it);
+			++it;
+		}
+		_CurrentHTMLElement = NULL;
 
 		// invalidate coords
 		endBuild();
@@ -5383,11 +5736,64 @@ namespace NLGUI
 			setTitle(_TitlePrefix);
 		}
 
-		return success;
+		//TGameTime renderStop = CTime::getLocalTime();
+		//nlwarning("[%s] render: %.1fms (%s)\n", _Id.c_str(), (renderStop - renderStart), _URL.c_str());
 	}
 
 	// ***************************************************************************
 
+	bool CGroupHTML::renderHtmlString(const std::string &html)
+	{
+		bool success;
+
+		// if we are already rendering, then queue up the next page
+		if (_CurrentHTMLElement)
+		{
+			_DocumentHtml = html;
+			_RenderNextTime = true;
+
+			return true;
+		}
+
+		//
+		_Browsing = true;
+		_DocumentUrl = _URL;
+		_DocumentHtml = html;
+		_NextRefreshTime = 0;
+		_RefreshUrl.clear();
+
+		// clear content
+		beginBuild();
+		resetCssStyle();
+
+		// start new rendering
+		_HtmlDOM = CHtmlElement(CHtmlElement::NONE, "<root>");
+
+		if (!trim(html).empty())
+		{
+			success = parseHtml(html);
+			if (success)
+			{
+				_WaitingForStylesheet = !_StylesheetQueue.empty();
+				renderDocument();
+			}
+			else
+			{
+				std::string error = "ERROR: HTML parse failed.";
+				error += toString("\nsize %d bytes", html.size());
+				error += toString("\n---start---\n%s\n---end---\n", html.c_str());
+				browseError(error.c_str());
+			}
+		}
+
+		endBuild();
+		updateRefreshButton();
+		_Browsing = false;
+
+		return success;
+	}
+
+	// ***************************************************************************
 	void CGroupHTML::doBrowseAnchor(const std::string &anchor)
 	{
 		if (_Anchors.count(anchor) == 0)
@@ -5832,8 +6238,11 @@ namespace NLGUI
 	}
 
 	// ***************************************************************************
+	// @deprecated
 	int CGroupHTML::luaBeginElement(CLuaState &ls)
 	{
+		nlwarning("Deprecated luaBeginElement on url '%s'", _URL.c_str());
+
 		const char *funcName = "beginElement";
 		CLuaIHM::checkArgCount(ls, funcName, 2);
 		CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
@@ -5877,7 +6286,7 @@ namespace NLGUI
 		// ingame lua scripts from browser are using <a href="#http://..."> url scheme
 		// reason unknown
 		_LuaHrefHack = true;
-		beginElement(element_number, present, value);
+		beginElementDeprecated(element_number, present, value);
 		_LuaHrefHack = false;
 
 		return 0;
@@ -5885,6 +6294,7 @@ namespace NLGUI
 
 
 	// ***************************************************************************
+	// @deprecated
 	int CGroupHTML::luaEndElement(CLuaState &ls)
 	{
 		const char *funcName = "endElement";
@@ -5892,7 +6302,7 @@ namespace NLGUI
 		CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
 
 		uint element_number = (uint)ls.toInteger(1);
-		endElement(element_number);
+		endElementDeprecated(element_number);
 
 		return 0;
 	}
@@ -5926,16 +6336,157 @@ namespace NLGUI
 		browse(url.c_str());
 	}
 
+	// ***************************************************************************
+	void CGroupHTML::parseStylesheetFile(const std::string &fname)
+	{
+		CIFile css;
+		if (css.open(fname))
+		{
+			uint32 remaining = css.getFileSize();
+			std::string content;
+			try {
+				while(!css.eof() && remaining > 0)
+				{
+					const uint BUF_SIZE = 4096;
+					char buf[BUF_SIZE];
+
+					uint32 readJustNow = std::min(remaining, BUF_SIZE);
+					css.serialBuffer((uint8 *)&buf, readJustNow);
+					content.append(buf, readJustNow);
+					remaining -= readJustNow;
+				}
+
+				_Style.parseStylesheet(content);
+			}
+			catch(const Exception &e)
+			{
+				nlwarning("exception while reading css file '%s'", e.what());
+			}
+		}
+		else
+		{
+			nlwarning("Stylesheet file '%s' not found (%s)", fname.c_str(), _URL.c_str());
+		}
+	}
+
 	// ***************************************************************************
 	bool CGroupHTML::parseHtml(const std::string &htmlString)
 	{
-		CHtmlParser html(this);
+		std::vector<std::string> links;
+		std::string styleString;
 
-		bool result = html.parseHtml(htmlString);
-		if (result)
-			_DocumentHtml = htmlString;
+		CHtmlElement *parsedDOM;
+		if (_CurrentHTMLElement == NULL)
+		{
+			// parse under <root> element (clean dom)
+			parsedDOM = &_HtmlDOM;
+		}
+		else
+		{
+			// parse under currently rendered <lua> element
+			parsedDOM = _CurrentHTMLElement;
+		}
 
-		return result;
+		CHtmlParser parser;
+		parser.getDOM(htmlString, *parsedDOM, styleString, links);
+
+		if (!styleString.empty())
+		{
+			_Style.parseStylesheet(styleString);
+		}
+		if (!links.empty())
+		{
+			addStylesheetDownload(links);
+		}
+
+		// this should rarely fail as first element should be <html>
+		bool success = parsedDOM->Children.size() > 0;
+
+		std::list<CHtmlElement>::iterator it = parsedDOM->Children.begin();
+		while(it != parsedDOM->Children.end())
+		{
+			if (it->Type == CHtmlElement::ELEMENT_NODE && it->Value == "html")
+			{
+				// more newly parsed childs from <body> into siblings
+				if (_CurrentHTMLElement) {
+					std::list<CHtmlElement>::iterator it2 = it->Children.begin();
+					while(it2 != it->Children.end())
+					{
+						if (it2->Type == CHtmlElement::ELEMENT_NODE && it2->Value == "body")
+						{
+							spliceFragment(it2);
+							break;
+						}
+						++it2;
+					}
+					// remove <html> fragment from current element child
+					it = parsedDOM->Children.erase(it);
+				}
+				else
+				{
+					// remove link to <root> (html->parent == '<root>') or css selector matching will break
+					it->parent = NULL;
+					++it;
+				}
+				continue;
+			}
+
+			// skip over other non-handled element
+			++it;
+		}
+
+		return success;
+	}
+
+	void CGroupHTML::spliceFragment(std::list<CHtmlElement>::iterator src)
+	{
+		if(!_CurrentHTMLElement->parent)
+		{
+			nlwarning("BUG: Current node is missing parent element. unable to splice fragment");
+			return;
+		}
+
+		// get the iterators for current element (<lua>) and next sibling
+		std::list<CHtmlElement>::iterator currentElement;
+		currentElement = std::find(_CurrentHTMLElement->parent->Children.begin(), _CurrentHTMLElement->parent->Children.end(), *_CurrentHTMLElement);
+		if (currentElement == _CurrentHTMLElement->parent->Children.end())
+		{
+			nlwarning("BUG: unable to find current element iterator from parent");
+			return;
+		}
+		
+		// where fragment should be moved
+		std::list<CHtmlElement>::iterator insertBefore;
+		if (_CurrentHTMLNextSibling == NULL)
+		{
+			insertBefore = _CurrentHTMLElement->parent->Children.end();
+		} else {
+			// get iterator for nextSibling
+			insertBefore = std::find(_CurrentHTMLElement->parent->Children.begin(), _CurrentHTMLElement->parent->Children.end(), *_CurrentHTMLNextSibling);
+		}
+
+		_CurrentHTMLElement->parent->Children.splice(insertBefore, src->Children);
+
+		// reindex moved elements
+		CHtmlElement *prev = NULL;
+		uint childIndex = _CurrentHTMLElement->childIndex;
+		while(currentElement != _CurrentHTMLElement->parent->Children.end())
+		{
+			if (currentElement->Type == CHtmlElement::ELEMENT_NODE)
+			{
+				if (prev != NULL)
+				{
+					currentElement->parent = _CurrentHTMLElement->parent;
+					currentElement->childIndex = childIndex;
+					currentElement->previousSibling = prev;
+					prev->nextSibling = &(*currentElement);
+				}
+
+				childIndex++;
+				prev = &(*currentElement);
+			}
+			++currentElement;
+		}
 	}
 
 	// ***************************************************************************
@@ -6039,11 +6590,38 @@ namespace NLGUI
 	// ***************************************************************************
 	void CGroupHTML::resetCssStyle()
 	{
+		_WaitingForStylesheet = false;
+		_StylesheetQueue.clear();
+
+		std::string css;
+
+		// TODO: browser css
+		css += "html { background-color: " + getRGBAString(BgColor) + "; color: " + getRGBAString(TextColor) + "; font-size: " + toString(TextFontSize) + "px;}";
+		css += "a { color: " + getRGBAString(LinkColor) + "; text-decoration: underline; -ryzom-modulate-color: "+toString(LinkColorGlobalColor)+";}";
+		css += "h1 { color: " + getRGBAString(H1Color) + "; font-size: "+ toString("%d", H1FontSize) + "px; -ryzom-modulate-color: "+toString(H1ColorGlobalColor)+";}";
+		css += "h2 { color: " + getRGBAString(H2Color) + "; font-size: "+ toString("%d", H2FontSize) + "px; -ryzom-modulate-color: "+toString(H2ColorGlobalColor)+";}";
+		css += "h3 { color: " + getRGBAString(H3Color) + "; font-size: "+ toString("%d", H3FontSize) + "px; -ryzom-modulate-color: "+toString(H3ColorGlobalColor)+";}";
+		css += "h4 { color: " + getRGBAString(H4Color) + "; font-size: "+ toString("%d", H4FontSize) + "px; -ryzom-modulate-color: "+toString(H4ColorGlobalColor)+";}";
+		css += "h5 { color: " + getRGBAString(H5Color) + "; font-size: "+ toString("%d", H5FontSize) + "px; -ryzom-modulate-color: "+toString(H5ColorGlobalColor)+";}";
+		css += "h6 { color: " + getRGBAString(H6Color) + "; font-size: "+ toString("%d", H6FontSize) + "px; -ryzom-modulate-color: "+toString(H6ColorGlobalColor)+";}";
+		css += "input[type=\"text\"] { color: " + getRGBAString(TextColor) + "; font-size: " + toString("%d", TextFontSize) + "px; font-weight: normal; text-shadow: 1px 1px #000;}";
+		css += "pre { font-family: monospace;}";
+		// th { text-align: center; } - overwrites align property
+		css += "th { font-weight: bold; }";
+		css += "textarea { color: " + getRGBAString(TextColor) + "; font-weight: normal; font-size: " + toString("%d", TextFontSize) + "px; text-shadow: 1px 1px #000;}";
+		css += "del { text-decoration: line-through;}";
+		css += "u { text-decoration: underline;}";
+		css += "em { font-style: italic; }";
+		css += "strong { font-weight: bold; }";
+		css += "small { font-size: smaller;}";
+		css += "dt { font-weight: bold; }";
+		css += "hr { color: rgb(120, 120, 120);}";
+		// td { padding: 1px;} - overwrites cellpadding attribute
+		// table { border-spacing: 2px;} - overwrites cellspacing attribute
+		css += "table { border-collapse: separate;}";
+
 		_Style.reset();
-		_Style.Root.TextColor = TextColor;
-		_Style.Root.FontSize = TextFontSize;
-		_Style.Root.BackgroundColor = BgColor;
-		_Style.Current = _Style.Root;
+		_Style.parseStylesheet(css);
 	}
 	
 	// ***************************************************************************
@@ -6147,5 +6725,1519 @@ namespace NLGUI
 		return ret;
 	}
 
+	void CGroupHTML::getCellsParameters(const CHtmlElement &elm, bool inherit)
+	{
+		CGroupHTML::CCellParams cellParams;
+		if (!_CellParams.empty() && inherit)
+		{
+			cellParams = _CellParams.back();
+		}
+
+		if (_Style.hasStyle("background-color"))
+			cellParams.BgColor = _Style.Current.BackgroundColor;
+		else if (elm.hasNonEmptyAttribute("bgcolor"))
+			scanHTMLColor(elm.getAttribute("bgcolor").c_str(), cellParams.BgColor);
+
+		if (elm.hasAttribute("nowrap") || _Style.Current.WhiteSpace == "nowrap")
+			cellParams.NoWrap = true;
+
+		if (elm.hasNonEmptyAttribute("l_margin"))
+			fromString(elm.getAttribute("l_margin"), cellParams.LeftMargin);
+
+		{
+			std::string align;
+			// having text-align on table/tr should not override td align attribute
+			if (_Style.hasStyle("text-align"))
+				align = _Style.Current.TextAlign;
+			else if (elm.hasNonEmptyAttribute("align"))
+				align = toLower(elm.getAttribute("align"));
+
+			if (align == "left")
+				cellParams.Align = CGroupCell::Left;
+			else if (align == "center")
+				cellParams.Align = CGroupCell::Center;
+			else if (align == "right")
+				cellParams.Align = CGroupCell::Right;
+		}
+
+		{
+			std::string valign;
+			if (_Style.hasStyle("vertical-align"))
+				valign = _Style.Current.VerticalAlign;
+			else if (elm.hasNonEmptyAttribute("valign"))
+				valign = toLower(elm.getAttribute("valign"));
+			
+			if (valign == "top")
+				cellParams.VAlign = CGroupCell::Top;
+			else if (valign == "middle")
+				cellParams.VAlign = CGroupCell::Middle;
+			else if (valign == "bottom")
+				cellParams.VAlign = CGroupCell::Bottom;
+		}
+		
+		_CellParams.push_back (cellParams);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlA(const CHtmlElement &elm)
+	{
+		_A.push_back(true);
+		_Link.push_back ("");
+		_LinkTitle.push_back("");
+		_LinkClass.push_back("");
+		if (elm.hasClass("ryzom-ui-button"))
+			_LinkClass.back() = "ryzom-ui-button";
+
+		// #fragment works with both ID and NAME so register both
+		if (elm.hasNonEmptyAttribute("name"))
+			_AnchorName.push_back(elm.getAttribute("name"));
+		if (elm.hasNonEmptyAttribute("title"))
+			_LinkTitle.back() = elm.getAttribute("title");
+		if (elm.hasNonEmptyAttribute("href"))
+		{
+			string suri = elm.getAttribute("href");
+			if(suri.find("ah:") == 0)
+			{
+				if (_TrustedDomain)
+					_Link.back() = suri;
+			}
+			else if (_TrustedDomain && suri[0] == '#' && _LuaHrefHack)
+			{
+				// Direct url (hack for lua beginElement)
+				_Link.back() = suri.substr(1);
+			}
+			else
+			{
+				// convert href from "?key=val" into "http://domain.com/?key=val"
+				_Link.back() = getAbsoluteUrl(suri);
+			}
+		}
+
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlAend(const CHtmlElement &elm)
+	{
+		renderPseudoElement(":after", elm);
+
+		popIfNotEmpty(_A);
+		popIfNotEmpty(_Link);
+		popIfNotEmpty(_LinkTitle);
+		popIfNotEmpty(_LinkClass);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlBASE(const CHtmlElement &elm)
+	{
+		if (!_ReadingHeadTag || _IgnoreBaseUrlTag)
+			return;
+
+		if (elm.hasNonEmptyAttribute("href"))
+		{
+			CUrlParser uri(elm.getAttribute("href"));
+			if (uri.isAbsolute())
+			{
+				_URL = uri.toString();
+				_IgnoreBaseUrlTag = true;
+			}
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlBODY(const CHtmlElement &elm)
+	{
+		// override <body> (or <html>) css style attribute
+		if (elm.hasNonEmptyAttribute("bgcolor"))
+		{
+			_Style.applyStyle("background-color: " + elm.getAttribute("bgcolor"));
+		}
+
+		if (_Style.hasStyle("background-color"))
+		{
+			CRGBA bgColor = _Style.Current.BackgroundColor;
+			scanHTMLColor(elm.getAttribute("bgcolor").c_str(), bgColor);
+			setBackgroundColor(bgColor);
+		}
+
+		if (elm.hasNonEmptyAttribute("style"))
+		{
+			string style = elm.getAttribute("style");
+
+			TStyle styles = parseStyle(style);
+			TStyle::iterator	it;
+
+			it = styles.find("background-repeat");
+			bool repeat = (it != styles.end() && it->second == "1");
+
+			// Webig only
+			it = styles.find("background-scale");
+			bool scale = (it != styles.end() && it->second == "1");
+
+			it = styles.find("background-image");
+			if (it != styles.end())
+			{
+				string image = it->second;
+				string::size_type texExt = toLower(image).find("url(");
+				// Url image
+				if (texExt != string::npos)
+					// Remove url()
+					image = image.substr(4, image.size()-5);
+				setBackground (image, scale, repeat);
+			}
+		}
+
+		renderPseudoElement(":before", elm);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlBR(const CHtmlElement &elm)
+	{
+		endParagraph();
+
+		// insert zero-width-space (0x200B) to prevent removal of empty lines
+		ucstring tmp;
+		tmp.fromUtf8("\xe2\x80\x8b");
+		addString(tmp);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlDD(const CHtmlElement &elm)
+	{
+		if (_DL.empty())
+			return;
+
+		// if there was no closing tag for <dt>, then remove <dt> style
+		if (_DL.back().DT)
+		{
+			nlwarning("BUG: nested DT in DD");
+			_DL.back().DT = false;
+		}
+
+		if (_DL.back().DD)
+		{
+			nlwarning("BUG: nested DD in DD");
+			_DL.back().DD = false;
+			popIfNotEmpty(_Indent);
+		}
+
+		_DL.back().DD = true;
+		_Indent.push_back(getIndent() + ULIndent);
+
+		if (!_LI)
+		{
+			_LI = true;
+			newParagraph(ULBeginSpace);
+		}
+		else
+		{
+			newParagraph(LIBeginSpace);
+		}
+
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlDDend(const CHtmlElement &elm)
+	{
+		if (_DL.empty())
+			return;
+
+		renderPseudoElement(":after", elm);
+
+		// parser will process two DD in a row as nested when first DD is not closed
+		if (_DL.back().DD)
+		{
+			_DL.back().DD = false;
+			popIfNotEmpty(_Indent);
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlDIV(const CHtmlElement &elm)
+	{
+		_BlockLevelElement.push_back(true);
+
+		_DivName = elm.getAttribute("name");
+
+		string instClass = elm.getAttribute("class");
+
+		// use generic template system
+		if (_TrustedDomain && !instClass.empty() && instClass == "ryzom-ui-grouptemplate")
+		{
+			string style = elm.getAttribute("style");
+			string id = elm.getAttribute("id");
+
+			typedef pair<string, string> TTmplParam;
+			vector<TTmplParam> tmplParams;
+
+			string templateName;
+			if (!style.empty())
+			{
+				TStyle styles = parseStyle(style);
+				TStyle::iterator	it;
+				for (it=styles.begin(); it != styles.end(); it++)
+				{
+					if ((*it).first == "template")
+						templateName = (*it).second;
+					else if ((*it).first == "display" && (*it).second == "inline-block")
+						_BlockLevelElement.back() = false;
+					else
+						tmplParams.push_back(TTmplParam((*it).first, (*it).second));
+				}
+			}
+
+			if (!templateName.empty())
+			{
+				string parentId;
+				bool haveParentDiv = getDiv() != NULL;
+				if (haveParentDiv)
+					parentId = getDiv()->getId();
+				else
+				{
+					if (!_Paragraph)
+						newParagraph (0);
+
+					parentId = _Paragraph->getId();
+				}
+
+				CInterfaceGroup *inst = CWidgetManager::getInstance()->getParser()->createGroupInstance(templateName, this->_Id+":"+id, tmplParams);
+				if (inst)
+				{
+					inst->setId(this->_Id+":"+id);
+					inst->updateCoords();
+					if (haveParentDiv)
+					{
+							inst->setParent(getDiv());
+							inst->setParentSize(getDiv());
+							inst->setParentPos(getDiv());
+							inst->setPosRef(Hotspot_TL);
+							inst->setParentPosRef(Hotspot_TL);
+							getDiv()->addGroup(inst);
+
+							_BlockLevelElement.back() = false;
+					}
+					else
+					{
+						getParagraph()->addChild(inst);
+						paragraphChange();
+					}
+					_Divs.push_back(inst);
+				}
+			}
+		}
+
+		if (isBlockLevelElement())
+		{
+			newParagraph(0);
+		}
+
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlDIVend(const CHtmlElement &elm)
+	{
+		renderPseudoElement(":after", elm);
+
+		if (isBlockLevelElement())
+		{
+			endParagraph();
+		}
+		_DivName.clear();
+		popIfNotEmpty(_Divs);
+		popIfNotEmpty(_BlockLevelElement);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlDL(const CHtmlElement &elm)
+	{
+		_DL.push_back(HTMLDListElement());
+		_LI = _DL.size() > 1 || !_UL.empty();
+		endParagraph();
+
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlDLend(const CHtmlElement &elm)
+	{
+		if (_DL.empty())
+			return;
+
+		renderPseudoElement(":after", elm);
+
+		endParagraph();
+
+		// unclosed DT
+		if (_DL.back().DT)
+		{
+			nlwarning("BUG: unclosed DT in DL");
+		}
+
+		// unclosed DD
+		if (_DL.back().DD)
+		{
+			popIfNotEmpty(_Indent);
+			nlwarning("BUG: unclosed DD in DL");
+		}
+
+		popIfNotEmpty (_DL);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlDT(const CHtmlElement &elm)
+	{
+		if (_DL.empty())
+			return;
+
+		// TODO: check if nested tags still happen and fix it in parser
+		//     : remove special handling for nesting and let it happen
+
+		// html parser and libxml2 should prevent nested tags like these
+		if (_DL.back().DD)
+		{
+			nlwarning("BUG: nested DD in DT");
+
+			_DL.back().DD = false;
+			popIfNotEmpty(_Indent);
+		}
+
+		// html parser and libxml2 should prevent nested tags like these
+		if (_DL.back().DT)
+		{
+			nlwarning("BUG: nested DT in DT");
+		}
+
+		_DL.back().DT = true;
+
+		if (!_LI)
+		{
+			_LI = true;
+			newParagraph(ULBeginSpace);
+		}
+		else
+		{
+			newParagraph(LIBeginSpace);
+		}
+		
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlDTend(const CHtmlElement &elm)
+	{
+		if (_DL.empty())
+			return;
+
+		renderPseudoElement(":after", elm);
+
+		_DL.back().DT = false;
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlFONT(const CHtmlElement &elm)
+	{
+		if (elm.hasNonEmptyAttribute("color"))
+		{
+			CRGBA color;
+			if (scanHTMLColor(elm.getAttribute("color").c_str(), color))
+				_Style.Current.TextColor = color;
+		}
+
+		if (elm.hasNonEmptyAttribute("size"))
+		{
+			uint fontsize;
+			fromString(elm.getAttribute("size"), fontsize);
+			_Style.Current.FontSize = fontsize;
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlFORM(const CHtmlElement &elm)
+	{
+		// Build the form
+		CGroupHTML::CForm form;
+
+		// Get the action name
+		if (elm.hasNonEmptyAttribute("action"))
+		{
+			form.Action = getAbsoluteUrl(elm.getAttribute("action"));
+		}
+		else
+		{
+			form.Action = _URL;
+		}
+
+		_Forms.push_back(form);
+
+		renderPseudoElement(":before", elm);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlH(const CHtmlElement &elm)
+	{
+		newParagraph(PBeginSpace);
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlHend(const CHtmlElement &elm)
+	{
+		renderPseudoElement(":after", elm);
+		endParagraph();
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlHEAD(const CHtmlElement &elm)
+	{
+		_ReadingHeadTag = !_IgnoreHeadTag;
+		_IgnoreHeadTag = true;
+	}
+
+	void CGroupHTML::htmlHEADend(const CHtmlElement &elm)
+	{
+		_ReadingHeadTag = false;
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlHR(const CHtmlElement &elm)
+	{
+		newParagraph(0);
+
+		CInterfaceGroup *sep = CWidgetManager::getInstance()->getParser()->createGroupInstance("html_hr", "", NULL, 0);
+		if (sep)
+		{
+			CViewBitmap *bitmap = dynamic_cast<CViewBitmap*>(sep->getView("hr"));
+			if (bitmap)
+			{
+				bitmap->setColor(_Style.Current.TextColor);
+				if (_Style.Current.Width > 0)
+				{
+					clamp(_Style.Current.Width, 1, 32000);
+					bitmap->setW(_Style.Current.Width);
+					bitmap->setSizeRef(CInterfaceElement::none);
+				}
+				if (_Style.Current.Height > 0)
+				{
+					clamp(_Style.Current.Height, 1, 1000);
+					bitmap->setH(_Style.Current.Height);
+				}
+			}
+
+			renderPseudoElement(":before", elm);
+			getParagraph()->addChild(sep);
+			renderPseudoElement(":after", elm);
+
+			endParagraph();
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlHTML(const CHtmlElement &elm)
+	{
+		if (elm.hasNonEmptyAttribute("style"))
+		{
+			_Style.Root = _Style.Current;
+			_Style.applyRootStyle(elm.getAttribute("style"));
+			_Style.Current = _Style.Root;
+		}
+		setBackgroundColor(_Style.Current.BackgroundColor);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlI(const CHtmlElement &elm)
+	{
+		_Localize = true;
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlIend(const CHtmlElement &elm)
+	{
+		renderPseudoElement(":after", elm);
+		_Localize = false;
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlIMG(const CHtmlElement &elm)
+	{
+		// Get the string name
+		if (elm.hasNonEmptyAttribute("src"))
+		{
+			float tmpf;
+			std::string id = elm.getAttribute("id");
+			std::string src = elm.getAttribute("src");
+
+			if (elm.hasNonEmptyAttribute("width"))
+				getPercentage(_Style.Current.Width, tmpf, elm.getAttribute("width").c_str());
+			if (elm.hasNonEmptyAttribute("height"))
+				getPercentage(_Style.Current.Height, tmpf, elm.getAttribute("height").c_str());
+
+			// Get the global color name
+			if (elm.hasAttribute("global_color"))
+				_Style.Current.GlobalColor = true;
+
+			// Tooltip
+			// keep "alt" attribute for backward compatibility
+			std::string strtooltip = elm.getAttribute("alt");
+			// tooltip
+			if (elm.hasNonEmptyAttribute("title"))
+				strtooltip = elm.getAttribute("title");
+
+			const char *tooltip = NULL;
+			// note: uses pointer to string data
+			if (!strtooltip.empty())
+				tooltip = strtooltip.c_str();
+
+			// Mouse over image
+			string overSrc = elm.getAttribute("data-over-src");
+
+			if (getA() && getParent () && getParent ()->getParent())
+			{
+				string params = "name=" + getId() + "|url=" + getLink ();
+				addButton(CCtrlButton::PushButton, id, src, src, overSrc, "browse", params.c_str(), tooltip, _Style.Current);
+			}
+			else
+			if (tooltip || !overSrc.empty())
+			{
+				addButton(CCtrlButton::PushButton, id, src, src, overSrc, "", "", tooltip, _Style.Current);
+			}
+			else
+			{
+				// Get the option to reload (class==reload)
+				bool reloadImg = false;
+
+				if (elm.hasNonEmptyAttribute("style"))
+				{
+					string styleString = elm.getAttribute("style");
+					TStyle styles = parseStyle(styleString);
+					TStyle::iterator	it;
+
+					it = styles.find("reload");
+					if (it != styles.end() && (*it).second == "1")
+						reloadImg = true;
+				}
+
+				addImage(id, elm.getAttribute("src"), reloadImg, _Style.Current);
+			}
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlINPUT(const CHtmlElement &elm)
+	{
+		if (_Forms.empty())
+			return;
+
+		// read general property
+		string id = elm.getAttribute("id");
+
+		// Widget template name (old)
+		string templateName = elm.getAttribute("z_btn_tmpl");
+		// Input name is the new
+		if (elm.hasNonEmptyAttribute("z_input_tmpl"))
+			templateName = elm.getAttribute("z_input_tmpl");
+
+		// Widget minimal width
+		string minWidth = elm.getAttribute("z_input_width");
+
+		// Get the type
+		if (elm.hasNonEmptyAttribute("type"))
+		{
+			// Global color flag
+			if (elm.hasAttribute("global_color"))
+				_Style.Current.GlobalColor = true;
+
+			// Tooltip
+			std::string strtooltip = elm.getAttribute("alt");
+			const char *tooltip = NULL;
+			// note: uses pointer to strtooltip data
+			if (!strtooltip.empty())
+				tooltip = strtooltip.c_str();
+
+			string type = toLower(elm.getAttribute("type"));
+			if (type == "image")
+			{
+				// The submit button
+				string name = elm.getAttribute("name");
+				string normal = elm.getAttribute("src");
+				string pushed;
+				string over;
+
+				// Action handler parameters : "name=group_html_id|form=id_of_the_form|submit_button=button_name"
+				string param = "name=" + getId() + "|form=" + toString (_Forms.size()-1) + "|submit_button=" + name + "|submit_button_type=image";
+
+				// Add the ctrl button
+				addButton (CCtrlButton::PushButton, name, normal, pushed.empty()?normal:pushed, over,
+					"html_submit_form", param.c_str(), tooltip, _Style.Current);
+			}
+			else if (type == "button" || type == "submit")
+			{
+				// The submit button
+				string name = elm.getAttribute("name");
+				string normal = elm.getAttribute("src");
+				string text = elm.getAttribute("value");
+				string pushed;
+				string over;
+
+				string buttonTemplate(!templateName.empty() ? templateName : DefaultButtonGroup );
+
+				// Action handler parameters : "name=group_html_id|form=id_of_the_form|submit_button=button_name"
+				string param = "name=" + getId() + "|form=" + toString (_Forms.size()-1) + "|submit_button=" + name + "|submit_button_type=submit";
+				if (!text.empty())
+				{
+					// escape AH param separator
+					string tmp = text;
+					while(NLMISC::strFindReplace(tmp, "|", "&#124;"))
+						;
+					param = param + "|submit_button_value=" + tmp;
+				}
+
+				// Add the ctrl button
+				if (!_Paragraph)
+				{
+					newParagraph (0);
+					paragraphChange ();
+				}
+
+				typedef pair<string, string> TTmplParam;
+				vector<TTmplParam> tmplParams;
+				tmplParams.push_back(TTmplParam("id", name));
+				tmplParams.push_back(TTmplParam("onclick", "html_submit_form"));
+				tmplParams.push_back(TTmplParam("onclick_param", param));
+				//tmplParams.push_back(TTmplParam("text", text));
+				tmplParams.push_back(TTmplParam("active", "true"));
+				if (!minWidth.empty())
+					tmplParams.push_back(TTmplParam("wmin", minWidth));
+				CInterfaceGroup *buttonGroup = CWidgetManager::getInstance()->getParser()->createGroupInstance(buttonTemplate, _Paragraph->getId(), tmplParams);
+				if (buttonGroup)
+				{
+
+					// Add the ctrl button
+					CCtrlTextButton *ctrlButton = dynamic_cast<CCtrlTextButton*>(buttonGroup->getCtrl("button"));
+					if (!ctrlButton) ctrlButton = dynamic_cast<CCtrlTextButton*>(buttonGroup->getCtrl("b"));
+					if (ctrlButton)
+					{
+						ctrlButton->setModulateGlobalColorAll (_Style.Current.GlobalColor);
+
+						// Translate the tooltip
+						if (tooltip)
+						{
+							if (CI18N::hasTranslation(tooltip))
+							{
+								ctrlButton->setDefaultContextHelp(CI18N::get(tooltip));
+							}
+							else
+							{
+								ctrlButton->setDefaultContextHelp(ucstring(tooltip));
+							}
+						}
+
+						ctrlButton->setText(ucstring::makeFromUtf8(text));
+
+						setTextButtonStyle(ctrlButton, _Style.Current);
+					}
+					getParagraph()->addChild (buttonGroup);
+					paragraphChange ();
+				}
+			}
+			else if (type == "text")
+			{
+				// Get the string name
+				string name = elm.getAttribute("name");
+				ucstring ucValue;
+				ucValue.fromUtf8(elm.getAttribute("value"));
+
+				uint size = 120;
+				uint maxlength = 1024;
+				if (elm.hasNonEmptyAttribute("size"))
+					fromString(elm.getAttribute("size"), size);
+				if (elm.hasNonEmptyAttribute("maxlength"))
+					fromString(elm.getAttribute("maxlength"), maxlength);
+
+				string textTemplate(!templateName.empty() ? templateName : DefaultFormTextGroup);
+				// Add the editbox
+				CInterfaceGroup *textArea = addTextArea (textTemplate, name.c_str (), 1, size/12, false, ucValue, maxlength);
+				if (textArea)
+				{
+					// Add the text area to the form
+					CGroupHTML::CForm::CEntry entry;
+					entry.Name = name;
+					entry.TextArea = textArea;
+					_Forms.back().Entries.push_back (entry);
+				}
+			}
+			else if (type == "checkbox" || type == "radio")
+			{
+				renderPseudoElement(":before", elm);
+
+				CCtrlButton::EType btnType;
+				string name = elm.getAttribute("name");
+				string normal = elm.getAttribute("src");
+				string pushed;
+				string over;
+				ucstring ucValue = ucstring("on");
+				bool checked = elm.hasAttribute("checked");
+
+				// TODO: unknown if empty attribute should override or not
+				if (elm.hasNonEmptyAttribute("value"))
+					ucValue.fromUtf8(elm.getAttribute("value"));
+
+				if (type == "radio")
+				{
+					btnType = CCtrlButton::RadioButton;
+					normal = DefaultRadioButtonBitmapNormal;
+					pushed = DefaultRadioButtonBitmapPushed;
+					over = DefaultRadioButtonBitmapOver;
+				}
+				else
+				{
+					btnType = CCtrlButton::ToggleButton;
+					normal = DefaultCheckBoxBitmapNormal;
+					pushed = DefaultCheckBoxBitmapPushed;
+					over = DefaultCheckBoxBitmapOver;
+				}
+
+				// Add the ctrl button
+				CCtrlButton *checkbox = addButton (btnType, name, normal, pushed, over, "", "", tooltip, _Style.Current);
+				if (checkbox)
+				{
+					if (btnType == CCtrlButton::RadioButton)
+					{
+						// override with 'id' because radio buttons share same name
+						if (!id.empty())
+							checkbox->setId(id);
+
+						// group together buttons with same name
+						CForm &form = _Forms.back();
+						bool notfound = true;
+						for (uint i=0; i<form.Entries.size(); i++)
+						{
+							if (form.Entries[i].Name == name && form.Entries[i].Checkbox->getType() == CCtrlButton::RadioButton)
+							{
+								checkbox->initRBRefFromRadioButton(form.Entries[i].Checkbox);
+								notfound = false;
+								break;
+							}
+						}
+						if (notfound)
+						{
+							// this will start a new group (initRBRef() would take first button in group container otherwise)
+							checkbox->initRBRefFromRadioButton(checkbox);
+						}
+					}
+
+					checkbox->setPushed (checked);
+
+					// Add the button to the form
+					CGroupHTML::CForm::CEntry entry;
+					entry.Name = name;
+					entry.Value = decodeHTMLEntities(ucValue);
+					entry.Checkbox = checkbox;
+					_Forms.back().Entries.push_back (entry);
+				}
+				renderPseudoElement(":after", elm);
+			}
+			else if (type == "hidden")
+			{
+				if (elm.hasNonEmptyAttribute("name"))
+				{
+					// Get the name
+					string name = elm.getAttribute("name");
+
+					// Get the value
+					ucstring ucValue;
+					ucValue.fromUtf8(elm.getAttribute("value"));
+
+					// Add an entry
+					CGroupHTML::CForm::CEntry entry;
+					entry.Name = name;
+					entry.Value = decodeHTMLEntities(ucValue);
+					_Forms.back().Entries.push_back (entry);
+				}
+			}
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlLI(const CHtmlElement &elm)
+	{
+		if (_UL.empty())
+			return;
+
+		// UL, OL top margin if this is the first LI
+		if (!_LI)
+		{
+			_LI = true;
+			newParagraph(ULBeginSpace);
+		}
+		else
+		{
+			newParagraph(LIBeginSpace);
+		}
+
+		// OL list index can be overridden by <li value="1"> attribute
+		if (elm.hasNonEmptyAttribute("value"))
+			fromString(elm.getAttribute("value"), _UL.back().Value);
+
+		ucstring str;
+		str.fromUtf8(_UL.back().getListMarkerText());
+		addString (str);
+
+		// list-style-type: outside
+		if (_CurrentViewLink)
+		{
+			getParagraph()->setFirstViewIndent(-_CurrentViewLink->getMaxUsedW());
+		}
+
+		flushString ();
+
+		// after marker
+		renderPseudoElement(":before", elm);
+
+		_UL.back().Value++;
+	}
+
+	void CGroupHTML::htmlLIend(const CHtmlElement &elm)
+	{
+		renderPseudoElement(":after", elm);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlLUA(const CHtmlElement &elm)
+	{
+		// we receive an embeded lua script
+		_ParsingLua = _TrustedDomain; // Only parse lua if TrustedDomain
+		_LuaScript.clear();
+	}
+	
+	void CGroupHTML::htmlLUAend(const CHtmlElement &elm)
+	{
+		if (_ParsingLua && _TrustedDomain)
+		{
+			_ParsingLua = false;
+			// execute the embeded lua script
+			_LuaScript = "\nlocal __CURRENT_WINDOW__=\""+this->_Id+"\" \n"+_LuaScript;
+			CLuaManager::getInstance().executeLuaScript(_LuaScript, true);
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlMETA(const CHtmlElement &elm)
+	{
+		if (!_ReadingHeadTag)
+			return;
+
+		std::string httpEquiv = elm.getAttribute("http-equiv");
+		std::string httpContent = elm.getAttribute("content");
+		if (!httpEquiv.empty() && !httpContent.empty())
+		{
+			// only first http-equiv="refresh" should be handled
+			if (_RefreshUrl.empty() && httpEquiv == "refresh")
+			{
+				const CWidgetManager::SInterfaceTimes &times = CWidgetManager::getInstance()->getInterfaceTimes();
+				double timeSec = times.thisFrameMs / 1000.0f;
+
+				string::size_type pos = httpContent.find_first_of(";");
+				if (pos == string::npos)
+				{
+					fromString(httpContent, _NextRefreshTime);
+					_RefreshUrl = _URL;
+				}
+				else
+				{
+					fromString(httpContent.substr(0, pos), _NextRefreshTime);
+
+					pos = toLower(httpContent).find("url=");
+					if (pos != string::npos)
+						_RefreshUrl = getAbsoluteUrl(httpContent.substr(pos + 4));
+				}
+
+				_NextRefreshTime += timeSec;
+			}
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlOBJECT(const CHtmlElement &elm)
+	{
+		_ObjectType = elm.getAttribute("type");
+		_ObjectData = elm.getAttribute("data");
+		_ObjectMD5Sum = elm.getAttribute("id");
+		_ObjectAction = elm.getAttribute("standby");
+		_Object = true;
+	}
+
+	void CGroupHTML::htmlOBJECTend(const CHtmlElement &elm)
+	{
+		if (!_TrustedDomain)
+			return;
+
+		if (_ObjectType=="application/ryzom-data")
+		{
+			if (!_ObjectData.empty())
+			{
+				if (addBnpDownload(_ObjectData, _ObjectAction, _ObjectScript, _ObjectMD5Sum))
+				{
+					CLuaManager::getInstance().executeLuaScript("\nlocal __ALLREADYDL__=true\n"+_ObjectScript, true);
+				}
+				_ObjectScript.clear();
+			}
+		}
+		_Object = false;
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlOL(const CHtmlElement &elm)
+	{
+		sint32 start = 1;
+		std::string type("1");
+
+		if (elm.hasNonEmptyAttribute("start"))
+			fromString(elm.getAttribute("start"), start);
+		if (elm.hasNonEmptyAttribute("type"))
+			type = elm.getAttribute("type");
+
+		_UL.push_back(HTMLOListElement(start, type));
+		// if LI is already present
+		_LI = _UL.size() > 1 || _DL.size() > 1;
+		_Indent.push_back(getIndent() + ULIndent);
+		endParagraph();
+
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlOLend(const CHtmlElement &elm)
+	{
+		htmlULend(elm);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlOPTION(const CHtmlElement &elm)
+	{
+		_SelectOption = true;
+		_SelectOptionStr.clear();
+
+		// Got one form ?
+		if (_Forms.empty() || _Forms.back().Entries.empty())
+			return;
+
+		_Forms.back().Entries.back().SelectValues.push_back(elm.getAttribute("value"));
+
+		if (elm.hasAttribute("selected"))
+			_Forms.back().Entries.back().InitialSelection = (sint)_Forms.back().Entries.back().SelectValues.size() - 1;
+
+		if (elm.hasAttribute("disabled"))
+			_Forms.back().Entries.back().sbOptionDisabled = (sint)_Forms.back().Entries.back().SelectValues.size() - 1;
+	}
+
+	void CGroupHTML::htmlOPTIONend(const CHtmlElement &elm)
+	{
+		if (_Forms.empty() || _Forms.back().Entries.empty())
+			return;
+
+		// insert the parsed text into the select control
+		CDBGroupComboBox *cb = _Forms.back().Entries.back().ComboBox;
+		if (cb)
+		{
+			uint lineIndex = cb->getNumTexts();
+			cb->addText(_SelectOptionStr);
+			if (_Forms.back().Entries.back().sbOptionDisabled == lineIndex)
+			{
+				cb->setGrayed(lineIndex, true);
+			}
+		}
+		else
+		{
+			CGroupMenu *sb = _Forms.back().Entries.back().SelectBox;
+			if (sb)
+			{
+				uint lineIndex = sb->getNumLine();
+				sb->addLine(_SelectOptionStr, "", "");
+
+				if (_Forms.back().Entries.back().sbOptionDisabled == lineIndex)
+				{
+					sb->setGrayedLine(lineIndex, true);
+				}
+				else
+				{
+					// create option line checkbox, CGroupMenu is taking ownership of the checbox
+					CInterfaceGroup *ig = CWidgetManager::getInstance()->getParser()->createGroupInstance("menu_checkbox", "", NULL, 0);
+					if (ig)
+					{
+						CCtrlButton *cb = dynamic_cast<CCtrlButton *>(ig->getCtrl("b"));
+						if (cb)
+						{
+							if (_Forms.back().Entries.back().sbMultiple)
+							{
+								cb->setType(CCtrlButton::ToggleButton);
+								cb->setTexture(DefaultCheckBoxBitmapNormal);
+								cb->setTexturePushed(DefaultCheckBoxBitmapPushed);
+								cb->setTextureOver(DefaultCheckBoxBitmapOver);
+							}
+							else
+							{
+								cb->setType(CCtrlButton::RadioButton);
+								cb->setTexture(DefaultRadioButtonBitmapNormal);
+								cb->setTexturePushed(DefaultRadioButtonBitmapPushed);
+								cb->setTextureOver(DefaultRadioButtonBitmapOver);
+
+								if (_Forms.back().Entries.back().sbRBRef == NULL)
+									_Forms.back().Entries.back().sbRBRef = cb;
+
+								cb->initRBRefFromRadioButton(_Forms.back().Entries.back().sbRBRef);
+							}
+
+							cb->setPushed(_Forms.back().Entries.back().InitialSelection == lineIndex);
+							sb->setUserGroupLeft(lineIndex, ig);
+						}
+						else
+						{
+							nlwarning("Failed to get 'b' element from 'menu_checkbox' template");
+							delete ig;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlP(const CHtmlElement &elm)
+	{
+		newParagraph(PBeginSpace);
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlPend(const CHtmlElement &elm)
+	{
+		renderPseudoElement(":after", elm);
+		endParagraph();
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlPRE(const CHtmlElement &elm)
+	{
+		_PRE.push_back(true);
+		newParagraph(0);
+
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlPREend(const CHtmlElement &elm)
+	{
+		renderPseudoElement(":after", elm);
+
+		endParagraph();
+		popIfNotEmpty(_PRE);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlSCRIPT(const CHtmlElement &elm)
+	{
+		_IgnoreText = true;
+	}
+
+	void CGroupHTML::htmlSCRIPTend(const CHtmlElement &elm)
+	{
+		_IgnoreText = false;
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlSELECT(const CHtmlElement &elm)
+	{
+		if (_Forms.empty())
+			return;
+
+		// A select box
+		string name = elm.getAttribute("name");
+		bool multiple = elm.hasAttribute("multiple");
+		sint32 size = 0;
+
+		if (elm.hasNonEmptyAttribute("size"))
+			fromString(elm.getAttribute("size"), size);
+
+		CGroupHTML::CForm::CEntry entry;
+		entry.Name = name;
+		entry.sbMultiple = multiple;
+		if (size > 1 || multiple)
+		{
+			entry.InitialSelection = -1;
+			CGroupMenu *sb = addSelectBox(DefaultFormSelectBoxMenuGroup, name.c_str());
+			if (sb)
+			{
+				if (size < 1)
+					size = 4;
+
+				if (_Style.Current.Width > -1)
+					sb->setMinW(_Style.Current.Width);
+
+				if (_Style.Current.Height > -1)
+					sb->setMinH(_Style.Current.Height);
+
+				sb->setMaxVisibleLine(size);
+				sb->setFontSize(_Style.Current.FontSize);
+			}
+
+			entry.SelectBox = sb;
+		}
+		else
+		{
+			CDBGroupComboBox *cb = addComboBox(DefaultFormSelectGroup, name.c_str());
+			entry.ComboBox = cb;
+
+			if (cb)
+			{
+				// create view text
+				cb->updateCoords();
+				setTextStyle(cb->getViewText(), _Style.Current);
+			}
+		}
+		_Forms.back().Entries.push_back (entry);
+	}
+
+	void CGroupHTML::htmlSELECTend(const CHtmlElement &elm)
+	{
+		_SelectOption = false;
+		if (_Forms.empty() || _Forms.back().Entries.empty())
+			return;
+
+		CDBGroupComboBox *cb = _Forms.back().Entries.back().ComboBox;
+		if (cb)
+		{
+			cb->setSelectionNoTrigger(_Forms.back().Entries.back().InitialSelection);
+			// TODO: magic padding
+			cb->setW(cb->evalContentWidth() + 16);
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlSTYLE(const CHtmlElement &elm)
+	{
+		_IgnoreText = true;
+	}
+
+	void CGroupHTML::htmlSTYLEend(const CHtmlElement &elm)
+	{
+		_IgnoreText = false;
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlTABLE(const CHtmlElement &elm)
+	{
+		// Get cells parameters
+		getCellsParameters(elm, false);
+
+		CGroupTable *table = new CGroupTable(TCtorParam());
+		table->BgColor = _CellParams.back().BgColor;
+
+		// TODO: border-spacing: 2em;
+		{
+			if (elm.hasNonEmptyAttribute("cellspacing"))
+				fromString(elm.getAttribute("cellspacing"), table->CellSpacing);
+			
+			// TODO: cssLength, horiz/vert values
+			if (_Style.hasStyle("border-spacing"))
+				fromString(_Style.getStyle("border-spacing"), table->CellSpacing);
+
+			// overrides border-spacing if set to 'collapse'
+			if (_Style.checkStyle("border-collapse", "collapse"))
+				table->CellSpacing = 0;
+		}
+
+		if (elm.hasNonEmptyAttribute("cellpadding"))
+			fromString(elm.getAttribute("cellpadding"), table->CellPadding);
+
+		if (_Style.hasStyle("width"))
+			getPercentage(table->ForceWidthMin, table->TableRatio, _Style.getStyle("width").c_str());
+		else if (elm.hasNonEmptyAttribute("width"))
+			getPercentage (table->ForceWidthMin, table->TableRatio, elm.getAttribute("width").c_str());
+
+		if (_Style.hasStyle("border") || _Style.hasStyle("border-width"))
+		{
+			table->Border = _Style.Current.BorderWidth;
+		}
+		else if (elm.hasAttribute("border"))
+		{
+			std::string s = elm.getAttribute("border");
+			if (s.empty())
+				table->Border = 1;
+			else
+				fromString(elm.getAttribute("border"), table->Border);
+		}
+
+		if (_Style.hasStyle("border-color"))
+		{
+			std::string s = toLower(_Style.getStyle("border-color"));
+			if (s == "currentcolor")
+				table->BorderColor = _Style.Current.TextColor;
+			else
+				scanHTMLColor(s.c_str(), table->BorderColor);
+		}
+		else if (elm.hasNonEmptyAttribute("bordercolor"))
+		{
+			scanHTMLColor(elm.getAttribute("bordercolor").c_str(), table->BorderColor);
+		}
+
+		table->setMarginLeft(getIndent());
+		addHtmlGroup (table, 0);
+
+		renderPseudoElement(":before", elm);
+
+		_Tables.push_back(table);
+
+		// Add a cell pointer
+		_Cells.push_back(NULL);
+		_TR.push_back(false);
+		_Indent.push_back(0);
+	}
+
+	void CGroupHTML::htmlTABLEend(const CHtmlElement &elm)
+	{
+		popIfNotEmpty(_CellParams);
+		popIfNotEmpty(_TR);
+		popIfNotEmpty(_Cells);
+		popIfNotEmpty(_Tables);
+		popIfNotEmpty(_Indent);
+
+		renderPseudoElement(":after", elm);
+		endParagraph();
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlTD(const CHtmlElement &elm)
+	{
+		// Get cells parameters
+		getCellsParameters(elm, true);
+
+		if (elm.ID == HTML_TH)
+		{
+			if (!_Style.hasStyle("font-weight"))
+				_Style.Current.FontWeight = FONT_WEIGHT_BOLD;
+			// center if not specified otherwise.
+			if (!elm.hasNonEmptyAttribute("align") && !_Style.hasStyle("text-align"))
+				_CellParams.back().Align = CGroupCell::Center;
+		}
+
+		CGroupTable *table = getTable();
+		if (table)
+		{
+			if (_Style.hasStyle("padding"))
+			{
+				uint32 a;
+				// TODO: cssLength
+				if (fromString(_Style.getStyle("padding"), a))
+					table->CellPadding = a;
+			}
+
+			if (!_Cells.empty())
+			{
+				_Cells.back() = new CGroupCell(CViewBase::TCtorParam());
+
+				if (_Style.checkStyle("background-repeat", "1") || _Style.checkStyle("background-repeat", "repeat"))
+					_Cells.back()->setTextureTile(true);
+
+				if (_Style.checkStyle("background-scale", "1") || _Style.checkStyle("background-size", "cover"))
+					_Cells.back()->setTextureScale(true);
+
+				if (_Style.hasStyle("background-image"))
+				{
+					string image = _Style.getStyle("background-image");
+
+					string::size_type texExt = toLower(image).find("url(");
+					// Url image
+					if (texExt != string::npos)
+					{
+						// Remove url()
+						image = image.substr(4, image.size()-5);
+						addImageDownload(image, _Cells.back());
+					// Image in BNP
+					}
+					else
+					{
+						_Cells.back()->setTexture(image);
+					}
+				}
+
+				if (elm.hasNonEmptyAttribute("colspan"))
+					fromString(elm.getAttribute("colspan"), _Cells.back()->ColSpan);
+				if (elm.hasNonEmptyAttribute("rowspan"))
+					fromString(elm.getAttribute("rowspan"), _Cells.back()->RowSpan);
+
+				_Cells.back()->BgColor = _CellParams.back().BgColor;
+				_Cells.back()->Align = _CellParams.back().Align;
+				_Cells.back()->VAlign = _CellParams.back().VAlign;
+				_Cells.back()->LeftMargin = _CellParams.back().LeftMargin;
+				_Cells.back()->NoWrap = _CellParams.back().NoWrap;
+				_Cells.back()->ColSpan = std::max(1, _Cells.back()->ColSpan);
+				_Cells.back()->RowSpan = std::max(1, _Cells.back()->RowSpan);
+
+				float temp;
+				if (_Style.hasStyle("width"))
+					getPercentage (_Cells.back()->WidthWanted, _Cells.back()->TableRatio, _Style.getStyle("width").c_str());
+				else if (elm.hasNonEmptyAttribute("width"))
+					getPercentage (_Cells.back()->WidthWanted, _Cells.back()->TableRatio, elm.getAttribute("width").c_str());
+				
+				if (_Style.hasStyle("height"))
+					getPercentage (_Cells.back()->Height, temp, _Style.getStyle("height").c_str());
+				else if (elm.hasNonEmptyAttribute("height"))
+					getPercentage (_Cells.back()->Height, temp, elm.getAttribute("height").c_str());
+
+				_Cells.back()->NewLine = getTR();
+				table->addChild (_Cells.back());
+
+				// reusing indent pushed by table
+				_Indent.back() = 0;
+
+				newParagraph(TDBeginSpace);
+				// indent is already 0, getParagraph()->setMarginLeft(0); // maybe setIndent(0) if LI is using one
+
+				// Reset TR flag
+				if (!_TR.empty())
+					_TR.back() = false;
+
+				renderPseudoElement(":before", elm);
+			}
+		}
+	}
+
+	void CGroupHTML::htmlTDend(const CHtmlElement &elm)
+	{
+		renderPseudoElement(":after", elm);
+
+		popIfNotEmpty(_CellParams);
+		if (!_Cells.empty())
+			_Cells.back() = NULL;
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlTEXTAREA(const CHtmlElement &elm)
+	{
+		_PRE.push_back(true);
+
+		// Got one form ?
+		if (!(_Forms.empty()))
+		{
+			// read general property
+			string templateName;
+
+			// Widget template name
+			if (elm.hasNonEmptyAttribute("z_input_tmpl"))
+				templateName = elm.getAttribute("z_input_tmpl");
+
+			// Get the string name
+			_TextAreaName.clear();
+			_TextAreaRow = 1;
+			_TextAreaCols = 10;
+			_TextAreaContent.clear();
+			_TextAreaMaxLength = 1024;
+			if (elm.hasNonEmptyAttribute("name"))
+				_TextAreaName = elm.getAttribute("name");
+			if (elm.hasNonEmptyAttribute("rows"))
+				fromString(elm.getAttribute("rows"), _TextAreaRow);
+			if (elm.hasNonEmptyAttribute("cols"))
+				fromString(elm.getAttribute("cols"), _TextAreaCols);
+			if (elm.hasNonEmptyAttribute("maxlength"))
+				fromString(elm.getAttribute("maxlength"), _TextAreaMaxLength);
+
+			_TextAreaTemplate = !templateName.empty() ? templateName : DefaultFormTextAreaGroup;
+			_TextArea = true;
+		}
+	}
+
+	void CGroupHTML::htmlTEXTAREAend(const CHtmlElement &elm)
+	{
+		_TextArea = false;
+		popIfNotEmpty (_PRE);
+
+		if (_Forms.empty())
+			return;
+
+		CInterfaceGroup *textArea = addTextArea (_TextAreaTemplate, _TextAreaName.c_str (), _TextAreaRow, _TextAreaCols, true, _TextAreaContent, _TextAreaMaxLength);
+		if (textArea)
+		{
+			// Add the text area to the form
+			CGroupHTML::CForm::CEntry entry;
+			entry.Name = _TextAreaName;
+			entry.TextArea = textArea;
+			_Forms.back().Entries.push_back (entry);
+		}
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlTH(const CHtmlElement &elm)
+	{
+		htmlTD(elm);
+	}
+
+	void CGroupHTML::htmlTHend(const CHtmlElement &elm)
+	{
+		htmlTDend(elm);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlTITLE(const CHtmlElement &elm)
+	{
+		// TODO: only from <head>
+		// if (!_ReadingHeadTag) return;
+		if(!_TitlePrefix.empty())
+			_TitleString = _TitlePrefix + " - ";
+		else
+			_TitleString.clear();
+		_Title = true;
+	}
+
+	void CGroupHTML::htmlTITLEend(const CHtmlElement &elm)
+	{
+		_Title = false;
+		setTitle(_TitleString);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlTR(const CHtmlElement &elm)
+	{
+		// Get cells parameters
+		getCellsParameters(elm, true);
+
+		// TODO: this probably ends up in first cell
+		renderPseudoElement(":before", elm);
+
+		// Set TR flag
+		if (!_TR.empty())
+			_TR.back() = true;
+	}
+
+	void CGroupHTML::htmlTRend(const CHtmlElement &elm)
+	{
+		// TODO: this probably ends up in last cell
+		renderPseudoElement(":after", elm);
+
+		popIfNotEmpty(_CellParams);
+	}
+
+	// ***************************************************************************
+	void CGroupHTML::htmlUL(const CHtmlElement &elm)
+	{
+		if (_UL.empty())
+			_UL.push_back(HTMLOListElement(1, "disc"));
+		else if (_UL.size() == 1)
+			_UL.push_back(HTMLOListElement(1, "circle"));
+		else
+			_UL.push_back(HTMLOListElement(1, "square"));
+
+		// if LI is already present
+		_LI = _UL.size() > 1 || _DL.size() > 1;
+		_Indent.push_back(getIndent() + ULIndent);
+		endParagraph();
+
+		renderPseudoElement(":before", elm);
+	}
+
+	void CGroupHTML::htmlULend(const CHtmlElement &elm)
+	{
+		if (_UL.empty())
+			return;
+
+		renderPseudoElement(":after", elm);
+
+		endParagraph();
+		popIfNotEmpty(_UL);
+		popIfNotEmpty(_Indent);
+	}
+
 }
 
diff --git a/code/nel/src/gui/html_element.cpp b/code/nel/src/gui/html_element.cpp
new file mode 100644
index 000000000..215c1c9f5
--- /dev/null
+++ b/code/nel/src/gui/html_element.cpp
@@ -0,0 +1,168 @@
+// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
+// Copyright (C) 2010  Winch Gate Property Limited
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as
+// published by the Free Software Foundation, either version 3 of the
+// License, or (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#include "stdpch.h"
+
+#include "nel/gui/html_element.h"
+
+using namespace std;
+using namespace NLMISC;
+
+#ifdef DEBUG_NEW
+#define new DEBUG_NEW
+#endif
+
+namespace NLGUI
+{
+	// ***************************************************************************
+	CHtmlElement::CHtmlElement(ENodeType type, std::string value)
+		: ID(0), Type(type), Value(value), parent(NULL), previousSibling(NULL), nextSibling(NULL), childIndex(0)
+	{}
+
+	// ***************************************************************************
+	bool CHtmlElement::hasAttribute(const std::string &key) const
+	{
+		return Attributes.find(key) != Attributes.end();
+	}
+
+	// ***************************************************************************
+	bool CHtmlElement::hasNonEmptyAttribute(const std::string &key) const
+	{
+		return !getAttribute(key).empty();
+	}
+
+	// ***************************************************************************
+	std::string CHtmlElement::getAttribute(const std::string &key) const
+	{
+		std::map<std::string, std::string>::const_iterator it = Attributes.find(key);
+		return (it != Attributes.end() ? it->second : "");
+	}
+
+	// ***************************************************************************
+	bool CHtmlElement::hasClass(const std::string &key) const
+	{
+		return ClassNames.find(key) != ClassNames.end();
+	}
+
+	// ***************************************************************************
+	void CHtmlElement::reindexChilds()
+	{
+		uint index = 0;
+		CHtmlElement *prev = NULL;
+		std::list<CHtmlElement>::iterator it;
+		for(it = Children.begin(); it != Children.end(); ++it)
+		{
+			if (it->Type == ELEMENT_NODE)
+			{
+				it->parent = this;
+				it->previousSibling = prev;
+				it->nextSibling = NULL;
+				if (prev)
+				{
+					prev->nextSibling = &(*it);
+				}
+				it->childIndex = index;
+				index++;
+				prev = &(*it);
+			}
+		}
+	}
+
+	// ***************************************************************************
+	std::string CHtmlElement::toString(bool tree, uint depth) const
+	{
+		std::string result;
+		if (depth > 0)
+		{
+			result = NLMISC::toString("[%d]", depth);
+			result.append(depth, '-');
+		}
+		if (Type == NONE || Type == ELEMENT_NODE)
+		{
+			result += "<" + Value;
+			for(std::map<std::string, std::string>::const_iterator it = Attributes.begin(); it != Attributes.end(); ++it)
+			{
+				if (it->first == "class")
+				{
+					result += " class=\"";
+					for(std::set<std::string>::const_iterator it2 = ClassNames.begin(); it2 != ClassNames.end(); ++it2)
+					{
+						if (it2 != ClassNames.begin())
+						{
+							result += " ";
+						}
+						result += *it2;
+					}
+					result += "\"";
+				}
+				else
+				{
+					result += " " + it->first + "=\"" + it->second + "\"";
+				}
+			}
+			result += NLMISC::toString(" data-debug=\"childIndex: %d\"", childIndex);
+			result += ">";
+
+			if (tree)
+			{
+				result += "\n";
+				for(std::list<CHtmlElement>::const_iterator it = Children.begin(); it != Children.end(); ++it)
+				{
+					result += it->toString(tree, depth+1);
+				}
+				if (depth > 0)
+				{
+					result += NLMISC::toString("[%d]", depth);
+					result.append(depth, '-');
+				}
+				result += "</" + Value + ">\n";
+			}
+		}
+		else
+		{
+			if (Value.find("\n") == std::string::npos)
+			{
+				result += "{" + Value + "}";
+			}
+			else
+			{
+				result += "{";
+				std::string::size_type start = 0;
+				std::string::size_type pos = Value.find_first_of("\n\r\t");
+				while(pos != std::string::npos)
+				{
+					result += Value.substr(start, pos - start);
+					if (Value[pos] == '\n')
+					{
+						result += "⏎";
+					}
+					else if (Value[pos] == '\t')
+					{
+						result += "⇥";
+					}
+
+					start = pos+1;
+					pos = Value.find_first_of("\n\r\t", start);
+				}
+				result += "}";
+			}
+			if (tree) result += "\n";
+		}
+
+		return result;
+	};
+} // namespace
diff --git a/code/nel/src/gui/html_parser.cpp b/code/nel/src/gui/html_parser.cpp
index 8470d0524..d411b856e 100644
--- a/code/nel/src/gui/html_parser.cpp
+++ b/code/nel/src/gui/html_parser.cpp
@@ -35,71 +35,40 @@ using namespace NLMISC;
 
 namespace NLGUI
 {
+
 	// ***************************************************************************
-	void CHtmlParser::htmlElement(xmlNode *node, int element_number)
+	void CHtmlParser::parseStyle(xmlNode *a_node, std::string &styleString) const
 	{
-		SGML_dtd *HTML_DTD = HTML_dtd ();
-
-		if (element_number < HTML_ELEMENTS)
+		xmlNode *node = a_node;
+		while(node)
 		{
-			CXMLAutoPtr ptr;
-			// load attributes into libwww structs
-			std::vector<bool> present;
-			std::vector<const char *>value;
-			std::string strvalues[MAX_ATTRIBUTES];
-			present.resize(30, false);
-			value.resize(30);
-
-			uint nbAttributes = std::min(MAX_ATTRIBUTES, HTML_DTD->tags[element_number].number_of_attributes);
-			for(uint i=0; i<nbAttributes; i++)
+			if (node->type == XML_CDATA_SECTION_NODE)
 			{
-				std::string name;
-				name = toLower(std::string(HTML_DTD->tags[element_number].attributes[i].name));
-				ptr = xmlGetProp(node, (const xmlChar *)name.c_str());
-				if (ptr)
-				{
-					// copy xmlChar to string (xmlChar will be released)
-					strvalues[i] = (const char *)(ptr);
-					// now use string pointer in value[] array
-					value[i] = strvalues[i].c_str();
-					present[i] = true;
-				}
+				styleString += (const char*)node->content;
+			}
+			else
+			{
+				nlwarning("<style> tag has child elements other than cdata[%d]", node->type);
 			}
 
-			_GroupHtml->beginElement(element_number, present, value);
-		}
-		else
-		{
-			_GroupHtml->beginUnparsedElement((const char *)(node->name), xmlStrlen(node->name));
-		}
-
-		// recursive - text content / child nodes
-		parseNode(node->children);
-
-		// closing tag
-		if (element_number < HTML_ELEMENTS)
-		{
-			_GroupHtml->endElement(element_number);
-		}
-		else
-		{
-			_GroupHtml->endUnparsedElement((const char *)(node->name), xmlStrlen(node->name));
+			node = node->next;
 		}
 	}
 
 	// ***************************************************************************
 	// recursive function to walk html document
-	void CHtmlParser::parseNode(xmlNode *a_node)
+	void CHtmlParser::parseNode(xmlNode *a_node, CHtmlElement &parent, std::string &styleString, std::vector<std::string> &links) const
 	{
 		SGML_dtd *HTML_DTD = HTML_dtd ();
 
+		uint childIndex = 0;
 		uint element_number;
 		xmlNode *node = a_node;
 		while(node)
 		{
 			if (node->type == XML_TEXT_NODE)
 			{
-				_GroupHtml->addText((const char *)(node->content), xmlStrlen(node->content));
+				parent.Children.push_back(CHtmlElement(CHtmlElement::TEXT_NODE, (const char*)(node->content)));
 			}
 			else
 			if (node->type == XML_ELEMENT_NODE)
@@ -111,7 +80,123 @@ namespace NLGUI
 						break;
 				}
 
-				htmlElement(node, element_number);
+				// get pointer to previous sibling
+				CHtmlElement *prevSibling = NULL;
+				if (!parent.Children.empty())
+				{
+					// skip text nodes
+					for(std::list<CHtmlElement>::reverse_iterator it = parent.Children.rbegin(); it != parent.Children.rend(); ++it)
+					{
+						if (it->Type == CHtmlElement::ELEMENT_NODE)
+						{
+							prevSibling = &(*it);
+							break;
+						}
+					}
+				}
+
+				parent.Children.push_back(CHtmlElement(CHtmlElement::ELEMENT_NODE, toLower((const char*)node->name)));
+				CHtmlElement &elm = parent.Children.back();
+				elm.ID = element_number;
+				elm.parent = &parent;
+				elm.childIndex = childIndex;
+
+				// previous/next sibling that is ELEMENT_NODE
+				elm.previousSibling = prevSibling;
+				if (prevSibling)
+				{
+					prevSibling->nextSibling = &parent.Children.back();
+				}
+
+				childIndex++;
+
+				// TODO: harvest <link type="css">, <style>, <img>
+
+				elm.Attributes.clear();
+
+				for (xmlAttr *cur_attr = node->properties; cur_attr; cur_attr = cur_attr->next) {
+					std::string key(toLower((const char *)(cur_attr->name)));
+					std::string value;
+					if (cur_attr->children)
+					{
+						value = (const char *)(cur_attr->children->content);
+					}
+					elm.Attributes[key] = value;
+				}
+
+				if (elm.hasAttribute("class"))
+				{
+					std::vector<std::string> parts;
+					NLMISC::splitString(elm.getAttribute("class"), " ", parts);
+					for(uint i = 0; i<parts.size();++i)
+					{
+						elm.ClassNames.insert(toLower(trim(parts[i])));
+					}
+				}
+
+				if (elm.Value == "style")
+				{
+					// <style type="text/css" media="all, screen">
+					// ...
+					// </style>
+					bool useStyle = true;
+					if (elm.hasAttribute("media"))
+					{
+						std::string media = trim(toLower(elm.Attributes["media"]));
+						useStyle = media.empty() || media.find("all") != std::string::npos || media.find("screen") != std::string::npos;
+
+						// <style media="ryzom"> for ingame browser
+						useStyle = useStyle || media == "ryzom";
+					}
+
+					if (useStyle)
+					{
+						parseStyle(node->children, styleString);
+					}
+					// style tag is kept in dom
+				}
+				if (elm.Value == "link" && elm.getAttribute("rel") == "stylesheet")
+				{
+					bool useStyle = true;
+					if (elm.hasAttribute("media"))
+					{
+						std::string media = trim(toLower(elm.Attributes["media"]));
+						useStyle = media.empty() || media.find("all") != std::string::npos || media.find("screen") != std::string::npos;
+
+						// <style media="ryzom"> for ingame browser
+						useStyle = useStyle || media == "ryzom";
+					}
+
+					if (useStyle)
+					{
+						links.push_back(elm.getAttribute("href"));
+					}
+					// link tag is kept in dom
+				}
+				else if (node->children)
+				{
+					parseNode(node->children, elm, styleString, links);
+
+					// must cleanup nested tags that libxml2 does not fix
+					// dt without end tag: <dl><dt><dt></dl>
+					// dd without end tag: <dl><dd><dd></dl>
+					if (!elm.Children.empty() && (elm.Value == "dt" || elm.Value == "dd"))
+					{
+						std::string tag = elm.Value;
+						std::list<CHtmlElement>::iterator it;
+						for(it = elm.Children.begin(); it != elm.Children.end(); ++it)
+						{
+							if (it->Type == CHtmlElement::ELEMENT_NODE && it->Value == tag)
+							{
+								// relocate this and remaining elements over to parent
+								parent.Children.splice(parent.Children.end(), elm.Children, it, elm.Children.end());
+								break;
+							}
+						}
+						elm.reindexChilds();
+						parent.reindexChilds();
+					}
+				}
 			}
 
 			// move into next sibling
@@ -298,13 +383,13 @@ namespace NLGUI
 	}
 
 	// ***************************************************************************
-	bool CHtmlParser::parseHtml(std::string htmlString)
+	void CHtmlParser::getDOM(std::string htmlString, CHtmlElement &dom, std::string &styleString, std::vector<std::string> &links) const
 	{
 		htmlParserCtxtPtr parser = htmlCreatePushParserCtxt(NULL, NULL, NULL, 0, NULL, XML_CHAR_ENCODING_UTF8);
 		if (!parser)
 		{
 			nlwarning("Creating html parser context failed");
-			return false;
+			return;
 		}
 
 		htmlCtxtUseOptions(parser, HTML_PARSE_NOBLANKS | HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING | HTML_PARSE_NONET);
@@ -315,29 +400,26 @@ namespace NLGUI
 		htmlParseChunk(parser, htmlString.c_str(), htmlString.size(), 0);
 		htmlParseChunk(parser, "", 0, 1);
 
-		bool success = true;
 		if (parser->myDoc)
 		{
 			xmlNode *root = xmlDocGetRootElement(parser->myDoc);
 			if (root)
 			{
-				parseNode(root);
+				styleString.clear();
+				parseNode(root, dom, styleString, links);
 			}
 			else
 			{
 				nlwarning("html root node failed");
-				success = false;
 			}
 			xmlFreeDoc(parser->myDoc);
 		}
 		else
 		{
 			nlwarning("htmlstring parsing failed");
-			success = false;
 		}
 
 		htmlFreeParserCtxt(parser);
-		return success;
 	}
 
 }
diff --git a/code/nel/src/gui/libwww.cpp b/code/nel/src/gui/libwww.cpp
index 50cac24bf..0ee6c01f2 100644
--- a/code/nel/src/gui/libwww.cpp
+++ b/code/nel/src/gui/libwww.cpp
@@ -599,6 +599,11 @@ namespace NLGUI
 			return true;
 		}
 
+		// TODO: CSS Colors Level 4 support
+		// Whitespace syntax, aliases: rgb == rgba, hsl == hsla
+		// rgb(51 170 51 / 0.4)    /* 40% opaque green */ 
+		// rgb(51 170 51 / 40%)    /* 40% opaque green */ 
+
 		if (strnicmp(src, "rgb(", 4) == 0 || strnicmp(src, "rgba(", 5) == 0)
 		{
 			src += 4;
@@ -743,6 +748,11 @@ namespace NLGUI
 		return dst;
 	}
 
+	std::string getRGBAString(const CRGBA &color)
+	{
+		return toString("rgba(%d, %d, %d, %.1f)", color.R, color.G, color.B, color.A / 255.f);
+	}
+
 	// update HTTPCookies list
 	static void receiveCookie(const char *nsformat, const std::string &domain, bool trusted)
 	{
diff --git a/code/nel/src/gui/libwww_types.cpp b/code/nel/src/gui/libwww_types.cpp
index 9731e9aca..12a16e5d6 100644
--- a/code/nel/src/gui/libwww_types.cpp
+++ b/code/nel/src/gui/libwww_types.cpp
@@ -784,6 +784,8 @@ static HTTag tags[HTML_ELEMENTS] = {
 	{ "U"	, gen_attr,	HTML_GEN_ATTRIBUTES },
 	{ "UL"	, ul_attr,	HTML_UL_ATTRIBUTES },
 	{ "VAR"	, gen_attr,	HTML_GEN_ATTRIBUTES },
+	//
+	{ "LUA" , gen_attr, HTML_GEN_ATTRIBUTES },
 };
 
 static SGML_dtd HTMLP_dtd = {
diff --git a/code/ryzom/client/src/interface_v3/group_quick_help.cpp b/code/ryzom/client/src/interface_v3/group_quick_help.cpp
index 144dc9b9a..857c3cacd 100644
--- a/code/ryzom/client/src/interface_v3/group_quick_help.cpp
+++ b/code/ryzom/client/src/interface_v3/group_quick_help.cpp
@@ -25,6 +25,7 @@
 #include "nel/gui/group_list.h"
 #include "nel/gui/group_paragraph.h"
 #include "nel/gui/libwww.h"
+#include "nel/gui/html_element.h"
 #include "interface_manager.h"
 #include "nel/gui/action_handler.h"
 #include "nel/misc/xml_auto_ptr.h"
@@ -215,33 +216,29 @@ void CGroupQuickHelp::setGroupTextSize (CInterfaceGroup *group, bool selected)
 
 extern CActionsContext ActionsContext;
 
-void CGroupQuickHelp::beginElement (uint element_number, const std::vector<bool> &present, const std::vector<const char *>&value)
+void CGroupQuickHelp::beginElement(CHtmlElement &elm)
 {
-	CGroupHTML::beginElement (element_number, present, value);
+	CGroupHTML::beginElement (elm);
 
 	// Paragraph ?
-	switch(element_number)
+	switch(elm.ID)
 	{
 	case HTML_A:
 			// Quick help
-			if (_TrustedDomain && present[MY_HTML_A_Z_ACTION_SHORTCUT] && value[MY_HTML_A_Z_ACTION_SHORTCUT])
+			if (_TrustedDomain && elm.hasNonEmptyAttribute("z_action_shortcut"))
 			{
 				// Get the action category
-				string category;
-				if (present[MY_HTML_A_Z_ACTION_CATEGORY] && value[MY_HTML_A_Z_ACTION_CATEGORY])
-					category = value[MY_HTML_A_Z_ACTION_CATEGORY];
+				string category = elm.getAttribute("z_action_category");
 
 				// Get the action params
-				string params;
-				if (present[MY_HTML_A_Z_ACTION_PARAMS] && value[MY_HTML_A_Z_ACTION_PARAMS])
-					params = value[MY_HTML_A_Z_ACTION_PARAMS];
+				string params = elm.getAttribute("z_action_params");
 
 				// Get the action descriptor
 				CActionsManager *actionManager = ActionsContext.getActionsManager (category);
 				if (actionManager)
 				{
 					const CActionsManager::TActionComboMap &actionCombo = actionManager->getActionComboMap ();
-					CActionsManager::TActionComboMap::const_iterator ite = actionCombo.find (CAction::CName (value[MY_HTML_A_Z_ACTION_SHORTCUT], params.c_str()));
+					CActionsManager::TActionComboMap::const_iterator ite = actionCombo.find (CAction::CName (elm.getAttribute("z_action_shortcut").c_str(), params.c_str()));
 					if (ite != actionCombo.end())
 					{
 						addString (ite->second.toUCString());
@@ -252,7 +249,7 @@ void CGroupQuickHelp::beginElement (uint element_number, const std::vector<bool>
 
 	case HTML_P:
 		// Get the action name
-		if (present[MY_HTML_P_QUICK_HELP_EVENTS])
+		if (elm.hasAttribute("quick_help_events"))
 		{
 			// This page is a quick help
 			_IsQuickHelp = true;
@@ -260,38 +257,29 @@ void CGroupQuickHelp::beginElement (uint element_number, const std::vector<bool>
 			_Steps.push_back (CStep());
 			CStep &step = _Steps.back();
 
-			if (value[MY_HTML_P_QUICK_HELP_EVENTS])
+			// Get the event names
+			string events = elm.getAttribute("quick_help_events");
+			if (!events.empty())
 			{
-				// Get the event names
-				string events = value[MY_HTML_P_QUICK_HELP_EVENTS];
-				if (!events.empty())
+				uint first = 0;
+				while (first < events.size())
 				{
-					uint first = 0;
-					while (first < events.size())
-					{
-						// String end
-						string::size_type last = events.find_first_of(" ", first);
-						if (last == string::npos)
-							last = events.size();
+					// String end
+					string::size_type last = events.find_first_of(" ", first);
+					if (last == string::npos)
+						last = events.size();
 
-						// Extract the string
-						step.EventToComplete.insert (events.substr (first, last-first));
-						first = (uint)last+1;
-					}
+					// Extract the string
+					step.EventToComplete.insert (events.substr (first, last-first));
+					first = (uint)last+1;
 				}
 			}
 
 			// Get the condition
-			if (present[MY_HTML_P_QUICK_HELP_CONDITION] && value[MY_HTML_P_QUICK_HELP_CONDITION])
-			{
-				step.Condition = value[MY_HTML_P_QUICK_HELP_CONDITION];
-			}
+			step.Condition = elm.getAttribute("quick_help_condition");
 
 			// Get the action handlers to run
-			if (present[MY_HTML_P_QUICK_HELP_LINK] && value[MY_HTML_P_QUICK_HELP_LINK])
-			{
-				step.URL = value[MY_HTML_P_QUICK_HELP_LINK];
-			}
+			step.URL = elm.getAttribute("quick_help_link");
 		}
 		break;
 	}
diff --git a/code/ryzom/client/src/interface_v3/group_quick_help.h b/code/ryzom/client/src/interface_v3/group_quick_help.h
index 3dc1c8afa..6af4e91b0 100644
--- a/code/ryzom/client/src/interface_v3/group_quick_help.h
+++ b/code/ryzom/client/src/interface_v3/group_quick_help.h
@@ -23,7 +23,6 @@
 #include "nel/misc/types_nl.h"
 #include "nel/gui/group_html.h"
 
-
 /**
  * Quick help group
  * \author Cyril 'Hulud' Corvazier
@@ -48,7 +47,7 @@ private:
 	virtual void updateCoords();
 
 	// From CGroupHTML
-	virtual void beginElement (uint element_number, const std::vector<bool> &present, const std::vector<const char *>&value);
+	virtual void beginElement (NLGUI::CHtmlElement &elm);
 	virtual void endBuild ();
 	virtual void browse (const char *url);
 	virtual std::string	home();