diff --git a/ctl/ctlStyledText.cpp b/ctl/ctlStyledText.cpp
new file mode 100644
index 0000000..27bb138
--- /dev/null
+++ b/ctl/ctlStyledText.cpp
@@ -0,0 +1,427 @@
+
+#include "pgAdmin3.h"
+
+#include "ctl/ctlStyledText.h"
+#include <wx/log.h>
+#include <wx/regex.h>
+
+BEGIN_EVENT_TABLE(ctlStyledText, wxStyledTextCtrl)
+//EVT_KEY_DOWN(ctlStyledText::OnKeyDown)
+//	EVT_ERASE_BACKGROUND(ctlSQLBox::OnBackGround)
+#ifdef __WXMAC__
+EVT_STC_PAINTED(-1, ctlStyledText::OnPositionStc)
+#else
+EVT_STC_UPDATEUI(-1, ctlStyledText::OnPositionStc)
+#endif
+//EVT_STC_MARGINCLICK(-1, ctlSQLBox::OnMarginClick)
+//EVT_STC_DOUBLECLICK(-1, ctlSQLBox::OnDoubleClick)
+
+END_EVENT_TABLE()
+
+
+IMPLEMENT_DYNAMIC_CLASS(ctlStyledText, wxStyledTextCtrl)
+
+ctlStyledText::ctlStyledText()
+{
+	m_regparser.SetStyleControl(this);
+	setDecorate();
+}
+void ctlStyledText::setDecorate() {
+	extern sysSettings* settings;
+	wxFont fntSQLBox = settings->GetSQLFont();
+
+	StyleSetBackground(wxSTC_STYLE_BRACELIGHT, wxColour(0x99, 0xF9, 0xFF));
+	StyleSetBackground(wxSTC_STYLE_BRACEBAD, wxColour(0xFF, 0xCF, 0x27));
+	StyleSetFont(wxSTC_STYLE_BRACELIGHT, fntSQLBox);
+	StyleSetFont(wxSTC_STYLE_BRACEBAD, fntSQLBox);
+
+}
+ctlStyledText::ctlStyledText(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style)
+{
+	Create(parent, id, pos, size, style);
+	m_regparser.SetStyleControl(this);
+	setDecorate();
+}
+void ctlStyledText::OnPositionStc(wxStyledTextEvent& event) {
+
+	int u = event.GetUpdated();
+	if ((u & wxSTC_UPDATE_CONTENT) && ishighlight) {
+		wxString t = GetText();
+		{
+			//			wxLogNull logNo;
+			//			wxRegEx r(t, wxRE_NEWLINE);
+		}
+		if (m_regparser.ParseStr(t, RegExpParser::defrule::pcre) > 0) {
+		}
+		m_regparser.StyledTextControl(this);
+
+	}
+
+	int pos = GetCurrentPos();
+	wxChar ch = GetCharAt(pos - 1);
+	wxChar nextch = GetCharAt(pos);
+	int st = GetStyleAt(pos - 1);
+	int match;
+	// Line numbers
+	// Ensure we don't recurse through any paint handlers on Mac
+	// Roll back through the doc and highlight any unmatched braces
+	int tmp = pos;
+
+	while ((pos--) >= 0)
+	{
+		ch = GetCharAt(pos);
+		st = GetStyleAt(pos)- (wxSTC_STYLE_LASTPREDEFINED + 1);
+		if ( (
+			//ch == '{' || ch == '}' ||
+			//ch == '[' || ch == ']' ||
+			ch == '(' || ch == ')') &&
+			st != 5 )
+		{
+			match = BraceMatch(pos);
+			if (match == wxSTC_INVALID_POSITION)
+			{
+				event.Skip();
+				return;
+			}
+			BraceHighlight(pos, match);
+			break;
+		}
+	}
+
+
+	event.Skip();
+}
+void ctlStyledText::setRegExphighlight(bool enable) {
+	ishighlight = enable;
+	if (!enable) m_regparser.SetStyleControl(NULL);
+}
+
+///////////////////////////// RegExpParser
+
+void RegExpParser::init() {
+	for (int i = 0; i < sizeof(rulemap) / sizeof(rulemap[0]); i++) rulemap[i] = -1;
+	for (int i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
+		if (ISCHECKTYPE(i, rule_type::start_rule)) {
+			wxASSERT_MSG(rules[i].ruledef >= 0, "rule < 0 this bad");
+			rulemap[rules[i].ruledef] = i;
+		}
+	}
+	// check all refernce
+	for (int i = 0; i < sizeof(rules) / sizeof(rules[0]); i++) {
+		if (rules[i].ruleref > 0) {
+			wxASSERT_MSG(rulemap[rules[i].ruleref] >= 0, wxString::Format("rule %d not define", rules[i].ruleref));
+		}
+	}
+};
+int RegExpParser::ParseStr(const wxString str, defrule start_rule) {
+	t = str;
+	len = t.length();
+	maxPos = 0;
+	int idx = rulemap[start_rule];
+	int n;
+	marker.clear();
+	int r = testRule(idx, 0, n, -1);
+	if (r > 0) {
+		if (n == len) return 1;
+		if (n < len) {
+			if (marker.size() > 0) marker.push_back(styletextmarker{ 0, n,len });
+		}
+		return -11;
+	}
+
+	return -1;
+}
+void RegExpParser::SetStyleControl(wxStyledTextCtrl* ctrl) {
+	if (ctrl == NULL) {
+		intitstyle = false;
+		return;
+	}
+	//ctrl->StyleClearAll();
+	for (int i = 0; i < sizeof(stylemap) / sizeof(stylemap[0]); i++) stylemap[i] = -1;
+	wxColour bgdef = ctrl->GetBackgroundColour();
+	wxColour fgdef = ctrl->GetForegroundColour();
+	tablestyle.push_back(styletextdef{ fgdef,wxColour("#ddd0fe") }); // 00 verb
+	tablestyle.push_back(styletextdef{ fgdef,wxColour("#fed1ff") }); // 1 capture (reed)
+	tablestyle.push_back(styletextdef{ fgdef,wxColour("#e3e3e3") }); // 2 backslash
+	tablestyle.push_back(styletextdef{ fgdef,wxColour("#d3a776") }); // 3 class char 
+	tablestyle.push_back(styletextdef{ fgdef,wxColour("#99beff") }); // 4 quantifier
+	tablestyle.push_back(styletextdef{ wxColour("#989898"),bgdef }); // 5 comment
+	tablestyle.push_back(styletextdef{ fgdef,wxColour("#bae634") }); // 6 captute (green)
+
+	tablestyle.push_back(styletextdef{ fgdef,wxColour("#ed5c65") }); // last color.  error bg
+	stylemap[0] = tablestyle.size() - 1; // error bg
+
+	stylemap[defrule::option_setting] = 0;
+	stylemap[defrule::atomic_group] = 0;
+	stylemap[defrule::lookaround] = 0;
+	stylemap[defrule::quantifier] = 4;
+	stylemap[defrule::comment] = 5;
+	stylemap[defrule::character_class] = 3;
+	stylemap[defrule::posix_character_class] = 3;
+	stylemap[defrule::character_type] = 2;
+	stylemap[defrule::character] = 2;
+	stylemap[defrule::character_type] = 2;
+	stylemap[defrule::backreference] = 2;
+	stylemap[defrule::anchor] = 2;
+	stylemap[defrule::match_point_reset] = 2;
+	stylemap[defrule::backtracking_control] = 0;
+	stylemap[defrule::alternation] = 0;
+	stylemap[defrule::capture] = 6;
+	stylemap[defrule::capture_1] = 6;
+	stylemap[defrule::conditional_pattern] = 1;
+	//wxLogNull logNo;
+	int count = 0;
+	int userstyle = wxSTC_STYLE_LASTPREDEFINED + 1;
+	for (int i = 0; i < sizeof(stylemap) / sizeof(stylemap[0]); i++) {
+		if (stylemap[i] != -1) {
+			int k = stylemap[i];
+			stylemap[i] += userstyle;
+			ctrl->StyleSetBackground(stylemap[i], tablestyle[k].bg);
+			ctrl->StyleSetForeground(stylemap[i], tablestyle[k].fg);
+		}
+	}
+	intitstyle = true;
+}
+void RegExpParser::StyledTextControl(wxStyledTextCtrl* ctrl) {
+	if (!intitstyle) SetStyleControl(ctrl);
+	ctrl->ClearDocumentStyle();
+	if (marker.size() == 0) {
+		marker.push_back(styletextmarker{ 0,maxPos + 1,maxPos + 2 });
+	}
+	int userstyle = wxSTC_STYLE_LASTPREDEFINED + 1;
+	for (auto m : marker) {
+		if (m.rule >= 0) {
+			int style = stylemap[m.rule];
+			if (style < 0) continue;
+			int CharPos = ctrl->PositionRelative(0, m.start);
+			ctrl->StartStyling(CharPos);
+			int CharPosEnd = ctrl->PositionRelative(CharPos, m.end - m.start);
+			int ll = CharPosEnd - CharPos;
+			//ctrl->SetStyling(m.end - m.start, style);
+			ctrl->SetStyling(ll, style);
+		}
+	}
+}
+bool RegExpParser::iseqchar(int pos, const char* const str) {
+	int i = 0;
+	int n = len - pos;
+	char c;
+	if (n == 0)
+		return false;
+	wxChar tc = t[pos];
+	while (str[i] != 0) {
+		c = str[i++];
+		if (c == tc) return true;
+	}
+	return false;
+}
+bool RegExpParser::istexteq(int pos, int& nextpos, const char* str) {
+	int i = 0;
+	int n = len - pos;
+	char c;
+	while (str[i] != 0) {
+		if (n - i == 0) {
+			return false; // end of string
+		}
+		c = str[i];
+		wxChar tc = t[pos + i++];
+		if (c == tc) continue;
+		return false;
+	}
+	//equal
+	nextpos = pos + i;
+	return true;
+}
+int RegExpParser::testRule(int ruleindex, int startCharPosition, int& nextCharPosition, int ruleparent) {
+	int p = startCharPosition;
+	int n = p;
+	bool isruleok = false;
+	bool isanonim = false;
+	int ri = ruleindex;
+	int rule = -1;
+	int ruletype = 0;
+	int sizemarker = marker.size();
+	if (ISCHECKTYPE(ri, start_anonim_rule)) {
+		ri++;
+		rule = ruleparent;
+	};
+	int countOkrule = 0;
+	int nextel = true;
+	int nextRule = 0;
+	while (nextel) {
+		p = n;
+		int incnextrule = 1;
+		if (rules[ri].type == 0) { // end rule
+			break;
+		}
+		if (ISCHECKTYPE(ri, start_rule)) {
+			rule = rules[ri].ruledef;
+			ruletype = rules[ri].type;
+			ri = ri + incnextrule;
+			continue;
+		}
+		isruleok = false;
+		if (ISCHECKTYPE(ri, text)) {
+			// 
+			isruleok = (istexteq(p, n, rules[ri].text));
+			//if (ISCHECKTYPE(ri, inversion) && p != len) isruleok = !isruleok;
+			if (isruleok) marker.push_back(styletextmarker{ rule,p,n });
+		}
+		else if (ISCHECKTYPE(ri, char_any)) {
+			int n2 = p;
+			if (rule == defrule::other && (maskOpt & maskopt::extended) && (p < len && t[p] == '#')) {
+				//extended comment 
+				while (n2 < len && t[n2] != '\n') n2++;
+				if (n2 < len) n2++;
+				marker.push_back(styletextmarker{ defrule::comment,p,n2 });
+				isruleok = true;
+				n = n2;
+			}
+			else {
+				isruleok = iseqchar(p, rules[ri].text);
+				if (ISCHECKTYPE(ri, inversion) && p != len) isruleok = !isruleok;
+				if (isruleok) n = p + 1;
+				if (isruleok) marker.push_back(styletextmarker{ rule,p,n });
+			}
+		}
+		else if (ISCHECKTYPE(ri, special_dot)) {
+			isruleok = false;
+			int n2 = p;
+			{
+				if (ISCHECKTYPE(ri, zero_more) && ISCHECKTYPE(ri + 1, text)) {
+					isruleok = istexteq(p, n2, rules[ri + 1].text);
+					isruleok = !isruleok;
+					if (isruleok) n2++;
+				}
+				else {
+					isruleok = true; // only 1 spec dot
+					n2++;
+				}
+
+				if (p == len || n2 == p) isruleok = false; // end expression alaways false
+				if (isruleok) n = n2;
+			}
+		}
+		else if (rules[ri].ruleref >= 0) {
+			//Use defibe rule
+			int r = GETRULEREFINDEX(ri);
+			isanonim = ISCHECKTYPE(ri, start_anonim_rule);
+			if (isanonim) r = ri;
+			nextRule = testRule(r, p, n, rule);
+			isruleok = nextRule > 0;
+			if (isanonim) {
+				if (!isruleok) nextRule = nextRule * -1;
+				incnextrule = nextRule - ri + 1; // next element after ZERO
+			}
+			else
+				nextRule = 0;
+		}
+		// 
+		if (isruleok) countOkrule++;
+		if (countOkrule < 2 && (ISCHECKTYPE(ri, zero_one))) {
+			isruleok = true;
+		}
+		if (countOkrule >= 0 && (ISCHECKTYPE(ri, zero_more))) {
+			if (countOkrule > 0 && isruleok) continue;
+			if (countOkrule >= 0) isruleok = true;
+		}
+		if ((ISCHECKTYPE(ri, one_more))) {
+			if (countOkrule > 0 && isruleok) continue;
+			// zero - this false rule
+			if (countOkrule > 0) isruleok = true;
+		}
+		// next element
+		countOkrule = 0;
+		ri = ri + incnextrule;
+		// NEXT elemenT
+		if (isruleok && ISCHECKTYPE(ri, alternative)) break; // end rule
+		if (isruleok) continue;
+		n = p; // undo position
+		n = startCharPosition;
+		// find alternative or end rule (control anonim rule)
+		int llvel = 0;
+		while (!((rules[ri].type == 0 || ISCHECKTYPE(ri, alternative)
+			) && llvel == 0)
+			)
+		{ // find alternative or end rule
+
+			if (ISCHECKTYPE(ri, start_anonim_rule)) {
+				llvel++; // inner rule 
+			}
+			if ((rules[ri].type == 0) && (llvel != 0)) {
+				llvel--; //end inner rule
+			}
+			ri++;
+		}
+	}
+
+	// 
+	// isruleok
+
+	if (isruleok) {
+		p = n;
+		nextCharPosition = p;
+		if (p > maxPos) maxPos = p;
+		// find end rule (control anonim rule)
+		int llvel = 0;
+		while (!((rules[ri].type == 0
+			) && llvel == 0)
+			) { // find end rule
+			if (ISCHECKTYPE(ri, start_anonim_rule)) {
+				llvel++; // inner rule 
+			}
+			if ((rules[ri].type == 0) && (llvel != 0)) {
+				llvel--; //end inner rule
+			}
+			ri++;
+
+		}
+		if ((ruletype & styled_ALL) == styled_ALL) {
+			// undo marker
+			marker.resize(sizemarker);
+			// replace all rule
+			marker.push_back(styletextmarker{ rule,startCharPosition,n });
+		}
+		// check is option_setting ?
+
+		if (rule == defrule::option_setting && (startCharPosition + 1<len) && t[startCharPosition + 1] == '?') {
+			// (?is-xJ)
+			int maskset = 0;
+			int maskreset = 0;
+			bool neg = false;
+			int mask = 0;
+			for (int i = startCharPosition; i < nextCharPosition; i++) {
+				wxChar c = t[i];
+				if (c == 'i') mask |= (int)maskopt::caseless;
+				if (c == 'J') mask |= (int)maskopt::allow_duplicate_names;
+				if (c == 'm') mask |= (int)maskopt::multiline;
+				if (c == 's') mask |= (int)maskopt::single_line;
+				if (c == 'U') mask |= (int)maskopt::default_ungreed;
+				if (c == 'x') mask |= (int)maskopt::extended;
+				if (c == '-') {
+					maskset = mask;
+					mask = 0;
+					neg = true;
+				}
+			}
+			if (neg) {
+				maskOpt |= maskset;
+				maskreset = ~mask;
+				maskOpt &= maskreset;
+			}
+			else if (mask > 0) {
+				maskOpt |= mask;
+			}
+		}
+		return ri; // end rule position , isruleok=true;
+	}
+	else {
+		// undo marker
+		marker.resize(sizemarker);
+
+		nextCharPosition = startCharPosition;
+		return -ri; //- end rule position isruleok=false;
+	}
+
+}
+
diff --git a/ctl/xh_styledtext.cpp b/ctl/xh_styledtext.cpp
new file mode 100644
index 0000000..5650f67
--- /dev/null
+++ b/ctl/xh_styledtext.cpp
@@ -0,0 +1,45 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// pgAdmin III - PostgreSQL Tools
+//
+// Copyright (C) 2002 - 2016, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+// xh_styledtext.cpp - ctlStyledText handler
+//
+//////////////////////////////////////////////////////////////////////////
+
+#include "pgAdmin3.h"
+
+#include "wx/wx.h"
+#include "ctl/xh_styledtext.h"
+#include "ctl/ctlStyledText.h"
+
+
+IMPLEMENT_DYNAMIC_CLASS(ctlStyledTextXmlHandler, wxXmlResourceHandler)
+
+ctlStyledTextXmlHandler::ctlStyledTextXmlHandler()
+	: wxXmlResourceHandler()
+{
+	XRC_ADD_STYLE(wxTE_MULTILINE);
+	XRC_ADD_STYLE(wxSIMPLE_BORDER);
+	XRC_ADD_STYLE(wxSUNKEN_BORDER);
+	XRC_ADD_STYLE(wxTE_RICH2);
+
+	AddWindowStyles();
+}
+
+
+wxObject *ctlStyledTextXmlHandler::DoCreateResource()
+{
+	ctlStyledText *StyledText = new ctlStyledText(m_parentAsWindow, GetID(), GetPosition(), GetSize(), GetStyle());
+
+	SetupWindow(StyledText);
+
+	return StyledText;
+}
+
+bool ctlStyledTextXmlHandler::CanHandle(wxXmlNode *node)
+{
+	return IsOfClass(node, wxT("ctlStyledText"));
+}
diff --git a/include/ctl/ctlStyledText.h b/include/ctl/ctlStyledText.h
new file mode 100644
index 0000000..e4ebe2a
--- /dev/null
+++ b/include/ctl/ctlStyledText.h
@@ -0,0 +1,597 @@
+#ifndef _CTLSTYLEDTEXT_H_
+#define _CTLSTYLEDTEXT_H_
+#include <wx/stc/stc.h>
+#include <vector>
+
+
+struct styletextmarker {
+	int rule; // rule
+	int start;
+	int end;	// next char
+};
+struct styletextdef {
+	wxColour fg;
+	wxColour bg;
+};
+
+
+
+class RegExpParser
+{
+public:
+	enum  maskopt {
+		caseless = 1,
+		allow_duplicate_names = 2,
+		multiline = 4,
+		single_line = 8,
+		default_ungreed = 16,
+		extended = 32
+	};
+	enum defrule {
+		digits = 1,
+		digit,
+		quoting,
+		letter,
+		letters,
+		name,
+		newline_conventions,
+		option_setting,
+		option_setting_1,
+		option_setting_11,
+		option_setting_111,
+		option_setting_12,
+		option_setting_2,
+		option_setting_21,
+		option_setting_22,
+		option_setting_flag,
+		option_setting_flag_cap,
+		backtracking_control,
+		backtracking_control_1,
+
+		pcre,
+		expr,
+		alternation,
+		element,
+		atom,
+		quantifier,
+		comment,
+		capture,
+		capture_1,
+		atomic_group,
+		lookaround,
+		backreference,
+		hex,
+		hex4,
+		anchor,
+		match_point_reset,
+		character,
+		character_type,
+		posix_character_class,
+		posix_character_class_name,
+		character_class_range_atom,
+		character_class_range,
+		character_class_atom,
+		character_class,
+		conditional_pattern,
+		call_out,
+
+		other,
+
+		MAX_COUNT_RULE
+	};
+	enum rule_type {
+		end_rule = 0,
+		start_rule = 1,
+		zero_one = 2,
+		one_more = 4,
+		zero_more = 8,
+		alternative = 16,
+		char_any = 32,
+		text = 64,
+		none = 128,
+		special_dot = 256,
+		start_anonim_rule = 512,
+		inversion = 1024,
+		styled_parent = 1024 * 2,
+		styled_ALL = 1024 * 4,
+	};
+	struct ERule {
+		int type;
+		int ruleref = 0; // use rule reference
+		int ruledef; // start define rule
+		const char* text;
+	};
+	RegExpParser() {
+		init();
+		intitstyle = false;
+	}
+	int ParseStr(const wxString str, RegExpParser::defrule start_rule);
+	void SetStyleControl(wxStyledTextCtrl* ctrl);
+	void StyledTextControl(wxStyledTextCtrl* ctrl);
+	static void TEST() {
+
+		const char* const t1[] = { "F0", "Z0T_a1234", "f" };
+		const char* const t2[] = { "(?i-ix)", "(*UTF)" };
+		const char* const t3[] = { "(*SKIP:m9)","(*:q2)", "(*FAIL)", "(*MARK:q)" };
+		const char* const t4[] = { "(?#аы)","(?#d2)", };
+		const char* const t5[] = { "(?|das)","(?i-i:ab)", "$ \\p{Fre}","(?>ATM)\\n\\0\\x{FFF}\\u1234abcd","(?P=ss)", "\\g{1}", "(P=ss)","\\g2",".\\V","\\Q\\s\\E" };
+		const char* const t6[] = { "\\0","\\u1abc", "\\o{881}","\\xaa" };
+		const char* const t7[] = { ".","\\V", "\\p{^ssa&}","\\psd" };
+		const char* const t8[] = { "[[:^digit:]]", "[[:digit:]]" };
+		const char* const t9[] = { "(?(sd)ffff)","(?(-23)cond_expr|no_expr_cond)" };
+
+		test_2(RegExpParser::defrule::pcre, t5, sizeof(t5) / sizeof(t5[0]));
+		test_2(RegExpParser::defrule::conditional_pattern, t9, sizeof(t9) / sizeof(t9[0]));
+		test_2(RegExpParser::defrule::character_class, t8, sizeof(t8) / sizeof(t8[0]));
+		test_2(RegExpParser::defrule::character_type, t7, sizeof(t7) / sizeof(t7[0]));
+		test_2(RegExpParser::defrule::character, t6, sizeof(t6) / sizeof(t6[0]));
+		test_2(RegExpParser::defrule::backtracking_control, t3, sizeof(t3) / sizeof(t3[0]));
+
+		//test_2(RegExpParser::defrule::backreference, t5);
+		test_2(RegExpParser::defrule::comment, t4, sizeof(t4) / sizeof(t4[0]));
+		test_2(RegExpParser::defrule::option_setting, t2, sizeof(t2) / sizeof(t2[0]));
+		test_2(RegExpParser::defrule::name, t1, sizeof(t1) / sizeof(t1[0]));
+
+
+	}
+	static void test_2(RegExpParser::defrule rule, const char* const arr[], int arraysize) {
+		RegExpParser t;
+		int nt = 1;
+		int sz = arraysize;
+		wxString ss;
+		for (int i = 0; i < sz; i++) {
+			ss = arr[i];
+			int rez = t.ParseStr(ss, rule);
+			wxString rezfail = wxString::Format("Test %d to %d failed\n Regexp expression: %s", nt, arraysize, wxString(ss));
+			wxASSERT_MSG(rez >= 0, rezfail.c_str());
+			nt++;
+		}
+	}
+private:
+	std::vector<styletextmarker> marker;
+	std::vector<styletextdef> tablestyle;
+	int stylemap[RegExpParser::defrule::MAX_COUNT_RULE] = { -1 };
+	int rulemap[RegExpParser::defrule::MAX_COUNT_RULE] = { -1 };
+	bool intitstyle;
+	wxString t;
+	int len;
+	int maxPos = 0;   // last position
+	int maskOpt = 0; // global options
+	bool iseqchar(int pos, const char* const str);
+	bool istexteq(int pos, int& nextpos, const char* str);
+	void init();
+	//////
+	int testRule(int ruleindex, int startCharPosition, int& nextCharPosition, int ruleparent);
+};
+/// <summary>
+/// ctlStyledText - Regexp hightli
+/// </summary>
+class ctlStyledText :
+	public wxStyledTextCtrl
+{
+public:
+	ctlStyledText();
+	ctlStyledText(wxWindow* parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style);
+	void setRegExphighlight(bool enable);
+	void setDecorate();
+	DECLARE_DYNAMIC_CLASS(ctlStyledText)
+		DECLARE_EVENT_TABLE()
+private:
+	void OnPositionStc(wxStyledTextEvent& event);
+	RegExpParser m_regparser;
+	bool ishighlight = false;
+	// 
+	//
+};
+//using namespace RegExpParser;
+#define ZERO RegExpParser::ERule {0,0,0,0}
+#define TEXTSIM(str)  RegExpParser::ERule {RegExpParser::rule_type::text,0,0,str}
+#define TEXT_TYPE(type,str)  {type,0,0,str}
+#define USE_RULE(type,rule)  {type,rule,0,0}
+#define START_R(rule) {RegExpParser::rule_type::start_rule,0,rule,0}
+#define START_R_STYLE(rule,style) {RegExpParser::rule_type::start_rule|style,0,rule,0}
+#define START_A_R(type) {RegExpParser::rule_type::start_anonim_rule|RegExpParser::rule_type::styled_parent|type,0,0,0}
+#define ISCHECKTYPE(i,typerule) ((rules[i].type & typerule) == typerule)
+#define GETRULEREFINDEX(i) (rulemap[(rules[i].ruleref)])
+
+const RegExpParser::ERule rules[] = {
+	ZERO,
+	START_R(RegExpParser::defrule::letter),
+	  TEXT_TYPE(RegExpParser::rule_type::char_any, "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_"),
+	  ZERO,
+	START_R(RegExpParser::defrule::letters),
+	  USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::letter),
+	  ZERO,
+	START_R(RegExpParser::defrule::anchor),
+	  TEXTSIM("\\"),
+	  TEXT_TYPE(RegExpParser::rule_type::char_any, "bBAzZG"),
+	  TEXT_TYPE(RegExpParser::rule_type::char_any | RegExpParser::rule_type::alternative, "^$"),
+	  ZERO,
+	START_R(RegExpParser::defrule::match_point_reset),
+	  TEXTSIM("\\K"),
+	  ZERO,
+	START_R(RegExpParser::defrule::backtracking_control_1),
+	  TEXTSIM("ACCEPT"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "FAIL"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "COMMIT"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text | RegExpParser::rule_type::zero_one, "MARK"),
+	  TEXTSIM(":"),
+	  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::name),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "PRUNE"),
+	  START_A_R(RegExpParser::rule_type::zero_one),
+		  TEXTSIM(":"),
+		  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::name),
+		  ZERO,
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "SKIP"),
+	  START_A_R(RegExpParser::rule_type::zero_one),
+		  TEXTSIM(":"),
+		  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::name),
+		  ZERO,
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "THEN"),
+	  START_A_R(RegExpParser::rule_type::zero_one),
+		  TEXTSIM(":"),
+		  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::name),
+		  ZERO,
+	  ZERO,
+	START_R_STYLE(RegExpParser::defrule::backtracking_control,RegExpParser::rule_type::styled_ALL),
+	  TEXTSIM("(*"),
+	  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::backtracking_control_1),
+	  TEXTSIM(")"),
+	ZERO,
+	START_R(RegExpParser::defrule::name),
+	  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::letter),
+	  START_A_R(RegExpParser::rule_type::zero_more),
+		  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::letter),
+		  USE_RULE(RegExpParser::rule_type::alternative,RegExpParser::defrule::digit),
+		  ZERO,
+	  ZERO,
+	START_R(RegExpParser::defrule::option_setting_flag),
+	  TEXT_TYPE(RegExpParser::rule_type::char_any, "iJmsUx"),
+	  ZERO,
+	START_R(RegExpParser::defrule::digit),
+	  TEXT_TYPE(RegExpParser::rule_type::char_any, "0123456789"),
+	  ZERO,
+	START_R(RegExpParser::defrule::digits),
+	  USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::digit),
+	  ZERO,
+	START_R(RegExpParser::defrule::hex),
+	  TEXT_TYPE(RegExpParser::rule_type::char_any, "0123456789abcdefABCDEF"),
+	  ZERO,
+	START_R(RegExpParser::defrule::quoting),
+	  TEXTSIM("\\Q"),
+	  TEXT_TYPE(RegExpParser::rule_type::special_dot | RegExpParser::rule_type::zero_more, ""),
+	  TEXTSIM("\\E"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\"),
+	  TEXT_TYPE(RegExpParser::rule_type::special_dot, ""),
+	  ZERO,
+	START_R(RegExpParser::defrule::newline_conventions),
+	  TEXTSIM("CRLF"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"LF"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"CR"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"ANYCRLF"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"ANY"),
+	  ZERO,
+
+	  // option_setting
+	START_R(RegExpParser::defrule::option_setting_22),
+	  TEXT_TYPE(RegExpParser::rule_type::text,"-"),
+	  USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::option_setting_flag),
+	  ZERO,
+	START_R(RegExpParser::defrule::option_setting_21),
+	  USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::option_setting_flag),
+	  USE_RULE(RegExpParser::rule_type::zero_one,RegExpParser::defrule::option_setting_22),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"-"),
+	  USE_RULE(RegExpParser::rule_type::one_more,RegExpParser::defrule::option_setting_flag),
+	  ZERO,
+	START_R(RegExpParser::defrule::option_setting_111),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "UTF"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"UCP"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"NO_AUTO_POSSESS"),
+	  USE_RULE(RegExpParser::rule_type::alternative,RegExpParser::defrule::newline_conventions),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"NO_START_OPT"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"BSR_ANYCRLF"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"BSR_UNICODE"),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"LIMIT_MATCH="),
+	  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::digits),
+	  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text,"LIMIT_RECURSION="),
+	  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::digits),
+	  ZERO,
+	START_R(RegExpParser::defrule::option_setting_1),
+	  TEXTSIM("*"),
+	  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::option_setting_111),
+	  ZERO,
+	START_R(RegExpParser::defrule::option_setting_2),
+	  TEXTSIM("?"),
+	  USE_RULE(RegExpParser::rule_type::zero_one,RegExpParser::defrule::option_setting_21),
+	  ZERO,
+	START_R_STYLE(RegExpParser::defrule::option_setting,RegExpParser::rule_type::styled_ALL),
+	  TEXTSIM("("),
+		  START_A_R(RegExpParser::rule_type::none),
+		  USE_RULE(RegExpParser::rule_type::none,RegExpParser::defrule::option_setting_1),
+		  USE_RULE(RegExpParser::rule_type::alternative,RegExpParser::defrule::option_setting_2),
+		  ZERO,
+	  TEXTSIM(")"),
+	  ZERO,
+	  // PCRE START rule
+	  START_R(RegExpParser::defrule::pcre),
+		  USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::alternation),
+		  ZERO,
+	  START_R(RegExpParser::defrule::alternation),
+		  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::expr),
+		  START_A_R(RegExpParser::rule_type::zero_more),
+			  TEXTSIM("|"),
+			  USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::expr),
+			  ZERO,
+		  ZERO,
+	  START_R(RegExpParser::defrule::expr),
+		  USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::element),
+		  ZERO,
+	  START_R(RegExpParser::defrule::element),
+		  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::atom),
+		  USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::quantifier),
+		  ZERO,
+	  START_R(RegExpParser::defrule::atom),		////////////////////////////////////////////  ATOM
+		  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::option_setting),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::backtracking_control),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::atomic_group),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::lookaround),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::backreference),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::conditional_pattern),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::comment),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::capture),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character_type),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character_class),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::posix_character_class),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::letter),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::digit),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::anchor),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::match_point_reset),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::quoting),
+		  USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::other),
+		  ZERO,
+	  START_R_STYLE(RegExpParser::defrule::quantifier, RegExpParser::rule_type::styled_ALL),
+		  TEXT_TYPE(RegExpParser::rule_type::char_any, "?*+"),
+		  START_A_R(RegExpParser::rule_type::zero_one),
+			  TEXTSIM("+"),
+			  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "?"),
+			  ZERO,
+		  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "{"),
+		  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digits),
+		  START_A_R(RegExpParser::rule_type::zero_one),
+			  TEXTSIM(","),
+			  USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::digits),
+			  ZERO,
+		  TEXTSIM("}"),
+		  START_A_R(RegExpParser::rule_type::zero_one),
+			  TEXTSIM("+"),
+			  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "?"),
+			  ZERO,
+		  ZERO,
+	  START_R(RegExpParser::defrule::comment),
+		  TEXTSIM("(?#"),
+		  TEXT_TYPE(RegExpParser::rule_type::inversion | RegExpParser::rule_type::char_any | RegExpParser::rule_type::one_more, ")"),
+		  TEXTSIM(")"),
+		  ZERO,
+	  START_R(RegExpParser::defrule::option_setting_flag_cap),
+		  USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::option_setting_flag),
+		  USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::option_setting_22),
+		  ZERO,
+	  START_R(RegExpParser::defrule::capture_1),
+		  TEXTSIM("?"),
+		  START_A_R(RegExpParser::rule_type::none),
+			  TEXTSIM("<"),
+			  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+			  TEXTSIM(">"),
+			  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
+			  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\'"),
+			  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+			  TEXTSIM("\'"),
+			  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
+			  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "P<"),
+			  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+			  TEXTSIM(">"),
+			  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
+			  USE_RULE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::zero_one, RegExpParser::defrule::option_setting_flag_cap),
+			  TEXTSIM(":"),
+			  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
+			  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "|"),
+			  USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
+			  ZERO,
+		  ZERO,
+	  START_R(RegExpParser::defrule::capture),
+		TEXTSIM("("),
+		  START_A_R(RegExpParser::rule_type::none),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::capture_1),
+			USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::alternation),
+			//TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "?"),
+			ZERO,
+		TEXTSIM(")"),
+		ZERO,
+	  START_R(RegExpParser::defrule::atomic_group),
+		TEXTSIM("(?>"),
+		USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
+		TEXTSIM(")"),
+		ZERO,
+	  START_R(RegExpParser::defrule::lookaround),
+		TEXTSIM("(?"),
+		START_A_R(RegExpParser::rule_type::none),
+			  TEXTSIM("="),
+			  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "!"),
+			  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "<="),
+			  TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "<!"),
+			  ZERO,
+		USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::alternation),
+		TEXTSIM(")"),
+		ZERO,
+		START_R_STYLE(RegExpParser::defrule::backreference,RegExpParser::rule_type::styled_ALL),
+			START_A_R(RegExpParser::rule_type::none),
+				TEXTSIM("\\g"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digits),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\g{"),
+				TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "-"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digits),
+				TEXTSIM("}"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\g{"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+				TEXTSIM("}"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\k<"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+				TEXTSIM(">"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\k\'"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+				TEXTSIM("\'"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\k{"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+				TEXTSIM("}"),
+				ZERO,
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "(?P="),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+			TEXTSIM(")"),
+			ZERO,
+		START_R(RegExpParser::defrule::hex4),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
+			ZERO,
+		START_R_STYLE(RegExpParser::defrule::character,RegExpParser::rule_type::styled_ALL),
+			TEXTSIM("\\"),
+			START_A_R(RegExpParser::rule_type::none),
+				TEXT_TYPE(RegExpParser::rule_type::char_any, "acefnrt"),
+				USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::digit),
+				START_A_R(RegExpParser::rule_type::zero_one),
+					 USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digit),
+					 USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::digit),
+					 ZERO,
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "o{"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digit),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digit),
+				USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::digit),
+				TEXTSIM("}"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "x"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "x{"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex),
+				USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::hex),
+				TEXTSIM("}"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "u"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::hex4),
+				USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::hex4),
+				ZERO,
+			ZERO,
+		START_R_STYLE(RegExpParser::defrule::character_type,RegExpParser::rule_type::styled_ALL),
+			TEXTSIM("."),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\\"),
+			START_A_R(RegExpParser::rule_type::none),
+				TEXT_TYPE(RegExpParser::rule_type::char_any, "CdDhHNRsSvVwWX"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "p{"),
+				TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "^"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+				TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "&"),
+				TEXTSIM("}"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "P{"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+				TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "&"),
+				TEXTSIM("}"),
+				TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "p"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::letter),
+				USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::letter),
+				ZERO,
+			ZERO,
+		START_R(RegExpParser::defrule::posix_character_class_name),
+			TEXTSIM("alnum"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "alpha"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "ascii"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "blank"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "ctrl"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "digit"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "graph"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "lower"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "print"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "punct"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "space"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "upper"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "word"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "xdigit"),
+			ZERO,
+		START_R_STYLE(RegExpParser::defrule::posix_character_class,RegExpParser::rule_type::styled_ALL),
+			TEXTSIM("[:"),
+			TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "^"),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::posix_character_class_name),
+			TEXTSIM(":]"),
+			//TEXT_TYPE(RegExpParser::rule_type::inversion | RegExpParser::rule_type::char_any | RegExpParser::rule_type::zero_one, "^"),
+			ZERO,
+		START_R(RegExpParser::defrule::character_class_range_atom),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::character),
+			TEXT_TYPE(RegExpParser::rule_type::inversion | RegExpParser::rule_type::char_any , "]"),
+			ZERO,
+		START_R(RegExpParser::defrule::character_class_range),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::character_class_range_atom),
+			TEXTSIM("-"),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::character_class_range_atom),
+			ZERO,
+		START_R(RegExpParser::defrule::character_class_atom),
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::quoting),
+			USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character_class_range_atom),
+			USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::posix_character_class),
+			USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character),
+			USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::character_type),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::inversion | RegExpParser::rule_type::char_any, "\\]"),
+			ZERO,
+		START_R(RegExpParser::defrule::character_class),
+			TEXTSIM("["),
+			TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "^"),
+			TEXTSIM("]"),
+			USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::character_class_atom),
+			TEXTSIM("]"),
+			TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "["),
+			TEXT_TYPE(RegExpParser::rule_type::zero_one | RegExpParser::rule_type::text, "^"),
+			USE_RULE(RegExpParser::rule_type::one_more, RegExpParser::defrule::character_class_atom),
+			TEXTSIM("]"),
+			ZERO,
+		START_R(RegExpParser::defrule::other),
+			TEXT_TYPE(RegExpParser::rule_type::char_any | RegExpParser::rule_type::inversion, "\\^$.[|()?+{"),
+			//TEXT_TYPE(RegExpParser::rule_type::none |RegExpParser::rule_type::special_dot, ""),
+			//TEXT_TYPE(RegExpParser::rule_type::alternative |RegExpParser::rule_type::text, "\\"),
+			ZERO,
+		START_R(RegExpParser::defrule::call_out),
+			TEXTSIM("(?C"),
+			USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::digits),
+			TEXTSIM(")"),
+			ZERO,
+		START_R(RegExpParser::defrule::conditional_pattern),
+			TEXTSIM("(?"),
+			START_A_R(RegExpParser::rule_type::none),
+				TEXTSIM("("),
+					START_A_R(RegExpParser::rule_type::none),
+						TEXT_TYPE(RegExpParser::rule_type::char_any | RegExpParser::rule_type::zero_one, "+-"),
+						USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::digits),
+						TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "<"),
+						USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+						TEXT_TYPE(RegExpParser::rule_type::text, ">"),
+						TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "\'"),
+						USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+						TEXT_TYPE(RegExpParser::rule_type::text, "\'"),
+						TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "R&"),
+						USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::name),
+						TEXT_TYPE(RegExpParser::rule_type::alternative | RegExpParser::rule_type::text, "R"),
+						USE_RULE(RegExpParser::rule_type::zero_one, RegExpParser::defrule::digits),
+						USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::name),
+						ZERO,
+				TEXTSIM(")"),
+				USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::call_out),
+				USE_RULE(RegExpParser::rule_type::alternative, RegExpParser::defrule::lookaround),
+				ZERO,
+			USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::expr),
+			START_A_R(RegExpParser::rule_type::zero_one),
+				TEXTSIM("|"),
+				USE_RULE(RegExpParser::rule_type::none, RegExpParser::defrule::expr),
+				ZERO,
+			TEXTSIM(")"),
+			ZERO,
+ZERO
+};
+#endif
diff --git a/include/ctl/xh_styledtext.h b/include/ctl/xh_styledtext.h
new file mode 100644
index 0000000..f7b2906
--- /dev/null
+++ b/include/ctl/xh_styledtext.h
@@ -0,0 +1,30 @@
+//////////////////////////////////////////////////////////////////////////
+//
+// pgAdmin III - PostgreSQL Tools
+//
+// Copyright (C) 2002 - 2016, The pgAdmin Development Team
+// This software is released under the PostgreSQL Licence
+//
+// xh_styledtext.h - wxStyledText handler
+//
+//////////////////////////////////////////////////////////////////////////
+
+
+#ifndef _WX_XH_STYLEDTEXT_H_
+#define _WX_XH_STYLEDTEXT_H_
+
+
+#include "wx/xrc/xmlres.h"
+
+//class WXDLLIMPEXP_XRC
+class ctlStyledTextXmlHandler : public wxXmlResourceHandler
+{
+	DECLARE_DYNAMIC_CLASS(ctlStyledTextXmlHandler)
+public:
+	ctlStyledTextXmlHandler();
+	virtual wxObject *DoCreateResource();
+	virtual bool CanHandle(wxXmlNode *node);
+};
+
+
+#endif // _WX_XH_STYLEDTEXT_H_
diff --git a/pgAdmin3.cpp b/pgAdmin3.cpp
index f90fa55..d01cae4 100644
--- a/pgAdmin3.cpp
+++ b/pgAdmin3.cpp
@@ -73,6 +73,8 @@
 #include "ctl/xh_ctltree.h"
 #include "ctl/xh_ctlchecktreeview.h"
 #include "ctl/xh_ctlcolourpicker.h"
+#include "ctl/xh_styledtext.h"
+
 
 #define DOC_DIR       wxT("/docs")
 #define UI_DIR        wxT("/ui")
@@ -508,7 +510,8 @@ bool pgAdmin3::OnInit()
 	wxXmlResource::Get()->AddHandler(new ctlTreeXmlHandler);
 	wxXmlResource::Get()->AddHandler(new ctlCheckTreeViewXmlHandler);
 	wxXmlResource::Get()->AddHandler(new ctlColourPickerXmlHandler);
-
+	wxXmlResource::Get()->AddHandler(new ctlStyledTextXmlHandler);
+	//wxXmlResource::Get()->AddHandler(new ctlTreeJSONXmlHandler);
 	InitXml();
 
 	wxOGLInitialize();