diff --git a/Ide/Code/IdeDoc.cpp b/Ide/Code/IdeDoc.cpp
--- a/Ide/Code/IdeDoc.cpp
+++ b/Ide/Code/IdeDoc.cpp
@@ -1,2119 +1,2132 @@
 #include <stdio.h>
 #include <ctype.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Token.h"
 #include "lgi/common/Net.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/ScrollBar.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/List.h"
 #include "lgi/common/PopupList.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/EventTargetThread.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/Http.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/FileSelect.h"
 #include "LgiIde.h"
 #include "ProjectNode.h"
 #include "SpaceTabConv.h"
 #include "DocEdit.h"
 #include "IdeDocPrivate.h"
 
 const char *Untitled = "[untitled]";
 // static const char *White = " \r\t\n";
 
 #define USE_OLD_FIND_DEFN	1
 #define POPUP_WIDTH			700 // px
 #define POPUP_HEIGHT		350 // px
 
 enum
 {
 	IDM_COPY_FILE = 1100,
 	IDM_COPY_PATH,
 	IDM_BROWSE
 };
 
 int FileNameSorter(char **a, char **b)
 {
 	char *A = strrchr(*a, DIR_CHAR);
 	char *B = strrchr(*b, DIR_CHAR);
 	return stricmp(A?A:*a, B?B:*b);
 }
 
 EditTray::EditTray(LTextView3 *ctrl, IdeDoc *doc)
 {
 	Ctrl = ctrl;
 	Doc = doc;
 	Line = Col = 0;
 	FuncBtn.ZOff(-1, -1);
 	SymBtn.ZOff(-1, -1);
 		
 	int Ht = LSysFont->GetHeight() + 6;
 	AddView(FileSearch   = new LEdit(IDC_FILE_SEARCH,   0, 0, EDIT_CTRL_WIDTH, Ht));
 	AddView(FuncSearch   = new LEdit(IDC_METHOD_SEARCH, 0, 0, EDIT_CTRL_WIDTH, Ht));
 	AddView(SymSearch    = new LEdit(IDC_SYMBOL_SEARCH, 0, 0, EDIT_CTRL_WIDTH, Ht));
 	AddView(AllPlatforms = new LCheckBox(IDC_ALL_PLATFORMS, 0, 0, 20, Ht, "All Platforms"));
 }
 	
 EditTray::~EditTray()
 {
 }
 	
 void EditTray::GotoSearch(int CtrlId, char *InitialText)
 {
 	if (FileSearch && FileSearch->GetId() == CtrlId)
 	{
 		FileSearch->Name(InitialText);
 		FileSearch->Focus(true);
 		if (InitialText)
 			FileSearch->SendNotify(LNotifyDocChanged);
 	}
 		
 	if (FuncSearch && FuncSearch->GetId() == CtrlId)
 	{
 		FuncSearch->Name(InitialText);
 		FuncSearch->Focus(true);
 		if (InitialText)
 			FuncSearch->SendNotify(LNotifyDocChanged);
 	}
 
 	if (SymSearch && SymSearch->GetId() == CtrlId)
 	{
 		SymSearch->Name(InitialText);
 		SymSearch->Focus(true);
 		if (InitialText)
 			SymSearch->SendNotify(LNotifyDocChanged);
 	}
 }
 	
 void EditTray::OnCreate()
 {
 	AttachChildren();
 }
 
 int MeasureText(const char *s)
 {
 	LDisplayString Ds(LSysFont, s);
 	return Ds.X();
 }
 
 #define HEADER_BTN_LABEL	"h"
 #define FUNCTION_BTN_LABEL	"{ }"
 #define SYMBOL_BTN_LABEL	"s"
 	
 void EditTray::OnPosChange()
 {
 	LLayoutRect c(this, 2);
 
 	c.Left(FileBtn, MeasureText(HEADER_BTN_LABEL)+10);
 	if (FileSearch)
 		c.Left(FileSearch, EDIT_CTRL_WIDTH);
 	c.x1 += 8;
 
 	c.Left(FuncBtn, MeasureText(FUNCTION_BTN_LABEL)+10);
 	if (FuncSearch)
 		c.Left(FuncSearch, EDIT_CTRL_WIDTH);
 	c.x1 += 8;
 
 	c.Left(SymBtn, MeasureText(SYMBOL_BTN_LABEL)+10);
 	if (SymSearch)
 		c.Left(SymSearch, EDIT_CTRL_WIDTH);
 	c.x1 += 8;
 
 	if (AllPlatforms)
 	{
 		LViewLayoutInfo Inf;
 		AllPlatforms->OnLayout(Inf);
 		c.Left(AllPlatforms, Inf.Width.Max);
 	}
 		
 	c.Remaining(TextMsg);
 }
 	
 void EditTray::OnPaint(LSurface *pDC)
 {
 	LRect c = GetClient();
 	pDC->Colour(L_MED);
 	pDC->Rectangle();
 	LSysFont->Colour(L_TEXT, L_MED);
 	LSysFont->Transparent(true);
 		
 	LString s;
 	s.Printf("Cursor: %i,%i", Col, Line + 1);
 	{
 		LDisplayString ds(LSysFont, s);
 		ds.Draw(pDC, TextMsg.x1, TextMsg.y1 + ((c.Y()-TextMsg.Y())/2), &TextMsg);
 	}
 
 	LRect f = FileBtn;
 	LThinBorder(pDC, f, DefaultRaisedEdge);
 	{
 		LDisplayString ds(LSysFont, HEADER_BTN_LABEL);
 		ds.Draw(pDC, f.x1 + 4, f.y1);
 	}
 
 	f = FuncBtn;
 	LThinBorder(pDC, f, DefaultRaisedEdge);
 	{
 		LDisplayString ds(LSysFont, FUNCTION_BTN_LABEL);
 		ds.Draw(pDC, f.x1 + 4, f.y1);
 	}
 
 	f = SymBtn;
 	LThinBorder(pDC, f, DefaultRaisedEdge);
 	{
 		LDisplayString ds(LSysFont, SYMBOL_BTN_LABEL);
 		ds.Draw(pDC, f.x1 + 4, f.y1);
 	}
 }
 
 bool EditTray::Pour(LRegion &r)
 {
 	LRect *c = FindLargest(r);
 	if (c)
 	{
 		LRect n = *c;
 		SetPos(n);		
 		return true;
 	}
 	return false;
 }
 
 void EditTray::OnHeaderList(LMouse &m)
 {
 	// Header list button
 	LArray<LString> Paths;
 	if (Doc->BuildIncludePaths(Paths, PlatformCurrent, false))
 	{
 		LArray<char*> Headers;
 		if (Doc->BuildHeaderList(Ctrl->NameW(), Headers, Paths))
 		{
 			// Sort them..
 			Headers.Sort(FileNameSorter);
 			
 			LSubMenu *s = new LSubMenu;
 			if (s)
 			{
 				// Construct the menu
 				LHashTbl<StrKey<char>, int> Map;
 				int DisplayLines = GdcD->Y() / LSysFont->GetHeight();
 				if (Headers.Length() > (0.9 * DisplayLines))
 				{
 					LArray<char*> Letters[26];
 					LArray<char*> Other;
 					
 					for (int i=0; i<Headers.Length(); i++)
 					{
 						char *h = Headers[i];
 						char *f = LGetLeaf(h);
 						
 						Map.Add(h, i + 1);
 						
 						if (IsAlpha(*f))
 						{
 							int Idx = tolower(*f) - 'a';
 							Letters[Idx].Add(h);
 						}
 						else
 						{
 							Other.Add(h);
 						}
 					}
 					
 					for (int i=0; i<CountOf(Letters); i++)
 					{
 						if (Letters[i].Length() > 1)
 						{
 							char *First = LGetLeaf(Letters[i][0]);
 							char *Last = LGetLeaf(Letters[i].Last());
 
 							char Title[256];
 							sprintf_s(Title, sizeof(Title), "%s - %s", First, Last);
 							LSubMenu *sub = s->AppendSub(Title);
 							if (sub)
 							{
 								for (int n=0; n<Letters[i].Length(); n++)
 								{
 									char *h = Letters[i][n];
 									int Id = Map.Find(h);
 									LAssert(Id > 0);
 									sub->AppendItem(LGetLeaf(h), Id, true);
 								}
 							}
 						}
 						else if (Letters[i].Length() == 1)
 						{
 							char *h = Letters[i][0];
 							int Id = Map.Find(h);
 							LAssert(Id > 0);
 							s->AppendItem(LGetLeaf(h), Id, true);
 						}
 					}
 
 					if (Other.Length() > 0)
 					{
 						for (int n=0; n<Other.Length(); n++)
 						{
 							char *h = Other[n];
 							int Id = Map.Find(h);
 							LAssert(Id > 0);
 							s->AppendItem(LGetLeaf(h), Id, true);
 						}
 					}
 				}
 				else
 				{
 					for (int i=0; i<Headers.Length(); i++)
 					{
 						char *h = Headers[i];
 						// char *f = LGetLeaf(h);
 						
 						Map.Add(h, i + 1);
 					}
 
 					for (int i=0; i<Headers.Length(); i++)
 					{
 						char *h = Headers[i];
 						int Id = Map.Find(h);
 						if (Id > 0)
 							s->AppendItem(LGetLeaf(h), Id, true);
 						else
 							LgiTrace("%s:%i - Failed to get id for '%s' (map.len=%i)\n", _FL, h, Map.Length());
 					}
 
 					if (!Headers.Length())
 					{
 						s->AppendItem("(none)", 0, false);
 					}
 				}
 				
 				// Show the menu
 				LPoint p(m.x, m.y);
 				PointToScreen(p);
 				int Goto = s->Float(this, p.x, p.y, true);
 				if (Goto > 0)
 				{
 					char *File = Headers[Goto-1];
 					if (File)
 					{
 						// Open the selected file
 						Doc->GetProject()->GetApp()->OpenFile(File);
 					}
 				}
 				
 				DeleteObj(s);
 			}
 		}
 		
 		// Clean up memory
 		Headers.DeleteArrays();
 	}
 	else
 	{
 		LgiTrace("%s:%i - No include paths set.\n", _FL);
 	}
 }
 
 void EditTray::OnFunctionList(LMouse &m)
 {
 	LArray<DefnInfo> Funcs;
 
 	if (BuildDefnList(Doc->GetFileName(), (char16*)Ctrl->NameW(), Funcs, DefnNone /*DefnFunc | DefnClass*/))
 	{
 		LSubMenu s;
 		LArray<DefnInfo*> a;					
 		
 		int ScreenHt = GdcD->Y();
 		int ScreenLines = ScreenHt / LSysFont->GetHeight();
 		float Ratio = ScreenHt ? (float)(LSysFont->GetHeight() * Funcs.Length()) / ScreenHt : 0.0f;
 		bool UseSubMenus = Ratio > 0.9f;
 		int Buckets = UseSubMenus ? (int)(ScreenLines * 0.9) : 1;
 		int BucketSize = MAX(2, (int)Funcs.Length() / Buckets);
 		LSubMenu *Cur = NULL;
 		
 		for (unsigned n=0; n<Funcs.Length(); n++)
 		{
 			DefnInfo *i = &Funcs[n];
 			char Buf[256], *o = Buf;
 			
 			if (i->Type != DefnEnumValue)
 			{
 				for (char *k = i->Name; *k && o < Buf+sizeof(Buf)-8; k++)
 				{
 					if (*k == '&')
 					{
 						*o++ = '&';
 						*o++ = '&';
 					}
 					else if (*k == '\t')
 					{
 						*o++ = ' ';
 					}
 					else
 					{
 						*o++ = *k;
 					}
 				}
 				*o++ = 0;
 				
 				a[n] = i;
 
 				if (UseSubMenus)
 				{
 					if (!Cur || n % BucketSize == 0)
 					{
 						LString SubMsg;
 						SubMsg.Printf("%s...", Buf);
 						Cur = s.AppendSub(SubMsg);
 					}
 					if (Cur)
 						Cur->AppendItem(Buf, n+1, true);
 				}
 				else
 				{
 					s.AppendItem(Buf, n+1, true);
 				}
 			}
 		}
 		
 		LPoint p(m.x, m.y);
 		PointToScreen(p);
 		int Goto = s.Float(this, p.x, p.y, true);
 		if (Goto)
 		{
 			DefnInfo *Info = a[Goto-1];
 			if (Info)
 			{
 				Ctrl->SetLine(Info->Line);
 			}
 		}
 	}
 	else
 	{
 		LgiTrace("%s:%i - No functions in input.\n", _FL);
 	}
 }
 
 void EditTray::OnSymbolList(LMouse &m)
 {
 	LAutoString s(Ctrl->GetSelection());
 	if (s)
 	{
 		LAutoWString sw(Utf8ToWide(s));
 		if (sw)
 		{
 			#if USE_OLD_FIND_DEFN
 			List<DefnInfo> Matches;
 			Doc->FindDefn(sw, Ctrl->NameW(), Matches);
 			#else
 			LArray<FindSymResult> Matches;
 			Doc->GetApp()->FindSymbol(s, Matches);
 			#endif
 
 			LSubMenu *s = new LSubMenu;
 			if (s)
 			{
 				// Construct the menu
 				int n=1;
 				
 				#if USE_OLD_FIND_DEFN
 				for (auto Def: Matches)
 				{
 					char m[512];
 					char *d = strrchr(Def->File, DIR_CHAR);
 					sprintf(m, "%s (%s:%i)", Def->Name.Get(), d ? d + 1 : Def->File.Get(), Def->Line);
 					s->AppendItem(m, n++, true);
 				}
 				#else
 				for (int i=0; i<Matches.Length(); i++)
 				{
 					FindSymResult &Res = Matches[i];
 					char m[512];
 					char *d = strrchr(Res.File, DIR_CHAR);
 					sprintf(m, "%s (%s:%i)", Res.Symbol.Get(), d ? d + 1 : Res.File.Get(), Res.Line);
 					s->AppendItem(m, n++, true);
 				}
 				#endif
 
 				if (!Matches.Length())
 				{
 					s->AppendItem("(none)", 0, false);
 				}
 				
 				// Show the menu
 				LPoint p(m.x, m.y);
 				PointToScreen(p);
 				int Goto = s->Float(this, p.x, p.y, true);
 				if (Goto)
 				{
 					#if USE_OLD_FIND_DEFN
 					DefnInfo *Def = Matches[Goto-1];
 					#else
 					FindSymResult *Def = &Matches[Goto-1];
 					#endif
 					{
 						// Open the selected symbol
 						if (Doc->GetProject() &&
 							Doc->GetProject()->GetApp())
 						{
 							AppWnd *App = Doc->GetProject()->GetApp();
 							IdeDoc *Doc = App->OpenFile(Def->File);
 
 							if (Doc)
 							{
 								Doc->SetLine(Def->Line, false);
 							}
 							else
 							{
 								char *f = Def->File;
 								LgiTrace("%s:%i - Couldn't open doc '%s'\n", _FL, f);
 							}
 						}
 						else
 						{
 							LgiTrace("%s:%i - No project / app ptr.\n", _FL);
 						}
 					}
 				}
 				
 				DeleteObj(s);
 			}
 		}
 	}
 	else
 	{
 		LSubMenu *s = new LSubMenu;
 		if (s)
 		{
 			s->AppendItem("(No symbol currently selected)", 0, false);
 			LPoint p(m.x, m.y);
 			PointToScreen(p);
 			s->Float(this, p.x, p.y, true);
 			DeleteObj(s);
 		}
 	}
 }
 
 void EditTray::OnMouseClick(LMouse &m)
 {
 	if (m.Left() && m.Down())
 	{
 		if (FileBtn.Overlap(m.x, m.y))
 		{
 			OnHeaderList(m);
 		}
 		else if (FuncBtn.Overlap(m.x, m.y))
 		{
 			OnFunctionList(m);
 		}
 		else if (SymBtn.Overlap(m.x, m.y))
 		{
 			OnSymbolList(m);
 		}
 	}
 }
 
 class ProjMethodPopup : public LPopupList<DefnInfo>
 {
 	AppWnd *App;
 
 public:
 	LArray<DefnInfo> All;
 
 	ProjMethodPopup(AppWnd *app, LViewI *target) : LPopupList(target, PopupAbove, POPUP_WIDTH)
 	{
 		App = app;
 	}
 
 	LString ToString(DefnInfo *Obj)
 	{
 		return Obj->Name;
 	}
 	
 	void OnSelect(DefnInfo *Obj)
 	{
 		App->GotoReference(Obj->File, Obj->Line, false);
 	}
 	
 	bool Name(const char *s)
 	{
 		LString InputStr = s;
 		LString::Array p = InputStr.SplitDelimit(" \t");
 		
 		LArray<DefnInfo*> Matching;
 		for (unsigned i=0; i<All.Length(); i++)
 		{
 			DefnInfo *Def = &All[i];
 			
 			bool Match = true;
 			for (unsigned n=0; n<p.Length(); n++)
 			{
 				if (!stristr(Def->Name, p[n]))
 				{
 					Match = false;
 					break;
 				}
 			}
 			
 			if (Match)
 				Matching.Add(Def);
 		}
 		
 		return SetItems(Matching);
 	}
 	
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		if (Lst &&
 			Ctrl == Edit &&
 			(n.Type == LNotifyValueChanged || n.Type == LNotifyDocChanged))
 		{
 			Name(Edit->Name());
 		}
 		
 		return LPopupList<DefnInfo>::OnNotify(Ctrl, n);
 	}
 };
 
 class ProjSymPopup : public LPopupList<FindSymResult>
 {
 	AppWnd *App;
 	IdeDoc *Doc;
 	int CommonPathLen;
 
 public:
 	LArray<FindSymResult*> All;
 
 	ProjSymPopup(AppWnd *app, IdeDoc *doc, LViewI *target) : LPopupList(target, PopupAbove, POPUP_WIDTH)
 	{
 		App = app;
 		Doc = doc;
 		CommonPathLen = 0;
 	}
 	
 	void FindCommonPathLength()
 	{
 		LString s;
 		
 		for (unsigned i=0; i<All.Length(); i++)
 		{
 			if (i)
 			{
 				char *a = s.Get();
 				char *a_end = strrchr(a, DIR_CHAR);
 
 				char *b = All[i]->File.Get();
 				char *b_end = strrchr(b, DIR_CHAR);
 
 				int Common = 0;
 				while (	*a && a <= a_end
 						&& 
 						*b && b <= b_end
 						&&
 						ToLower(*a) == ToLower(*b))
 				{
 					Common++;
 					a++;
 					b++;
 				}
 				if (i == 1)
 					CommonPathLen = Common;
 				else
 					CommonPathLen = MIN(CommonPathLen, Common);
 			}
 			else s = All[i]->File;
 		}
 	}
 
 	LString ToString(FindSymResult *Obj)
 	{
 		LString s;
 		s.Printf("%s:%i - %s",
 				CommonPathLen < Obj->File.Length()
 				?
 				Obj->File.Get() + CommonPathLen
 				:
 				Obj->File.Get(),
 				Obj->Line,
 				Obj->Symbol.Get());
 		return s;
 	}
 	
 	void OnSelect(FindSymResult *Obj)
 	{
 		App->GotoReference(Obj->File, Obj->Line, false);
 	}
 	
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		if (Lst &&
 			Ctrl == Edit &&
 			(n.Type == LNotifyValueChanged || n.Type == LNotifyDocChanged))
 		{
 			// Kick off search...
 			LString s = Ctrl->Name();
 			int64 AllPlatforms = Ctrl->GetParent()->GetCtrlValue(IDC_ALL_PLATFORMS);
 			s = s.Strip();
 			if (s.Length() > 2)
 				App->FindSymbol(Doc->AddDispatch(), s, AllPlatforms != 0);
 		}
 		
 		return LPopupList<FindSymResult>::OnNotify(Ctrl, n);
 	}
 };
 
 void FilterFiles(LArray<ProjectNode*> &Perfect, LArray<ProjectNode*> &Nodes, LString InputStr)
 {
 	LString::Array p = InputStr.SplitDelimit(" \t");
 		
 	auto InputLen = InputStr.RFind(".");
 	if (InputLen < 0)
 		InputLen = InputStr.Length();
 
 	LArray<ProjectNode*> Partial;
 	auto Start = LCurrentTime();
 	for (unsigned i=0; i<Nodes.Length(); i++)
 	{
 		if (i % 100 == 0 && LCurrentTime() - Start > 400)
 		{
 			break;
 		}
 		ProjectNode *Pn = Nodes[i];
 		auto Fn = Pn->GetFileName();
 		if (Fn)
 		{
 			char *Dir = strchr(Fn, '/');
 			if (!Dir) Dir = strchr(Fn, '\\');
 			auto Leaf = Dir ? strrchr(Fn, *Dir) : Fn;
 				
 			bool Match = true;
 			for (unsigned n=0; n<p.Length(); n++)
 			{
 				if (!stristr(Leaf, p[n]))
 				{
 					Match = false;
 					break;
 				}
 			}
 			if (Match)
 			{
 				bool PerfectMatch = false;
 				auto Leaf = LGetLeaf(Fn);
 				if (Leaf)
 				{
 					auto Dot = strrchr(Leaf, '.');
 					if (Dot)
 					{
 						auto Len = Dot - Leaf;
 						PerfectMatch =	Len == InputLen &&
 										strncmp(InputStr, Leaf, Len) == 0;
 					}
 					else
 					{
 						PerfectMatch = stricmp(InputStr, Leaf);
 					}
 				}
 
 				if (PerfectMatch)
 					Perfect.Add(Pn);
 				else
 					Partial.Add(Pn);
 			}
 		}
 	}
 
 	Perfect.Add(Partial);
 }
 
 class ProjFilePopup : public LPopupList<ProjectNode>
 {
 	AppWnd *App;
 
 public:
 	LArray<ProjectNode*> Nodes;
 
 	ProjFilePopup(AppWnd *app, LViewI *target) : LPopupList(target, PopupAbove, POPUP_WIDTH)
 	{
 		App = app;
 	}
 
 	LString ToString(ProjectNode *Obj)
 	{
 		return LString(Obj->GetFileName());
 	}
 	
 	void OnSelect(ProjectNode *Obj)
 	{
 		auto Fn = Obj->GetFileName();
 		if (LIsRelativePath(Fn))
 		{
 			IdeProject *Proj = Obj->GetProject();
 			LAutoString Base = Proj->GetBasePath();
 			LFile::Path p(Base);
 			p += Fn;
 			App->GotoReference(p, 1, false);			
 		}
 		else
 		{
 			App->GotoReference(Fn, 1, false);
 		}
 	}
 	
 	void Update(LString InputStr)
 	{
 		LArray<ProjectNode*> Matches;
 		FilterFiles(Matches, Nodes, InputStr);
 		SetItems(Matches);
 	}
 	
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		if (Lst &&
 			Ctrl == Edit &&
 			(n.Type == LNotifyValueChanged || n.Type == LNotifyDocChanged))
 		{
 			auto s = Ctrl->Name();
 			if (ValidStr(s))
 				Update(s);
 		}
 		
 		return LPopupList<ProjectNode>::OnNotify(Ctrl, n);
 	}
 };
 
 class LStyleThread : public LEventTargetThread
 {
 public:
 	LStyleThread() : LEventTargetThread("StyleThread")
 	{
 	}
 	
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		switch (Msg->Msg())
 		{
 		}
 		
 		return 0;
 	}
 	
 }	StyleThread;
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 IdeDocPrivate::IdeDocPrivate(IdeDoc *d, AppWnd *a, NodeSource *src, const char *file) : NodeView(src), LMutex("IdeDocPrivate.Lock")
 {
 	FilePopup = NULL;
 	MethodPopup = NULL;
 	SymPopup = NULL;
 
 	App = a;
 	Doc = d;
 	Project = 0;
 	FileName = file;
 	
 	LFontType Font, *Use = 0;
 	if (Font.Serialize(App->GetOptions(), OPT_EditorFont, false))
 	{
 		Use = &Font;
 	}		
 	
 	Doc->AddView(Edit = new DocEdit(Doc, Use));
 	Doc->AddView(Tray = new EditTray(Edit, Doc));
 }
 
 void IdeDocPrivate::OnDelete()
 {
 	IdeDoc *Temp = Doc;
 	DeleteObj(Temp);
 }
 
 void IdeDocPrivate::UpdateName()
 {
 	char n[MAX_PATH_LEN+30];
 	
 	LString Dsp = GetDisplayName();
 	char *File = Dsp;
 	#if MDI_TAB_STYLE
 	char *Dir = File ? strrchr(File, DIR_CHAR) : NULL;
 	if (Dir) File = Dir + 1;
 	#endif
 	
 	strcpy_s(n, sizeof(n), File ? File : Untitled);
 	if (Edit->IsDirty())
 	{
 		strcat(n, " (changed)");
 	}	
 	Doc->Name(n);
 }
 
 LString IdeDocPrivate::GetDisplayName()
 {
 	if (nSrc)
 	{
 		auto Fn = nSrc->GetFileName();
 		if (Fn)
 		{
 			if (stristr(Fn, "://"))
 			{
 				LUri u(nSrc->GetFileName());
 				if (u.sPass)
 				{
 					u.sPass = "******";
 				}
 				
 				return u.ToString();
 			}
 			else if (*Fn == '.')
 			{
 				return nSrc->GetFullPath();
 			}
 		}
 
 		return LString(Fn);
 	}
 
 	return LString(FileName);
 }
 
 bool IdeDocPrivate::IsFile(const char *File)
 {
 	LString Mem;
 	char *f = NULL;
 	
 	if (nSrc)
 	{
 		Mem = nSrc->GetFullPath();
 		f = Mem;
 	}
 	else
 	{
 		f = FileName;
 	}
 
 	if (!f)
 		return false;
 
 	LToken doc(f, DIR_STR);
 	LToken in(File, DIR_STR);
 	ssize_t in_pos = (ssize_t)in.Length() - 1;
 	ssize_t doc_pos = (ssize_t)doc.Length() - 1;
 	while (in_pos >= 0 && doc_pos >= 0)
 	{
 		char *i = in[in_pos--];
 		char *d = doc[doc_pos--];
 		if (!i || !d)
 		{
 			return false;
 		}
 		
 		if (!strcmp(i, ".") ||
 			!strcmp(i, ".."))
 		{
 			continue;
 		}
 		
 		if (stricmp(i, d))
 		{
 			return false;
 		}
 	}
 	
 	return true;
 }
 
 const char *IdeDocPrivate::GetLocalFile()
 {
 	if (nSrc)
 	{
 		if (nSrc->IsWeb())
 			return nSrc->GetLocalCache();
 		
 		auto fp = nSrc->GetFullPath();
 		if (_stricmp(fp.Get()?fp.Get():"", Buffer.Get()?Buffer.Get():""))
 			Buffer = fp;
 		return Buffer;
 	}
 	
 	return FileName;
 }
 
 void IdeDocPrivate::SetFileName(const char *f)
 {
 	nSrc = NULL;
 	FileName = f;
 	Edit->IsDirty(true);
 }
 
 bool IdeDocPrivate::Load()
 {
 	bool Status = false;
 	
 	if (nSrc)
 	{
 		Status = nSrc->Load(Edit, this);
 	}
 	else if (FileName)
 	{
 		if (LFileExists(FileName))
 		{
 			Status = Edit->Open(FileName);
 		}
 		else LgiTrace("%s:%i - '%s' doesn't exist.\n", _FL, FileName.Get());
 	}
 
 	if (Status)
 		ModTs = GetModTime();	
 
 	return Status;
 }
 
 bool IdeDocPrivate::Save()
 {
 	bool Status = false;
 	
 	if (nSrc)
 	{
 		Status = nSrc->Save(Edit, this);
 	}
 	else if (FileName)
 	{
 		Status = Edit->Save(FileName);
 		if (!Status)
 		{
 			const char *Err = Edit->GetLastError();
 			LgiMsg(App, "%s", AppName, MB_OK, Err ? Err : "$unknown_error");
 		}
 		
 		OnSaveComplete(Status);
 	}
 	else
 	{
 		Edit->IsDirty(false);
 	}
 
 	if (Status)
 		ModTs = GetModTime();
 
 	return Status;
 }
 
 void IdeDocPrivate::OnSaveComplete(bool Status)
 {
 	if (Status)
 		Edit->IsDirty(false);
 	UpdateName();
 
 	ProjectNode *Node = dynamic_cast<ProjectNode*>(nSrc);
 	if (Node)
 	{
 		auto Full = nSrc->GetFullPath();
 		App->OnNode(Full, Node, FindSymbolSystem::FileReparse);
 	}
 }
 
 void IdeDocPrivate::CheckModTime()
 {
 	if (!ModTs.IsValid())
 		return;
 
 	LDateTime Ts = GetModTime();
 	if (Ts.IsValid() && Ts > ModTs)
 	{
 		static bool InCheckModTime = false;
 		if (!InCheckModTime)
 		{
 			InCheckModTime = true;
 			if (!Edit->IsDirty() ||
 				LgiMsg(Doc, "Do you want to reload modified file from\ndisk and lose your changes?", AppName, MB_YESNO) == IDYES)
 			{
 				auto Ln = Edit->GetLine();
 				Load();
 				Edit->IsDirty(false);
 				UpdateName();
 				Edit->SetLine((int)Ln);
 			}
 			InCheckModTime = false;
 		}
 	}
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////
 LString IdeDoc::CurIpDoc;
 int IdeDoc::CurIpLine = -1;
 
 IdeDoc::IdeDoc(AppWnd *a, NodeSource *src, const char *file)
 {
 	d = new IdeDocPrivate(this, a, src, file);
 	d->UpdateName();
 
 	/*
 	if (src || file)
 		d->Load();
 	*/
 }
 
 IdeDoc::~IdeDoc()
 {
 	d->App->OnDocDestroy(this);
 	DeleteObj(d);
 }
 
 class WebBuild : public LThread
 {
 	IdeDocPrivate *d;
 	LString Uri;
 	int64 SleepMs;
 	LStream *Log;
 	LCancel Cancel;
 
 public:
 	WebBuild(IdeDocPrivate *priv, LString uri, int64 sleepMs) :
 		LThread("WebBuild"), d(priv), Uri(uri), SleepMs(sleepMs)
 	{
 		Log = d->App->GetBuildLog();
 		Run();
 	}
 
 	~WebBuild()
 	{
 		Cancel.Cancel();
 		while (!IsExited())
 		{
 			LSleep(1);
 		}
 	}
 
 	int Main()
 	{
 		if (SleepMs > 0)
 		{
 			// Sleep for a number of milliseconds to allow the file to upload/save to the website
 			uint64 Ts = LCurrentTime();
 			while (!Cancel.IsCancelled() && (LCurrentTime()-Ts) < SleepMs)
 				LSleep(1);
 		}
 
 		// Download the file...
 		LStringPipe Out;
 		LString Error;
 		bool r = LgiGetUri(&Cancel, &Out, &Error, Uri, NULL/*InHdrs*/, NULL/*Proxy*/);
 		if (r)
 		{
 			// Parse through it and extract any errors...
 		}
 		else
 		{
 			// Show the download error in the build log...
 			Log->Print("%s:%i - Web build download failed: %s\n", _FL, Error.Get());
 		}
 
 		return 0;
 	}
 };
 
 bool IdeDoc::Build()
 {
 	if (!d->Edit)
 		return false;
 
 	int64 SleepMs = -1;
 	LString s = d->Edit->Name(), Uri;
 	LString::Array Lines = s.Split("\n");
 	for (auto Ln : Lines)
 	{
 		s = Ln.Strip();
 		if (s.Find("//") == 0)
 		{
 			LString::Array p = s(2,-1).Strip().Split(":", 1);
 			if (p.Length() == 2)
 			{
 				if (p[0].Equals("build-sleep"))
 				{
 					SleepMs = p[1].Strip().Int();
 				}
 				else if (p[0].Equals("build-uri"))
 				{
 					Uri = p[1].Strip();
 					break;
 				}
 			}
 		}
 	}
 
 	if (Uri)
 	{
 		if (d->Build &&
 			!d->Build->IsExited())
 		{
 			// Already building...
 			LStream *Log = d->App->GetBuildLog();
 			if (Log)
 				Log->Print("%s:%i - Already building...\n");
 			return false;
 		}
 		
 		return d->Build.Reset(new WebBuild(d, Uri, SleepMs));
 	}
 
 	return false;
 }
 
 void IdeDoc::OnLineChange(int Line)
 {
 	d->App->OnLocationChange(d->GetLocalFile(), Line);
 }
 
 void IdeDoc::OnMarginClick(int Line)
 {
 	LString Dn = d->GetDisplayName();
 	d->App->ToggleBreakpoint(Dn, Line);
 }
 
 void IdeDoc::OnTitleClick(LMouse &m)
 {
 	LMdiChild::OnTitleClick(m);
 	
 	if (m.IsContextMenu())
 	{
 		char Full[MAX_PATH_LEN] = "", sFile[MAX_PATH_LEN] = "", sFull[MAX_PATH_LEN] = "", sBrowse[MAX_PATH_LEN] = "";
 		const char *Fn = GetFileName(), *Dir = NULL;
 		IdeProject *p = GetProject();
 		if (Fn)
 		{
 			strcpy_s(Full, sizeof(Full), Fn);
 			if (LIsRelativePath(Fn) && p)
 			{
 				LAutoString Base = p->GetBasePath();
 				if (Base)
 					LMakePath(Full, sizeof(Full), Base, Fn);
 			}
 			
 			Dir = strrchr(Full, DIR_CHAR);
 			if (Dir)
 				sprintf_s(sFile, sizeof(sFile), "Copy '%s'", Dir + 1);
 			sprintf_s(sFull, sizeof(sFull), "Copy '%s'", Full);
 			sprintf_s(sBrowse, sizeof(sBrowse), "Browse to '%s'", Dir ? Dir + 1 : Full);			
 		}
 		
 		LSubMenu s;
 		s.AppendItem("Save", IDM_SAVE, d->Edit->IsDirty());
 		s.AppendItem("Close", IDM_CLOSE, true);
 		if (Fn)
 		{
 			s.AppendSeparator();
 			if (Dir)
 				s.AppendItem(sFile, IDM_COPY_FILE, true);
 			s.AppendItem(sFull, IDM_COPY_PATH, true);
 			s.AppendItem(sBrowse, IDM_BROWSE, true);
 			s.AppendItem("Show In Project", IDM_SHOW_IN_PROJECT, true);
 		}
 		if (p)
 		{
 			s.AppendSeparator();
 			s.AppendItem("Properties", IDM_PROPERTIES, true);
 		}
 		
 		m.ToScreen();
 		int Cmd = s.Float(this, m.x, m.y, m.Left());
 		switch (Cmd)
 		{
 			case IDM_SAVE:
 			{
 				SetClean(NULL);
 				break;
 			}
 			case IDM_CLOSE:
 			{
 				if (OnRequestClose(false))
 					Quit();
 				break;
 			}
 			case IDM_COPY_FILE:
 			{
 				if (Dir)
 				{
 					LClipBoard c(this);
 					c.Text(Dir + 1);
 				}
 				break;
 			}
 			case IDM_COPY_PATH:
 			{
 				LClipBoard c(this);
 				c.Text(Full);
 				break;
 			}
 			case IDM_BROWSE:
 			{
 				LBrowseToFile(Full);
 				break;
 			}
 			case IDM_SHOW_IN_PROJECT:
 			{
 				d->App->ShowInProject(Fn);
 				break;
 			}
 			case IDM_PROPERTIES:
 			{
 				p->ShowFileProperties(Full);
 				break;
 			}
 		}
 	}
 }
 
 AppWnd *IdeDoc::GetApp()
 {
 	return d->App;
 }
 
 bool IdeDoc::IsFile(const char *File)
 {
 	return File ? d->IsFile(File) : false;
 }
 
 bool IdeDoc::AddBreakPoint(ssize_t Line, bool Add)
 {
 	if (Add)
 		d->BreakPoints.Add(Line, true);
 	else
 		d->BreakPoints.Delete(Line);
 	
 	if (d->Edit)
 		d->Edit->Invalidate();
 
 	return true;
 }
 
 
 void IdeDoc::GotoSearch(int CtrlId, char *InitialText)
 {
 	LString File;
 
 	if (CtrlId == IDC_SYMBOL_SEARCH)
 	{
 		// Check if the cursor is on a #include line... in which case we
 		// should look up the header and go to that instead of looking for
 		// a symbol in the code.
 		if (d->Edit)
 		{
 			// Get current line
 			LString Ln = (*d->Edit)[d->Edit->GetLine()];
 			if (Ln.Find("#include") >= 0)
 			{
 				LString::Array a = Ln.SplitDelimit(" \t", 1);
 				if (a.Length() == 2)
 				{
 					File = a[1].Strip("\'\"<>");
 					InitialText = File;
 					CtrlId = IDC_FILE_SEARCH;
 				}
 			}			
 		}
 	}
 
 	if (d->Tray)
 		d->Tray->GotoSearch(CtrlId, InitialText);
 }
 
 #define IsVariableChar(ch) \
 	( \
 		IsAlpha(ch) \
 		|| \
 		IsDigit(ch) \
 		|| \
 		strchr("-_~", ch) != NULL \
 	)
 
 void IdeDoc::SearchSymbol()
 {
 	if (!d->Edit || !d->Tray)
 	{
 		LAssert(0);
 		return;
 	}
 	
 	ssize_t Cur = d->Edit->GetCaret();
 	auto Txt = d->Edit->NameW();
 	if (Cur >= 0 &&
 		Txt != NULL)
 	{
 		ssize_t Start = Cur;
 		while (	Start > 0 &&
 				IsVariableChar(Txt[Start-1]))
 			Start--;
 		ssize_t End = Cur;
 		while (	Txt[End] &&
 				IsVariableChar(Txt[End]))
 			End++;
 		LString Word(Txt + Start, End - Start);
 		GotoSearch(IDC_SYMBOL_SEARCH, Word);
 	}
 }
 
 void IdeDoc::UpdateControl()
 {
 	if (d->Edit)
 		d->Edit->Invalidate();
 }
 
 void IdeDoc::SearchFile()
 {
 	GotoSearch(IDC_FILE_SEARCH, NULL);
 }
 
 bool IdeDoc::IsCurrentIp()
 {
 	auto Fn = GetFileName();
 	bool DocMatch = CurIpDoc &&
 					Fn &&
 					!_stricmp(Fn, CurIpDoc);
 	return DocMatch;
 }
 
 void IdeDoc::ClearCurrentIp()
 {
 	CurIpDoc.Empty();
 	CurIpLine = -1;
 }
 
 void IdeDoc::SetCrLf(bool CrLf)
 {
 	if (d->Edit)
 		d->Edit->SetCrLf(CrLf);
 }
 
 bool IdeDoc::OpenFile(const char *File)
 {
 	if (!d->Edit)
 		return false;
 
 	auto Cs = d->GetSrc() ? d->GetSrc()->GetCharset() : NULL;
 
 	return d->Edit->Open(File, Cs);
 }
 
 void IdeDoc::SetEditorParams(int IndentSize, int TabSize, bool HardTabs, bool ShowWhiteSpace)
 {
 	if (d->Edit)
 	{
 		d->Edit->SetIndentSize(IndentSize > 0 ? IndentSize : 4);
 		d->Edit->SetTabSize(TabSize > 0 ? TabSize : 4);
 		d->Edit->SetHardTabs(HardTabs);
 		d->Edit->SetShowWhiteSpace(ShowWhiteSpace);
 		d->Edit->Invalidate();
 	}
 }
 
 bool IdeDoc::HasFocus(int Set)
 {
 	if (!d->Edit)
 		return false;
 
 	if (Set)
 		d->Edit->Focus(Set);
 
 	return d->Edit->Focus();
 }
 
 void IdeDoc::SplitSelection(LString Sep)
 {
 	if (!d->Edit)
 		return;
 
 	auto r = d->Edit->GetSelectionRange();
 	LString s = d->Edit->GetSelection();
 	if (!s)
 		return;
 
 	auto parts = s.SplitDelimit(Sep);
 	auto joined = LString("\n").Join(parts);
 
 	LAutoWString w(Utf8ToWide(joined));
 	d->Edit->DeleteSelection();
 	d->Edit->Insert(r.Start, w, StrlenW(w));
 }
 
 void IdeDoc::JoinSelection(LString Sep)
 {
 	if (!d->Edit)
 		return;
 
 	auto r = d->Edit->GetSelectionRange();
 	LString s = d->Edit->GetSelection();
 	if (!s)
 		return;
 
 	LAutoWString w(Utf8ToWide(s.Replace("\n", Sep)));
 	d->Edit->DeleteSelection();
 	d->Edit->Insert(r.Start, w, StrlenW(w));
 }
 
 void IdeDoc::EscapeSelection(bool ToEscaped)
 {
 	if (!d->Edit)
 		return;
 
 	LString s = d->Edit->GetSelection();
 	if (!s)
 		return;
 
+	auto ReplaceSelection = [this](LString s)
+	{
+		auto r = d->Edit->GetSelectionRange();
+		LAutoWString w(Utf8ToWide(s));
+		d->Edit->DeleteSelection();
+		d->Edit->Insert(r.Start, w, StrlenW(w));
+	};
+
 	if (ToEscaped)
 	{
 		LMouse m;
 		GetMouse(m);
 		LString Delim = "\r\n\\";
 		if (m.Ctrl())
 		{
-			LInput Inp(this, LString::Escape(Delim, -1, "\\"), "Delimiter chars:", "Escape");
-			Inp.DoModal([&](auto d, auto code) {
-				Delim = LString::UnEscape(Inp.GetStr().Get(), -1);
+			auto Inp = new LInput(this, LString::Escape(Delim, -1, "\\"), "Delimiter chars:", "Escape");
+			Inp->DoModal([this, ReplaceSelection, s, Inp](auto d, auto code)
+			{
+				if (code)
+				{
+					auto Delim = LString::UnEscape(Inp->GetStr().Get(), -1);
+					auto str = LString::Escape(s, -1, Delim);
+					ReplaceSelection(str);
+				}
+				delete d;
 			});
+			return;
 		}
+
 		s = LString::Escape(s, -1, Delim);
 	}
 	else
 	{
 		s = LString::UnEscape(s.Get(), -1);
 	}
 
-	auto r = d->Edit->GetSelectionRange();
-
-	LAutoWString w(Utf8ToWide(s));
-	d->Edit->DeleteSelection();
-	d->Edit->Insert(r.Start, w, StrlenW(w));
+	ReplaceSelection(s);
 }
 
 void IdeDoc::ConvertWhiteSpace(bool ToTabs)
 {
 	if (!d->Edit)
 		return;
 
 	LAutoString Sp(
 		ToTabs ?
 		SpacesToTabs(d->Edit->Name(), d->Edit->GetTabSize()) :
 		TabsToSpaces(d->Edit->Name(), d->Edit->GetTabSize())
 		);
 	if (Sp)
 	{
 		d->Edit->Name(Sp);
 		SetDirty();
 	}
 }
 
 ssize_t IdeDoc::GetLine()
 {
 	return d->Edit ? d->Edit->GetLine() : -1;
 }
 
 void IdeDoc::SetLine(int Line, bool CurIp)
 {
 	if (CurIp)
 	{
 		LString CurDoc = GetFileName();
 		
 		if (ValidStr(CurIpDoc) ^ ValidStr(CurDoc)
 			||
 			(CurIpDoc && CurDoc && strcmp(CurDoc, CurIpDoc) != 0)
 			||
 			Line != CurIpLine)
 		{
 			bool Cur = IsCurrentIp();
 			if (d->Edit && Cur && CurIpLine >= 0)
 			{
 				// Invalidate the old IP location
 				d->Edit->InvalidateLine(CurIpLine - 1);
 			}
 			
 			CurIpLine = Line;
 			CurIpDoc = CurDoc;
 			
 			// LgiTrace("%s:%i - CurIpLine=%i\n", _FL, CurIpLine);
 			d->Edit->InvalidateLine(CurIpLine - 1);
 		}
 	}
 	
 	if (d->Edit)
 	{
 		d->Edit->SetLine(Line);
 	}
 }
 
 IdeProject *IdeDoc::GetProject()
 {
 	return d->Project;
 }
 
 void IdeDoc::SetProject(IdeProject *p)
 {
 	d->Project = p;
 	
 	if (d->Project->GetApp() &&
 		d->BreakPoints.Length() == 0)
 		d->Project->GetApp()->LoadBreakPoints(this);
 }
 
 const char *IdeDoc::GetFileName()
 {
 	return d->GetLocalFile();
 }
 
 void IdeDoc::SetFileName(const char *f, bool Write)
 {
 	d->SetFileName(f);
 	if (Write)
 		d->Edit->Save(d->GetLocalFile());
 }
 
 void IdeDoc::Focus(bool f)
 {
 	d->Edit->Focus(f);
 }
 
 LMessage::Result IdeDoc::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_FIND_SYM_REQUEST:
 		{
 			LAutoPtr<FindSymRequest> Resp((FindSymRequest*)Msg->A());
 			if (Resp && d->SymPopup)
 			{
 				LViewI *SymEd;
 				if (GetViewById(IDC_SYMBOL_SEARCH, SymEd))
 				{
 					LString Input = SymEd->Name();
 					if (Input == Resp->Str) // Is the input string still the same?
 					{
 						/*
 						The problem with this is that the user it still typing something
 						and the cursor / focus jumps to the document now they are typing
 						a search string into the document, which is not what they intended.
 						
 						if (Resp->Results.Length() == 1)
 						{
 							FindSymResult *r = Resp->Results[0];
 							d->SymPopup->Visible(false);
 
 							d->App->GotoReference(r->File, r->Line, false);
 						}
 						else
 						*/
 						{
 							d->SymPopup->All = Resp->Results;
 							Resp->Results.Length(0);
 							d->SymPopup->FindCommonPathLength();
 							d->SymPopup->SetItems(d->SymPopup->All);
 							d->SymPopup->Visible(true);
 						}
 					}
 				}
 			}
 			break;
 		}
 	}
 	
 	return LMdiChild::OnEvent(Msg);
 }
 
 void IdeDoc::OnPulse()
 {
 	d->CheckModTime();
 
 	if (d->Lock(_FL))
 	{
 		if (d->WriteBuf.Length())
 		{
 			bool Pour = d->Edit->SetPourEnabled(false);
 			for (auto s: d->WriteBuf)
 			{
 				LAutoWString w(Utf8ToWide(s, s.Length()));
 				d->Edit->Insert(d->Edit->Length(), w, Strlen(w.Get()));
 			}
 			d->Edit->SetPourEnabled(Pour);
 
 			d->WriteBuf.Empty();
 			d->Edit->Invalidate();
 		}
 		d->Unlock();
 	}
 }
 
 LString IdeDoc::Read()
 {
 	return d->Edit->Name();
 }
 
 ssize_t IdeDoc::Write(const void *Ptr, ssize_t Size, int Flags)
 {
 	if (d->Lock(_FL))
 	{
 		d->WriteBuf.New().Set((char*)Ptr, Size);
 		d->Unlock();
 	}
 	return 0;
 }
 
 void IdeDoc::OnProjectChange()
 {
 	DeleteObj(d->FilePopup);
 	DeleteObj(d->MethodPopup);
 	DeleteObj(d->SymPopup);
 }
 
 int IdeDoc::OnNotify(LViewI *v, LNotification n)
 {
 	// printf("IdeDoc::OnNotify(%i, %i)\n", v->GetId(), f);
 	
 	switch (v->GetId())
 	{
 		case IDC_EDIT:
 		{
 			switch (n.Type)
 			{
 				case LNotifyDocChanged:
 				{
 					d->UpdateName();
 					break;
 				}
 				case LNotifyCursorChanged:
 				{
 					if (d->Tray)
 					{
 						LPoint Pt;
 						if (d->Edit->GetLineColumnAtIndex(Pt, d->Edit->GetCaret()))
 						{
 							d->Tray->Col = Pt.x;
 							d->Tray->Line = Pt.y;
 							d->Tray->Invalidate();
 						}
 					}
 					break;
 				}
 				default:
 					break;
 			}
 			break;
 		}
 		case IDC_FILE_SEARCH:
 		{
 			if (n.Type == LNotifyEscapeKey)
 			{
 				d->Edit->Focus(true);
 				break;
 			}
 			
 			auto SearchStr = v->Name();
 			if (ValidStr(SearchStr))
 			{
 				if (!d->FilePopup)
 				{
 					if ((d->FilePopup = new ProjFilePopup(d->App, v)))
 					{
 						// Populate with files from the project...
 						
 						// Find the root project...
 						IdeProject *p = d->Project;
 						while (p && p->GetParentProject())
 							p = p->GetParentProject();
 						
 						if (p)
 						{
 							// Get all the nodes
 							List<IdeProject> All;
 							p->GetChildProjects(All);
 							All.Insert(p);							
 							for (auto p: All)
 							{
 								p->GetAllNodes(d->FilePopup->Nodes);
 							}
 						}
 					}
 				}
 				if (d->FilePopup)
 				{
 					// Update list elements...
 					d->FilePopup->OnNotify(v, n);
 				}
 			}
 			else if (d->FilePopup)
 			{
 				DeleteObj(d->FilePopup);
 			}
 			break;
 		}
 		case IDC_METHOD_SEARCH:
 		{
 			if (n.Type == LNotifyEscapeKey)
 			{
 				printf("%s:%i Got LNotifyEscapeKey\n", _FL);
 				d->Edit->Focus(true);
 				break;
 			}
 			
 			auto SearchStr = v->Name();
 			if (ValidStr(SearchStr))
 			{
 				if (!d->MethodPopup)
 					d->MethodPopup = new ProjMethodPopup(d->App, v);
 				if (d->MethodPopup)
 				{
 					// Populate with symbols
 					d->MethodPopup->All.Length(0);
 					BuildDefnList(GetFileName(), (char16*)d->Edit->NameW(), d->MethodPopup->All, DefnFunc);
 
 					// Update list elements...
 					d->MethodPopup->OnNotify(v, n);
 				}
 			}
 			else if (d->MethodPopup)
 			{
 				DeleteObj(d->MethodPopup);
 			}
 			break;
 		}
 		case IDC_SYMBOL_SEARCH:
 		{
 			if (n.Type == LNotifyEscapeKey)
 			{
 				printf("%s:%i Got LNotifyEscapeKey\n", _FL);
 				d->Edit->Focus(true);
 				break;
 			}
 			
 			auto SearchStr = v->Name();
 			if (ValidStr(SearchStr))
 			{
 				if (!d->SymPopup)
 					d->SymPopup = new ProjSymPopup(d->App, this, v);
 				if (d->SymPopup)
 					d->SymPopup->OnNotify(v, n);
 			}
 			else if (d->SymPopup)
 			{
 				DeleteObj(d->SymPopup);
 			}
 			break;
 		}
 	}
 	
 	return 0;
 }
 
 void IdeDoc::SetDirty()
 {
 	d->Edit->IsDirty(true);
 	d->UpdateName();
 }
 
 bool IdeDoc::GetClean()
 {
 	return !d->Edit->IsDirty();
 }
 
 LString IdeDoc::GetFullPath()
 {
 	LAutoString Base;
 	if (GetProject())
 		Base = GetProject()->GetBasePath();
 	
 	LString LocalPath;
 	if (d->GetLocalFile() &&
 		LIsRelativePath(LocalPath) &&
 		Base)
 	{
 		char p[MAX_PATH_LEN];
 		LMakePath(p, sizeof(p), Base, d->GetLocalFile());
 		LocalPath = p;
 	}
 	else
 	{
 		LocalPath = d->GetLocalFile();
 	}
 	
 	if (d->Project)
 		d->Project->CheckExists(LocalPath);
 
 	return LocalPath;
 }
 
 void IdeDoc::SetClean(std::function<void(bool)> Callback)
 {
 	static bool Processing = false;
 	bool Status = false;
 
 	if (!Processing)
 	{
 		Processing = true;
 
 		LAutoString Base;
 		if (GetProject())
 			Base = GetProject()->GetBasePath();
 		LString LocalPath = GetFullPath();
 
 		// printf("OnSave setup d=%p\n", d);
 		auto OnSave = [this, Callback](bool ok)
 		{
 			// printf("OnSave %i d=%p\n", ok, d);
 			if (ok)
 				d->Save();
 			// printf("OnSave cb\n");
 			if (Callback)
 				Callback(ok);
 			// printf("OnSave done\n");
 		};		
 		
 		if (d->Edit->IsDirty() &&
 			!LFileExists(LocalPath))
 		{
 			// We need a valid filename to save to...			
 			auto s = new LFileSelect;
 			s->Parent(this);
 			if (Base)
 				s->InitialDir(Base);			
 			s->Save([this, OnSave](auto fileSel, auto ok)
 			{
 				// printf("Doc.Save.Cb ok=%i d=%p\n", ok, d);
 				if (ok)
 					d->SetFileName(fileSel->Name());
 				// printf("Doc.Save.Cb onsave\n", ok);
 				OnSave(ok);
 				// printf("Doc.Save.Cb del\n", ok);
 				delete fileSel;
 			});
 		}
 		else OnSave(true);
 		
 		Processing = false;
 	}
 }
 
 void IdeDoc::OnPaint(LSurface *pDC)
 {
 	LMdiChild::OnPaint(pDC);
 	
 	#if !MDI_TAB_STYLE
 	LRect c = GetClient();
 	LWideBorder(pDC, c, SUNKEN);
 	#endif
 }
 
 void IdeDoc::OnPosChange()
 {
 	LMdiChild::OnPosChange();
 }
 
 bool IdeDoc::OnRequestClose(bool OsShuttingDown)
 {
 	if (d->Edit->IsDirty())
 	{
 		LString Dsp = d->GetDisplayName();
 		int a = LgiMsg(this, "Save '%s'?", AppName, MB_YESNOCANCEL, Dsp ? Dsp.Get() : Untitled);
 		switch (a)
 		{
 			case IDYES:
 			{
 				SetClean([](bool ok)
 				{
 					if (ok)
 					{
 						LAssert(!"Impl close doc.");
 					}
 				});
 
 				// This is returned immediately... before the user has decided to save or not
 				return false;
 			}
 			case IDNO:
 			{
 				break;
 			}
 			default:
 			case IDCANCEL:
 			{
 				return false;
 			}
 		}
 	}
 	
 	return true;
 }
 
 /*
 LTextView3 *IdeDoc::GetEdit()
 {
 	return d->Edit;
 }
 */
 
 bool IdeDoc::BuildIncludePaths(LArray<LString> &Paths, IdePlatform Platform, bool IncludeSysPaths)
 {
 	if (!GetProject())
 	{
 		LgiTrace("%s:%i - GetProject failed.\n", _FL);
 		return false;
 	}
 
 	bool Status = GetProject()->BuildIncludePaths(Paths, true, IncludeSysPaths, Platform);
 	if (Status)
 	{
 		if (IncludeSysPaths)
 			GetApp()->GetSystemIncludePaths(Paths);
 	}
 	else
 	{
 		LgiTrace("%s:%i - GetProject()->BuildIncludePaths failed.\n", _FL);
 	}
 	
 	return Status;
 }
 
 bool IdeDoc::BuildHeaderList(const char16 *Cpp, LArray<char*> &Headers, LArray<LString> &IncPaths)
 {
 	LAutoString c8(WideToUtf8(Cpp));
 	if (!c8)
 		return false;
 
 	return ::BuildHeaderList(c8, Headers, IncPaths, true);
 }
 
 bool MatchSymbol(DefnInfo *Def, char16 *Symbol)
 {
 	static char16 Dots[] = {':', ':', 0};
 
 	LBase o;
 	o.Name(Def->Name);
 	auto Name = o.NameW();
 
 	auto Sep = StristrW((char16*)Name, Dots);
 	auto Start = Sep ? Sep : Name;
 	// char16 *End = StrchrW(Start, '(');
 	ssize_t Len = StrlenW(Symbol);
 	char16 *Match = StristrW((char16*)Start, Symbol);
 
 	if (Match) // && Match + Len <= End)
 	{
 		if (Match > Start && isword(Match[-1]))
 		{
 			return false;
 		}
 		
 		char16 *e = Match + Len;
 		if (*e && isword(*e))
 		{
 			return false;
 		}
 		
 		return true;
 	}
 	
 	return false;
 }
 
 bool IdeDoc::FindDefn(char16 *Symbol, const char16 *Source, List<DefnInfo> &Matches)
 {
 	if (!Symbol || !Source)
 	{
 		LgiTrace("%s:%i - Arg error.\n", _FL);
 		return false;
 	}
 
 	#if DEBUG_FIND_DEFN
 	LStringPipe Dbg;
 	LgiTrace("FindDefn(%S)\n", Symbol);
 	#endif
 
 	LString::Array Paths;
 	LArray<char*> Headers;
 
 	if (!BuildIncludePaths(Paths, PlatformCurrent, true))
 	{
 		LgiTrace("%s:%i - BuildIncludePaths failed.\n", _FL);
 		// return false;
 	}
 
 	char Local[MAX_PATH_LEN];
 	strcpy_s(Local, sizeof(Local), GetFileName());
 	LTrimDir(Local);
 	Paths.New() = Local;
 
 	if (!BuildHeaderList(Source, Headers, Paths))
 	{
 		LgiTrace("%s:%i - BuildHeaderList failed.\n", _FL);
 		// return false;
 	}
 
 	{
 		LArray<DefnInfo> Defns;
 		
 		for (int i=0; i<Headers.Length(); i++)
 		{
 			char *h = Headers[i];
 			char *c8 = LReadTextFile(h);
 			if (c8)
 			{
 				char16 *c16 = Utf8ToWide(c8);
 				DeleteArray(c8);
 				if (c16)
 				{
 					LArray<DefnInfo> Defns;
 					if (BuildDefnList(h, c16, Defns, DefnNone, false ))
 					{
 						bool Found = false;
 						for (unsigned n=0; n<Defns.Length(); n++)
 						{
 							DefnInfo &Def = Defns[n];
 							if (MatchSymbol(&Def, Symbol))
 							{
 								Matches.Insert(new DefnInfo(Def));
 								Found = true;
 							}
 						}
 						
 						#if DEBUG_FIND_DEFN
 						if (!Found)
 							Dbg.Print("Not in '%s'\n", h);
 						#endif
 					}
 					
 					DeleteArray(c16);
 				}
 			}
 		}
 
 		auto FileName = GetFileName();
 		if (BuildDefnList(FileName, (char16*)Source, Defns, DefnNone))
 		{
 			#if DEBUG_FIND_DEFN
 			bool Found = false;
 			#endif
 			
 			for (unsigned i=0; i<Defns.Length(); i++)
 			{
 				DefnInfo &Def = Defns[i];
 				if (MatchSymbol(&Def, Symbol))
 					Matches.Insert(new DefnInfo(Def));
 			}
 
 			#if DEBUG_FIND_DEFN
 			if (!Found)
 				Dbg.Print("Not in current file.\n");
 			#endif
 		}
 	}
 	
 	Headers.DeleteArrays();
 
 	#if DEBUG_FIND_DEFN
 	{
 		LAutoString a(Dbg.NewStr());
 		if (a) LgiTrace("%s", a.Get());
 	}
 	#endif
 	
 	return Matches.Length() > 0;
 }
diff --git a/Ide/Code/IdeProject.cpp b/Ide/Code/IdeProject.cpp
--- a/Ide/Code/IdeProject.cpp
+++ b/Ide/Code/IdeProject.cpp
@@ -1,4100 +1,4102 @@
 #if defined(WIN32)
 #include <direct.h>
 #else
 #include <unistd.h>
 #endif
 #include <stdio.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/DragAndDrop.h"
 #include "lgi/common/Token.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Net.h"
 #include "lgi/common/ListItemCheckBox.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DropFiles.h"
 #include "lgi/common/SubProcess.h"
 #include "lgi/common/Css.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/RegKey.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 
 #include "LgiIde.h"
 #include "resdefs.h"
 #include "FtpThread.h"
 #include "ProjectNode.h"
 #include "WebFldDlg.h"
 
 extern const char *Untitled;
 const char SourcePatterns[] = "*.c;*.h;*.cpp;*.cc;*.java;*.d;*.php;*.html;*.css;*.js";
 const char *AddFilesProgress::DefaultExt = "c,cpp,cc,cxx,h,hpp,hxx,html,css,json,js,jsx,txt,png,jpg,jpeg,rc,xml,mk,paths,makefile,py,java,php";
 const char *VsBinaries[] = {"devenv.com", "WDExpress.exe"};
 
 #define USE_OPEN_PROGRESS			1
 
 #define STOP_BUILD_TIMEOUT			2000
 #ifdef WINDOWS
 #define LGI_STATIC_LIBRARY_EXT		"lib"
 #else
 #define LGI_STATIC_LIBRARY_EXT		"a"
 #endif
 
 const char *PlatformNames[] =
 {
 	"Windows",
 	"Linux",
 	"Mac",
 	"Haiku",
 	0
 };
 
 int PlatformCtrlId[] =
 {
 	IDC_WIN32,
 	IDC_LINUX,
 	IDC_MAC,
 	IDC_HAIKU,
 	0
 };
 
 const char *PlatformDynamicLibraryExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return "dll";
 	if (Platform == PlatformMac)
 		return "dylib";
 	
 	return "so";
 }
 
 const char *PlatformSharedLibraryExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return "lib";
 
 	return "a";
 }
 
 const char *PlatformExecutableExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return ".exe";
 	return "";
 }
 
 char *ToUnixPath(char *s)
 {
 	if (s)
 	{
 		char *c;
 		while ((c = strchr(s, '\\')))
 			*c = '/';
 	}
 	return s;
 }
 
 const char *CastEmpty(char *s)
 {
 	return s ? s : "";
 }
 
 bool FindInPath(LString &Exe)
 {
 	LString::Array Path = LString(getenv("PATH")).Split(LGI_PATH_SEPARATOR);
 	for (unsigned i=0; i<Path.Length(); i++)
 	{
 		char p[MAX_PATH_LEN];
 		LMakePath(p, sizeof(p), Path[i], Exe);
 		if (LFileExists(p))
 		{
 			Exe = p;
 			return true;
 		}
 	}
 	
 	return false;
 }
 
 LAutoString ToNativePath(const char *s)
 {
 	LAutoString a(NewStr(s));
 	if (a)
 	{
 		if (strnicmp(a, "ftp://", 6))
 		{
 			for (char *c = a; *c; c++)
 			{
 				#ifdef WIN32
 				if (*c == '/')
 					*c = '\\';
 				#else
 				if (*c == '\\')
 					*c = '/';
 				#endif
 			}
 		}
 	}
 	return a;
 }
 
 int StrCmp(char *a, char *b, NativeInt d)
 {
 	return stricmp(a, b);
 }
 
 int StrSort(char **a, char **b)
 {
 	return stricmp(*a, *b);
 }
 
 //////////////////////////////////////////////////////////////////////////////////
 class ProjectNode;
 
 class BuildThread : public LThread, public LStream
 {
 	IdeProject *Proj;
 	LString Makefile, CygwinPath;
 	bool Clean, All;
 	BuildConfig Config;
 	int WordSize;
 	LAutoPtr<LSubProcess> SubProc;
 	LString::Array BuildConfigs;
 	LString::Array PostBuild;
 	int AppHnd;
 
 	enum CompilerType
 	{
 		DefaultCompiler,
 		VisualStudio,
 		MingW,
 		Gcc,
 		CrossCompiler,
 		PythonScript,
 		IAR,
 		Nmake,
 		Cygwin,
 		Xcode,
 	}
 		Compiler;
 
 	enum ArchType
 	{
 		DefaultArch,
 		ArchX32,
 		ArchX64,
 		ArchArm6,
 		ArchArm7,
 	}
 		Arch;
 
 public:
 	BuildThread(IdeProject *proj, char *makefile, bool clean, BuildConfig config, bool all, int wordsize);
 	~BuildThread();
 	
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0) override;
 	LString FindExe();
 	LAutoString WinToMingWPath(const char *path);
 	int Main() override;
 };
 
 class IdeProjectPrivate
 {
 public:
 	AppWnd *App;
 	IdeProject *Project;
 	bool Dirty, UserFileDirty;
 	LString FileName;
 	IdeProject *ParentProject;
 	IdeProjectSettings Settings;
 	LAutoPtr<BuildThread> Thread;
 	LHashTbl<ConstStrKey<char,false>, ProjectNode*> Nodes;
 	int NextNodeId;
 
 	// Threads
 	LAutoPtr<class MakefileThread> CreateMakefile;
 
 	// User info file
 	LString UserFile;
 	LHashTbl<IntKey<int>,int> UserNodeFlags;
 
 	IdeProjectPrivate(AppWnd *a, IdeProject *project) :
 		Project(project),
 		Settings(project)
 	{
 		App = a;
 		Dirty = false;
 		UserFileDirty = false;
 		ParentProject = 0;
 		NextNodeId = 1;
 	}
 
 	void CollectAllFiles(LTreeNode *Base, LArray<ProjectNode*> &Files, bool SubProjects, int Platform);
 };
 
 LString ToPlatformPath(const char *s, IdePlatform platform)
 {
 	LString p = s;
 	if (platform == PlatformWin)
 		return p.Replace("/", "\\");
 	else
 		return p.Replace("\\", "/");
 }
 
 class MakefileThread : public LThread, public LCancel
 {
 	IdeProjectPrivate *d;
 	IdeProject *Proj;
 	IdePlatform Platform;
 	LStream *Log;
 	bool BuildAfterwards;
 	bool HasError;
 	
 public:
 	static int Instances;
 
 	MakefileThread(IdeProjectPrivate *priv, IdePlatform platform, bool Build) : LThread("MakefileThread")
 	{
 		Instances++;
 
 		d = priv;
 		Proj = d->Project;
 		Platform = platform;
 		BuildAfterwards = Build;
 		HasError = false;
 		Log = d->App->GetBuildLog();
 		
 		Run();
 	}
 
 	~MakefileThread()
 	{
 		Cancel();
 		while (!IsExited())
 			LSleep(1);
 		Instances--;
 	}
 	
 	void OnError(const char *Fmt, ...)
 	{
 		va_list Arg;
 		va_start(Arg, Fmt);
 		LStreamPrintf(Log, 0, Fmt, Arg);
 		va_end(Arg);
 		HasError = true;
 	}
 	
 	int Main()
 	{
 		const char *PlatformName = PlatformNames[Platform];
 		const char *PlatformLibraryExt = NULL;
 		const char *PlatformStaticLibExt = NULL;
 		const char *PlatformExeExt = "";
 		LString LinkerFlags;
 		const char *TargetType = d->Settings.GetStr(ProjTargetType, NULL, Platform);
 		const char *CompilerName = d->Settings.GetStr(ProjCompiler);
 		LString CCompilerBinary = "gcc";
 		LString CppCompilerBinary = "g++";
 		LStream *Log = d->App->GetBuildLog();
 		bool IsExecutableTarget = TargetType && !stricmp(TargetType, "Executable");
 		bool IsDynamicLibrary	= TargetType && !stricmp(TargetType, "DynamicLibrary");
 		
 		LAssert(Log);
 		if (!Log)
 			return false;
 		
 		Log->Print("CreateMakefile for '%s'...\n", PlatformName);
 		
 		if (Platform == PlatformWin)
 		{
 			LinkerFlags = ",--enable-auto-import";
 		}
 		else
 		{
 			if (IsDynamicLibrary)
 			{
 				LinkerFlags = ",-soname,$(TargetFile)";
 			}
 			LinkerFlags += ",-export-dynamic,-R.";
 		}
 
 		char Buf[256];
 		auto MakeFile = Proj->GetMakefile(Platform);
 		Proj->CheckExists(MakeFile);
 		if (!MakeFile)
 			MakeFile = "../Makefile";
 		
 		// LGI_LIBRARY_EXT
 		switch (Platform)
 		{
 			case PlatformWin:
 				PlatformLibraryExt = "dll";
 				PlatformStaticLibExt = "lib";
 				PlatformExeExt = ".exe";
 				break;
 			case PlatformLinux:
 			case PlatformHaiku:
 				PlatformLibraryExt = "so";
 				PlatformStaticLibExt = "a";
 				break;
 			case PlatformMac:
 				PlatformLibraryExt = "dylib";
 				PlatformStaticLibExt = "a";
 				break;
 			default:
 				LAssert(0);
 				break;
 		}
 
 		if (CompilerName)
 		{
 			if (!stricmp(CompilerName, "cross"))
 			{
 				LString CBin = d->Settings.GetStr(ProjCCrossCompiler, NULL, Platform);
 				if (CBin && !LFileExists(CBin))
 					FindInPath(CBin);
 				if (CBin && LFileExists(CBin))
 					CCompilerBinary = CBin;
 				else
 					Log->Print("%s:%i - Error: C cross compiler '%s' not found.\n", _FL, CBin.Get());
 				
 				LString CppBin = d->Settings.GetStr(ProjCppCrossCompiler, NULL, Platform);
 				if (CppBin && !LFileExists(CppBin))
 					FindInPath(CppBin);
 				if (CppBin && LFileExists(CppBin))
 					CppCompilerBinary = CppBin;
 				else
 					Log->Print("%s:%i - Error: C++ cross compiler '%s' not found.\n", _FL, CppBin.Get());
 			}
 		}
 		
 		LFile m;
 		if (!m.Open(MakeFile, O_WRITE))
 		{
 			Log->Print("Error: Failed to open '%s' for writing.\n", MakeFile.Get());
 			return false;
 		}
 		
 		m.SetSize(0);
 		
 		m.Print("#!/usr/bin/make\n"
 				"#\n"
 				"# This makefile generated by LgiIde\n"
 				"# http://www.memecode.com/lgi.php\n"
 				"#\n"
 				"\n"
 				".SILENT :\n"
 				"\n"
 				"CC = %s\n"
 				"CPP = %s\n",
 				CCompilerBinary.Get(),
 				CppCompilerBinary.Get());
 
 		// Collect all files that require building
 		LArray<ProjectNode*> Files;
 		d->CollectAllFiles
 		(
 			Proj,
 			Files,
 			false,
 			1 << Platform
 		);
 		
 		auto Base = Proj->GetBasePath();
 		if (IsExecutableTarget)
 		{
 			LString Exe = Proj->GetExecutable(Platform);
 			if (Exe)
 			{
 				if (LIsRelativePath(Exe))
 					m.Print("Target = %s\n", ToPlatformPath(Exe, Platform).Get());
 				else
 				{
 					auto RelExe = LMakeRelativePath(Base, Exe);
 					if (Base && RelExe)
 					{
 						m.Print("Target = %s\n", ToPlatformPath(RelExe, Platform).Get());
 					}
 					else
 					{
 						Log->Print("%s:%i - Error: Missing path (%s, %s).\n", _FL, Base.Get(), RelExe.Get());
 						return false;
 					}
 				}
 			}
 			else
 			{
 				Log->Print("%s:%i - Error: No executable name specified (%s, %s).\n", _FL, TargetType, d->FileName.Get());
 				return false;
 			}
 		}
 		else
 		{
 			LString Target = Proj->GetTargetName(Platform);
 			if (Target)
 				m.Print("Target = %s\n", ToPlatformPath(Target, Platform).Get());
 			else
 			{
 				Log->Print("%s:%i - Error: No target name specified.\n", _FL);
 				return false;
 			}
 		}
 
 		// Output the build mode, flags and some paths
 		auto BuildMode = d->App->GetBuildMode();
 		auto BuildModeName = toString(BuildMode);
 		m.Print("ifndef Build\n"
 				"	Build = %s\n"
 				"endif\n",
 				BuildModeName);
 		
 		LString sDefines[BuildMax];
 		LString sLibs[BuildMax];
 		LString sIncludes[BuildMax];
 		const char *ExtraLinkFlags = NULL;
 		const char *ExeFlags = NULL;
 		if (Platform == PlatformWin)
 		{
 			ExtraLinkFlags = "";
 			ExeFlags = " -mwindows";
 			m.Print("BuildDir = $(Build)\n"
 					"\n"
 					"Flags = -fPIC -w -fno-inline -fpermissive\n");
 			
 			const char *DefDefs = "-DWIN32 -D_REENTRANT";
 			sDefines[BuildDebug] = DefDefs;
 			sDefines[BuildRelease] = DefDefs;
 		}
 		else
 		{
 			LString PlatformCap = PlatformName;
 		
 			ExtraLinkFlags = "";
 			ExeFlags = "";
 			m.Print("BuildDir = $(Build)\n"
 					"\n"
 					"Flags = -fPIC -w -fno-inline -fpermissive\n" // -fexceptions
 					);
 			sDefines[0].Printf("-D%s -D_REENTRANT", PlatformCap.Upper().Get());
 			#ifdef LINUX
 			sDefines[BuildDebug] += " -D_FILE_OFFSET_BITS=64"; // >:-(
 			sDefines[BuildDebug] += " -DPOSIX";
 			#endif
 			sDefines[BuildRelease] = sDefines[BuildDebug];
 		}
 
 		List<IdeProject> Deps;
 		Proj->GetChildProjects(Deps);
 
 		for (int Cfg = BuildDebug; Cfg < BuildMax; Cfg++)
 		{
 			// Set the config
 			auto cfgName = toString((BuildConfig)Cfg);
 			d->Settings.SetCurrentConfig(cfgName);
 		
 			// Get the defines setup
 			auto PDefs = d->Settings.GetStr(ProjDefines, NULL, Platform);
 			if (ValidStr(PDefs))
 			{
 				LToken Defs(PDefs, " ;,\r\n");
 				for (int i=0; i<Defs.Length(); i++)
 				{
 					LString s;
 					s.Printf(" -D%s", Defs[i]);
 					sDefines[Cfg] += s;
 				}
 			}
 		
 			// Collect all dependencies, output their lib names and paths
 			LString PLibPaths = d->Settings.GetStr(ProjLibraryPaths, NULL, Platform);
 			if (ValidStr(PLibPaths))
 			{
 				LString::Array LibPaths = PLibPaths.Split("\n");
 				for (auto i: LibPaths)
 				{
 					LString s, in = i.Strip();
 					if (!in.Length())
 						continue;
 					
 					if (strchr("`-", in(0)))
 					{
 						s.Printf(" \\\n\t\t%s", in.Get());
 					}
 					else
 					{
 						LString Rel;
 						if (!LIsRelativePath(in))
 							Rel = LMakeRelativePath(Base, in);
 
 						LString Final = Rel ? Rel.Get() : in.Get();
 						if (!Proj->CheckExists(Final))
 							OnError("%s:%i - Library path '%s' doesn't exist (from %s).\n",
 								_FL, Final.Get(),
 								Proj->GetFileName());
 
 						s.Printf(" \\\n\t\t-L%s", ToUnixPath(Final));
 					}
 					
 					sLibs[Cfg] += s;
 				}
 			}
 
 			const char *PLibs = d->Settings.GetStr(ProjLibraries, NULL, Platform);
 			if (ValidStr(PLibs))
 			{
 				LToken Libs(PLibs, "\r\n");
 				for (int i=0; i<Libs.Length(); i++)
 				{
 					LString l = Libs[i];
 
 					LString s;
 					if (l(0) == '`' || l(0) == '-')
 						s.Printf(" \\\n\t\t%s", l.Get());
 					else
 					{
 						Proj->CheckExists(l);
 						s.Printf(" \\\n\t\t-l%s", ToUnixPath(l));
 					}
 					sLibs[Cfg] += s;
 				}
 			}
 
 			for (auto dep: Deps)
 			{
 				LString Target = dep->GetTargetName(Platform);
 				if (Target)
 				{
 					char t[MAX_PATH_LEN];
 					strcpy_s(t, sizeof(t), Target);
 					if (!strnicmp(t, "lib", 3))
 						memmove(t, t + 3, strlen(t + 3) + 1);
 					char *dot = strrchr(t, '.');
 					if (dot)
 						*dot = 0;
 													
 					LString s, sTarget = t;
 					Proj->CheckExists(sTarget);
 					s.Printf(" \\\n\t\t-l%s$(Tag)", ToUnixPath(sTarget));
 					sLibs[Cfg] += s;
 
 					auto DepBase = dep->GetBasePath();
 					if (DepBase)
 					{
 						LString DepPath = DepBase.Get();
 						
 						auto Rel = LMakeRelativePath(Base, DepPath);
 
 						LString Final = Rel ? Rel.Get() : DepPath.Get();
 						Proj->CheckExists(Final);
 						s.Printf(" \\\n\t\t-L%s/$(BuildDir)", ToUnixPath(Final.RStrip("/\\")));
 						sLibs[Cfg] += s;
 					}
 				}
 			}
 			
 			// Includes
 
 			// Do include paths
 			LHashTbl<StrKey<char>,bool> Inc;
 			auto ProjIncludes = d->Settings.GetStr(ProjIncludePaths, NULL, Platform);
 			if (ValidStr(ProjIncludes))
 			{
 				// Add settings include paths.
 				LToken Paths(ProjIncludes, "\r\n");
 				for (int i=0; i<Paths.Length(); i++)
 				{
 					char *p = Paths[i];
 					LAutoString pn = ToNativePath(p);					
 					if (pn.Get()[0] != '`' && !Proj->CheckExists(pn))
 						OnError("%s:%i - Include path '%s' doesn't exist.\n", _FL, pn.Get());
 					else if (!Inc.Find(pn))
 						Inc.Add(pn, true);
 				}
 			}
 			const char *SysIncludes = d->Settings.GetStr(ProjSystemIncludes, NULL, Platform);
 			if (ValidStr(SysIncludes))
 			{
 				// Add settings include paths.
 				LToken Paths(SysIncludes, "\r\n");
 				for (int i=0; i<Paths.Length(); i++)
 				{
 					char *p = Paths[i];
 					LAutoString pn = ToNativePath(p);
 					if (pn.Get()[0] != '`' && !Proj->CheckExists(pn))
 						OnError("%s:%i - System include path '%s' doesn't exist (from %s).\n",
 							_FL, pn.Get(),
 							Proj->GetFileName());
 					else if (!Inc.Find(pn))
 						Inc.Add(pn, true);
 				}
 			}
 
 			#if 0
 			/*
 			Currently this code is adding extra paths that are covered by the official 'IncludePaths'
 			in addition to relative paths in the actual #include parameter. e.g.
 				#include "lgi/common/SomeHeader.h"
 			Hence disabling it for the time being.
 			*/
 			// Add paths of headers
 			for (int i=0; i<Files.Length(); i++)
 			{
 				ProjectNode *n = Files[i];
 				
 				if (n->GetFileName())
 				{
 					char *e = LGetExtension(n->GetFileName());
 					if (e && stricmp(e, "h") == 0)
 					{
 						LString Fn = n->GetFileName();
 						for (char *Dir = Fn; *Dir; Dir++)
 						{
 							if (*Dir == '/' || *Dir == '\\')
 							{
 								*Dir = DIR_CHAR;
 							}
 						}						
 
 						char Path[MAX_PATH_LEN];
 						strcpy_s(Path, sizeof(Path), Fn);
 
 						LTrimDir(Path);
 					
 						LString Rel;
 						if (!Proj->RelativePath(Rel, Path))
 							Rel = Path;
 						
 						if (stricmp(Rel, ".") != 0)
 						{
 							LAutoString RelN = ToNativePath(Rel);
 							if (!Proj->CheckExists(RelN))
 								OnError("Header include path '%s' doesn't exist.\n", RelN.Get());
 							else if (!Inc.Find(RelN))
 								Inc.Add(RelN, true);
 						}
 					}
 				}
 			}
 			#endif
 
 			LString::Array Incs;
 			for (auto i: Inc)
 				Incs.New() = i.key;
 			Incs.Sort();
 			
 			for (auto i: Incs)
 			{
 				LString s;
 				if (*i == '`')
 					s.Printf(" \\\n\t\t%s", i.Get());
 				else
 					s.Printf(" \\\n\t\t-I%s", ToUnixPath(i));
 				sIncludes[Cfg] += s;
 			}
 		}
 
 		// Output the defs section for Debug and Release		
 
 		// Debug specific
 		m.Print("\n"
 				"ifeq ($(Build),Debug)\n"
 				"	Flags += -g -std=c++14\n"
 				"	Tag = d\n"
 				"	Defs = -D_DEBUG %s\n"
 				"	Libs = %s\n"
 				"	Inc = %s\n",
 					CastEmpty(sDefines[0].Get()),
 					CastEmpty(sLibs[0].Get()),
 					CastEmpty(sIncludes[0].Get()));
 		
 		// Release specific
 		m.Print("else\n"
 				"	Flags += -s -Os -std=c++14\n"
 				"	Defs = %s\n"
 				"	Libs = %s\n"
 				"	Inc = %s\n"
 				"endif\n"
 				"\n",
 					CastEmpty(sDefines[1].Get()),
 					CastEmpty(sLibs[1].Get()),
 					CastEmpty(sIncludes[1].Get()));
 		
 		if (Files.Length())
 		{
 			LArray<LString> IncPaths;
 			if (Proj->BuildIncludePaths(IncPaths, false, false, Platform))
 			{
 				// Do source code list...
 				m.Print("# Dependencies\n"
 						"Source =\t");
 					
 				LString::Array SourceFiles;
 				for (auto &n: Files)
 				{
 					if (n->GetType() == NodeSrc)
 					{
 						auto f = n->GetFileName();
 						auto path = ToPlatformPath(f, Platform);
 						if (path.Find("./") == 0)
 							path = path(2,-1);
 						SourceFiles.Add(path);
 					}
 				}
 				SourceFiles.Sort();
 				int c = 0;
 				for (auto &src: SourceFiles)
 				{
 					if (c++) m.Print(" \\\n\t\t\t");
 					m.Print("%s", src.Get());
 				}
 				m.Print("\n"
 						"\n"
 						"SourceLst := $(patsubst %%.c,%%.o,$(patsubst %%.cpp,%%.o,$(Source)))\n"
 						"Objects := $(addprefix $(BuildDir)/,$(SourceLst))\n"
 						"Deps := $(patsubst %%.o,%%.d,$(Objects))\n"
 						"\n");
 
 				// Write out the target stuff
 				m.Print("# Target\n");
 
 				LHashTbl<StrKey<char,false>,bool> DepFiles;
 
 				if (TargetType)
 				{
 					if (IsExecutableTarget)
 					{
 						m.Print("# Executable target\n"
 								"$(Target) :");
 								
 						LStringPipe Rules;
 						IdeProject *Dep;
 						
 						uint64 Last = LCurrentTime();
 						int Count = 0;
 						auto It = Deps.begin();
 						for (Dep=*It; Dep && !IsCancelled(); Dep=*(++It), Count++)
 						{
 							// Get dependency to create it's own makefile...
 							Dep->CreateMakefile(Platform, false);
 						
 							// Build a rule to make the dependency if any of the source changes...
 							auto DepBase = Dep->GetBasePath();
 							auto Base = Proj->GetBasePath();
 							auto TargetFile = Dep->GetTargetFile(Platform);
 							
 							if (DepBase && Base && TargetFile)
 							{
 								LString Rel;
 								if (!Proj->RelativePath(Rel, DepBase))
 									Rel = DepBase;
 								ToUnixPath(Rel);
 								
 								// Add tag to target name
 								auto Parts = TargetFile.SplitDelimit(".");
 								if (Parts.Length() == 2)
 									TargetFile.Printf("lib%s$(Tag).%s", Parts[0].Get(), Parts[1].Get());
 
 								sprintf(Buf, "%s/$(BuildDir)/%s", Rel.Get(), TargetFile.Get());
 								m.Print(" %s", Buf);
 								
 								LArray<char*> AllDeps;
 								Dep->GetAllDependencies(AllDeps, Platform);
 								LAssert(AllDeps.Length() > 0);
 								AllDeps.Sort(StrSort);
 
 								Rules.Print("%s : ", Buf);
 								for (int i=0; i<AllDeps.Length(); i++)
 								{
 									if (i)
 										Rules.Print(" \\\n\t");
 									
 									LString DepRel;
 									char *f = Proj->RelativePath(DepRel, AllDeps[i]) ? DepRel.Get() : AllDeps[i];
 									ToUnixPath(f);
 									Rules.Print("%s", f);
 									
 									// Add these dependencies to this makefiles dep list
 									if (!DepFiles.Find(f))
 										DepFiles.Add(f, true);
 								}
 
 								AllDeps.DeleteArrays();
 
 								Rules.Print("\n\texport Build=$(Build); \\\n"
 											"\t$(MAKE) -C %s",
 											Rel.Get());
 
 								auto Mk = Dep->GetMakefile(Platform);
 								// RenameMakefileForPlatform(Mk, Platform);
 								if (Mk)
 								{
 									char *DepMakefile = strrchr(Mk, DIR_CHAR);
 									if (DepMakefile)
 										Rules.Print(" -f %s", DepMakefile + 1);
 								}
 								else
 								{
 									Mk = Dep->GetMakefile(Platform);
 									OnError("%s:%i - No makefile for '%s'\n", _FL, Dep->GetFullPath().Get());
 								}
 
 								Rules.Print("\n\n");
 							}
 							
 							uint64 Now = LCurrentTime();
 							if (Now - Last > 1000)
 							{
 								Last = Now;
 								Log->Print("Building deps %i%%...\n", (int) (((int64)Count+1)*100/Deps.Length()));
 							}
 						}
 
 						m.Print(" $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(Target) [$(Build)]...\n"
 								"	$(CPP)%s%s %s%s -o \\\n"
 								"		$(Target) $(Objects) $(Libs)\n",
 								ExtraLinkFlags,
 								ExeFlags,
 								ValidStr(LinkerFlags) ? "-Wl" : "", LinkerFlags.Get());
 
 						if (Platform == PlatformHaiku)
 						{
 							// Is there an application icon configured?
 							const char *AppIcon = d->Settings.GetStr(ProjApplicationIcon, NULL, Platform);
 							if (AppIcon)
 							{
 								m.Print("	addattr -f %s -t \"'VICN'\" \"BEOS:ICON\" $(Target)\n", AppIcon);
 							}							
 						}
 						
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						LAutoString r(Rules.NewStr());
 						if (r)
 							m.Write(r, strlen(r));
 
 						// Various fairly global rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"						
 								"# Clean just this target\n"
 								"clean :\n"
 								"	rm $(Objects) $(Deps) $(Target)%s\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformExecutableExt(Platform));
 						
 						m.Print("# Clean all targets\n"
 								"cleanall :\n"
 								"	rm $(Objects) $(Deps) $(Target)%s\n"
 								"	@echo Cleaned $(BuildDir)\n",
 								PlatformExecutableExt(Platform));
 						
 						for (auto d: Deps)
 						{
 							auto mk = d->GetMakefile(Platform);
 							if (mk)
 							{
 								LAutoString my_base = Proj->GetBasePath();
 								LAutoString dep_base = d->GetBasePath();
 								d->CheckExists(dep_base);
 
 								auto rel_dir = LMakeRelativePath(my_base, dep_base);
 								d->CheckExists(rel_dir);
 								
 								char *mk_leaf = strrchr(mk, DIR_CHAR);
 								m.Print("	+make -C \"%s\" -f \"%s\" clean\n",
 									ToUnixPath(rel_dir ? rel_dir.Get() : dep_base.Get()),
 									ToUnixPath(mk_leaf ? mk_leaf + 1 : mk.Get()));
 							}
 						}
 						m.Print("\n");
 					}
 					// Shared library
 					else if (!stricmp(TargetType, "DynamicLibrary"))
 					{
 						m.Print("TargetFile = lib$(Target)$(Tag).%s\n"
 								"$(TargetFile) : $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(TargetFile) [$(Build)]...\n"
 								"	$(CPP)$s -shared \\\n"
 								"		%s%s \\\n"
 								"		-o $(BuildDir)/$(TargetFile) \\\n"
 								"		$(Objects) \\\n"
 								"		$(Libs)\n",
 								PlatformLibraryExt,
 								ValidStr(ExtraLinkFlags) ? "-Wl" : "", ExtraLinkFlags,
 								LinkerFlags.Get());
 
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						// Other rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"
 								"# Clean out targets\n"
 								"clean :\n"
 								"	rm $(Objects) $(Deps) $(BuildDir)/$(TargetFile)\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformLibraryExt);
 					}
 					// Static library
 					else if (!stricmp(TargetType, "StaticLibrary"))
 					{
 						m.Print("TargetFile = lib$(Target)$(Tag).%s\n"
 								"$(TargetFile) : $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(TargetFile) [$(Build)]...\n"
 								"	ar rcs $(BuildDir)/$(TargetFile) $(Objects)\n",
 								PlatformStaticLibExt);
 
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						// Other rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"
 								"# Clean out targets\n"
 								"clean :\n"
 								"	rm $(Objects) $(Deps) $(BuildDir)/$(TargetFile)\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformStaticLibExt);
 					}
 				}
 
 				// Output VPATH
 				m.Print("VPATH=%%.cpp \\\n");
 				IncPaths.Sort();
 				for (int i=0; i<IncPaths.Length() && !IsCancelled(); i++)
 				{
 					LString p = IncPaths[i];
 					Proj->CheckExists(p);
 					if (p && !strchr(p, '`'))
 					{
 						if (!LIsRelativePath(p))
 						{
 							auto a = LMakeRelativePath(Base, p);
 							m.Print("\t%s \\\n", ToPlatformPath(a ? a.Get() : p.Get(), Platform).Get());
 						}
 						else
 						{
 							m.Print("\t%s \\\n", ToPlatformPath(p, Platform).Get());
 						}
 					}
 				}
 				m.Print("\t$(BuildDir)\n\n");
 
 				const char *OtherMakefileRules = d->Settings.GetStr(ProjMakefileRules, NULL, Platform);
 				if (ValidStr(OtherMakefileRules))
 				{
 					m.Print("\n%s\n", OtherMakefileRules);
 				}
 			}
 		}
 		else
 		{
 			m.Print("# No files require building.\n");
 		}
 
 		Log->Print("...Done: '%s'\n", MakeFile.Get());
 
 		if (BuildAfterwards)
 		{
 			if (!Proj->GetApp()->PostEvent(M_START_BUILD))
 				printf("%s:%i - PostEvent(M_START_BUILD) failed.\n", _FL);
 		}
 		
 		return HasError;
 	}
 
 	void OnAfterMain()
 	{
 		Proj->GetApp()->PostEvent(M_MAKEFILES_CREATED, (LMessage::Param)Proj);
 	}
 };
 
 
 /////////////////////////////////////////////////////////////////////////////////////
 NodeSource::~NodeSource()
 {
 	if (nView)
 	{
 		nView->nSrc = 0;
 	}
 }
 
 NodeView::~NodeView()
 {
 	if (nSrc)
 	{
 		nSrc->nView = 0;
 	}
 }
 
 
 //////////////////////////////////////////////////////////////////////////////////
 int NodeSort(LTreeItem *a, LTreeItem *b, NativeInt d)
 {
 	ProjectNode *A = dynamic_cast<ProjectNode*>(a);
 	ProjectNode *B = dynamic_cast<ProjectNode*>(b);
 	if (A && B)
 	{
 		if
 		(
 			(A->GetType() == NodeDir)
 			^
 			(B->GetType() == NodeDir)
 		)
 		{
 			return A->GetType() == NodeDir ? -1 : 1;
 		}
 		else
 		{
 			return Stricmp(a->GetText(0), b->GetText(0));
 		}
 	}
 
 	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 bool ReadVsProjFile(LString File, LString &Ver, LString::Array &Configs)
 {
 	const char *Ext = LGetExtension(File);
 	if (!Ext || _stricmp(Ext, "vcxproj"))
 		return false;
 
 	LFile f;
 	if (!f.Open(File, O_READ))
 		return false;
 
 	LXmlTree Io;
 	LXmlTag r;
 	if (Io.Read(&r, &f) &&
 		r.IsTag("Project"))
 	{
 		Ver = r.GetAttr("ToolsVersion");
 
 		LXmlTag *ItemGroup = r.GetChildTag("ItemGroup");
 		if (ItemGroup)
 			for (auto c: ItemGroup->Children)
 			{
 				if (c->IsTag("ProjectConfiguration"))
 				{
 					char *s = c->GetAttr("Include");
 					if (s)
 						Configs.New() = s;
 				}
 			}
 	}
 	else return false;
 
 	return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 BuildThread::BuildThread(IdeProject *proj, char *makefile, bool clean, BuildConfig config, bool all, int wordsize) : LThread("BuildThread")
 {
 	Proj = proj;
 	Makefile = makefile;
 	Clean = clean;
 	Config = config;
 	All = all;
 	WordSize = wordsize;
 	Arch = DefaultArch;
 	Compiler = DefaultCompiler;
 	AppHnd = Proj->GetApp()->AddDispatch();
 	
 	LString Cmds = proj->d->Settings.GetStr(ProjPostBuildCommands, NULL);
 	if (ValidStr(Cmds))
 		PostBuild = Cmds.SplitDelimit("\r\n");
 
 	auto Ext = LGetExtension(Makefile);
 	if (Ext && !_stricmp(Ext, "py"))
 		Compiler = PythonScript;
 	else if (Ext && !_stricmp(Ext, "sln"))
 		Compiler = VisualStudio;
 	else if (Ext && !Stricmp(Ext, "xcodeproj"))
 		Compiler = Xcode;
 	else
 	{
 		auto Comp = Proj->GetSettings()->GetStr(ProjCompiler);
 		if (Comp)
 		{
 			// Use the specified compiler...
 			if (!stricmp(Comp, "VisualStudio"))
 				Compiler = VisualStudio;
 			else if (!stricmp(Comp, "MingW"))
 				Compiler = MingW;
 			else if (!stricmp(Comp, "gcc"))
 				Compiler = Gcc;
 			else if (!stricmp(Comp, "cross"))
 				Compiler = CrossCompiler;
 			else if (!stricmp(Comp, "IAR"))
 				Compiler = IAR;
 			else if (!stricmp(Comp, "Cygwin"))
 				Compiler = Cygwin;
 			else
 				LAssert(!"Unknown compiler.");
 		}
 	}
 
 	if (Compiler == DefaultCompiler)
 	{
 		// Use default compiler for platform...
 		#ifdef WIN32
 		Compiler = VisualStudio;
 		#else
 		Compiler = Gcc;
 		#endif
 	}
 
 	Run();
 }
 
 BuildThread::~BuildThread()
 {
 	if (SubProc)
 	{
 		bool b = SubProc->Interrupt();
 		LgiTrace("%s:%i - Sub process interrupt = %i.\n", _FL, b);
 	}
 	else LgiTrace("%s:%i - No sub process to interrupt.\n", _FL);
 
 	uint64 Start = LCurrentTime();
 	bool Killed = false;
 	while (!IsExited())
 	{
 		LSleep(10);
 
 		if (LCurrentTime() - Start > STOP_BUILD_TIMEOUT &&
 			SubProc)
 		{
 			if (Killed)
 			{
 				// Thread is stuck as well... ok kill that too!!! Argh - kill all the things!!!!
 				Terminate();
 				LgiTrace("%s:%i - Thread killed.\n", _FL);
 				Proj->GetApp()->PostEvent(M_BUILD_DONE);
 				break;
 			}
 			else
 			{
 				// Kill the sub-process...
 				bool b = SubProc->Kill();
 				Killed = true;
 				LgiTrace("%s:%i - Sub process killed.\n", _FL, b);
 				Start = LCurrentTime();
 			}
 		}
 	}
 }
 
 ssize_t BuildThread::Write(const void *Buffer, ssize_t Size, int Flags)
 {
 	if (Proj->GetApp())
 	{
 		Proj->GetApp()->PostEvent(M_APPEND_TEXT, (LMessage::Param)NewStr((char*)Buffer, Size), AppWnd::BuildTab);
 	}
 	return Size;
 }
 
 #pragma comment(lib, "version.lib")
 
 struct ProjInfo
 {
 	LString Guid, Name, File;
 	LHashTbl<StrKey<char>,ssize_t> Configs;
 };
 
 LString BuildThread::FindExe()
 {
 	LString::Array p = LGetPath();
 
 	if (Compiler == PythonScript)
 	{
 		#if defined(WINDOWS)
 		uint32_t BestVer = 0;
 		#else
 		LString BestVer;
 		#endif
 		static LString Best;
 
 		if (!Best)
 		{
 			const char *binName[] = {"python3", "python"};
 			for (int i=0; i<p.Length(); i++)
 			{
 				char Path[MAX_PATH_LEN];
 				for (unsigned n=0; n<CountOf(binName); n++)
 				{
 					LMakePath(Path, sizeof(Path), p[i], LString(binName[n]) + LGI_EXECUTABLE_EXT);
 					if (LFileExists(Path))
 					{			
 						// Check version
 						#if defined(WINDOWS)
 							DWORD Sz = GetFileVersionInfoSizeA(Path, NULL);
 							void *Buf = malloc(Sz);
 							if (GetFileVersionInfoA(Path, NULL, Sz, Buf))
 							{
 								LPVOID Ptr = NULL;
 								UINT Bytes;
 								if (VerQueryValueA(Buf, "\\", &Ptr, &Bytes))
 								{
 									VS_FIXEDFILEINFO *v = (VS_FIXEDFILEINFO *)Ptr;
 									if (v->dwProductVersionMS > BestVer)
 									{
 										BestVer = v->dwProductVersionMS;
 										Best = Path;
 									}
 								}
 							}
 							else if (!Best)
 							{
 								Best = Path;
 							}
 							free(Buf);
 						#else
 							LSubProcess p(Path, "--version");
 							LStringPipe o;
 							if (p.Start())
 								p.Communicate(&o);
 							auto Out = o.NewGStr();
 							auto Ver = Out.SplitDelimit().Last();
 							printf("Ver=%s\n", Ver.Get());
 
 							if (!BestVer || Stricmp(Ver.Get(), BestVer.Get()) > 0)
 							{
 								Best = Path;
 								BestVer = Ver;
 							}
 							break;
 						#endif
 					}
 				}
 			}
 		}
 
 		return Best;
 	}
 	else if (Compiler == VisualStudio)
 	{
 		// Find the version we need:
 		double fVer = 0.0;
 
 		ProjInfo *First = NULL;
 		LHashTbl<StrKey<char>, ProjInfo*> Projects;
 		const char *Ext = LGetExtension(Makefile);
 		if (Ext && !_stricmp(Ext, "sln"))
 		{
 			LFile f;
 			if (f.Open(Makefile, O_READ))
 			{
 				LString ProjKey = "Project(";
 				LString StartSection = "GlobalSection(";
 				LString EndSection = "EndGlobalSection";
 				LString Section;
 				ssize_t Pos;
 
 				LString::Array Ln = f.Read().SplitDelimit("\r\n");
 				for (size_t i = 0; i < Ln.Length(); i++)
 				{
 					LString s = Ln[i].Strip();
 					if ((Pos = s.Find(ProjKey)) >= 0)
 					{
 						LString::Array p = s.SplitDelimit("(),=");
 						if (p.Length() > 5)
 						{
 							ProjInfo *i = new ProjInfo;
 							i->Name = p[3].Strip(" \t\"");
 							i->File = p[4].Strip(" \t\'\"");
 							i->Guid = p[5].Strip(" \t\"");
 							if (LIsRelativePath(i->File))
 							{
 								char f[MAX_PATH_LEN];
 								LMakePath(f, sizeof(f), Makefile, "..");
 								LMakePath(f, sizeof(f), f, i->File);
 								if (LFileExists(f))
 									i->File = f;
 								/*
 								else
 									LAssert(0);
 								*/
 							}
 
 							if (!First)
 								First = i;
 
 							Projects.Add(i->Guid, i);
 						}
 					}
 					else if (s.Find(StartSection) >= 0)
 					{
 						auto p = s.SplitDelimit("() \t");
 						Section = p[1];
 					}
 					else if (s.Find(EndSection) >= 0)
 					{
 						Section.Empty();
 					}
 					else if (Section == "ProjectConfigurationPlatforms")
 					{
 						auto p = s.SplitDelimit(". \t");
 						auto i = Projects.Find(p[0]);
 						if (i)
 						{
 							if (!i->Configs.Find(p[1]))
 							{
 								auto Idx = i->Configs.Length() + 1;
 								i->Configs.Add(p[1], Idx);
 							}
 						}
 					}
 					else if (Section == "SolutionConfigurationPlatforms")
 					{
 						auto p = s.SplitDelimit();
 						auto config = p[0];
 						for (auto &it: Projects)
 						{							
 							auto proj = it.value;
 							if (!proj->Configs.Find(config))
 								proj->Configs.Add(config, proj->Configs.Length()+1);
 						}
 					}
 				}
 			}
 		}
 		else if (Ext && !_stricmp(Ext, "vcxproj"))
 		{
 			// ProjFile = Makefile;
 		}
 		else
 		{
 			if (Arch == DefaultArch)
 			{
 				if (sizeof(size_t) == 4)
 					Arch = ArchX32;
 				else
 					Arch = ArchX64;
 			}
 
 			#ifdef _MSC_VER
 			// Nmake file..
 			LString NmakePath;
 			switch (_MSC_VER)
 			{
 				#ifdef _MSC_VER_VS2013
 				case _MSC_VER_VS2013:
 				{
 					if (Arch == ArchX32)
 						NmakePath = "c:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\bin\\nmake.exe";
 					else
 						NmakePath = "c:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\bin\\amd64\\nmake.exe";
 					break;
 				}
 				#endif
 				#ifdef _MSC_VER_VS2015
 				case _MSC_VER_VS2015:
 				{
 					if (Arch == ArchX32)
 						NmakePath = "c:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\nmake.exe";
 					else
 						NmakePath = "c:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\amd64\\nmake.exe";
 					break;
 				}
 				#endif
 				default:
 				{
 					LAssert(!"Impl me.");
 					break;
 				}
 			}
 
 			if (LFileExists(NmakePath))
 			{
 				Compiler = Nmake;
 				return NmakePath;
 			}
 			#endif
 		}
 
 		/*
 		if (ProjFile && LFileExists(ProjFile))
 		{
 			LString sVer;
 			if (ReadVsProjFile(ProjFile, sVer, BuildConfigs))
 			{
 				fVer = sVer.Float();
 			}
 		}
 		*/
 		if (First)
 		{
 			for (auto i: First->Configs)
 			{
 				BuildConfigs[i.value - 1] = i.key;
 
 				LFile f(First->File, O_READ);
 				LXmlTree t;
 				LXmlTag r;
 				if (t.Read(&r, &f))
 				{
 					if (r.IsTag("Project"))
 					{
 						auto ToolsVersion = r.GetAttr("ToolsVersion");
 						if (ToolsVersion)
 						{
 							fVer = atof(ToolsVersion);
 						}
 					}
 				}
 			}
 		}
 
 		if (fVer > 0.0)
 		{
 			for (int i=0; i<CountOf(VsBinaries); i++)
 			{
 				LString p;
 				p.Printf("C:\\Program Files (x86)\\Microsoft Visual Studio %.1f\\Common7\\IDE\\%s", fVer, VsBinaries[i]);
 				if (LFileExists(p))
 				{
 					return p;
 				}
 			}
 		}
 	}
 	else if (Compiler == IAR)
 	{
 		// const char *Def = "c:\\Program Files (x86)\\IAR Systems\\Embedded Workbench 7.0\\common\\bin\\IarBuild.exe";
 		
 		LString ProgFiles = LGetSystemPath(LSP_USER_APPS, 32);
 		char p[MAX_PATH_LEN];
 		if (!LMakePath(p, sizeof(p), ProgFiles, "IAR Systems"))
 			return LString();
 		LDirectory d;
 		double LatestVer = 0.0;
 		LString Latest;
 		for (int b = d.First(p); b; b = d.Next())
 		{
 			if (d.IsDir())
 			{
 				LString n(d.GetName());
 				LString::Array p = n.Split(" ");
 				if (p.Length() == 3 &&
 					p[2].Float() > LatestVer)
 				{
 					LatestVer = p[2].Float();
 					Latest = n;
 				}
 			}
 		}
 		if (Latest &&
 			LMakePath(p, sizeof(p), p, Latest) &&
 			LMakePath(p, sizeof(p), p, "common\\bin\\IarBuild.exe"))
 		{
 			if (LFileExists(p))
 				return p;
 		}
 	}
 	else if (Compiler == Xcode)
 	{
 		return "/usr/bin/xcodebuild";
 	}
 	else if (Compiler == Cygwin)
 	{
 		#ifdef WINDOWS
 		LRegKey k(false, "HKEY_CURRENT_USER\\Software\\Cygwin\\Installations");
 		List<char> n;
 		k.GetValueNames(n);
 		LString s;
 		for (auto i:n)
 		{
 			s = k.GetStr(i);
 			if (s.Find("\\??\\") == 0)
 				s = s(4,-1);
 			if (LDirExists(s))
 			{
 				CygwinPath = s;
 				break;
 			}
 		}
 		n.DeleteArrays();
 
 		LFile::Path p(s, "bin\\make.exe");
 		if (p.Exists())
 			return p.GetFull();
 		#endif
 	}
 	else
 	{
 		if (Compiler == MingW)
 		{
 			// Have a look in the default spot first...
 			const char *Def = "C:\\MinGW\\msys\\1.0\\bin\\make.exe";
 			if (LFileExists(Def))
 			{
 				return Def;
 			}				
 		}
 		
 		for (int i=0; i<p.Length(); i++)
 		{
 			char Exe[MAX_PATH_LEN];
 			LMakePath
 			(
 				Exe,
 				sizeof(Exe),
 				p[i],
 				"make"
 				#ifdef WIN32
 				".exe"
 				#endif
 			);
 			if (LFileExists(Exe))
 			{
 				return Exe;
 			}
 		}
 	}
 	
 	return LString();
 }
 
 LAutoString BuildThread::WinToMingWPath(const char *path)
 {
 	LToken t(path, "\\");
 	LStringPipe a(256);
 	for (int i=0; i<t.Length(); i++)
 	{
 		char *p = t[i];
 		char *colon = strchr(p, ':');
 		if (colon)
 		{
 			*colon = 0;
 			StrLwr(p);
 		}
 		a.Print("/%s", p);				
 	}
 	return LAutoString(a.NewStr());
 }
 
 int BuildThread::Main()
 {
 	const char *Err = 0;
 	char ErrBuf[256];
 
 	auto Exe = FindExe();
 	if (Exe)
 	{
 		bool Status = false;
 		LString MakePath = Makefile.Get();
 		LString InitDir = Makefile.Get();
 		LVariant Jobs;
 		if (!Proj->GetApp()->GetOptions()->GetValue(OPT_Jobs, Jobs) || Jobs.CastInt32() < 1)
 			Jobs = 2;
 
 		auto Pos = InitDir.RFind(DIR_STR);
 		if (Pos)
 			InitDir.Length(Pos);
 
 		LString TmpArgs, Include, Lib, LibPath, Path;
 		
 		if (Compiler == VisualStudio)
 		{
 			// TmpArgs.Printf("\"%s\" /make \"All - Win32 Debug\"", Makefile.Get());
 			LString BuildConf = "All - Win32 Debug";
 			if (BuildConfigs.Length())
 			{
 				auto Key = toString(Config);
 				for (size_t i=0; i<BuildConfigs.Length(); i++)
 				{
 					LString c = BuildConfigs[i];
 					if (c.Find(Key) >= 0)
 					{
 						if (!BuildConf || (c.Find("x64") >= 0 && BuildConf.Find("x64") < 0))
 							BuildConf = c;
 					}
 				}
 			}
 			TmpArgs.Printf("\"%s\" %s \"%s\"", Makefile.Get(), Clean ? "/Clean" : "/Build", BuildConf.Get());
 		}
 		else if (Compiler == Nmake)
 		{
 			const char *DefInc[] = {
 				"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\INCLUDE",
 				"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\INCLUDE",
 				"C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\shared",
 				"C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\um",
 				"C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\winrt"
 			};
 			LString f;
 
 			#define ADD_PATHS(out, in) \
 				for (unsigned i=0; i<CountOf(in); i++) \
 				{ \
 					f.Printf("%s%s", i ? LGI_PATH_SEPARATOR : "", in[i]); \
 					out += f; \
 				}
 			if (Arch == ArchX32)
 			{
 				const char *DefLib[] = {
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB",
 					"C:\\Program Files (x86)\\Windows Kits\\8.1\\lib\\winv6.3\\um\\x32"
 				};
 				const char *DefLibPath[] = {
 					"C:\\WINDOWS\\Microsoft.NET\\Framework64\\v4.0.30319",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB",
 					"C:\\Program Files (x86)\\Windows Kits\\8.1\\References\\CommonConfiguration\\Neutral",
 					"C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v8.1\\ExtensionSDKs\\Microsoft.VCLibs\\12.0\\References\\CommonConfiguration\\neutral"
 				};
 				const char *DefPath[] = {
 					"c:\\Program Files (x86)\\Windows Kits\\8.1\\bin\\x86"
 				};
 			
 				ADD_PATHS(Include, DefInc);
 				ADD_PATHS(Lib, DefLib);
 				ADD_PATHS(LibPath, DefLibPath);
 				ADD_PATHS(Path, DefPath);
 			}
 			else if (Arch == ArchX64)
 			{
 				const char *DefLib[] = {
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB\\amd64",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB\\amd64",
 					"C:\\Program Files (x86)\\Windows Kits\\8.1\\lib\\winv6.3\\um\\x64"
 				};
 				const char *DefLibPath[] = {
 					"C:\\WINDOWS\\Microsoft.NET\\Framework64\\v4.0.30319",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB\\amd64",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB\\amd64",
 					"C:\\Program Files (x86)\\Windows Kits\\8.1\\References\\CommonConfiguration\\Neutral",
 					"C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v8.1\\ExtensionSDKs\\Microsoft.VCLibs\\12.0\\References\\CommonConfiguration\\neutral"
 				};
 				const char *DefPath[] = {
 					"c:\\Program Files (x86)\\Windows Kits\\8.1\\bin\\x64"
 				};
 							
 				ADD_PATHS(Include, DefInc);
 				ADD_PATHS(Lib, DefLib);
 				ADD_PATHS(LibPath, DefLibPath);
 				ADD_PATHS(Path, DefPath);
 			}
 			else LAssert(!"Invalid Arch");
 
 			TmpArgs.Printf(" -f \"%s\"", Makefile.Get());
 
 			if (Clean)
 				TmpArgs += " clean";
 		}
 		else if (Compiler == PythonScript)
 		{
 			TmpArgs = MakePath;
 		}
 		else if (Compiler == IAR)
 		{
 			LString Conf;
 
 			LFile f;
 			if (f.Open(Makefile, O_READ))
 			{
 				LXmlTree t;
 				LXmlTag r;
 				if (t.Read(&r, &f))
 				{
 					LXmlTag *c = r.GetChildTag("configuration");
 					c = c ? c->GetChildTag("name") : NULL;
 					if (c)
 						Conf = c->GetContent();
 				}				
 			}
 
 			TmpArgs.Printf("\"%s\" %s %s -log warnings", Makefile.Get(), Clean ? "-clean" : "-make", Conf.Get());
 		}
 		else if (Compiler == Xcode)
 		{
 			LString::Array Configs;
 			Configs.SetFixedLength(false);
 			LString a;
 			a.Printf("-list -project \"%s\"", Makefile.Get());
 			LSubProcess Ls(Exe, a);
 			if (Ls.Start())
 			{
 				LStringPipe o;
 				Ls.Communicate(&o);
 				auto key = "Build Configurations:";
 				auto lines = o.NewGStr().SplitDelimit("\n");
 				int inKey = -1;
 				for (auto l: lines)
 				{
 					int ws = 0;
 					for (int i=0; i<l.Length(); i++)
 						if (IsWhiteSpace(l(i))) ws++;
 						else break;
 					if (l.Find(key)>=0)
 						inKey = ws;
 					else if (inKey>=0)
 					{
 						if (ws>inKey) { Configs.New() = l.Strip(); }
 						else { inKey = -1; }
 					}
 					// printf("%s\n", l.Get());
 				}
 			}
 			
 			auto Config = Configs.Length() > 0 ? Configs[0] : LString("Debug");
 			TmpArgs.Printf("-project \"%s\" -configuration %s", Makefile.Get(), Config.Get());
 		}
 		else
 		{
 			if (Compiler == Cygwin)
 			{
 				LFile::Path p(CygwinPath, "bin");
 				Path = p.GetFull();
 			}
 
 			if (Compiler == MingW)
 			{
 				LString a;
 				char *Dir = strrchr(MakePath, DIR_CHAR);
 				#if 1
 				TmpArgs.Printf("/C \"%s\"", Exe.Get());
 
 				
 				/*	As of MSYS v1.0.18 the support for multiple jobs causes make to hang:
 					http://sourceforge.net/p/mingw/bugs/1950/
 					http://mingw-users.1079350.n2.nabble.com/MSYS-make-freezes-td7579038.html
 					
 					Apparently it'll be "fixed" in v1.0.19. We'll see. >:-(
 				
 				if (Jobs.CastInt32() > 1)
 					a.Print(" -j %i", Jobs.CastInt32());
 				
 				*/
 				
 				a.Printf(" -f \"%s\"", Dir ? Dir + 1 : MakePath.Get());
 				TmpArgs += a;
 				#else
 				TmpArgs.Printf("/C set");
 				#endif
 				Exe = "C:\\Windows\\System32\\cmd.exe";
 			}
 			else
 			{
 				if (Jobs.CastInt32())
 					TmpArgs.Printf("-j %i -f \"%s\"", Jobs.CastInt32(), MakePath.Get());
 				else
 					TmpArgs.Printf("-f \"%s\"", MakePath.Get());
 			}
 
 			if (Clean)
             {
 				if (All)
 					TmpArgs += " cleanall";
 				else
 					TmpArgs += " clean";
             }
 			if (Config == BuildRelease)
 				TmpArgs += " Build=Release";
 		}
 
 		PostThreadEvent(AppHnd, M_SELECT_TAB, AppWnd::BuildTab);
 
 		LString Msg;
 		Msg.Printf("Making: %s\n", MakePath.Get());
 		Proj->GetApp()->PostEvent(M_APPEND_TEXT, (LMessage::Param)NewStr(Msg), AppWnd::BuildTab);
 
 		LgiTrace("%s %s\n", Exe.Get(), TmpArgs.Get());
 		if (SubProc.Reset(new LSubProcess(Exe, TmpArgs)))
 		{
 			SubProc->SetNewGroup(false);
 			SubProc->SetInitFolder(InitDir);
 			if (Include)
 				SubProc->SetEnvironment("INCLUDE", Include);
 			if (Lib)
 				SubProc->SetEnvironment("LIB", Lib);
 			if (LibPath)
 				SubProc->SetEnvironment("LIBPATHS", LibPath);
 			if (Path)
 			{
 				LString Cur = getenv("PATH");
 				LString New = Cur + LGI_PATH_SEPARATOR + Path;
 				SubProc->SetEnvironment("PATH", New);
 			}
 			// SubProc->SetEnvironment("DLL", "1");
 
 			if (Compiler == MingW)
 				SubProc->SetEnvironment("PATH", "c:\\MingW\\bin;C:\\MinGW\\msys\\1.0\\bin;%PATH%");
 				
 			if ((Status = SubProc->Start(true, false)))
 			{
 				// Read all the output					
 				char Buf[256];
 				ssize_t rd;
 
 				while ( (rd = SubProc->Read(Buf, sizeof(Buf))) > 0 )
 				{
 					Write(Buf, rd);
 				}
 					
 				uint32_t ex = SubProc->Wait();
 				Print("Make exited with %i (0x%x)\n", ex, ex);
 
 				if (Compiler == IAR &&
 					ex == 0 &&
 					PostBuild.Length())
 				{
 					for (auto Cmd : PostBuild)
 					{
 						auto p = Cmd.Split(" ", 1);
 						if (p[0].Equals("cd"))
 						{
 							if (p.Length() > 1)
 								FileDev->SetCurrentFolder(p[1]);
 							else
 								LAssert(!"No folder for cd?");
 						}
 						else
 						{
 							LSubProcess PostCmd(p[0], p.Length() > 1 ? p[1] : LString());
 							if (PostCmd.Start(true, false))
 							{
 								char Buf[256];
 								ssize_t rd;
 								while ( (rd = PostCmd.Read(Buf, sizeof(Buf))) > 0 )
 								{
 									Write(Buf, rd);
 								}
 							}
 						}
 					}
 				}
 			}
 			else
 			{
 				// Create a nice error message.
 				LString ErrStr = LErrorCodeToString(SubProc->GetErrorCode());
 				if (ErrStr)
 				{
 					char *e = ErrStr.Get() + ErrStr.Length();
 					while (e > ErrStr && strchr(" \t\r\n.", e[-1]))
 						*(--e) = 0;
 				}
 					
 				sprintf_s(ErrBuf, sizeof(ErrBuf), "Running make failed with %i (%s)\n",
 					SubProc->GetErrorCode(),
 					ErrStr.Get());
 				Err = ErrBuf;
 			}
 		}
 	}
 	else
 	{
 		Err = "Couldn't find program to build makefile.";
 		LgiTrace("%s,%i - %s.\n", _FL, Err);
 	}
 
 	AppWnd *w = Proj->GetApp();
 	if (w)
 	{
 		w->PostEvent(M_BUILD_DONE);
 		if (Err)
 			Proj->GetApp()->PostEvent(M_BUILD_ERR, 0, (LMessage::Param)NewStr(Err));
 	}
 	else LAssert(0);
 	
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////////
 IdeProject::IdeProject(AppWnd *App) : IdeCommon(NULL)
 {
 	Project = this;
 	d = new IdeProjectPrivate(App, this);
 	Tag = NewStr("Project");
 }
 
 IdeProject::~IdeProject()
 {
 	d->App->OnProjectDestroy(this);
 	LXmlTag::Empty(true);
 	DeleteObj(d);
 }
 
 bool IdeProject::OnNode(const char *Path, ProjectNode *Node, bool Add)
 {
 	if (!Path || !Node)
 	{
 		LAssert(0);
 		return false;
 	}
 
 	char Full[MAX_PATH_LEN];
 	if (LIsRelativePath(Path))
 	{
 		LAutoString Base = GetBasePath();
 		if (LMakePath(Full, sizeof(Full), Base, Path))
 		{
 			Path = Full;
 		}
 	}
 
 	bool Status = false;
 	if (Add)
 		Status = d->Nodes.Add(Path, Node);
 	else
 		Status = d->Nodes.Delete(Path);
 	
 	LString p = Path;
 	if (Status && CheckExists(p))
 		d->App->OnNode(p, Node, Add ? FindSymbolSystem::FileAdd : FindSymbolSystem::FileRemove);
 
 	return Status;
 }
 
 void IdeProject::ShowFileProperties(const char *File)
 {
 	ProjectNode *Node = NULL;
 	// char *fp = FindFullPath(File, &Node);
 	if (Node)
 	{
 		Node->OnProperties();
 	}
 }
 
 const char *IdeProject::GetFileComment()
 {
 	return d->Settings.GetStr(ProjCommentFile);
 }
 
 const char *IdeProject::GetFunctionComment()
 {
 	return d->Settings.GetStr(ProjCommentFunction);
 }
 
 IdeProject *IdeProject::GetParentProject()
 {
 	return d->ParentProject;
 }
 
 void IdeProject::SetParentProject(IdeProject *p)
 {
 	d->ParentProject = p;
 }
 
 bool IdeProject::GetChildProjects(List<IdeProject> &c)
 {
 	CollectAllSubProjects(c);
 	return c.Length() > 0;
 }
 
 bool IdeProject::RelativePath(LString &Out, const char *In, bool Debug)
 {
 	if (!In)
 		return false;
 
 	auto Base = GetBasePath();
 	if (!Base)
 		return false;
 
 	CheckExists(Base);
 if (Debug) LgiTrace("XmlBase='%s'\n		In='%s'\n", Base.Get(), In);
 		
 	LToken b(Base, DIR_STR);
 	LToken i(In, DIR_STR);
 	char out[MAX_PATH_LEN] = "";
 	
 if (Debug) LgiTrace("Len %i-%i\n", b.Length(), i.Length());
 	
 	auto ILen = i.Length() + (LDirExists(In) ? 0 : 1);
 	auto Max = MIN(b.Length(), ILen);
 	int Common = 0;
 	for (; Common < Max; Common++)
 	{
 		#ifdef WIN32
 		#define StrCompare stricmp
 		#else
 		#define StrCompare strcmp
 		#endif
 		
 if (Debug) LgiTrace("Cmd '%s'-'%s'\n", b[Common], i[Common]);
 		if (StrCompare(b[Common], i[Common]) != 0)
 		{
 			break;
 		}
 	}
 	
 if (Debug) LgiTrace("Common=%i\n", Common);
 	if (Common > 0)
 	{
 		if (Common < b.Length())
 		{
 			out[0] = 0;
 			auto Back = b.Length() - Common;
 if (Debug) LgiTrace("Back=%i\n", (int)Back);
 			for (int n=0; n<Back; n++)
 			{
 				strcat(out, "..");
 				if (n < Back - 1) strcat(out, DIR_STR);
 			}
 		}
 		else
 		{
 			strcpy(out, ".");
 		}
 		for (int n=Common; n<i.Length(); n++)
 		{
 			sprintf(out+strlen(out), "%s%s", DIR_STR, i[n]);
 		}
 		
 		Out = out;
 	}	
 	else
 	{
 		Out = In;
 	}		
 
 	CheckExists(Out);
 	return true;
 }
 
 bool IdeProject::GetExePath(char *Path, int Len)
 {
 	auto PExe = d->Settings.GetStr(ProjExe);
 	LString Exe;
 	if (!PExe)
 	{
 		// Use the default exe name?
 		Exe = GetExecutable(GetCurrentPlatform());
 		if (Exe)
 		{
 			printf("Exe='%s'\n", Exe.Get());
 			PExe = Exe;
 		}
 	}
 	
 	if (!PExe)
 		return false;	
 	
 	if (LIsRelativePath(PExe))
 	{
 		auto Base = GetBasePath();
 		if (Base)
 			LMakePath(Path, Len, Base, PExe);
 		else
 			return false;
 	}
 	else
 	{
 		strcpy_s(Path, Len, PExe);
 	}
 	
 	return true;
 }
 
 LString IdeProject::GetMakefile(IdePlatform Platform)
 {
 	const char *PMakefile = d->Settings.GetStr(ProjMakefile, NULL, Platform);
 	if (!PMakefile)
 		return LString();
 	
 	LString Path;
 	if (LIsRelativePath(PMakefile))
 	{
 		auto Base = GetBasePath();
 		if (Base)
 		{
 			char p[MAX_PATH_LEN];
 			LMakePath(p, sizeof(p), Base, PMakefile);
 			Path = p;
 		}
 	}
 	else
 	{
 		Path = PMakefile;
 	}
 	
 	return Path;
 }
 
 void IdeProject::Clean(bool All, BuildConfig Config)
 {
 	if (!d->Thread &&
 		d->Settings.GetStr(ProjMakefile))
 	{
 		auto m = GetMakefile(PlatformCurrent);
 		if (m)		
 		{
 			CheckExists(m);
 			d->Thread.Reset(new BuildThread(this, m, true, Config, All, sizeof(ssize_t)*8));
 		}
 	}
 }
 
 char *QuoteStr(char *s)
 {
 	LStringPipe p(256);
 	while (s && *s)
 	{
 		if (*s == ' ')
 		{
 			p.Push("\\ ", 2);
 		}
 		else p.Push(s, 1);
 		s++;
 	}
 	return p.NewStr();
 }
 
 class ExecuteThread : public LThread, public LStream, public LCancel
 {
 	IdeProject *Proj;
 	LString Exe, Args, Path;
 	int Len;
 	ExeAction Act;
 	int AppHnd;
 
 public:
 	ExecuteThread(IdeProject *proj, const char *exe, const char *args, char *path, ExeAction act) : LThread("ExecuteThread")
 	{
 		Len = 32 << 10;
 		Proj = proj;
 		Act = act;
 		Exe = exe;
 		Args = args;
 		Path = path;
 		DeleteOnExit = true;
 		AppHnd = proj->GetApp()->AddDispatch();
 		
 		Run();
 	}
 	
 	~ExecuteThread()
 	{
 		Cancel();
 		while (!IsExited())
 			LSleep(1);
 	}
 	
 	int Main() override
 	{
 		PostThreadEvent(AppHnd, M_SELECT_TAB, AppWnd::OutputTab);
 		PostThreadEvent(AppHnd, M_APPEND_TEXT, 0, AppWnd::OutputTab);
 		
 		if (Exe)
 		{
 			if (Act == ExeDebug)
 			{
 				LSubProcess sub("kdbg", Exe);
 				if (Path)
 					sub.SetInitFolder(Path);
 				if (sub.Start())
 					sub.Communicate(this, NULL, this);
 			}
 			else if (Act == ExeValgrind)
 			{
 				#ifdef LINUX
 				LString ExePath = Proj->GetExecutable(GetCurrentPlatform());
 				if (ExePath)
 				{
 					char Path[MAX_PATH_LEN];
 					char *ExeLeaf = LGetLeaf(Exe);
 					strcpy_s(Path, sizeof(Path), ExeLeaf ? ExeLeaf : Exe.Get());
 					LTrimDir(Path);
 									
 					char *Term = 0;
 					char *WorkDir = 0;
 					char *Execute = 0;
 					switch (LGetWindowManager())
 					{
 						case WM_Kde:
 							Term = "konsole";
 							WorkDir = "--workdir ";
 							Execute = "-e";
 							break;
 						case WM_Gnome:
 							Term = "gnome-terminal";
 							WorkDir = "--working-directory=";
 							Execute = "-x";
 							break;
 					}
 					
 					if (Term && WorkDir && Execute)
 					{					
 						char *e = QuoteStr(ExePath);
 						char *p = QuoteStr(Path);
 						char *a = Proj->GetExeArgs() ? Proj->GetExeArgs() : (char*)"";
 						char Args[512];
 						sprintf(Args,
 								"%s%s "
 								"--noclose "
 								"%s valgrind --tool=memcheck --num-callers=20 %s %s",
 								WorkDir,
 								p,
 								Execute,
 								e, a);
 								
 						LExecute(Term, Args);
 					}
 				}
 				#endif
 			}
 			else
 			{
 				LSubProcess sub(Exe, Args);
 				if (Path)
 					sub.SetInitFolder(Path);
 				if (sub.Start())
 					sub.Communicate(this, NULL, this);
 			}
 		}
 		
 		return 0;
 	}
 
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0) override
 	{
 		if (Len <= 0)
 			return 0;
 
 		PostThreadEvent(AppHnd, M_APPEND_TEXT, (LMessage::Param)NewStr((char*)Buffer, Size), AppWnd::OutputTab);
 		Len -= Size;
 		return Size;
 	}
 };
 
 LDebugContext *IdeProject::Execute(ExeAction Act, LString *ErrMsg)
 {
 	auto Base = GetBasePath();
 	
 	if (!Base)
 	{
 		if (ErrMsg) *ErrMsg = "No base path for project.";
 		return NULL;		
 	}
 	
 	char e[MAX_PATH_LEN];
 	if (!GetExePath(e, sizeof(e)))
 	{
 		if (ErrMsg) *ErrMsg = "GetExePath failed.";
 		return NULL;		
 	}
 	
 	if (!LFileExists(e))
 	{
 		if (ErrMsg) ErrMsg->Printf("Executable '%s' doesn't exist.\n", e);
 		return NULL;
 	}
 
 	const char *Args = d->Settings.GetStr(ProjArgs);
 	const char *Env = d->Settings.GetStr(ProjEnv);
 	LString InitDir = d->Settings.GetStr(ProjInitDir);
 	int RunAsAdmin = d->Settings.GetInt(ProjDebugAdmin);
 	
 	#ifndef HAIKU
 	if (Act == ExeDebug)
 	{
 		if (InitDir && LIsRelativePath(InitDir))
 		{
 			LFile::Path p(Base);
 			p += InitDir;
 			InitDir = p.GetFull();
 		}
 			
 		return new LDebugContext(d->App, this, e, Args, RunAsAdmin != 0, Env, InitDir);
 	}
 	#endif
 
 	new ExecuteThread(	this,
 						e,
 						Args,
 						Base,
 						#if defined(HAIKU) || defined(WINDOWS)
 							ExeRun // No gdb or valgrind
 						#else
 							Act
 						#endif
 						);
 	return NULL;
 }
 
 bool IdeProject::IsMakefileAScript()
 {
 	auto m = GetMakefile(PlatformCurrent);
 	if (m)
 	{
 		auto Ext = LGetExtension(m);
 		if (!Stricmp(Ext, "py"))
 		{
 			// Not a makefile but a build script... can't update.
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool IdeProject::IsMakefileUpToDate()
 {
 	if (IsMakefileAScript())
 		return true; // We can't know if it's up to date...
 
 	List<IdeProject> Proj;
 	GetChildProjects(Proj);
 
 	Proj.Insert(this);
 	for (auto p: Proj)
 	{
 		// Is the project file modified after the makefile?
 		auto Proj = p->GetFullPath();
 		uint64 ProjModTime = 0, MakeModTime = 0;
 		LDirectory dir;
 		if (dir.First(Proj))
 		{
 			ProjModTime = dir.GetLastWriteTime();
 			dir.Close();
 		}
 
 		auto m = p->GetMakefile(PlatformCurrent);
 		if (!m)
 		{		
 			d->App->GetBuildLog()->Print("Error: no makefile? (%s:%i)\n", _FL);
 			break;
 		}
 		
 		auto Ext = LGetExtension(m);
 		if (!Stricmp(Ext, "py"))
 		{
 			// Not a makefile but a build script... can't update.
 			return true;
 		}
 
 		if (dir.First(m))
 		{
 			MakeModTime = dir.GetLastWriteTime();
 			dir.Close();
 		}
 
 		// printf("Proj=%s - Timestamps " LGI_PrintfInt64 " - " LGI_PrintfInt64 "\n", Proj.Get(), ProjModTime, MakeModTime);
 		if (ProjModTime != 0 &&
 			MakeModTime != 0 &&
 			ProjModTime > MakeModTime)
 		{
 			// Need to rebuild the makefile...
 			return false;
 		}
 	}
 	
 	return true;
 }
 
 bool IdeProject::FindDuplicateSymbols()
 {
 	LStream *Log = d->App->GetBuildLog();	
 	Log->Print("FindDuplicateSymbols starting...\n");
 
 	List<IdeProject> Proj;
 	CollectAllSubProjects(Proj);
 	Proj.Insert(this);
 
 	int Lines = 0;
 	
 	LHashTbl<StrKey<char,false>,int64> Map(200000);
 	int Found = 0;
 	for (auto p: Proj)
 	{
 		LString s = p->GetExecutable(GetCurrentPlatform());
 		if (s)
 		{
 			LString Args;
 			Args.Printf("--print-size --defined-only -C %s", s.Get());
 			LSubProcess Nm("nm", Args);
 			if (Nm.Start(true, false))
 			{
 				char Buf[256];
 				LStringPipe q;
 				for (ssize_t Rd = 0; (Rd = Nm.Read(Buf, sizeof(Buf))); )
 					q.Write(Buf, Rd);
 				LString::Array a = q.NewGStr().SplitDelimit("\r\n");
 				LHashTbl<StrKey<char,false>,bool> Local(200000);
 				for (auto &Ln: a)
 				{
 					LString::Array p = Ln.SplitDelimit(" \t", 3);
 					if (!Local.Find(p.Last()))
 					{
 						Local.Add(p.Last(), true);
 					
 						// const char *Sz = p[1];
 						int64 Ours = p[1].Int(16);
 						int64 Theirs = Map.Find(p.Last());
 						if (Theirs >= 0)
 						{
 							if (Ours != Theirs)
 							{
 								if (Found++ < 100)
 									Log->Print("    %s (" LPrintfInt64 " -> " LPrintfInt64 ")\n",
 										p.Last().Get(),
 										Ours, Theirs);
 							}
 						}
 						else if (Ours >= 0)
 						{						
 							Map.Add(p.Last(), Ours);
 						}
 						else
 						{
 							printf("Bad line: %s\n", Ln.Get());
 						}
 					}
 					Lines++;
 				}
 			}
 		}
 		else printf("%s:%i - GetExecutable failed.\n", _FL);
 	}
 
 	/*
 	char *Sym;
 	for (int Count = Map.First(&Sym); Count; Count = Map.Next(&Sym))
 	{
 		if (Count > 1)
 			Log->Print("    %i: %s\n", Count, Sym);
 	}
 	*/
 
 	Log->Print("FindDuplicateSymbols finished (%i lines)\n", Lines);
 	return false;
 }
 
 bool IdeProject::FixMissingFiles()
 {
 	FixMissingFilesDlg(this);
 	return true;
 }
 
 void IdeProject::Build(bool All, BuildConfig Config)
 {
 	if (d->Thread)
 	{
 		d->App->GetBuildLog()->Print("Error: Already building (%s:%i)\n", _FL);
 		return;
 	}
 
 	auto m = GetMakefile(PlatformCurrent);
 	CheckExists(m);
 	if (!m)
 	{		
 		d->App->GetBuildLog()->Print("Error: no makefile? (%s:%i)\n", _FL);
 		return;
 	}
 
 	if (GetApp())
 		GetApp()->PostEvent(M_APPEND_TEXT, 0, 0);
 
 	SetClean([&](bool ok)
 	{
 		if (!ok)
 			return;
 
 		if (!IsMakefileUpToDate())
 			CreateMakefile(GetCurrentPlatform(), true);
 		else
 			// Start the build thread...
 			d->Thread.Reset
 			(
 				new BuildThread
 				(
 					this,
 					m,
 					false,
 					Config,
 					All,
 					sizeof(size_t)*8
 				)
 			);
 	});
 }
 
 void IdeProject::StopBuild()
 {
 	d->Thread.Reset();
 }
 
 bool IdeProject::Serialize(bool Write)
 {
 	return true;
 }
 
 AppWnd *IdeProject::GetApp()
 {
 	return d->App;
 }
 
 const char *IdeProject::GetIncludePaths()
 {
 	return d->Settings.GetStr(ProjIncludePaths);
 }
 
 const char *IdeProject::GetPreDefinedValues()
 {
 	return d->Settings.GetStr(ProjDefines);
 }
 
 const char *IdeProject::GetExeArgs()
 {
 	return d->Settings.GetStr(ProjArgs);
 }
 
 LString IdeProject::GetExecutable(IdePlatform Platform)
 {
 	LString Bin = d->Settings.GetStr(ProjExe, NULL, Platform);
 	auto TargetType = d->Settings.GetStr(ProjTargetType, NULL, Platform);
 	auto Base = GetBasePath();
 
 	if (Bin)
 	{
 		if (LIsRelativePath(Bin) && Base)
 		{
 			char p[MAX_PATH_LEN];
 			if (LMakePath(p, sizeof(p), Base, Bin))
 				Bin = p;
 		}
 		
 		return Bin;
 	}
 
 	// Create binary name from target:	
 	auto Target = GetTargetName(Platform);
 	if (Target)
 	{
 		bool IsLibrary = Stristr(TargetType, "library");
 		int BuildMode = d->App->GetBuildMode();
 		const char *Name = BuildMode ? "Release" : "Debug";
 		const char *Postfix = BuildMode ? "" : "d";
 		
 		switch (Platform)
 		{			
 			case PlatformWin:
 			{
 				if (IsLibrary)
 					Bin.Printf("%s%s.dll", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			case PlatformMac:
 			{
 				if (IsLibrary)
 					Bin.Printf("lib%s%s.dylib", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			case PlatformLinux:
 			case PlatformHaiku:
 			{
 				if (IsLibrary)
 					Bin.Printf("lib%s%s.so", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			default:
 			{
 				LAssert(0);
 				printf("%s:%i - Unknown platform.\n", _FL);
 				return LString();
 			}
 		}
 		
 		// Find the actual file...
 		if (!Base)
 		{
 			printf("%s:%i - GetBasePath failed.\n", _FL);
 			return LString();
 		}
 			
 		char Path[MAX_PATH_LEN];
 		LMakePath(Path, sizeof(Path), Base, Name);
 		LMakePath(Path, sizeof(Path), Path, Bin);
 		if (LFileExists(Path))
 			Bin = Path;
 		else
 			printf("%s:%i - '%s' doesn't exist.\n", _FL, Path);
 		
 		
 		return Bin;
 	}
 	
 	return LString();
 }
 
 const char *IdeProject::GetFileName()
 {
 	return d->FileName;
 }
 
 int IdeProject::GetPlatforms()
 {
 	return PLATFORM_ALL;
 }
 	
 LAutoString IdeProject::GetFullPath()
 {
 	LAutoString Status;
 	if (!d->FileName)
 	{
 		// LAssert(!"No path.");
 		return Status;
 	}
 
 	LArray<const char*> sections;
 	IdeProject *proj = this;
 	while (	proj &&
 			proj->GetFileName() &&
 			LIsRelativePath(proj->GetFileName()))
 	{
 		sections.AddAt(0, proj->GetFileName());
 		proj = proj->GetParentProject();
 	}
 
 	if (!proj)
 	{
 		// LAssert(!"All projects have a relative path?");
 		return Status; // No absolute path in the parent projects?
 	}
 
 	char p[MAX_PATH_LEN];
 	strcpy_s(p, sizeof(p), proj->GetFileName()); // Copy the base path
 	if (sections.Length() > 0)
 		LTrimDir(p); // Trim off the filename
 	for (int i=0; i<sections.Length(); i++) // For each relative section
 	{
 		LMakePath(p, sizeof(p), p, sections[i]); // Append relative path
 		if (i < sections.Length() - 1)
 			LTrimDir(p); // Trim filename off
 	}
 	
 	Status.Reset(NewStr(p));
 	return Status;
 }
 
 LAutoString IdeProject::GetBasePath()
 {
 	auto a = GetFullPath();
 	LTrimDir(a);
 	return a;
 }
 
 void IdeProject::CreateProject()
 {
 	Empty();
 	
 	d->FileName.Empty();
 	d->UserFile.Empty();
 	d->App->GetTree()->Insert(this);
 	
 	ProjectNode *f = new ProjectNode(this);
 	if (f)
 	{
 		f->SetName("Source");
 		f->SetType(NodeDir);
 		InsertTag(f);
 	}
 	
 	f = new ProjectNode(this);
 	if (f)
 	{
 		f->SetName("Headers");
 		f->SetType(NodeDir);
 		InsertTag(f);
 	}
 	
 	d->Settings.Set(ProjEditorTabSize, 4);
 	d->Settings.Set(ProjEditorIndentSize, 4);
 	d->Settings.Set(ProjEditorUseHardTabs, true);
 	
 	d->Dirty = true;
 	Expanded(true);	
 }
 
 ProjectStatus IdeProject::OpenFile(const char *FileName)
 {
 	auto Log = d->App->GetBuildLog();
 
 	LProfile Prof("IdeProject::OpenFile");
 	Prof.HideResultsIfBelow(1000);
 
 	Empty();
 
 	Prof.Add("Init");
 
 	d->UserNodeFlags.Empty();
 	if (LIsRelativePath(FileName))
 	{
 		char p[MAX_PATH_LEN];
 		getcwd(p, sizeof(p));
 		LMakePath(p, sizeof(p), p, FileName);
 		d->FileName = p;
 	}
 	else
 	{
 		d->FileName = FileName;
 	}
 	d->UserFile = d->FileName + "." + LCurrentUserName();
 
 	if (!d->FileName)
 	{
 		Log->Print("%s:%i - No filename.\n", _FL);
 		return OpenError;
 	}
 	
 	Prof.Add("FileOpen");
 
 	LFile f;
 	LString FullPath = d->FileName.Get();
 	if (!CheckExists(FullPath) ||
 		!f.Open(FullPath, O_READWRITE))
 	{
 		Log->Print("%s:%i - Error: Can't open '%s'.\n", _FL, FullPath.Get());
 		return OpenError;
 	}
 
 	Prof.Add("Xml");
 
 	LXmlTree x;
 	LXmlTag r;
 	if (!x.Read(&r, &f))
 	{
 		Log->Print("%s:%i - Error: Can't read XML: %s\n", _FL, x.GetErrorMsg());
 		return OpenError;
 	}
 
 	Prof.Add("Progress Setup");
 
 	#if DEBUG_OPEN_PROGRESS
 	int64 Nodes = r.CountTags();
 	LProgressDlg Prog(d->App, 1000);
 	Prog.SetDescription("Loading project...");
 	Prog.SetLimits(0, Nodes);
 	Prog.SetYieldTime(1000);
 	Prog.SetAlwaysOnTop(true);
 	#endif
 
 	Prof.Add("UserFile");
 
 	if (LFileExists(d->UserFile))
 	{
 		LFile Uf;
 		if (Uf.Open(d->UserFile, O_READ))
 		{
 			LString::Array Ln = Uf.Read().SplitDelimit("\n");
 			for (unsigned i=0; i<Ln.Length(); i++)
 			{
 				LString::Array p = Ln[i].SplitDelimit(",");
 				if (p.Length() == 2)
 					d->UserNodeFlags.Add((int)p[0].Int(), (int)p[1].Int(16));
 			}
 		}
 	}
 	
 	if (!r.IsTag("Project"))
 	{
 		Log->Print("%s:%i - No 'Project' tag.\n", _FL);
 		return OpenError;
 	}
 
 	Prof.Add("OnOpen");
 
 	bool Ok = OnOpen(
 		#if DEBUG_OPEN_PROGRESS
 		&Prog,
 		#else
 		NULL,
 		#endif
 		&r);
 	#if DEBUG_OPEN_PROGRESS
 	if (Prog.IsCancelled())
 		return OpenCancel;
 	else 
 	#endif
 	if (!Ok)
 		return OpenError;
 
 	Prof.Add("Insert");
 
 	d->App->GetTree()->Insert(this);
 	Expanded(true);
 
 	Prof.Add("Serialize");
 	
 	d->Settings.Serialize(&r, false /* read */);
 	return OpenOk;
 }
 
 bool IdeProject::SaveFile()
 {
 	auto Full = GetFullPath();
 
 	if (ValidStr(Full) && d->Dirty)
 	{
 		LFile f;
 		if (f.Open(Full, O_WRITE))
 		{
 			f.SetSize(0);
 
 			LXmlTree x;
 			d->Settings.Serialize(this, true /* write */);
 
 			if (x.Write(this, &f))
 				d->Dirty = false;
 			else
 				LgiTrace("%s:%i - Failed to write XML.\n", _FL);
 		}
 		else LgiTrace("%s:%i - Couldn't open '%s' for writing.\n", _FL, Full.Get());
 	}
 
 	if (d->UserFileDirty)
 	{
 		LFile f;
 		LAssert(d->UserFile.Get());
 		if (f.Open(d->UserFile, O_WRITE))
 		{
 			f.SetSize(0);
 
 			// Save user file details..
 			// int Id;
 			// for (int Flags = d->UserNodeFlags.First(&Id); Flags >= 0; Flags = d->UserNodeFlags.Next(&Id))
 			for (auto i : d->UserNodeFlags)
 			{
 				f.Print("%i,%x\n", i.key, i.value);
 			}
 
 			d->UserFileDirty = false;
 		}
 	}
 
 	printf("\tIdeProject::SaveFile %i %i\n", d->Dirty, d->UserFileDirty);
 
 	return	!d->Dirty &&
 			!d->UserFileDirty;
 }
 
 void IdeProject::SetDirty()
 {
 	d->Dirty = true;
 	d->App->OnProjectChange();
 }
 
 void IdeProject::SetUserFileDirty()
 {
 	d->UserFileDirty = true;
 }
 
 bool IdeProject::GetExpanded(int Id)
 {
 	int f = d->UserNodeFlags.Find(Id);
 	return f >= 0 ? f : false;
 }
 
 void IdeProject::SetExpanded(int Id, bool Exp)
 {
 	if (d->UserNodeFlags.Find(Id) != (int)Exp)
 	{
 		d->UserNodeFlags.Add(Id, Exp);
 		SetUserFileDirty();
 	}
 }
 
 int IdeProject::AllocateId()
 {
 	return d->NextNodeId++;
 }
 
 template<typename T, typename Fn>
 bool CheckExists(LAutoString Base, T &p, Fn Setter, bool Debug)
 {
 	LFile::Path Full;
 	bool WasRel = LIsRelativePath(p);
 	if (WasRel)
 	{
 		Full = Base.Get();
 		Full += p.Get();
 	}
 	else Full = p.Get();
 	
 	bool Ret = Full.Exists();
 	if (!Ret)
 	{
 		// Is the case wrong?
 		for (int i=1; i<Full.Length(); i++)
 		{
 			LFile::Path t;
 			t = Full.Slice(0, i);
 			if (!t.Exists())
 			{
 				LDirectory dir;
 				bool Matched = false;
 				auto &Leaf = Full[i-1];
 				auto Parent = t.GetParent();
 				
 				if (Debug)
 					printf("Searching '%s' for missing '%s'\n", Parent.GetFull().Get(), Leaf.Get());
 				
 				for (auto b=dir.First(Parent); b; b = dir.Next())
 				{
 					if (!Stricmp(dir.GetName(), t.Last().Get()))
 					{
 						if (Debug)
 							printf("t[%i]: %s->%s\n", i, Leaf.Get(), dir.GetName());
 						Leaf = dir.GetName();
 						Matched = true;
 						break;
 					}
 				}
 				if (!Matched)					
 					break;
 			}
 		}
 		
 		if ((Ret = Full.Exists()))
 		{
 			LString Old = p.Get();
 			if (WasRel)
 			{
 				auto r = LMakeRelativePath(Base, Full);
 				Setter(p, r);
 			}
 			else
 			{
 				Setter(p, Full.GetFull());
 			}
 			
 			if (Debug)
 				printf("%s -> %s\n", Old.Get(), p.Get());
 		}
 	}
 
 	if (Debug)
 		printf("CheckExists '%s' = %i\n", Full.GetFull().Get(), Ret);		
 
 	return Ret;
 }
 
 bool IdeProject::CheckExists(LString &p, bool Debug)
 {
 	return ::CheckExists(GetBasePath(), p, [](LString &o, const char *i) {
 			o = i;
 		}, Debug);
 }
 
 bool IdeProject::CheckExists(LAutoString &p, bool Debug)
 {
 	return ::CheckExists(GetBasePath(), p, [](LAutoString &o, const char *i) {
 			o.Reset(NewStr(i));
 		}, Debug);
 }
 
 bool IdeProject::GetClean()
 {
 	for (auto i: *this)
 	{
 		ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 		if (p && !p->GetClean())
 			return false;
 	}
 	
 	return !d->Dirty && !d->UserFileDirty;
 }
 
 void IdeProject::SetClean(std::function<void(bool)> OnDone)
 {
 	auto CleanNodes = [&]()
 	{
 		for (auto i: *this)
 		{
 			ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 			if (!p) break;
 			p->SetClean();
 		}
 
 		if (OnDone)
 			OnDone(true);
 	};
 
 	if (d->Dirty || d->UserFileDirty)
 	{
 		if (ValidStr(d->FileName))
 			SaveFile();
 		else
 		{
 			LFileSelect s;
 			s.Parent(Tree);
 			s.Name("Project.xml");
 			s.Save([&](auto s, auto ok)
 			{
 				if (!ok)
 				{
 					if (OnDone)
 						OnDone(false);
 					return;
 				}
 
 				d->FileName = s->Name();
 				d->UserFile = d->FileName + "." + LCurrentUserName();
 				d->App->OnFile(d->FileName, true);
 				Update();
 
 				CleanNodes();
 			});
 			return;
 		}
 	}
 	
 	CleanNodes();
 }
 
 
 const char *IdeProject::GetText(int Col)
 {
 	if (d->FileName)
 	{
 		char *s = strrchr(d->FileName, DIR_CHAR);
 		return s ? s + 1 : d->FileName.Get();
 	}
 
 	return Untitled;
 }
 
 int IdeProject::GetImage(int Flags)
 {
 	return 0;
 }
 
 void IdeProject::Empty()
 {
 	LXmlTag *t;
 	while (Children.Length() > 0 &&
 		(t = Children[0]))
 	{
 		ProjectNode *n = dynamic_cast<ProjectNode*>(t);
 		if (n)
 		{
 			n->Remove();
 		}
 		DeleteObj(t);
 	}
 }
 
 LXmlTag *IdeProject::Create(char *Tag)
 {
 	if (!stricmp(Tag, TagSettings))
 		return NULL;
 
 	return new ProjectNode(this);
 }
 
 void IdeProject::OnMouseClick(LMouse &m)
 {
 	if (m.IsContextMenu())
 	{
 		LSubMenu Sub;
 		Sub.AppendItem("New Folder", IDM_NEW_FOLDER);
 		Sub.AppendItem("New Web Folder", IDM_WEB_FOLDER);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Build", IDM_BUILD);
 		Sub.AppendItem("Clean Project", IDM_CLEAN_PROJECT);
 		Sub.AppendItem("Clean All", IDM_CLEAN_ALL);
 		Sub.AppendItem("Rebuild Project", IDM_REBUILD_PROJECT);
 		Sub.AppendItem("Rebuild All", IDM_REBUILD_ALL);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Sort Children", IDM_SORT_CHILDREN);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Settings", IDM_SETTINGS, true);
 		Sub.AppendItem("Insert Dependency", IDM_INSERT_DEP);
 
 		m.ToScreen();
 		auto c = _ScrollPos();
 		m.x -= c.x;
 		m.y -= c.y;
 		switch (Sub.Float(Tree, m.x, m.y))
 		{
 			case IDM_NEW_FOLDER:
 			{
-				LInput Name(Tree, "", "Name:", AppName);
-				Name.DoModal([&](auto d, auto code)
+				auto Name = new LInput(Tree, "", "Name:", AppName);
+				Name->DoModal([this, Name](auto d, auto code)
 				{
-					GetSubFolder(this, Name.GetStr(), true);
+					if (code)
+						GetSubFolder(this, Name->GetStr(), true);
+					delete d;
 				});
 				break;
 			}
 			case IDM_WEB_FOLDER:
 			{
 				WebFldDlg *Dlg = new WebFldDlg(Tree, 0, 0, 0);
 				Dlg->DoModal([&](auto d, auto code)
 				{
 					if (Dlg->Ftp && Dlg->Www)
 					{
 						IdeCommon *f = GetSubFolder(this, Dlg->Name, true);
 						if (f)
 						{
 							f->SetAttr(OPT_Ftp, Dlg->Ftp);
 							f->SetAttr(OPT_Www, Dlg->Www);
 						}
 					}
 					delete Dlg;
 				});
 				break;
 			}
 			case IDM_BUILD:
 			{
 				StopBuild();
 				Build(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_CLEAN_PROJECT:
 			{
 				Clean(false, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_CLEAN_ALL:
 			{
 				Clean(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_REBUILD_PROJECT:
 			{
 				StopBuild();
 				Clean(false, d->App->GetBuildMode());
 				Build(false, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_REBUILD_ALL:
 			{
 				StopBuild();
 				Clean(true, d->App->GetBuildMode());
 				Build(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_SORT_CHILDREN:
 			{
 				SortChildren();
 				Project->SetDirty();
 				break;
 			}
 			case IDM_SETTINGS:
 			{
 				d->Settings.Edit(Tree, [&]()
 				{
 					SetDirty();
 				});
 				break;
 			}
 			case IDM_INSERT_DEP:
 			{
 				LFileSelect *s = new LFileSelect;
 				s->Parent(Tree);
 				s->Type("Project", "*.xml");
 				s->Open([&](auto s, bool ok)
 				{
 					if (!ok)
 						return;
 					ProjectNode *New = new ProjectNode(this);
 					if (New)
 					{
 						New->SetFileName(s->Name());
 						New->SetType(NodeDependancy);
 						InsertTag(New);
 						SetDirty();
 					}
 					delete s;
 				});
 				break;
 			}
 		}
 	}
 }
 
 char *IdeProject::FindFullPath(const char *File, ProjectNode **Node)
 {
 	char *Full = 0;
 	
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		ProjectNode *n = c->FindFile(File, &Full);
 		if (n)
 		{
 			if (Node)
 				*Node = n;
 			break;
 		}
 	}
 	
 	return Full;
 }
 
 bool IdeProject::HasNode(ProjectNode *Node)
 {
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		if (c->HasNode(Node))
 			return true;
 	}
 	return false;
 }
 
 bool IdeProject::GetAllNodes(LArray<ProjectNode*> &Nodes)
 {
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		c->AddNodes(Nodes);
 	}
 	return true;
 }
 
 bool IdeProject::InProject(bool FuzzyMatch, const char *Path, bool Open, IdeDoc **Doc)
 {
 	if (!Path)
 		return false;
 		
 	// Search complete path first...
 	ProjectNode *n = d->Nodes.Find(Path);	
 	if (!n && FuzzyMatch)
 	{
 		// No match, do partial matching.
 		const char *Leaf = LGetLeaf(Path);
 		auto PathLen = strlen(Path);
 		auto LeafLen = strlen(Leaf);
 		uint32_t MatchingScore = 0;
 
 		// Traverse all nodes and try and find the best fit.
 		// const char *p;
 		// for (ProjectNode *Cur = d->Nodes.First(&p); Cur; Cur = d->Nodes.Next(&p))
 		for (auto Cur : d->Nodes)
 		{
 			int CurPlatform = Cur.value->GetPlatforms();
 			uint32_t Score = 0;
 
 			if (stristr(Cur.key, Path))
 			{
 				Score += PathLen;
 			}
 			else if (stristr(Cur.key, Leaf))
 			{
 				Score += LeafLen;
 			}
 
 			const char *pLeaf = LGetLeaf(Cur.key);
 			if (pLeaf && !stricmp(pLeaf, Leaf))
 			{
 				Score |= 0x40000000;
 			}
 			if (Score && (CurPlatform & PLATFORM_CURRENT) != 0)
 			{
 				Score |= 0x80000000;
 			}
 
 			if (Score > MatchingScore)
 			{
 				MatchingScore = Score;
 				n = Cur.value;
 			}
 		}
 	}
 	
 	if (n && Doc)
 	{
 		*Doc = n->Open();
 	}
 	
 	return n != 0;
 }
 
 char *GetQuotedStr(char *Str)
 {
 	char *s = strchr(Str, '\"');
 	if (s)
 	{
 		s++;
 		char *e = strchr(s, '\"');
 		if (e)
 		{
 			return NewStr(s, e - s);
 		}
 	}
 
 	return 0;
 }
 
 void IdeProject::ImportDsp(const char *File)
 {
 	if (File && LFileExists(File))
 	{
 		char Base[256];
 		strcpy(Base, File);
 		LTrimDir(Base);
 		
 		char *Dsp = LReadTextFile(File);
 		if (Dsp)
 		{
 			LToken Lines(Dsp, "\r\n");
 			IdeCommon *Current = this;
 			bool IsSource = false;
 			for (int i=0; i<Lines.Length(); i++)
 			{
 				char *L = Lines[i];
 				if (strnicmp(L, "# Begin Group", 13) == 0)
 				{
 					char *Folder = GetQuotedStr(L);
 					if (Folder)
 					{
 						IdeCommon *Sub = Current->GetSubFolder(this, Folder, true);
 						if (Sub)
 						{
 							Current = Sub;
 						}
 						DeleteArray(Folder);
 					}
 				}
 				else if (strnicmp(L, "# End Group", 11) == 0)
 				{
 					IdeCommon *Parent = dynamic_cast<IdeCommon*>(Current->GetParent());
 					if (Parent)
 					{
 						Current = Parent;
 					}
 				}
 				else if (strnicmp(L, "# Begin Source", 14) == 0)
 				{
 					IsSource = true;
 				}
 				else if (strnicmp(L, "# End Source", 12) == 0)
 				{
 					IsSource = false;
 				}
 				else if (Current && IsSource && strncmp(L, "SOURCE=", 7) == 0)
 				{
 					ProjectNode *New = new ProjectNode(this);
 					if (New)
 					{
 						char *Src = 0;
 						if (strchr(L, '\"'))
 						{
 							Src = GetQuotedStr(L);
 						}
 						else
 						{
 							Src = NewStr(L + 7);
 						}						
 						if (Src)
 						{
 							// Make absolute path
 							char Abs[256];
 							LMakePath(Abs, sizeof(Abs), Base, ToUnixPath(Src));
 							
 							// Make relitive path
 							New->SetFileName(Src);
 							DeleteArray(Src);
 						}
 
 						Current->InsertTag(New);
 						SetDirty();
 					}
 				}
 			}
 			
 			DeleteArray(Dsp);
 		}
 	}
 }
 
 IdeProjectSettings *IdeProject::GetSettings()
 {
 	return &d->Settings;
 }
 
 bool IdeProject::BuildIncludePaths(LArray<LString> &Paths, bool Recurse, bool IncludeSystem, IdePlatform Platform)
 {
 	List<IdeProject> Projects;
 	if (Recurse)
 		GetChildProjects(Projects);
 	Projects.Insert(this, 0);
 
 	LHashTbl<StrKey<char>, bool> Map;
 	
 	for (auto p: Projects)
 	{
 		LString ProjInclude = d->Settings.GetStr(ProjIncludePaths, NULL, Platform);
 		LAutoString Base = p->GetBasePath();
 		
 		const char *Delim = ",;\r\n";
 		LString::Array In, Out;
 		LString::Array a = ProjInclude.SplitDelimit(Delim);
 		In = a;
 		
 		if (IncludeSystem)
 		{
 			LString SysInclude = d->Settings.GetStr(ProjSystemIncludes, NULL, Platform);
 			a = SysInclude.SplitDelimit(Delim);
 			In.SetFixedLength(false);
 			In.Add(a);
 		}
 		
 		for (unsigned i=0; i<In.Length(); i++)
 		{
 			auto p = ToPlatformPath(In[i], Platform);
 
 			char *Path = p;
 			if (*Path == '`')
 			{
 				// Run config app to get the full path list...
 				p = p.Strip("`");
 				LString::Array a = p.Split(" ", 1);
 				LSubProcess Proc(a[0], a.Length() > 1 ? a[1].Get() : NULL);
 				LStringPipe Buf;
 				if (Proc.Start())
 				{
 					Proc.Communicate(&Buf);
 
 					LString result = Buf.NewGStr();
 					a = result.Split(" \t\r\n");
 					for (int i=0; i<a.Length(); i++)
 					{
 						char *inc = a[i];
 						if (inc[0] == '-' &&
 							inc[1] == 'I')
 						{
 							Out.New() = a[i](2,-1);
 						}
 					}
 				}
 				else LgiTrace("%s:%i - Error: failed to run process for '%s'\n", _FL, p.Get());
 			}
 			else
 			{
 				// Add path literal
 				Out.New() = Path;
 			}
 		}
 			
 		for (int i=0; i<Out.Length(); i++)
 		{
 			char *Path = Out[i];
 			char *Full = 0, Buf[MAX_PATH_LEN];
 			if
 			(
 				*Path != '/'
 				&&
 				!(
 					IsAlpha(*Path)
 					&&
 					Path[1] == ':'
 				)
 			)
 			{
 				LMakePath(Buf, sizeof(Buf), Base, Path);
 				Full = Buf;
 			}
 			else
 			{
 				Full = Out[i];
 			}
 			
 			if (!Map.Find(Full))
 				Map.Add(Full, true);
 		}
 
 		// Add paths for the headers in the project... bit of a hack but it'll
 		// help it find them if the user doesn't specify the paths in the project.
 		LArray<ProjectNode*> Nodes;
 		if (p->GetAllNodes(Nodes))
 		{
 			auto Base = p->GetFullPath();
 			if (Base)
 			{
 				LTrimDir(Base);
 
 				for (auto &n: Nodes)
 				{
 					if (n->GetType() == NodeHeader &&				// Only look at headers.
 						(n->GetPlatforms() & (1 << Platform)) != 0)	// Exclude files not on this platform.
 					{
 						auto f = n->GetFileName();
 						char p[MAX_PATH_LEN];
 						if (f &&
 							LMakePath(p, sizeof(p), Base, f))
 						{
 							char *l = strrchr(p, DIR_CHAR);
 							if (l)
 								*l = 0;
 							if (!Map.Find(p))
 							{
 								Map.Add(p, true);
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 	// char *p;
 	// for (bool b = Map.First(&p); b; b = Map.Next(&p))
 	for (auto p : Map)
 		Paths.Add(p.key);
 
 	return true;
 }
 
 void IdeProjectPrivate::CollectAllFiles(LTreeNode *Base, LArray<ProjectNode*> &Files, bool SubProjects, int Platform)
 {
 	for (auto i:*Base)
 	{
 		IdeProject *Proj = dynamic_cast<IdeProject*>(i);
 		if (Proj)
 		{
 			if (Proj->GetParentProject() && !SubProjects)
 			{
 				continue;
 			}
 		}
 		else
 		{
 			ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 			if (p)
 			{
 				if (p->GetType() == NodeSrc ||
 					p->GetType() == NodeHeader)
 				{
 					if (p->GetPlatforms() & Platform)
 					{
 						Files.Add(p);
 					}
 				}
 			}
 		}
 
 		CollectAllFiles(i, Files, SubProjects, Platform);
 	}
 }
 
 LString IdeProject::GetTargetName(IdePlatform Platform)
 {
 	LString Status;
 	const char *t = d->Settings.GetStr(ProjTargetName, NULL, Platform);
 	if (ValidStr(t))
 	{
 		// Take target name from the settings
 		Status = t;
 	}
 	else
 	{
 		char *s = strrchr(d->FileName, DIR_CHAR);
 		if (s)
 		{
 			// Generate the target executable name
 			char Target[MAX_PATH_LEN];
 			strcpy_s(Target, sizeof(Target), s + 1);
 			s = strrchr(Target, '.');
 			if (s) *s = 0;
 			strlwr(Target);
 			s = Target;
 			for (char *i = Target; *i; i++)
 			{
 				if (*i != '.' && *i != ' ')
 				{
 					*s++ = *i;
 				}
 			}
 			*s = 0;
 			Status = Target;
 		}
 	}
 	
 	return Status;
 }
 
 LString IdeProject::GetTargetFile(IdePlatform Platform)
 {
 	LString Target = GetTargetName(PlatformCurrent);
 	if (!Target)
 	{
 		LAssert(!"No target?");
 		return LString();
 	}
 
 	const char *TargetType = d->Settings.GetStr(ProjTargetType);
 	if (!TargetType)
 	{
 		LAssert(!"Needs a target type.");
 		return LString();
 	}
 
 	if (!stricmp(TargetType, "Executable"))
 	{
 		return Target;
 	}
 	else if (!stricmp(TargetType, "DynamicLibrary"))
 	{
 		char t[MAX_PATH_LEN];
 		auto DefExt = PlatformDynamicLibraryExt(Platform);
 		strcpy_s(t, sizeof(t), Target);
 		char *ext = LGetExtension(t);
 		if (!ext)
 			sprintf(t + strlen(t), ".%s", DefExt);
 		else if (stricmp(ext, DefExt))
 			strcpy(ext, DefExt);
 		return t;
 	}
 	else if (!stricmp(TargetType, "StaticLibrary"))
 	{
 		LString Ret;
 		Ret.Printf("%s.%s", Target.Get(), PlatformSharedLibraryExt(Platform));
 		return Ret;
 	}
 	
 	return LString();
 }
 
 struct ProjDependency
 {
 	bool Scanned;
 	LAutoString File;
 	
 	ProjDependency(const char *f)
 	{
 		Scanned = false;
 		File.Reset(NewStr(f));
 	}
 };
 
 bool IdeProject::GetAllDependencies(LArray<char*> &Files, IdePlatform Platform)
 {
 	if (!GetTree()->Lock(_FL))
 		return false;
 		
 	LHashTbl<StrKey<char>, ProjDependency*> Deps;
 	LAutoString Base = GetBasePath();
 	
 	// Build list of all the source files...
 	LArray<LString> Src;
 	CollectAllSource(Src, Platform);
 	
 	// Get all include paths
 	LArray<LString> IncPaths;
 	BuildIncludePaths(IncPaths, false, false, Platform);
 	
 	// Add all source to dependencies
 	for (int i=0; i<Src.Length(); i++)
 	{
 		char *f = Src[i];
 		ProjDependency *dep = Deps.Find(f);
 		if (!dep)
 			Deps.Add(f, new ProjDependency(f));
 	}
 	
 	// Scan all dependencies for includes
 	LArray<ProjDependency*> Unscanned;
 	do
 	{
 		// Find all the unscanned dependencies
 		Unscanned.Length(0);
 		// for (ProjDependency *d = Deps.First(); d; d = Deps.Next())
 		for (auto d : Deps)
 		{
 			if (!d.value->Scanned)
 				Unscanned.Add(d.value);
 		}		
 
 		for (int i=0; i<Unscanned.Length(); i++)
 		{
 			// Then scan source for includes...
 			ProjDependency *d = Unscanned[i];
 			d->Scanned = true;
 			
 			char *Src = d->File;
 			char Full[MAX_PATH_LEN];
 			if (LIsRelativePath(d->File))
 			{
 				LMakePath(Full, sizeof(Full), Base, d->File);
 				Src = Full;
 			}
 
 			LArray<char*> SrcDeps;
 			if (GetDependencies(Src, IncPaths, SrcDeps, Platform))
 			{
 				for (int n=0; n<SrcDeps.Length(); n++)
 				{
 					// Add include to dependencies...
 					char *File = SrcDeps[n];
 
 					if (LIsRelativePath(File))
 					{
 						LMakePath(Full, sizeof(Full), Base, File);
 						File = Full;
 					}
 
 					if (!Deps.Find(File))
 					{						
 						Deps.Add(File, new ProjDependency(File));
 					}
 				}
 				SrcDeps.DeleteArrays();
 			}
 		}
 	}
 	while (Unscanned.Length() > 0);
 	
 	// for (ProjDependency *d = Deps.First(); d; d = Deps.Next())
 	for (auto d : Deps)
 	{
 		Files.Add(d.value->File.Release());
 	}
 	
 	Deps.DeleteObjects();
 	GetTree()->Unlock();
 	
 	return true;
 }
 
 bool IdeProject::GetDependencies(const char *InSourceFile, LArray<LString> &IncPaths, LArray<char*> &Files, IdePlatform Platform)
 {
 	LString SourceFile = InSourceFile;
 	if (!CheckExists(SourceFile))
 	{
 		LgiTrace("%s:%i - can't read '%s'\n", _FL, SourceFile.Get());
 		return false;
 	}
 
 	LAutoString c8(LReadTextFile(SourceFile));
 	if (!c8)
 		return false;
 
 	LArray<char*> Headers;
 	if (!BuildHeaderList(c8, Headers, IncPaths, false))
 		return false;
 	
 	for (int n=0; n<Headers.Length(); n++)
 	{
 		char *i = Headers[n];
 		LString p;
 		if (!RelativePath(p, i))
 			p = i;
 		ToUnixPath(p);
 		Files.Add(NewStr(p));
 	}
 	Headers.DeleteArrays();
 	
 	return true;
 }
 
 int MakefileThread::Instances = 0;
 
 bool IdeProject::CreateMakefile(IdePlatform Platform, bool BuildAfterwards)
 {
 	if (d->CreateMakefile)
 	{
 		if (d->CreateMakefile->IsExited())
 			d->CreateMakefile.Reset();
 		else
 		{
 			d->App->GetBuildLog()->Print("%s:%i - Makefile thread still running.\n", _FL);
 			return false;
 		}
 	}
 	
 	if (Platform == PlatformCurrent)
 		Platform = GetCurrentPlatform();
 
 	return d->CreateMakefile.Reset(new MakefileThread(d, Platform, BuildAfterwards));
 }
 
 void IdeProject::OnMakefileCreated()
 {
 	if (d->CreateMakefile)
 	{
 		d->CreateMakefile.Reset();
 		if (MakefileThread::Instances == 0)
 			GetApp()->PostEvent(M_LAST_MAKEFILE_CREATED);
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 IdeTree::IdeTree() : LTree(IDC_PROJECT_TREE, 0, 0, 100, 100)
 {
 	Hit = 0;
 	MultiSelect(true);
 }
 
 void IdeTree::OnCreate()
 {
 	SetWindow(this);
 }
 
 void IdeTree::OnDragExit()
 {
 	SelectDropTarget(0);
 }
 
 int IdeTree::WillAccept(LDragFormats &Formats, LPoint p, int KeyState)
 {
 	static bool First = true;
 	
 	Formats.SupportsFileDrops();
 	Formats.Supports(NODE_DROP_FORMAT);
 	First = false;
 		
 	if (Formats.Length() == 0)
 	{
 		LgiTrace("%s:%i - No valid drop formats.\n", _FL);
 		return DROPEFFECT_NONE;
 	}
 
 	Hit = ItemAtPoint(p.x, p.y);
 	if (!Hit)
 	{
 		SelectDropTarget(NULL);
 		return DROPEFFECT_NONE;
 	}
 
 	if (Formats.HasFormat(LGI_FileDropFormat))
 	{
 		SelectDropTarget(Hit);
 		return DROPEFFECT_LINK;
 	}
 
 	IdeCommon *Src = dynamic_cast<IdeCommon*>(Selection());
 	IdeCommon *Dst = dynamic_cast<IdeCommon*>(Hit);
 	if (Src && Dst)
 	{
 		// Check this folder is not a child of the src
 		for (IdeCommon *n=Dst; n; n=dynamic_cast<IdeCommon*>(n->GetParent()))
 		{
 			if (n == Src)
 				return DROPEFFECT_NONE;
 		}
 	}
 
 	// Valid target
 	SelectDropTarget(Hit);
 	return DROPEFFECT_MOVE;
 }
 
 int IdeTree::OnDrop(LArray<LDragData> &Data, LPoint p, int KeyState)
 {
 	int Ret = DROPEFFECT_NONE;
 	SelectDropTarget(NULL);
 	if (!(Hit = ItemAtPoint(p.x, p.y)))
 		return Ret;
 	
 	for (unsigned n=0; n<Data.Length(); n++)
 	{
 		LDragData &dd = Data[n];
 		LVariant *Data = &dd.Data[0];
 		if (dd.IsFormat(NODE_DROP_FORMAT))
 		{
 			if (Data->Type == GV_BINARY && Data->Value.Binary.Length == sizeof(ProjectNode*))
 			{
 				ProjectNode *Src = ((ProjectNode**)Data->Value.Binary.Data)[0];
 				if (Src)
 				{
 					ProjectNode *Folder = dynamic_cast<ProjectNode*>(Hit);
 					while (Folder && Folder->GetType() != NodeDir)
 						Folder = dynamic_cast<ProjectNode*>(Folder->GetParent());
 
 					IdeCommon *Dst = dynamic_cast<IdeCommon*>(Folder?Folder:Hit);
 					if (Dst)
 					{
 						// Check this folder is not a child of the src
 						for (IdeCommon *n=Dst; n; n=dynamic_cast<IdeCommon*>(n->GetParent()))
 						{
 							if (n == Src)
 								return DROPEFFECT_NONE;
 						}
 
 						// Detach
 						LTreeItem *i = dynamic_cast<LTreeItem*>(Src);
 						i->Detach();
 						if (Src->LXmlTag::Parent)
 						{
 							LAssert(Src->LXmlTag::Parent->Children.HasItem(Src));
 							Src->LXmlTag::Parent->Children.Delete(Src);
 						}
 						
 						// Attach
 						Src->LXmlTag::Parent = Dst;
 						Dst->Children.SetFixedLength(false);
 						Dst->Children.Add(Src);
 						Dst->Children.SetFixedLength(true);
 						Dst->Insert(Src);
 						
 						// Dirty
 						Src->GetProject()->SetDirty();
 					}
 				
 					Ret = DROPEFFECT_MOVE;
 				}
 			}
 		}
 		else if (dd.IsFileDrop())
 		{
 			ProjectNode *Folder = dynamic_cast<ProjectNode*>(Hit);
 			while (Folder && Folder->GetType() > NodeDir)
 				Folder = dynamic_cast<ProjectNode*>(Folder->GetParent());
 			
 			IdeCommon *Dst = dynamic_cast<IdeCommon*>(Folder?Folder:Hit);
 			if (Dst)
 			{
 				AddFilesProgress Prog(this);
 				LDropFiles Df(dd);
 				for (int i=0; i<Df.Length() && !Prog.Cancel; i++)
 				{
 					if (Dst->AddFiles(&Prog, Df[i]))
 						Ret = DROPEFFECT_LINK;
 				}
 			}
 		}
 		else LgiTrace("%s:%i - Unknown drop format: %s.\n", _FL, dd.Format.Get());
 	}
 
 	return Ret;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 AddFilesProgress::AddFilesProgress(LViewI *par)
 {
 	v = 0;
 	Cancel = false;
 	Msg = NULL;
 	SetParent(par);
 	Ts = LCurrentTime();
 	LRect r(0, 0, 140, 100);
 	SetPos(r);
 	MoveSameScreen(par);
 	Name("Importing files...");
 
 	LString::Array a = LString(DefaultExt).SplitDelimit(",");
 	for (unsigned i=0; i<a.Length(); i++)
 	{
 		Exts.Add(a[i], true);
 	}
 
 	LTableLayout *t = new LTableLayout(100);
 	AddView(t);
 		
 	auto *c = t->GetCell(0, 0);
 	c->Add(new LTextLabel(-1, 0, 0, -1, -1, "Loaded:"));
 		
 	c = t->GetCell(1, 0);
 	c->Add(Msg = new LTextLabel(-1, 0, 0, -1, -1, "..."));
 		
 	c = t->GetCell(0, 1, true, 2);
 	c->TextAlign(LCss::Len(LCss::AlignRight));
 	c->Add(new LButton(IDCANCEL, 0, 0, -1, -1, "Cancel"));
 }
 
 int64 AddFilesProgress::Value()
 {
 	return v;
 }
 
 void AddFilesProgress::Value(int64 val)
 {
 	v = val;
 
 	uint64 Now = LCurrentTime();
 	if (Visible())
 	{
 		if (Now - Ts > 200)
 		{
 			if (Msg)
 			{
 				Msg->Value(v);
 				Msg->SendNotify(LNotifyTableLayoutRefresh);
 			}
 			Ts = Now;
 		}
 	}
 	else if (Now - Ts > 1000)
 	{
 		DoModeless();
 		SetAlwaysOnTop(true);
 	}
 }
 
 int AddFilesProgress::OnNotify(LViewI *c, LNotification n)
 {
 	if (c->GetId() == IDCANCEL)
 		Cancel = true;
 	return 0;
 }
diff --git a/Ide/Code/MissingFiles.cpp b/Ide/Code/MissingFiles.cpp
--- a/Ide/Code/MissingFiles.cpp
+++ b/Ide/Code/MissingFiles.cpp
@@ -1,402 +1,402 @@
 #include "lgi/common/Lgi.h"
 #include "lgi/common/FileSelect.h"
 #include "LgiIde.h"
 #include "ProjectNode.h"
 #include "levenshtein.h"
 
 enum Msgs
 {
 	M_CHECK_FILE = M_USER + 100,
 	M_MISSING_FILE,
 	M_ADD_SEARCH_PATH,
 	M_SEARCH,
 	M_RESULTS,
 	M_RECURSE,
 };
 
 struct SearchResults
 {
 	ProjectNode *Node;
 	LString Path;
 	LString::Array Matches;
 	
 	SearchResults()
 	{
 		Node = 0;
 	}
 };
 
 class FileExistsThread : public LEventTargetThread
 {
 	int Hnd;
 
 public:
 	FileExistsThread(int hnd) : LEventTargetThread("FileExistsThread")
 	{
 		Hnd = hnd;
 	}
 
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		switch (Msg->Msg())
 		{
 			case M_CHECK_FILE:
 			{
 				LAutoPtr<SearchResults> Sr((SearchResults*)Msg->A());
 				bool e = LFileExists(Sr->Path);
 				// printf("Checking '%s' = %i\n", Sr->Path.Get(), e);
 				if (!e)
 					PostObject(Hnd, M_MISSING_FILE, Sr);
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 bool IsParentFolder(LString p, LString c)
 {
 	LString::Array d1 = p.Split(DIR_STR);
 	LString::Array d2 = c.Split(DIR_STR);
 
 	if (d1.Length() > d2.Length())
 		return false;
 
 	for (unsigned i=0; i<d1.Length(); i++)
 	{
 		bool Match = d1[i].Equals(d2[i]);
 		if (!Match)
 			return false;
 	}
 
 	return true;
 }
 
 class SearchThread : public LEventTargetThread
 {
 	int Hnd;
 	LArray<LString> Search;
 	LArray<char*> Files;
 
 public:
 	SearchThread(int hnd) : LEventTargetThread("SearchThread")
 	{
 		Hnd = hnd;
 	}
 
 	~SearchThread()
 	{
 		Files.DeleteArrays();
 	}
 
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		switch (Msg->Msg())
 		{
 			case M_ADD_SEARCH_PATH:
 			{
 				LAutoPtr<LString> p((LString*)Msg->A());
 				bool IsParent = false;
 				for (unsigned i=0; i<Search.Length(); i++)
 				{
 					if (p->Equals(Search[i]) ||
 						(IsParent = IsParentFolder(Search[i], *p)))
 					{
 						printf("'%s' is parent of '%s'\n", Search[i].Get(), p->Get());
 						break;
 					}
 				}
 				if (!IsParent)
 				{
 					printf("Adding '%s'\n", p->Get());
 					Search.New() = *p;
 				}
 				break;
 			}
 			case M_RECURSE:
 			{
 				for (unsigned i=0; i<Search.Length(); i++)
 				{
 					LArray<const char*> Ext;
 					Ext.Add("*.h");
 					Ext.Add("*.hpp");
 					Ext.Add("*.c");
 					Ext.Add("*.cpp");
 					Ext.Add("*.mm");
 
 					// printf("Recursing '%s'\n", Search[i].Get());
 					LRecursiveFileSearch(Search[i], &Ext, &Files);
 				}
 				break;
 			}
 			case M_SEARCH:
 			{
 				LAutoPtr<SearchResults> Sr((SearchResults*)Msg->A());
 				char *leaf1 = LGetLeaf(Sr->Path);
 				for (unsigned i=0; i<Files.Length(); i++)
 				{
 					char *leaf2 = LGetLeaf(Files[i]);
 					size_t Dist = levenshtein(leaf1, leaf2);
 					if (Dist < 4)
 					{
 						Sr->Matches.New() = Files[i];
 					}
 				}
 
 				printf("Posting '%s' with %i results.\n", Sr->Path.Get(), (int)Sr->Matches.Length());
 				PostObject(Hnd, M_RESULTS, Sr);
 				break;
 			}
 		}
 
 		return 0;
 	}
 };
 
 class MissingFiles : public LDialog
 {
 	IdeProject *Proj;
 	int SearchHnd;
 	int ExistsHnd;
 	LList *Lst;
 	LArray<SearchResults*> Files;
 
 public:
 	MissingFiles(IdeProject *proj)
 	{
 		Proj = proj;
 		SearchHnd = -1;
 		ExistsHnd = -1;
 		Lst = NULL;
 		
 		SetParent(Proj->GetApp());
 		if (LoadFromResource(IDD_MISSING_FILES))
 		{
 			GetViewById(IDC_RESULTS, Lst);
 			MoveSameScreen(Proj->GetApp());
 
 			SetCtrlEnabled(IDC_MISSING, false);
 			SetCtrlEnabled(IDC_RESULTS, false);
 			SetCtrlEnabled(IDC_BROWSE, false);
 
 			ExistsHnd = (new FileExistsThread(AddDispatch()))->GetHandle();
 			SearchHnd = (new SearchThread(AddDispatch()))->GetHandle();
 
 			LHashTbl<StrKey<char>,bool> Flds;
 
 			List<IdeProject> Child;
 			Proj->GetChildProjects(Child);
 			Child.Add(Proj);
 
 			LArray<ProjectNode*> Nodes;
 
 			for (auto p: Child)
 			{
 				if (p->GetAllNodes(Nodes))
 				{
 					for (auto Node: Nodes)
 					{
 						auto s = Node->GetFullPath();
 						if (s)
 						{
 							LString sOld = s.Get();
 							if (p->CheckExists(s) &&
 								Strcmp(sOld.Get(), s.Get()) != 0 &&
 								Stricmp(sOld.Get(), s.Get()) == 0)
 							{
 								// Case change?
 								Node->SetFileName(s);
 							}
 
 							SearchResults *Sr = new SearchResults;
 							Sr->Node = Node;
 							Sr->Path = s;
 							PostThreadEvent(ExistsHnd, M_CHECK_FILE, (LMessage::Param) Sr);
 							
 							LString Parent = s.Get();
 							LTrimDir(Parent);
 							Flds.Add(Parent, true);
 						}
 					}
 				}
 
 				auto s = p->GetBasePath();
 				if (s)
 				{
 					LTrimDir(s);
 					Flds.Add(s, true);
 				}
 			}
 
 			for (auto i: Flds)
 				PostThreadEvent(SearchHnd, M_ADD_SEARCH_PATH, (LMessage::Param) new LString(i.key));
 
 			PostThreadEvent(SearchHnd, M_RECURSE);
 		}
 	}
 
 	~MissingFiles()
 	{
 		if (SearchHnd >= 0)
 			LEventSinkMap::Dispatch.CancelThread(SearchHnd);
 		if (ExistsHnd >= 0)
 			LEventSinkMap::Dispatch.CancelThread(ExistsHnd);
 	}
 
 	void OnReplace(const char *NewPath)
 	{
 		SearchResults *Sr = Files.First();
 		if (!Sr) return;
 
 		printf("%s:%i - Setting node to '%s'\n", _FL, Sr->Path.Get());
 		Sr->Node->SetFileName(NewPath);
 
 		Files.DeleteAt(0, true);
 		delete Sr;
 
 		OnFile();
 	}
 
 	void OnDelete()
 	{
 		SearchResults *Sr = Files.First();
 		if (!Sr) return;
 
 		bool Has = Proj->HasNode(Sr->Node);
 		if (Has)
 			Sr->Node->Delete();
 
 		Files.DeleteAt(0, true);
 
 		if (Has)
 			delete Sr;
 
 		OnFile();
 	}
 
 	void OnFile()
 	{
 		bool Has = Files.Length() > 0;
 
 		SetCtrlEnabled(IDC_MISSING, Has);
 		SetCtrlEnabled(IDC_BROWSE, Has);
 		SetCtrlEnabled(IDC_RESULTS, Has);
 		Lst->Empty();
 
 		if (Has)
 		{
 			SetCtrlName(IDC_MISSING, Files[0]->Path);
 
 			for (unsigned i=0; i<Files[0]->Matches.Length(); i++)
 			{
 				LListItem *li = new LListItem;
 				li->SetText(Files[0]->Matches[i]);
 				Lst->Insert(li);
 			}
 
 			Lst->ResizeColumnsToContent();
 		}
 		else
 		{
 			SetCtrlName(IDC_MISSING, NULL);
 		}
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		switch (Ctrl->GetId())
 		{
 			case IDC_BROWSE:
 			{
 				LFileSelect *s = new LFileSelect;
 				LAutoString Dir = Proj->GetBasePath();
 				s->Parent(this);
 				s->InitialDir(Dir);
 				s->Open([&](auto s, auto ok)
 				{
 					if (ok)
 						OnReplace(s->Name());
 					delete s;
 				});
 				break;
 			}
 			case IDC_DELETE:
 			{
 				OnDelete();
 				break;
 			}
 			case IDC_RESULTS:
 			{
 				switch (n.Type)
 				{
 					case LNotifyItemDoubleClick:
 					{
 						LListItem *li = Lst->GetSelected();
 						if (li)
 						{
 							OnReplace(li->GetText(0));
 						}
 						break;
 					}
 					default:
 						break;
 				}
 				break;
 			}
 			case IDOK:
 			{
 				EndModal();
 				break;
 			}
 		}
 
 		return 0;
 	}
 
 	LMessage::Result OnEvent(LMessage *Msg)
 	{
 		switch (Msg->Msg())
 		{
 			case M_MISSING_FILE:
 			{
 				LAutoPtr<SearchResults> Sr((SearchResults*)Msg->A());
 				if (Sr)
 				{
 					printf("Missing file '%s'\n", Sr->Path.Get());
 					PostThreadEvent(SearchHnd, M_SEARCH, (LMessage::Param) Sr.Release());
 				}
 				break;
 			}
 			case M_RESULTS:
 			{
 				SearchResults *Sr = (SearchResults*)Msg->A();
 				bool HasNode = false;
 				for (unsigned i=0; i<Files.Length(); i++)
 				{
 					if (Files[i]->Node == Sr->Node)
 					{
 						LgiTrace("%s:%i - Node already in Files.\n", _FL);
 						HasNode = true;
 						break;
 					}
 				}
 				
 				if (!HasNode)
 				{
 					Files.Add((SearchResults*)Msg->A());
 					OnFile();
 				}
 				break;
 			}
 		}
 
 		return LDialog::OnEvent(Msg);
 	}
 };
 
 void FixMissingFilesDlg(IdeProject *Proj)
 {
-	MissingFiles Dlg(Proj);
-	Dlg.DoModal(NULL);
+	auto Dlg = new MissingFiles(Proj);
+	Dlg->DoModal(NULL);
 }
diff --git a/Ide/Code/ProjectNode.cpp b/Ide/Code/ProjectNode.cpp
--- a/Ide/Code/ProjectNode.cpp
+++ b/Ide/Code/ProjectNode.cpp
@@ -1,1577 +1,1583 @@
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Token.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Charset.h"
 
 #include "LgiIde.h"
 #include "IdeProject.h"
 #include "ProjectNode.h"
 #include "AddFtpFile.h"
 #include "WebFldDlg.h"
 
 #define DEBUG_SHOW_NODE_COUNTS		0
 
 const char *TypeNames[NodeMax] = {
 	"None",
 	"Folder",
 	"Source",
 	"Header",
 	"Dependancy",
 	"Resources",
 	"Graphic",
 	"Web",
 	"Text",
 	"MakeFile",
 };
 
 //////////////////////////////////////////////////////////////////////////////////
 class FileProps : public LDialog
 {
 public:
 	NodeType Type;
 	LString Charset;
 	int Platforms;
 
 	FileProps(LView *p, char *m, NodeType t, int plat, const char *charset)
 	{
 		Platforms = plat;
 		Type = t;
 		SetParent(p);
 		if (LoadFromResource(IDD_FILE_PROPS))
 		{
 			MoveToCenter();
 			SetCtrlName(IDC_MSG, m);
 			
 			LCombo *c;
 			if (GetViewById(IDC_TYPE, c))
 			{
 				for (int i=NodeNone; i<NodeMax; i++)
 				{
 					c->Insert(TypeNames[i]);
 				}
 				c->Value(Type);
 			}
 			else LgiTrace("%s:%i - Failed to get Type combo.\n", _FL);
 
 			if (GetViewById(IDC_CHARSET, c))
 			{
 				if (!charset)
 					charset = "utf-8";
 				for (LCharset *cs = LGetCsList(); cs->Charset; cs++)
 				{
 					c->Insert(cs->Charset);
 					if (!Stricmp(charset, cs->Charset))
 						c->Value(c->Length()-1);
 				}
 
 			}
 
 			for (int i=0; PlatformNames[i]; i++)
 			{
 				SetCtrlValue(PlatformCtrlId[i], ((1 << i) & Platforms) != 0);
 			}
 			
 			OnPosChange();
 			
 			// Make sure the dialog can display the whole table...
 			LTableLayout *t;
 			if (GetViewById(IDC_TABLE, t))
 			{
 				LRect u = t->GetUsedArea();
 				u.Inset(-LTableLayout::CellSpacing, -LTableLayout::CellSpacing);
 				LRect p = GetPos();
 				if (u.X() < p.X() ||
 					u.Y() < p.Y())
 				{
 					p.SetSize(MAX(u.X(), p.X()),
 								MAX(u.Y(), p.Y()));
 					SetPos(p);
 				}				
 			}
 		}
 	}
 	
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDOK:
 			{
 				int64 t = GetCtrlValue(IDC_TYPE);
 				if (t >= NodeSrc)
 				{
 					Type = (NodeType) t;
 				}
 
 				Platforms = 0;
 				for (int i=0; PlatformNames[i]; i++)
 				{
 					if (GetCtrlValue(PlatformCtrlId[i]))
 					{
 						Platforms |= 1 << i;
 					}
 				}
 
 				Charset = GetCtrlName(IDC_CHARSET);
 				if (!Stricmp(Charset.Get(), "utf-8"))
 					Charset.Empty();
 				
 				// fall thru
 			}
 			case IDCANCEL:
 			case IDC_COPY_PATH:
 			{
 				EndModal(c->GetId());
 				break;
 			}
 		}
 		
 		return 0;
 	}
 };
 
 ////////////////////////////////////////////////////////////////////
 ProjectNode::ProjectNode(IdeProject *p) : IdeCommon(p)
 {
 	Platforms = PLATFORM_ALL;
 	NodeId = 0;
 	Type = NodeNone;
 	ChildCount = -1;
 	IgnoreExpand = false;
 	Dep = 0;
 	Tag = NewStr("Node");
 }
 
 ProjectNode::~ProjectNode()
 {
 	NeedsPulse(false);
 	
 	if (sFile && Project)
 		Project->OnNode(sFile, this, false);
 
 	if (Dep)
 		DeleteObj(Dep);
 }
 
 void ProjectNode::NeedsPulse(bool yes)
 {
 	if (!Project)
 	{
 		LAssert(!"No project.");
 		return;
 	}
 	auto app = Project->GetApp();
 	if (!app)
 	{
 		LAssert(!"No app.");
 		return;
 	}
 	app->NeedsPulse.Delete(this);
 	if (yes)
 		app->NeedsPulse.Add(this);
 }
 
 void ProjectNode::OpenLocalCache(IdeDoc *&Doc)
 {
 	if (sLocalCache)
 	{
 		Doc = Project->GetApp()->OpenFile(sLocalCache, this);
 		if (Doc)
 		{
 			Doc->SetProject(Project);
 			
 			IdeProjectSettings *Settings = Project->GetSettings();
 			Doc->SetEditorParams(Settings->GetInt(ProjEditorIndentSize),
 								Settings->GetInt(ProjEditorTabSize),
 								Settings->GetInt(ProjEditorUseHardTabs),
 								Settings->GetInt(ProjEditorShowWhiteSpace));
 		}
 		else
 		{
 			LgiMsg(Tree, "Couldn't open file '%s'", AppName, MB_OK, sLocalCache.Get());
 		}
 	}
 }
 
 int64 ProjectNode::CountNodes()
 {
 	int64 n = 1;
 
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode *>(i);
 		if (!c) break;
 		n += c->CountNodes();
 	}
 	return n;
 }
 
 void ProjectNode::OnCmdComplete(FtpCmd *Cmd)
 {
 	if (!Cmd)
 		return;
 
 	if (Cmd->Status && Cmd->File)
 	{
 		if (Cmd->Cmd == FtpRead)
 		{
 			sLocalCache = Cmd->File;
 			IdeDoc *Doc;
 			OpenLocalCache(Doc);
 		}
 		else if (Cmd->Cmd == FtpWrite)
 		{
 			Cmd->View->OnSaveComplete(Cmd->Status);
 		}
 	}
 }
 
 int ProjectNode::GetPlatforms()
 {
 	return Platforms;
 }
 
 const char *ProjectNode::GetLocalCache()
 {
 	return sLocalCache;
 }
 
 bool ProjectNode::Load(LDocView *Edit, NodeView *Callback)
 {
 	bool Status = false;
 
 	if (IsWeb())
 	{
 		if (sLocalCache)
 			Status = Edit->Open(sLocalCache);
 		else
 			LAssert(!"No LocalCache");
 	}
 	else
 	{
 		auto Full = GetFullPath();
 		Status = Edit->Open(Full, Charset);
 	}
 	
 	return Status;
 }
 
 bool ProjectNode::Save(LDocView *Edit, NodeView *Callback)
 {
 	bool Status = false;
 
 	if (IsWeb())
 	{
 		if (sLocalCache)
 		{
 			if (Edit->Save(sLocalCache))
 			{
 				FtpThread *t = GetFtpThread();
 				if (t)
 				{
 					FtpCmd *c = new FtpCmd(FtpWrite, this);
 					if (c)
 					{
 						c->View = Callback;
 						c->Watch = Project->GetApp()->GetFtpLog();
 						c->Uri = NewStr(sFile);
 						c->File = NewStr(sLocalCache);
 						t->Post(c);
 					}
 				}
 			}
 			else LAssert(!"Editbox save failed.");
 		}
 		else LAssert(!"No LocalCache");
 	}
 	else
 	{
 		auto f = GetFullPath();
 		if (Project)
 			Project->CheckExists(f);
 		Status = Edit->Save(f, Charset);
 
 		if (Callback)
 			Callback->OnSaveComplete(Status);
 	}
 	
 	
 	return Status;
 }
 
 int ProjectNode::GetId()
 {
 	if (!NodeId && Project)
 		NodeId = Project->AllocateId();
 
 	return NodeId;
 }
 
 bool ProjectNode::IsWeb()
 {
 	char *Www = GetAttr(OPT_Www);
 	char *Ftp = GetAttr(OPT_Ftp);
 
 	if
 	(
 		Www ||
 		Ftp ||
 		(sFile && strnicmp(sFile, "ftp://", 6) == 0)
 	)
 		return true;
 
 	return false;
 }
 
 bool ProjectNode::HasNode(ProjectNode *Node)
 {
 	printf("Has %s %s %p\n", sFile.Get(), sName.Get(), Dep);
 
 	if (this == Node)
 		return true;
 	if (Dep && Dep->HasNode(Node))
 		return true;
 
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode *>(i);
 		if (!c) break;
 
 		if (c->HasNode(Node))
 			return true;
 	}
 
 	return false;
 }
 
 void ProjectNode::AddNodes(LArray<ProjectNode*> &Nodes)
 {
 	Nodes.Add(this);
 
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode *>(i);
 		if (!c) break;
 
 		c->AddNodes(Nodes);
 	}
 }
 
 bool ProjectNode::GetClean()
 {
 	if (Dep)
 		return Dep->GetClean();
 
 	return true;
 }
 
 void ProjectNode::SetClean()
 {
 	auto CleanProj = [&]()
 	{
 		for (auto i: *this)
 		{
 			ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 			if (p)
 				p->SetClean();
 		}
 	};
 
 	if (Dep)
 		Dep->SetClean([&](bool ok)
 		{
 			if (ok)
 				CleanProj();
 		});
 	else
 		CleanProj();
 
 }
 
 IdeProject *ProjectNode::GetDep()
 {
 	return Dep;
 }
 
 IdeProject *ProjectNode::GetProject()
 {
 	return Project;
 }
 
 bool ProjectNode::GetFormats(LDragFormats &Formats)
 {
 	Formats.Supports(NODE_DROP_FORMAT);
 	return true;
 }
 
 bool ProjectNode::GetData(LArray<LDragData> &Data)
 {
 	for (unsigned i=0; i<Data.Length(); i++)
 	{
 		LDragData &dd = Data[i];
 		if (dd.IsFormat(NODE_DROP_FORMAT))
 		{
 			void *t = this;
 			dd.Data.New().SetBinary(sizeof(this), (void*) &t);
 			return true;
 		}
 	}
 	
 	return false;
 }
 
 bool ProjectNode::OnBeginDrag(LMouse &m)
 {
 	return Drag(Tree, m.Event, DROPEFFECT_MOVE);
 }
 
 const char *ProjectNode::GetFileName()
 {
 	return sFile;
 }
 
 void ProjectNode::AutoDetectType()
 {
 	auto FullPath = GetFullPath();
 	if (FullPath)
 	{
 		auto MimeType = LGetFileMimeType(FullPath);
 		if (MimeType &&
 			strnicmp(MimeType, "image/", 6) == 0)
 		{
 			Type = NodeGraphic;
 		}
 	}
 		
 	if (!Type)
 	{
 		char *Ext = LGetExtension(sFile);
 
 		if (stristr(sFile, "makefile") ||
 			!stricmp(sFile, "CMakeLists.txt"))
 		{
 			Type = NodeMakeFile;
 		}
 		else if (Ext)
 		{
 			if (!stricmp(Ext, "h") ||
 				!stricmp(Ext, "hpp"))
 			{
 				Type = NodeHeader;
 			}
 			else if (stricmp(Ext, "lr8") == 0 ||
 					stricmp(Ext, "rc") == 0)
 			{
 				Type = NodeResources;
 			}
 			else if (stricmp(Ext, "cpp") == 0 ||
 					stricmp(Ext, "cc") == 0 ||
 					stricmp(Ext, "mm") == 0 ||
 					stricmp(Ext, "c") == 0)
 			{
 				Type = NodeSrc;
 			}
 			else if (stricmp(Ext, "php") == 0 ||
 					stricmp(Ext, "asp") == 0 ||
 					stricmp(Ext, "html") == 0 ||
 					stricmp(Ext, "htm") == 0 ||
 					stricmp(Ext, "css") == 0)
 			{
 				Type = NodeWeb;
 			}
 			else
 			{
 				// Fall back to text...
 				Type = NodeText;
 			}
 		}
 	}
 }
 
 void ProjectNode::SetFileName(const char *f)
 {
 	LString Rel;
 
 	if (sFile && Project)
 		Project->OnNode(sFile, this, false);
 
 	if (Project->RelativePath(Rel, f, true))
 		sFile = Rel;
 	else
 		sFile = f;
 	
 	if (sFile)
 	{
 		auto FullPath = GetFullPath();
 
 		if (Project)
 			Project->OnNode(FullPath, this, true);
 
 		AutoDetectType();
 	}
 	
 	Project->SetDirty();
 }
 
 char *ProjectNode::GetName()
 {
 	return sName;
 }
 
 void ProjectNode::SetName(const char *f)
 {
 	sName = f;
 	Type = NodeDir;
 }
 
 NodeType ProjectNode::GetType()
 {
 	return Type;
 }
 
 void ProjectNode::SetType(NodeType t)
 {
 	Type = t;
 }
 
 int ProjectNode::GetImage(int f)
 {
 	if (IsWeb())
 	{
 		return sFile ? ICON_SOURCE : ICON_WEB;
 	}
 
 	switch (Type)
 	{
 		default:
 			break;
 		case NodeDir:
 			return ICON_FOLDER;
 		case NodeSrc:
 			return ICON_SOURCE;
 		case NodeDependancy:
 			return ICON_DEPENDANCY;
 		case NodeGraphic:
 			return ICON_GRAPHIC;
 		case NodeResources:
 			return ICON_RESOURCE;
 	}
 
 	return ICON_HEADER;
 }
 
 const char *ProjectNode::GetText(int c)
 {
 	if (sFile)
 	{
 		char *d = 0;
 
 		if (IsWeb())
 		{
 			d = sFile ? strrchr(sFile, '/') : 0;
 		}
 		else
 		{
 			#ifdef WIN32
 			char Other = '/';
 			#else
 			char Other = '\\';
 			#endif
 			char *s;
 			while ((s = strchr(sFile, Other)))
 			{
 				*s = DIR_CHAR;
 			}
 			
 			d = strrchr(sFile, DIR_CHAR);
 		}
 		
 		if (d) return d + 1;
 		else return sFile;
 	}
 
 	#if DEBUG_SHOW_NODE_COUNTS
 	if (Type == NodeDir)
 	{
 		if (ChildCount < 0)
 			ChildCount = CountNodes();
 		Label.Printf("%s ("LGI_PrintfInt64")", Name, ChildCount);
 		return Label;
 	}
 	#endif
 
 	return sName ? sName.Get() : Untitled;
 }
 
 void ProjectNode::OnExpand(bool b)
 {
 	if (!IgnoreExpand)
 	{
 		Project->SetExpanded(GetId(), b);
 	}
 }
 
 bool ProjectNode::Serialize(bool Write)
 {
 	if (!Write && sFile)
 		Project->OnNode(sFile, this, false);
 
 	SerializeAttr("File", sFile);
 	SerializeAttr("Name", sName);
 	SerializeAttr("Charset", Charset);
 	SerializeAttr("Type", (int&)Type);
 	SerializeAttr("Platforms", (int&)Platforms);
 	
 	if (!Write && sFile)
 		Project->OnNode(sFile, this, true);
 
 	if (Type == NodeNone)
 	{
 		AutoDetectType();
 	}
 
 	if (Type == NodeDir)
 	{
 		if (Write && !NodeId)
 			GetId(); // Make sure we have an ID
 
 		SerializeAttr("Id", NodeId);
 
 		if (Write)
 			Project->SetExpanded(GetId(), Expanded());
 		else
 		{
 			IgnoreExpand = true;
 			Expanded(Project->GetExpanded(GetId()));
 			IgnoreExpand = false;
 		}
 	}
 	else if (Type == NodeDependancy)
 	{
 		SerializeAttr("LinkAgainst", LinkAgainst);
 		if (!Write)
 		{
 			auto Full = GetFullPath();				
 			Dep = Project->GetApp()->OpenProject(Full, Project, false, true);
 		}
 	}
 	else
 	{
 		#if 0
 		if (!Write)
 		{
 			// Check that file exists.
 			auto p = GetFullPath();
 			if (p)
 			{
 				if (LFileExists(p))
 				{
 					if (!LIsRelativePath(File))
 					{
 						// Try and fix up any non-relative paths that have crept in...
 						char Rel[MAX_PATH_LEN];
 						if (Project->RelativePath(Rel, File))
 						{
 							if (File)
 								Project->OnNode(File, this, false);
 
 							DeleteArray(File);
 							File = NewStr(Rel);
 							Project->SetDirty();
 
 							Project->OnNode(File, this, true);
 						}
 					}
 				}
 				else
 				{
 					// File doesn't exist... has it moved???
 					LAutoString Path = Project->GetBasePath();
 					if (Path)
 					{
 						// Find the file.
 						char *d = strrchr(p, DIR_CHAR);
 						LArray<char*> Files;
 						LArray<const char*> Ext;
 						Ext.Add(d ? d + 1 : p.Get());
 						if (LRecursiveFileSearch(Path, &Ext, &Files))
 						{
 							if (Files.Length())
 							{
 								LStringPipe Buf;
 								Buf.Print(	"The file:\n"
 											"\n"
 											"\t%s\n"
 											"\n"
 											"doesn't exist. Is this the right file:\n"
 											"\n"
 											"\t%s",
 											p.Get(),
 											Files[0]);
-								char *Msg = Buf.NewStr();
+								auto Msg = Buf.NewGStr();
 								if (Msg)
 								{
-									LAlert a(Project->GetApp(), "Missing File", Msg, "Yes", "No", "Browse...");
-									switch (a.DoModal())
+									auto a = new LAlert(Project->GetApp(), "Missing File", Msg, "Yes", "No", "Browse...");
+									a->DoModal([this](auto dlg, auto code)
 									{
-										case 1: // Yes
+										switch (code)
 										{
-											SetFileName(Files[0]);
-											break;
-										}
-										case 2: // No
-										{
-											break;
+											case 1: // Yes
+											{
+												SetFileName(Files[0]);
+												break;
+											}
+											case 2: // No
+											{
+												break;
+											}
+											case 3: // Browse
+											{
+												LFileSelect s;
+												s.Parent(Project->GetApp());
+												s.Type("Code", SourcePatterns);
+												if (s.Open())
+												{
+													SetFileName(s.Name());
+												}
+												break;
+											}
 										}
-										case 3: // Browse
-										{
-											LFileSelect s;
-											s.Parent(Project->GetApp());
-											s.Type("Code", SourcePatterns);
-											if (s.Open())
-											{
-												SetFileName(s.Name());
-											}
-											break;
-										}
-									}
-									
-									DeleteArray(Msg);
+										delete dlg;
+									});
 								}
 							}
 							else
 							{
 								LStringPipe Buf;
 								Buf.Print(	"The file:\n"
 											"\n"
 											"\t%s\n"
 											"\n"
 											"doesn't exist.",
 											p.Get());
-								char *Msg = Buf.NewStr();
+								auto Msg = Buf.NewGStr();
 								if (Msg)
 								{
-									LAlert a(Project->GetApp(), "Missing File", Msg, "Skip", "Delete", "Browse...");
-									switch (a.DoModal())
+									auto a = new LAlert(Project->GetApp(), "Missing File", Msg, "Skip", "Delete", "Browse...");
+									a->DoModal([this](auto dlg, auto code)
 									{
-										case 1: // Skip
+										switch (code)
 										{
-											break;
-										}
-										case 2: // Delete
-										{
-											Project->SetDirty();
-											delete this;
-											return false;
-											break;
+											case 1: // Skip
+											{
+												break;
+											}
+											case 2: // Delete
+											{
+												Project->SetDirty();
+												delete this;
+												return false;
+												break;
+											}
+											case 3: // Browse
+											{
+												auto s = new LFileSelect;
+												s->Parent(Project->GetApp());
+												s->Type("Code", SourcePatterns);
+												s->Open([this](auto s, auto ok)
+												{
+													if (ok)
+														SetFileName(s->Name());
+													delete s;
+												});
+												break;
+											}
 										}
-										case 3: // Browse
-										{
-											LFileSelect s;
-											s.Parent(Project->GetApp());
-											s.Type("Code", SourcePatterns);
-											if (s.Open())
-											{
-												SetFileName(s.Name());
-											}
-											break;
-										}
-									}
-									
-									DeleteArray(Msg);
+										delete dlg;
+									});
 								}
 							}
 						}
 					}
 					else
 					{
 						LgiTrace("%s:%i - Project::GetBasePath failed.\n", _FL);
 					}
 				}
 			}
 		}
 		#endif
 	}
 
 	return true;
 }
 
 LString ProjectNode::GetFullPath()
 {
 	LString FullPath;
 	
 	if (LIsRelativePath(sFile))
 	{
 		// Relative path
 		auto Path = Project->GetBasePath();
 		if (Path)
 		{
 			char p[MAX_PATH_LEN];
 			LMakePath(p, sizeof(p), Path, sFile);
 			FullPath = p;
 		}
 	}
 	else
 	{
 		// Absolute path
 		FullPath = sFile;
 	}
 	
 	return FullPath;
 }
 
 IdeDoc *ProjectNode::Open()
 {
 	static bool Processing = false;
 	IdeDoc *Doc = 0;
 
 	if (Processing)
 	{
 		LAssert(!"Not recursive");
 	}
 
 	if (!Processing)
 	{
 		Processing = true;
 
 		if (IsWeb())
 		{
 			if (sFile)
 			{
 				if (sLocalCache)
 				{
 					OpenLocalCache(Doc);
 				}
 				else
 				{
 					FtpThread *t = GetFtpThread();
 					if (t)
 					{
 						FtpCmd *c = new FtpCmd(FtpRead, this);
 						if (c)
 						{
 							c->Watch = Project->GetApp()->GetFtpLog();
 							c->Uri = NewStr(sFile);
 							t->Post(c);
 						}
 					}
 				}
 			}
 		}
 		else
 		{		
 			switch (Type)
 			{
 				case NodeDir:
 				{
 					Expanded(true);
 					break;
 				}
 				case NodeResources:
 				{
 					auto FullPath = GetFullPath();
 					if (FullPath)
 					{
 						char Exe[MAX_PATH_LEN];
 						LMakePath(Exe, sizeof(Exe), LGetExePath(), "..");
 						#if defined WIN32
 						LMakePath(Exe, sizeof(Exe), Exe, "Debug\\LgiRes.exe");
 						#elif defined LINUX
 						LMakePath(Exe, sizeof(Exe), Exe, "LgiRes/lgires");
 						#endif
 						
 						if (LFileExists(Exe))
 						{
 							LExecute(Exe, FullPath);
 						}
 					}
 					else
 					{
 						LgiMsg(Tree, "No Path", AppName);
 					}
 					break;
 				}
 				case NodeGraphic:
 				{
 					auto FullPath = GetFullPath();
 					if (FullPath)
 					{
 						LExecute(FullPath);
 					}
 					else
 					{
 						LgiMsg(Tree, "No Path", AppName);
 					}
 					break;
 				}
 				default:
 				{
 					auto FullPath = GetFullPath();
 					if (Project->CheckExists(FullPath))
 					{
 						Doc = Project->GetApp()->FindOpenFile(FullPath);
 						if (!Doc)
 						{
 							Doc = Project->GetApp()->NewDocWnd(0, this);
 							if (Doc)
 							{
 								if (Doc->OpenFile(FullPath))
 								{
 									IdeProjectSettings *Settings = Project->GetSettings();
 
 									Doc->SetProject(Project);
 									Doc->SetEditorParams(Settings->GetInt(ProjEditorIndentSize),
 														Settings->GetInt(ProjEditorTabSize),
 														Settings->GetInt(ProjEditorUseHardTabs),
 														Settings->GetInt(ProjEditorShowWhiteSpace));
 								}
 								else
 								{
 									LgiMsg(Tree, "Couldn't open file '%s'", AppName, MB_OK, FullPath.Get());
 								}
 							}
 						}
 						else
 						{
 							Doc->Raise();
 							Doc->Focus(true);
 						}
 					}
 					else
 					{
 						LgiMsg(Tree, "No Path", AppName);
 					}
 					break;
 				}
 			}
 		}
 
 		Processing = false;
 	}
 	
 	return Doc;
 }
 
 void ProjectNode::Delete()
 {
 	if (Select())
 	{
 		LTreeItem *s = GetNext();
 		if (s || (s = GetParent()))
 			s->Select(true);
 	}
 			
 	if (nView)
 	{
 		nView->OnDelete();
 		nView = NULL;
 	}
 
 	Project->SetDirty();
 	LXmlTag::RemoveTag();							
 	delete this;
 }
 
 bool ProjectNode::OnKey(LKey &k)
 {
 	if (k.Down())
 	{
 		if (k.vkey == LK_RETURN && k.IsChar)
 		{
 			Open();
 			return true;
 		}
 		else if (k.vkey == LK_DELETE)
 		{
 			Delete();
 			return true;
 		}
 	}
 	
 	return false;
 }
 
 void ProjectNode::OnPulse()
 {
 	auto StartTs = LCurrentTime();
 	int TimeSlice = 700; //ms
 
 	auto Start = strlen(ImportPath) + 1;
 	while (ImportFiles.Length())
 	{
 		LAutoString f(ImportFiles[0]); // Take ownership of the string
 		ImportFiles.DeleteAt(0);
 		if (ImportProg)
 			(*ImportProg)++;
 		
 		LToken p(f + Start, DIR_STR);
 		ProjectNode *Insert = this;
 		
 		// Find sub nodes, and drill into directory heirarchy,
 		// creating the nodes if needed.
 		for (int i=0; Insert && i<p.Length()-1; i++)
 		{
 			// Find existing node...
 			bool Found = false;
 
 			for (auto it:*Insert)
 			{
 				ProjectNode *c = dynamic_cast<ProjectNode *>(it);
 				if (!c) break;
 
 				if (c->GetType() == NodeDir &&
 					c->GetName() &&
 					stricmp(c->GetName(), p[i]) == 0)
 				{
 					Insert = c;
 					Found = true;
 					break;
 				}
 			}
 			
 			if (!Found)
 			{
 				// Create the node
 				IdeCommon *Com = Insert->GetSubFolder(Project, p[i], true);												
 				Insert = dynamic_cast<ProjectNode*>(Com);
 				LAssert(Insert);
 			}
 		}
 		
 		// Insert the file into the tree...
 		if (Insert)
 		{
 			ProjectNode *New = new ProjectNode(Project);
 			if (New)
 			{
 				New->SetFileName(f);
 				Insert->InsertTag(New);
 				Insert->SortChildren();
 				Project->SetDirty();
 			}
 		}
 		
 		if (LCurrentTime() - StartTs >= TimeSlice)
 			break; // Yeild to the message loop
 	}
 
 	if (ImportFiles.Length() == 0)
 		NeedsPulse(false);
 }
 
 void ProjectNode::OnMouseClick(LMouse &m)
 {
 	LTreeItem::OnMouseClick(m);
 	
 	if (m.IsContextMenu())
 	{
 		LSubMenu Sub;
 
 		Select(true);
 
 		if (Type == NodeDir)
 		{
 			if (IsWeb())
 			{
 				Sub.AppendItem("Insert FTP File", IDM_INSERT_FTP, true);
 			}
 			else
 			{
 				Sub.AppendItem("Insert File", IDM_INSERT, true);
 			}
 			
 			Sub.AppendItem("New Folder", IDM_NEW_FOLDER, true);
 			Sub.AppendItem("Import Folder", IDM_IMPORT_FOLDER, true);
 			Sub.AppendSeparator();
 
 			if (!IsWeb())
 			{
 				Sub.AppendItem("Rename", IDM_RENAME, true);
 			}
 		}
 		Sub.AppendItem("Remove", IDM_DELETE, true);
 		Sub.AppendItem("Sort", IDM_SORT_CHILDREN, true);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Browse Folder", IDM_BROWSE_FOLDER, ValidStr(sFile));
 		Sub.AppendItem("Open Terminal", IDM_OPEN_TERM, ValidStr(sFile));
 		Sub.AppendItem("Properties", IDM_PROPERTIES, true);
 
 		m.ToScreen();
 		LPoint c = _ScrollPos();
 		m.x -= c.x;
 		m.y -= c.y;
 		switch (Sub.Float(Tree, m.x, m.y))
 		{
 			case IDM_INSERT_FTP:
 			{
 				AddFtpFile *Add = new AddFtpFile(Tree, GetAttr(OPT_Ftp));
 				Add->DoModal([&](auto dlg, auto code)
 				{
 					if (code)
 					{
 						for (int i=0; i<Add->Uris.Length(); i++)
 						{
 							ProjectNode *New = new ProjectNode(Project);
 							if (New)
 							{
 								New->SetFileName(Add->Uris[i]);
 								InsertTag(New);
 								SortChildren();
 								Project->SetDirty();
 							}
 						}
 					}
 					delete Add;
 				});
 				break;
 			}
 			case IDM_INSERT:
 			{
 				LFileSelect *s = new LFileSelect;
 				s->Parent(Tree);
 				s->Type("Source", SourcePatterns);
 				s->Type("Makefiles", "*makefile");
 				s->Type("All Files", LGI_ALL_FILES);
 				s->MultiSelect(true);
 
 				LAutoString Dir = Project->GetBasePath();
 				if (Dir)
 				{
 					s->InitialDir(Dir);
 				}
 
 				s->Open([this](auto s, auto ok)
 				{
 					if (ok)
 					{
 						for (int i=0; i<s->Length(); i++)
 						{
 							if (!Project->InProject(false, (*s)[i], false))
 							{
 								ProjectNode *New = new ProjectNode(Project);
 								if (New)
 								{
 									New->SetFileName((*s)[i]);
 									InsertTag(New);
 									SortChildren();
 									Project->SetDirty();
 								}
 							}
 							else
 							{
 								LgiMsg(Tree, "'%s' is already in the project.\n", AppName, MB_OK, (*s)[i]);
 							}
 						}
 					}
 					delete s;
 				});
 				break;
 			}
 			case IDM_IMPORT_FOLDER:
 			{
 				LFileSelect *s = new LFileSelect;
 				s->Parent(Tree);
 
 				auto Dir = Project->GetBasePath();
 				if (Dir)
 					s->InitialDir(Dir);
 
 				s->OpenFolder([this](auto s, auto ok)
 				{
 					if (ok)
 					{
 						ImportPath = s->Name();
 				
 						LArray<const char*> Ext;
 						LToken e(SourcePatterns, ";");
 						for (auto i: e)
 						{
 							Ext.Add(i);
 						}
 				
 						if (LRecursiveFileSearch(ImportPath, &Ext, &ImportFiles))
 						{
 							ImportProg.Reset(new LProgressDlg(GetTree(), 300));
 							ImportProg->SetDescription("Importing...");
 							ImportProg->SetRange(ImportFiles.Length());
 							NeedsPulse(true);
 						}
 					}
 
 					delete s;
 				});
 				break;
 			}
 			case IDM_SORT_CHILDREN:
 			{
 				SortChildren();
 				Project->SetDirty();
 				break;
 			}
 			case IDM_NEW_FOLDER:
 			{
 				LInput *Name = new LInput(Tree, "", "Name:", AppName);
 				Name->DoModal([&](auto dlg, auto ok)
 				{
 					if (ok)
 						GetSubFolder(Project, Name->GetStr(), true);
 					delete Name;
 				});
 				break;
 			}
 			case IDM_RENAME:
 			{
 				LInput *Name = new LInput(Tree, GetName(), "Name:", AppName);
 				Name->DoModal([&](auto dlg, auto ok)
 				{
 					if (ok)
 					{
 						SetName(Name->GetStr());
 						Project->SetDirty();
 						Update();
 					}
 					delete Name;
 				});
 				break;
 			}
 			case IDM_DELETE:
 			{
 				Delete();
 				return;
 				break;
 			}
 			case IDM_BROWSE_FOLDER:
 			{
 				auto Path = GetFullPath();
 				if (Path)
 					LBrowseToFile(Path);
 				break;
 			}
 			case IDM_OPEN_TERM:
 			{
 				if (Type == NodeDir)
 				{
 				}
 				else
 				{
 					auto Path = GetFullPath();
 					if (Path)
 					{
 						LTrimDir(Path);
 						
 						#if defined LINUX
 						
 						char *Term = 0;
 						char *Format = 0;
 						switch (LGetWindowManager())
 						{
 							case WM_Kde:
 								Term = "konsole";
 								Format = "--workdir ";
 								break;
 							case WM_Gnome:
 								Term = "gnome-terminal";
 								Format = "--working-directory=";
 								break;
 						}
 						
 						if (Term)
 						{
 							char s[256];
 							strcpy_s(s, sizeof(s), Format);
 							
 							char *o = s + strlen(s), *i = Path;
 							*o++ = '\"';
 							while (*i)
 							{
 								if (*i == ' ')
 								{
 									*o++ = '\\';
 								}
 								*o++ = *i++;
 							}
 							*o++ = '\"';
 							*o++ = 0;
 							LExecute(Term, s);
 						}
 						
 						#elif defined WIN32
 						
 						LExecute("cmd", 0, Path);
 						
 						#endif
 					}
 				}
 				break;
 			}
 			case IDM_PROPERTIES:
 			{
 				OnProperties();
 				break;
 			}
 		}
 	}
 	else if (m.Left())
 	{
 		if (Type != NodeDir && m.Double())
 		{
 			if
 			(
 				(
 					IsWeb()
 					||
 					Type != NodeDir
 				)
 				&&
 				ValidStr(sFile)
 			)
 			{
 				Open();
 			}
 			else
 			{
 				LAssert(!"Unknown file type");
 			}
 		}
 	}
 }
 
 #if 0
 #define LOG_FIND_FILE(...) printf(__VA_ARGS__)
 #else
 #define LOG_FIND_FILE(...)
 #endif
 
 ProjectNode *ProjectNode::FindFile(const char *In, char **Full)
 {
 	LOG_FIND_FILE("%s:%i Node='%s' '%s'\n", _FL, sFile.Get(), sName.Get());
 	if (sFile)
 	{
 		bool Match = false;
 		const char *AnyDir = "\\/";
 
 		if (IsWeb())
 		{
 			Match = sFile ? stricmp(In, sFile) == 0 : false;
 		}
 		else if (strchr(In, DIR_CHAR))
 		{
 			// Match partial or full path
 			char Full[MAX_PATH_LEN] = "";
 			
 			if (LIsRelativePath(sFile))
 			{
 				auto Base = Project->GetBasePath();
 				if (Base)
 					LMakePath(Full, sizeof(Full), Base, sFile);
 				else
 					LgiTrace("%s,%i - Couldn't get full IDoc path.\n", _FL);
 			}
 			else
 			{
 				strcpy_s(Full, sizeof(Full), sFile);
 			}
 			
 			LOG_FIND_FILE("%s:%i Full='%s'\n", _FL, Full);
 			
 			LString MyPath(Full);
 			LString::Array MyArr = MyPath.SplitDelimit(AnyDir);
 			LString InPath(In);
 			LString::Array InArr = InPath.SplitDelimit(AnyDir);
 			auto Common = MIN(MyArr.Length(), InArr.Length());
 			Match = true;
 			for (int i = 0; i < Common; i++)
 			{
 				char *a = MyArr[MyArr.Length()-(i+1)];
 				char *b = InArr[InArr.Length()-(i+1)];
 				auto res = _stricmp(a, b);
 				LOG_FIND_FILE("%s:%i cmp '%s','%s'=%i\n", _FL, a, b, res);
 				if (res)
 				{
 					Match = false;
 					break;
 				}
 			}
 		}
 		else
 		{
 			// Match file name only
 			auto p = sFile.SplitDelimit(AnyDir);
 			Match = p.Last().Equals(In);
 			LOG_FIND_FILE("%s:%i cmp '%s','%s'=%i\n", _FL, p.Last().Get(), In, Match);
 		}
 		
 		if (Match)
 		{
 			if (Full)
 			{
 				if (sFile(0) == '.')
 				{
 					LAutoString Base = Project->GetBasePath();
 					if (Base)
 					{
 						char f[256];
 						LMakePath(f, sizeof(f), Base, sFile);
 						*Full = NewStr(f);
 					}
 				}
 				else
 				{
 					*Full = NewStr(sFile);
 				}
 			}
 			
 			return this;
 		}
 	}
 	
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c)
 		{
 			LAssert(!"Not a node?");
 			break;
 		}
 
 		ProjectNode *n = c->FindFile(In, Full);
 		if (n)
 		{
 			return n;
 		}
 	}
 	
 	return 0;
 }
 
 struct DepDlg : public LDialog
 {
 	ProjectNode *Node;
 	
 	DepDlg(ProjectNode *node) : Node(node)
 	{
 		auto proj = node->GetProject();
 		auto app = proj ? proj->GetApp() : NULL;
 		if (!app)
 			LAssert(!"Can't get app ptr.");
 		else
 		{
 			SetParent(app);
 			MoveSameScreen(app);
 		}		
 		
 		if (!LoadFromResource(IDD_DEP_NODE))
 			LAssert(!"Resource missing.");
 		else
 		{
 			auto Path = node->GetFullPath();
 			if (Path)
 				SetCtrlName(IDC_PATH, Path);
 			SetCtrlValue(IDC_LINK_AGAINST, node->GetLinkAgainst());
 		}
 	}
 	
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		switch (Ctrl->GetId())
 		{
 			case IDOK:
 			{
 				Node->SetLinkAgainst(GetCtrlValue(IDC_LINK_AGAINST));
 				break;
 			}
 		}
 		
 		return LDialog::OnNotify(Ctrl, n);
 	}
 };
 
 void ProjectNode::OnProperties()
 {
 	if (IsWeb())
 	{
 		bool IsFolder = sFile.IsEmpty();
 
 		WebFldDlg *Dlg = new WebFldDlg(Tree, sName, IsFolder ? GetAttr(OPT_Ftp) : sFile.Get(), GetAttr(OPT_Www));
 		Dlg->DoModal([&](auto dlg, auto ok)
 		{
 			if (ok)
 			{
 				if (IsFolder)
 				{
 					SetName(Dlg->Name);
 					SetAttr(OPT_Ftp, Dlg->Ftp);
 					SetAttr(OPT_Www, Dlg->Www);
 				}
 				else
 				{
 					sFile = Dlg->Ftp;
 				}
 
 				Project->SetDirty();
 				Update();
 			}
 			delete Dlg;
 		});
 	}
 	else if (Type == NodeDir)
 	{
 	}
 	else if (Type == NodeDependancy)
 	{
-		DepDlg dlg(this);
-		dlg.DoModal(NULL);
+		auto dlg = new DepDlg(this);
+		dlg->DoModal(NULL);
 	}
 	else
 	{
 		auto Path = GetFullPath();
 		if (Path)
 		{
 			char Size[32];
 			int64 FSize = LFileSize(Path);
 			LFormatSize(Size, sizeof(Size), FSize);
 			char Msg[512];
 			sprintf(Msg, "Source Code:\n\n\t%s\n\nSize: %s (%i bytes)", Path.Get(), Size, (int32)FSize);
 		
 			FileProps *Dlg = new FileProps(Tree, Msg, Type, Platforms, Charset);
 			Dlg->DoModal([this, Dlg, Path](auto dlg, auto code)
 			{
 				switch (code)
 				{
 					case IDOK:
 					{
 						if (Type != Dlg->Type)
 						{
 							Type = Dlg->Type;
 							Project->SetDirty();
 						}
 						if (Platforms != Dlg->Platforms)
 						{
 							Platforms = Dlg->Platforms;
 							Project->SetDirty();
 						}
 						if (Charset != Dlg->Charset)
 						{
 							Charset = Dlg->Charset;
 							Project->SetDirty();
 						}
 					
 						Update();
 						break;
 					}
 					case IDC_COPY_PATH:
 					{
 						LClipBoard Clip(Tree);
 						Clip.Text(Path);
 						break;
 					}
 				}
 				delete Dlg;
 			});
 		}
 	}
 }
diff --git a/src/common/Text/TextView3.cpp b/src/common/Text/TextView3.cpp
--- a/src/common/Text/TextView3.cpp
+++ b/src/common/Text/TextView3.cpp
@@ -1,5442 +1,5439 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
 #include <algorithm>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/Input.h"
 #include "lgi/common/ScrollBar.h"
 #ifdef WIN32
 #include <imm.h>
 #endif
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Mail.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/DropFiles.h"
 #include "ViewPriv.h"
 
 #undef max
 #ifdef _DEBUG
 #define FEATURE_HILIGHT_ALL_MATCHES	1
 #else
 #define FEATURE_HILIGHT_ALL_MATCHES	0
 #endif
 
 #define DefaultCharset              "utf-8"
 #define SubtractPtr(a, b)			((a) - (b))
 
 #define GDCF_UTF8					-1
 #define POUR_DEBUG					0
 #define PROFILE_POUR				0
 #define PROFILE_PAINT				0
 #define DRAW_LINE_BOXES				0
 #define WRAP_POUR_TIMEOUT			90 // ms
 #define PULSE_TIMEOUT				500 // ms
 #define CURSOR_BLINK				1000 // ms
 
 #define ALLOC_BLOCK					64
 #define IDC_VS						1000
 
 #ifdef WINDOWS
 #define	DOUBLE_BUFFER_PAINT			1
 #endif
 
 enum Cmds
 {
 	IDM_COPY_URL = 100,
 	IDM_AUTO_INDENT,
 	IDM_UTF8,
 	IDM_PASTE_NO_CONVERT,
 	IDM_FIXED,
 	IDM_SHOW_WHITE,
 	IDM_HARD_TABS,
 	IDM_INDENT_SIZE,
 	IDM_TAB_SIZE,
 	IDM_DUMP,
 	IDM_RTL,
 	IDM_COPY_ALL,
 	IDM_SELECT_ALL,
 	#ifndef IDM_OPEN
 		IDM_OPEN,
 	#endif
 	#ifndef IDM_NEW
 		IDM_NEW,
 	#endif
 	#ifndef IDM_COPY
 		IDM_COPY,
 	#endif
 	#ifndef IDM_CUT
 		IDM_CUT,
 	#endif
 	#ifndef IDM_PASTE
 		IDM_PASTE,
 	#endif
 	#ifndef IDM_UNDO
 		IDM_UNDO,
 	#endif
 	#ifndef IDM_REDO
 		IDM_REDO,
 	#endif
 };
 
 #define PAINT_BORDER				Back
 #if DRAW_LINE_BOXES
 	#define PAINT_AFTER_LINE			LColour(240, 240, 240)
 #else
 	#define PAINT_AFTER_LINE			Back
 #endif
 
 #define CODEPAGE_BASE				100
 #define CONVERT_CODEPAGE_BASE		200
 
 #if !defined(WIN32) && !defined(toupper)
 #define toupper(c)					(((c)>='a'&&(c)<='z') ? (c)-'a'+'A' : (c))
 #endif
 
 #define THREAD_CHECK() \
 	if (!InThread()) \
 	{ \
 		LgiTrace("%s:%i - %s called out of thread.\n", _FL, __FUNCTION__); \
 		return false; \
 	}
 
 static char SelectWordDelim[] = " \t\n.,()[]<>=?/\\{}\"\';:+=-|!@#$%^&*";
 #ifndef WINDOWS
 static LArray<LTextView3*> Ctrls;
 #endif
 
 //////////////////////////////////////////////////////////////////////
 class LDocFindReplaceParams3 :
 	public LDocFindReplaceParams,
 	public LMutex
 {
 public:
 	// Find/Replace History
 	LAutoWString LastFind;
 	LAutoWString LastReplace;
 	bool MatchCase;
 	bool MatchWord;
 	bool SelectionOnly;
 	bool SearchUpwards;
 	
 	LDocFindReplaceParams3() : LMutex("LDocFindReplaceParams3")
 	{
 		MatchCase = false;
 		MatchWord = false;
 		SelectionOnly = false;
 		SearchUpwards = false;
 	}
 };
 
 class LTextView3Private : public LCss, public LMutex
 {
 public:
 	LTextView3 *View;
 	LRect rPadding;
 	int PourX;
 	bool LayoutDirty;
 	ssize_t DirtyStart, DirtyLen;
 	LColour UrlColour;
 	bool CenterCursor;
 	ssize_t WordSelectMode;
 	LString Eol;
 	LString LastError;
 	
 	// If the scroll position is set before we get a scroll bar, store the index
 	// here and set it when the LNotifyScrollBarCreate arrives.
 	ssize_t VScrollCache;
 
 	// Find/Replace Params
 	bool OwnFindReplaceParams;
 	LDocFindReplaceParams3 *FindReplaceParams;
 
 	// Map buffer
 	ssize_t MapLen;
 	char16 *MapBuf;
 
 	// <RequiresLocking>
 		// Thread safe Name(char*) impl
 		LString SetName;
 	// </RequiresLocking>
 
 	#ifdef _DEBUG
 	LString PourLog;
 	#endif
 
 	LTextView3Private(LTextView3 *view) : LMutex("LTextView3Private")
 	{
 		View = view;
 		WordSelectMode = -1;
 		PourX = -1;
 		VScrollCache = -1;
 		DirtyStart = DirtyLen = 0;
 		UrlColour.Rgb(0, 0, 255);		
 		LColour::GetConfigColour("colour.L_URL", UrlColour);
 
 		CenterCursor = false;
 		
 		LayoutDirty = true;
 		rPadding.ZOff(0, 0);
 		MapBuf = 0;
 		MapLen = 0;
 		
 		OwnFindReplaceParams = true;
 		FindReplaceParams = new LDocFindReplaceParams3;
 	}
 	
 	~LTextView3Private()
 	{
 		if (OwnFindReplaceParams)
 		{
 			DeleteObj(FindReplaceParams);
 		}
 		
 		DeleteArray(MapBuf);
 	}
 	
 	void SetDirty(ssize_t Start, ssize_t Len = 0)
 	{
 		LayoutDirty = true;
 		DirtyStart = Start;
 		DirtyLen = Len;
 	}
 
 	void OnChange(PropType Prop)
 	{
 		if (Prop == LCss::PropPadding ||
 			Prop == LCss::PropPaddingLeft ||
 			Prop == LCss::PropPaddingRight ||
 			Prop == LCss::PropPaddingTop ||
 			Prop == LCss::PropPaddingBottom)
 		{
 			LCssTools t(this, View->GetFont());
 			rPadding.ZOff(0, 0);
 			rPadding = t.ApplyPadding(rPadding);
 		}
 	}
 };
 
 //////////////////////////////////////////////////////////////////////
 enum UndoType
 {
 	UndoDelete, UndoInsert, UndoChange
 };
 
 struct Change : public LRange
 {
 	UndoType Type;
 	LArray<char16> Txt;
 };
 
 struct LTextView3Undo : public LUndoEvent
 {
 	LTextView3 *View;
 	LArray<Change> Changes;
 
 	LTextView3Undo(LTextView3 *view)
 	{
 		View = view;
 	}
 
 	void AddChange(ssize_t At, ssize_t Len, UndoType Type)
 	{
 		Change &c = Changes.New();
 		c.Start = At;
 		c.Len = Len;
 		c.Txt.Add(View->Text + At, Len);
 		c.Type = Type;
 	}
 
 	void OnChange()
 	{
 		for (auto &c : Changes)
 		{
 			size_t Len = c.Len;
 			if (View->Text)
 			{
 				char16 *t = View->Text + c.Start;
 				for (size_t i=0; i<Len; i++)
 				{
 					char16 n = c.Txt[i];
 					c.Txt[i] = t[i];
 					t[i] = n;
 				}
 			}
 
 			View->d->SetDirty(c.Start, c.Len);
 		}
 	}
 
 	// LUndoEvent
     void ApplyChange()
 	{
 		View->UndoOn = false;
 
 		for (auto &c : Changes)
 		{
 			switch (c.Type)
 			{
 				case UndoInsert:
 				{
 					View->Insert(c.Start, c.Txt.AddressOf(), c.Len);
 					View->Cursor = c.Start + c.Len;
 					break;
 				}
 				case UndoDelete:
 				{
 					View->Delete(c.Start, c.Len);
 					View->Cursor = c.Start;
 					break;
 				}
 				case UndoChange:
 				{
 					OnChange();
 					break;
 				}
 			}
 		}
 
 		View->UndoOn = true;
 		View->Invalidate();
 	}
 
     void RemoveChange()
 	{
 		View->UndoOn = false;
 
 		for (auto &c : Changes)
 		{
 			switch (c.Type)
 			{
 				case UndoInsert:
 				{
 					View->Delete(c.Start, c.Len);
 					break;
 				}
 				case UndoDelete:
 				{
 					View->Insert(c.Start, c.Txt.AddressOf(), c.Len);
 					break;
 				}
 				case UndoChange:
 				{
 					OnChange();				
 					break;
 				}
 			}
 
 			View->Cursor = c.Start;
 		}
 
 		View->UndoOn = true;
 		View->Invalidate();
 	}
 };
 
 void LTextView3::LStyle::RefreshLayout(size_t Start, ssize_t Len)
 {
 	View->PourText(Start, Len);
 	View->PourStyle(Start, Len);
 }
 
 //////////////////////////////////////////////////////////////////////
 LTextView3::LTextView3(	int Id,
 						int x, int y, int cx, int cy,
 						LFontType *FontType)
 	: ResObject(Res_Custom)
 {
 	// init vars
 	LView::d->Css.Reset(d = new LTextView3Private(this));
 	
 	TabSize = TAB_SIZE;
 	IndentSize = TAB_SIZE;
 	
 	// setup window
 	SetId(Id);
 
 	// default options
 	#if WINNATIVE
 	CrLf = true;
 	SetDlgCode(DLGC_WANTALLKEYS);
 	#else
 	#endif
 	d->Padding(LCss::Len(LCss::LenPx, 2));
 
 	#ifdef _DEBUG
 	// debug times
 	_PourTime = 0;
 	_StyleTime = 0;
 	_PaintTime = 0;
 	#endif
 
 	// Data
 	Alloc = ALLOC_BLOCK;
 	Text = new char16[Alloc];
 	if (Text) *Text = 0;
 	Cursor = 0;
 	Size = 0;
 
 	// Display
 	if (FontType)
 		Font = FontType->Create();
 	else
 	{
 		LFontType Type;
 		if (Type.GetSystemFont("Fixed"))
 			Font = Type.Create();
 		else
 			printf("%s:%i - failed to create font.\n", _FL);
 	}
 
 	if (Font)
 	{
 		SetTabStop(true);
 
 		Underline = new LFont;
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			if (d->UrlColour.IsValid())
 				Underline->Fore(d->UrlColour);
 			Underline->Create();
 		}
 		Bold = new LFont;
 		if (Bold)
 		{
 			*Bold = *Font;
 			Bold->Bold(true);
 			Bold->Create();
 		}
 
 		OnFontChange();
 	}
 	else
 	{
 		LgiTrace("%s:%i - Failed to create font, FontType=%p\n", _FL, FontType);
 		Font = LSysFont;
 	}
 
 	CursorPos.ZOff(1, LineY-1);
 	CursorPos.Offset(d->rPadding.x1, d->rPadding.y1);
 
 	LRect r;
 	r.ZOff(cx-1, cy-1);
 	r.Offset(x, y);
 	SetPos(r);
 	LResources::StyleElement(this);
 }
 
 LTextView3::~LTextView3()
 {
 	#ifndef WINDOWS
 	Ctrls.Delete(this);
 	#endif
 	Line.DeleteObjects();
 	Style.Empty();
 
 	DeleteArray(TextCache);
 	DeleteArray(Text);
 
 	if (Font != LSysFont) DeleteObj(Font);
 	DeleteObj(FixedFont);
 	DeleteObj(Underline);
 	DeleteObj(Bold);
 	// 'd' is owned by the LView::Css auto ptr
 }
 
 char16 *LTextView3::MapText(char16 *Str, ssize_t Len, bool RtlTrailingSpace)
 {
 	if (ObscurePassword /*|| ShowWhiteSpace*/ || RtlTrailingSpace)
 	{
 		if (Len > d->MapLen)
 		{
 			DeleteArray(d->MapBuf);
 			d->MapBuf = new char16[Len + RtlTrailingSpace];
 			d->MapLen = Len;
 		}
 
 		if (d->MapBuf)
 		{
 			int n = 0;
 
 			if (RtlTrailingSpace)
 			{
 				d->MapBuf[n++] = ' ';
 				for (int i=0; i<Len; i++)
 				{
 					d->MapBuf[n++] = Str[i];
 				}
 			}
 			else if (ObscurePassword)
 			{
 				for (int i=0; i<Len; i++)
 				{
 					d->MapBuf[n++] = '*';
 				}
 			}
 			/*
 			else if (ShowWhiteSpace)
 			{
 				for (int i=0; i<Len; i++)
 				{
 					if (Str[i] == ' ')
 					{
 						d->MapBuf[n++] = 0xb7;
 					}
 					else if (Str[i] == '\t')
 					{
 						d->MapBuf[n++] = 0x2192;
 					}
 					else
 					{
 						d->MapBuf[n++] = Str[i];
 					}
 				}
 			}
 			*/			
 
 			return d->MapBuf;
 		}
 	}
 
 	return Str;
 }
 
 void LTextView3::SetFixedWidthFont(bool i)
 {
 	if (FixedWidthFont ^ i)
 	{
 		if (i)
 		{
 			LFontType Type;
 			if (Type.GetSystemFont("Fixed"))
 			{
 				LFont *f = FixedFont;
 				FixedFont = Font;
 				Font = f;
 
 				if (!Font)
 				{
 					Font = Type.Create();
 					if (Font)
 					{
 						Font->PointSize(FixedFont->PointSize());
 					}
 				}
 
 				LDocView::SetFixedWidthFont(i);
 			}
 		}
 		else if (FixedFont)
 		{
 			LFont *f = FixedFont;
 			FixedFont = Font;
 			Font = f;
 			LDocView::SetFixedWidthFont(i);
 		}
 
 		OnFontChange();
 		Invalidate();
 	}
 }
 
 void LTextView3::SetReadOnly(bool i)
 {
 	LDocView::SetReadOnly(i);
 
 	#if WINNATIVE
 	SetDlgCode(i ? DLGC_WANTARROWS : DLGC_WANTALLKEYS);
 	#endif
 }
 
 void LTextView3::SetCrLf(bool crlf)
 {
 	CrLf = crlf;
 }
 
 
 void LTextView3::SetTabSize(uint8_t i)
 {
 	TabSize = limit(i, 2, 32);
 	OnFontChange();
 	OnPosChange();
 	Invalidate();
 }
 
 void LTextView3::SetWrapType(LDocWrapType i)
 {
 	LDocView::SetWrapType(i);
 	CanScrollX = i != TEXTED_WRAP_REFLOW;
 
 	OnPosChange();
 	Invalidate();
 }
 
 LFont *LTextView3::GetFont()
 {
 	return Font;
 }
 
 LFont *LTextView3::GetBold()
 {
 	return Bold;
 }
 
 void LTextView3::SetFont(LFont *f, bool OwnIt)
 {
 	if (!f)
 		return;
 	
 	if (OwnIt)
 	{
 		if (Font != LSysFont)
 			DeleteObj(Font);
 		Font = f;
 	}
 	else if (!Font || Font == LSysFont)
 	{
 		Font = new LFont(*f);
 	}
 	else
 	{
 		*Font = *f;
 	}
 
 	if (Font)
 	{
 		if (!Underline)
 			Underline = new LFont;
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			Underline->Create();
 			if (d->UrlColour.IsValid())
 				Underline->Fore(d->UrlColour);
 		}
 
 		if (!Bold)
 			Bold = new LFont;
 		if (Bold)
 		{
 			*Bold = *Font;
 			Bold->Bold(true);
 			Bold->Create();
 		}
 	}
 
 	OnFontChange();
 }
 
 void LTextView3::OnFontChange()
 {
 	if (Font)
 	{
 		// get line height
 		// int OldLineY = LineY;
 		if (!Font->Handle())
 			Font->Create();
 		LineY = Font->GetHeight();
 		if (LineY < 1) LineY = 1;
 
 		// get tab size
 		char Spaces[32];
 		memset(Spaces, 'A', TabSize);
 		Spaces[TabSize] = 0;
 		LDisplayString ds(Font, Spaces);
 		Font->TabSize(ds.X());
 
 		// repour doc
 		d->SetDirty(0, Size);
 
 		// validate blue underline font
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			Underline->Create();
 		}
 
 		#if WINNATIVE // Set the IME font.
 		HIMC hIMC = ImmGetContext(Handle());
 		if (hIMC)
 		{
 			COMPOSITIONFORM Cf;						
 			Cf.dwStyle = CFS_POINT;
 			Cf.ptCurrentPos.x = CursorPos.x1;
 			Cf.ptCurrentPos.y = CursorPos.y1;
 
 			LOGFONT FontInfo;
 			GetObject(Font->Handle(), sizeof(FontInfo), &FontInfo);
 			ImmSetCompositionFont(hIMC, &FontInfo);
 
 			ImmReleaseContext(Handle(), hIMC);
 		}
 		#endif
 
 	}
 }
 
 void LTextView3::LogLines()
 {
 	int Idx = 0;
 	LgiTrace("DocSize: %i\n", (int)Size);
 	for (auto i : Line)
 	{
 		LgiTrace("  [%i]=%p, %i+%i, %s\n", Idx, i, (int)i->Start, (int)i->Len, i->r.GetStr());
 		Idx++;
 	}
 
 	#ifdef _DEBUG
 	if (d->PourLog)
 		LgiTrace("%s", d->PourLog.Get());
 	#endif
 }
 
 bool LTextView3::ValidateLines(bool CheckBox)
 {
 	size_t Pos = 0;
 	char16 *c = Text;
 	size_t Idx = 0;
 	LTextLine *Prev = NULL;
 
 	for (auto i : Line)
 	{
 		LTextLine *l = i;
 		if (l->Start != Pos)
 		{
 			LogLines();
 			LAssert(!"Incorrect start.");
 			return false;
 		}
 
 		char16 *e = c;
 		if (WrapType == TEXTED_WRAP_NONE)
 		{
 			while (*e && *e != '\n')
 				e++;
 		}
 		else
 		{
 			char16 *end = Text + l->Start + l->Len;
 			while (*e && *e != '\n' && e < end)
 				e++;
 		}
 			
 		ssize_t Len = e - c;
 		if (l->Len != Len)
 		{
 			LogLines();
 			LAssert(!"Incorrect length.");
 			return false;
 		}
 
 
 		if (CheckBox &&
 			Prev &&
 			Prev->r.y2 != l->r.y1 - 1)
 		{
 			LogLines();
 			LAssert(!"Lines not joined vertically");
 		}
 
 		if (*e)
 		{
 			if (*e == '\n')
 				e++;
 			else if (WrapType == TEXTED_WRAP_REFLOW)
 				e++;
 		}
 		Pos = e - Text;
 		c = e;
 		Idx++;
 		Prev = l;
 	}
 
 	if (WrapType == TEXTED_WRAP_NONE &&
 		Pos != Size)
 	{
 		LogLines();
 		LAssert(!"Last line != end of doc");
 		return false;
 	}
 
 	return true;
 }
 
 int LTextView3::AdjustStyles(ssize_t Start, ssize_t Diff, bool ExtendStyle)
 {
 	int Changes = 0;
 	for (auto &s : Style)
 	{
 		if (s.Start == Start)
 		{
 			if (Diff < 0 || ExtendStyle)
 				s.Len += Diff;
 			else
 				s.Start += Diff;
 			Changes++;
 		}
 		else if (s.Start > Start)
 		{
 			s.Start += Diff;
 			Changes++;
 		}
 	}
 
 	return Changes;
 }
 
 // break array, break out of loop when we hit these chars
 #define ExitLoop(c)	(	(c) == 0 ||								\
 						(c) == '\n' ||							\
 						(c) == ' ' ||							\
 						(c) == '\t'								\
 					)
 
 // extra breaking opportunities
 #define ExtraBreak(c) (	( (c) >= 0x3040 && (c) <= 0x30FF ) ||	\
 						( (c) >= 0x3300 && (c) <= 0x9FAF )		\
 					)
 
 /*
 Prerequisite:
 The Line list must have either the objects with the correct Start/Len or be missing the lines altogether...
 */
 void LTextView3::PourText(size_t Start, ssize_t Length /* == 0 means it's a delete */)
 {
 	#if PROFILE_POUR
 	char _txt[256];
 	sprintf_s(_txt, sizeof(_txt), "%p::PourText Lines=%i Sz=%i", this, (int)Line.Length(), (int)Size);
 	LProfile Prof(_txt);
 	#endif
 
 	#if !defined(HAIKU)
 	LAssert(InThread());
 	#endif
 
 	LRect Client = GetClient();
 	int Mx = Client.X() - d->rPadding.x1 - d->rPadding.x2;
 	int Cy = 0;
 	MaxX = 0;
 
 	ssize_t Idx = -1;
 	LTextLine *Cur = GetTextLine(Start, &Idx);
 	// LgiTrace("Pour %i:%i Cur=%p Idx=%i\n", (int)Start, (int)Length, (int)Cur, (int)Idx);
 	if (!Cur || !Cur->r.Valid())
 	{
 		// Find the last line that has a valid position...
 		for (auto i = Idx >= 0 ? Line.begin(Idx) : Line.rbegin(); *i; i--, Idx--)
 		{
 			Cur = *i;
 			if (Cur->r.Valid())
 			{
 				Cy = Cur->r.y1;
 				if (Idx < 0)
 					Idx = Line.IndexOf(Cur);
 				break;
 			}
 		}
 	}
 	if (Cur && !Cur->r.Valid())
 		Cur = NULL;
 	if (Cur)
 	{
 		Cy = Cur->r.y1;
 		Start = Cur->Start;
 		Length = Size - Start;
 		// LgiTrace("Reset start to %i:%i because Cur!=NULL\n", (int)Start, (int)Length);
 	}
 	else
 	{
 		Idx = 0;
 		Start = 0;
 		Length = Size;
 	}
 			
 	if (!Text || !Font || Mx <= 0)
 		return;
 
 	// Tracking vars
 	ssize_t e;
 	//int LastX = 0;
 	int WrapCol = GetWrapAtCol();
 
 	LDisplayString Sp(Font, " ", 1);
 	int WidthOfSpace = Sp.X();
 	if (WidthOfSpace < 1)
 	{
 		printf("%s:%i - WidthOfSpace test failed.\n", _FL);
 		return;
 	}
 
 	// Alright... lets pour!
 	uint64 StartTs = LCurrentTime();
 	if (WrapType == TEXTED_WRAP_NONE)
 	{
 		// Find the dimensions of each line that is missing a rect
 		#if PROFILE_POUR
 		Prof.Add("NoWrap: ExistingLines");
 		#endif
 		#ifdef _DEGBUG
 		LStringPipe Log(1024);
 		Log.Printf("Pour: " LPrintfSizeT ", " LPrintfSSizeT ", partial=%i\n", Start, Length, PartialPour);
 		#endif
 
 		ssize_t Pos = 0;
 		for (auto i = Line.begin(Idx); *i; i++, Idx++)
 		{
 			LTextLine *l = *i;
 
 			#ifdef _DEGBUG
 			Log.Printf("	[%i] exist: r.val=%i\n", Idx, l->r.Valid());
 			#endif
 
 			if (!l->r.Valid()) // If the layout is not valid...
 			{
 				LDisplayString ds(Font, Text + l->Start, l->Len);
 
 				l->r.x1 = d->rPadding.x1;
 				l->r.x2 = l->r.x1 + ds.X();
 
 				MaxX = MAX(MaxX, l->r.X());
 			}
 
 			// Adjust the y position anyway... it's free.
 			l->r.y1 = Cy;
 			l->r.y2 = l->r.y1 + LineY - 1;
 			Cy = l->r.y2 + 1;
 			Pos = l->Start + l->Len;
 			if (Text[Pos] == '\n')
 				Pos++;
 		}
 
 		// Now if we are missing lines as well, create them and lay them out
 		#if PROFILE_POUR
 		Prof.Add("NoWrap: NewLines");
 		#endif
 		while (Pos < Size)
 		{
 			LTextLine *l = new LTextLine;
 			l->Start = Pos;
 			char16 *c = Text + Pos;
 			char16 *e = c;
 			while (*e && *e != '\n')
 				e++;
 			l->Len = e - c;
 
 			#ifdef _DEGBUG
 			Log.Printf("	[%i] new: start=" LPrintfSSizeT ", len=" LPrintfSSizeT "\n", Idx, l->Start, l->Len);
 			#endif
 
 			l->r.x1 = d->rPadding.x1;
 			l->r.y1 = Cy;
 			l->r.y2 = l->r.y1 + LineY - 1;
 			if (l->Len)
 			{
 				LDisplayString ds(Font, Text + l->Start, l->Len);
 				l->r.x2 = l->r.x1 + ds.X();
 			}
 			else
 			{
 				l->r.x2 = l->r.x1;
 			}
 
 			Line.Insert(l);
 
 			if (*e == '\n')
 				e++;
 
 			MaxX = MAX(MaxX, l->r.X());
 			Cy = l->r.y2 + 1;
 			Pos = e - Text;
 			Idx++;
 		}
 
 		#ifdef _DEGBUG
 		d->PourLog = Log.NewGStr();
 		#endif
 		PartialPour = false;
 		PartialPourLines = 0;
 	}
 	else // Wrap text
 	{
 		int DisplayStart = ScrollYLine();
 		int DisplayLines = 	(Client.Y() + LineY - 1) / LineY;
 		int DisplayEnd = DisplayStart + DisplayLines;
 		
 		// Pouring is split into 2 parts... 
 		// 1) pouring to the end of the displayed text.
 		// 2) pouring from there to the end of the document.
 		//	potentially taking several goes to complete the full pour
 		// This allows the document to display and edit faster..
 		bool PourToDisplayEnd = Line.Length() < DisplayEnd;
 
 		#if 0
 		LgiTrace("Idx=%i, DisplayStart=%i, DisplayLines=%i, DisplayEnd=%i, PourToDisplayEnd=%i\n",
 			Idx, DisplayStart, DisplayLines, DisplayEnd, PourToDisplayEnd);
 		#endif
 
 		if ((ssize_t)Line.Length() > Idx)
 		{
 			for (auto i = Line.begin(Idx); *i; i++)
 				delete *i;
 			Line.Length(Idx);
 			Cur = NULL;
 		}
 
 		int Cx = 0;
 		ssize_t i;
 		for (i=Start; i<Size; i = e)
 		{
 			// seek till next char of interest
 			e = i;
 			int	Width = 0;
 
 			// Find break point
 			if (WrapCol)
 			{
 				// Wrap at column
 					
 				// Find the end of line
 				while (true)
 				{
 					if (e >= Size ||
 						Text[e] == '\n' ||
 						(e-i) >= WrapCol)
 					{
 						break;
 					}
 
 					e++;
 				}
 
 				// Seek back some characters if we are mid word
 				size_t OldE = e;
 				if (e < Size &&
 					Text[e] != '\n')
 				{
 					while (e > i)
 					{
 						if (ExitLoop(Text[e]) ||
 							ExtraBreak(Text[e]))
 						{
 							break;
 						}
 
 						e--;
 					}
 				}
 
 				if (e == i)
 				{
 					// No line break at all, so seek forward instead
 					for (e=OldE; e < Size && Text[e] != '\n'; e++)
 					{
 						if (ExitLoop(Text[e]) ||
 							ExtraBreak(Text[e]))
 							break;
 					}
 				}
 
 				// Calc the width
 				LDisplayString ds(Font, Text + i, e - i);
 				Width = ds.X();
 			}
 			else
 			{
 				// Wrap to edge of screen
 				ssize_t PrevExitChar = -1;
 				int PrevX = -1;
 
 				while (true)
 				{
 					if (e >= Size ||
 						ExitLoop(Text[e]) ||
 						ExtraBreak(Text[e]))
 					{
 						LDisplayString ds(Font, Text + i, e - i);
 						if (ds.X() + Cx > Mx)
 						{
 							if (PrevExitChar > 0)
 							{
 								e = PrevExitChar;
 								Width = PrevX;
 							}
 							else
 							{
 								Width = ds.X();
 							}
 							break;
 						}
 						else if (e >= Size ||
 								Text[e] == '\n')							
 						{
 							Width = ds.X();
 							break;
 						}
 							
 						PrevExitChar = e;
 						PrevX = ds.X();
 					}
 						
 					e++;
 				}
 			}
 
 			// Create layout line
 			LTextLine *l = new LTextLine;
 			if (l)
 			{
 				l->Start = i;
 				l->Len = e - i;
 				l->r.x1 = d->rPadding.x1;
 				l->r.x2 = l->r.x1 + Width - 1;
 
 				l->r.y1 = Cy;
 				l->r.y2 = l->r.y1 + LineY - 1;
 
 				Line.Insert(l);
 				if (PourToDisplayEnd)
 				{
 					if (Line.Length() > DisplayEnd)
 					{
 						// We have reached the end of the displayed area... so
 						// exit out temporarily to display the layout to the user
 						PartialPour = true;
 						PartialPourLines = std::max(PartialPourLines, Line.Length());
 						break;
 					}
 				}
 				else
 				{
 					// Otherwise check if we are taking too long...
 					if (Line.Length() % 20 == 0)
 					{
 						uint64 Now = LCurrentTime();
 						if (Now - StartTs > WRAP_POUR_TIMEOUT)
 						{
 							PartialPour = true;
 							PartialPourLines = std::max(PartialPourLines, Line.Length());
 							break;
 						}
 					}
 				}
 					
 				MaxX = MAX(MaxX, l->r.X());
 				Cy += LineY;
 					
 				if (e < Size)
 					e++;
 			}
 		}
 
 		if (i >= Size)
 		{
 			PartialPour = false;
 			PartialPourLines = 0;
 		}
 		SendNotify(LNotifyCursorChanged);
 	}
 
 	#ifdef _DEBUG
 	// ValidateLines(true);
 	#endif
 	#if PROFILE_POUR
 	Prof.Add("LastLine");
 	#endif
 
 	if (!PartialPour)
 	{
 		auto It = Line.rbegin();
 		LTextLine *Last = It != Line.end() ? *It : NULL;
 		if (!Last ||
 			Last->Start + Last->Len < Size)
 		{
 			LTextLine *l = new LTextLine;
 			if (l)
 			{
 				l->Start = Size;
 				l->Len = 0;
 				l->r.x1 = l->r.x2 = d->rPadding.x1;
 				l->r.y1 = Cy;
 				l->r.y2 = l->r.y1 + LineY - 1;
 
 				Line.Insert(l);
 			
 				MaxX = MAX(MaxX, l->r.X());
 				Cy += LineY;
 			}
 		}
 	}
 
 	bool ScrollYNeeded = Client.Y() < (std::max(PartialPourLines, Line.Length()) * LineY);
 	bool ScrollChange = ScrollYNeeded ^ (VScroll != NULL);
 	d->LayoutDirty = WrapType != TEXTED_WRAP_NONE && ScrollChange;
 	#if PROFILE_POUR
 	static LString _s;
 	_s.Printf("ScrollBars dirty=%i", d->LayoutDirty);
 	Prof.Add(_s);
 	#endif
 
 	if (ScrollChange)
 	{
 		#if 0
 		LgiTrace("%s:%i - %p::SetScrollBars(%i) cliy=%i content=%i partial=%i\n",
 			_FL, this, ScrollYNeeded, Client.Y(), (Line.Length() * LineY), PartialPour);
 		#endif
 		SetScrollBars(false, ScrollYNeeded);
 	}
 	UpdateScrollBars();
 	
 	#if 0 // def _DEBUG
 	if (GetWindow())
 	{
 		static char s[256];
 		sprintf_s(s, sizeof(s), "Pour: %.2f sec", (double)_PourTime / 1000);
 		GetWindow()->PostEvent(M_TEXTVIEW_DEBUG_TEXT, (LMessage::Param)s);
 	}
 	#endif
 
 	#if POUR_DEBUG
 	printf("Lines=%i\n", Line.Length());
 	int Index = 0;
 	for (LTextLine *l=Line.First(); l; l=Line.Next(), Index++)
 	{
 		printf("\t[%i] %i,%i (%s)\n", Index, l->Start, l->Len, l->r.Describe());
 	}
 	#endif
 }
 
 bool LTextView3::InsertStyle(LAutoPtr<LStyle> s)
 {
 	if (!s)
 		return false;
 
 	LAssert(s->Start >= 0);
 	LAssert(s->Len > 0);
 	ssize_t Last = 0;
 	// int n = 0;
 
 	// LgiTrace("StartStyle=%i,%i(%i) %s\n", (int)s->Start, (int)s->Len, (int)(s->Start+s->Len), s->Fore.GetStr());
 
 	if (Style.Length() > 0)
 	{
 		// Optimize for last in the list
 		auto Last = Style.rbegin();
 		if (s->Start >= (ssize_t)Last->End())
 		{
 			Style.Insert(*s);
 			return true;
 		}
 	}
 
 	for (auto i = Style.begin(); i != Style.end(); i++)
 	{
 		if (s->Overlap(*i))
 		{
 			if (s->Owner > i->Owner)
 			{
 				// Fail the insert
 				return false;
 			}
 			else
 			{
 				// Replace mode...
 				*i = *s;
 				return true;
 			}
 		}
 
 		if (s->Start >= Last && s->Start < i->Start)
 		{
 			Style.Insert(*s, i);
 			return true;
 		}
 	}
 
 	Style.Insert(*s);
 	return true;
 }
 
 LTextView3::LStyle *LTextView3::GetNextStyle(StyleIter &s, ssize_t Where)
 {
 	if (Where >= 0)
 		s = Style.begin();
 	else
 		s++;
 
 	while (s != Style.end())
 	{
 		// determine whether style is relevant..
 		// styles in the selected region are ignored
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 		if (SelStart >= 0 &&
 			s->Start >= Min &&
 			s->Start+s->Len < Max)
 		{
 			// style is completely inside selection: ignore
 			s++;
 		}
 		else if (Where >= 0 &&
 			s->Start+s->Len < Where)
 		{
 			s++;
 		}
 		else
 		{
 			return &(*s);
 		}
 	}
 
 	return NULL;
 }
 
 #if 0
 CURSOR_CHAR GetCursor()
 {
 	#ifdef WIN32
 	LArray<int> Ver;
 	int Os = LGetOs(&Ver);
 	if ((Os == LGI_OS_WIN32 || Os == LGI_OS_WIN64) &&
 		Ver[0] >= 5)
 	{
 		return MAKEINTRESOURCE(32649); // hand
 	}
 	else
 	{
 		return IDC_ARROW;
 	}
 	#endif
 	return 0;
 }
 #endif
 
 LTextView3::LStyle *LTextView3::HitStyle(ssize_t i)
 {
 	for (auto &s : Style)
 	{
 		if (i >= s.Start && i < (ssize_t)s.End())
 		{
 			return &s;
 		}
 	}
 
 	return NULL;
 }
 
 void LTextView3::PourStyle(size_t Start, ssize_t EditSize)
 {
 	#ifdef _DEBUG
 	int64 StartTime = LCurrentTime();
 	#endif
 
 	LAssert(InThread());
 
 	if (!Text || Size < 1)
 		return;
 
 	ssize_t Length = MAX(EditSize, 0);
 	if ((ssize_t)Start + Length >= Size)
 		Length = Size - Start; // For deletes, this sizes the edit length within bounds.
 
 	// Expand re-style are to word boundaries before and after the area of change
 	while (Start > 0 && UrlChar(Text[Start-1]))
 	{
 		// Move the start back
 		Start--;
 		Length++;
 	}
 	while ((ssize_t)Start + Length < Size && UrlChar(Text[Start+Length]))
 	{
 		// Move the end back
 		Length++;
 	}
 
 	// Delete all the styles that we own inside the changed area
 	for (StyleIter s = Style.begin(); s != Style.end();)
 	{
 		if (s->Owner == STYLE_NONE)
 		{
 			if (EditSize > 0)
 			{
 				if (s->Overlap(Start, EditSize < 0 ? -EditSize : EditSize))
 				{
 					Style.Delete(s);
 					continue;
 				}
 			}
 			else
 			{
 				if (s->Overlap(Start, -EditSize))
 				{
 					Style.Delete(s);
 					continue;
 				}
 			}
 		}
 
 		s++;
 	}
 
 	if (UrlDetect)
 	{		
 		LArray<LLinkInfo> Links;		
 		LAssert((ssize_t)Start + Length <= Size);		
 		if (LDetectLinks(Links, Text + Start, Length))
 		{
 			for (uint32_t i=0; i<Links.Length(); i++)
 			{
 				LLinkInfo &Inf = Links[i];
                 LAutoPtr<LTextView3::LStyle> Url(new LStyle(STYLE_URL));
 				if (Url)
 				{
 					Url->View = this;
 					Url->Start = Inf.Start + Start;
 					Url->Len = Inf.Len;
 					// Url->Email = Inf.Email;
 					Url->Font = Underline;
 					Url->Fore = d->UrlColour;
 
 					InsertStyle(Url);
 				}
 			}
 		}
 	}
 
 	#ifdef _DEBUG
 	_StyleTime = LCurrentTime() - StartTime;
 	#endif
 }
 
 bool LTextView3::Insert(size_t At, const char16 *Data, ssize_t Len)
 {
 	LProfile Prof("LTextView3::Insert");
 	Prof.HideResultsIfBelow(1000);
 
 	LAssert(InThread());
 	
 	if (!ReadOnly && Len > 0)
 	{
 		if (!Data)
 			return false;
 
 		// limit input to valid data
 		At = MIN(Size, (ssize_t)At);
 
 		// make sure we have enough memory
 		size_t NewAlloc = Size + Len + 1;
 		NewAlloc += ALLOC_BLOCK - (NewAlloc % ALLOC_BLOCK);
 		if (NewAlloc != Alloc)
 		{
 			char16 *NewText = new char16[NewAlloc];
 			if (NewText)
 			{
 				if (Text)
 				{
 					// copy any existing data across
 					memcpy(NewText, Text, (Size + 1) * sizeof(char16));
 				}
 
 				DeleteArray(Text);
 				Text = NewText;
 				Alloc = NewAlloc;
 			}
 			else
 			{
 				// memory allocation error
 				return false;
 			}
 		}
 		
 		Prof.Add("MemChk");
 
 		if (Text)
 		{
 			// Insert the data
 
 			// Move the section after the insert to make space...
 			memmove(Text+(At+Len), Text+At, (Size-At) * sizeof(char16));
 
 			Prof.Add("Cpy");
 
 			// Copy new data in...
 			memcpy(Text+At, Data, Len * sizeof(char16));
 			Size += Len;
 			Text[Size] = 0; // NULL terminate
 
 			Prof.Add("Undo");
 			
 			// Add the undo object...
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView3Undo> Obj(new LTextView3Undo(this));
 				LTextView3Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(At, Len, UndoInsert);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			// Clear layout info for the new text
 			ssize_t Idx = -1;
 			LTextLine *Cur = NULL;
 			
 			if (Line.Length() == 0)
 			{
 				// Empty doc... set up the first line
 				Line.Insert(Cur = new LTextLine);
 				Idx = 0;
 				Cur->Start = 0;
 			}
 			else
 			{
 				Cur = GetTextLine(At, &Idx);
 			}
 
 			if (Cur)
 			{
 				if (WrapType == TEXTED_WRAP_NONE)
 				{
 					// Clear layout for current line...
 					Cur->r.ZOff(-1, -1);
 
 					Prof.Add("NoWrap add lines");
 					
 					// Add any new lines that we need...
 					char16 *e = Text + At + Len;
 					char16 *c;
 					for (c = Text + At; c < e; c++)
 					{
 						if (*c == '\n')
 						{
 							// Set the size of the current line...
 							size_t Pos = c - Text;
 							Cur->Len = Pos - Cur->Start;
 
 							// Create a new line...
 							Cur = new LTextLine();
 							if (!Cur)
 								return false;
 							Cur->Start = Pos + 1;
 							Line.Insert(Cur, ++Idx);
 						}
 					}
 
 					Prof.Add("CalcLen");
 
 					// Make sure the last Line's length is set..
 					Cur->CalcLen(Text);
 
 					Prof.Add("UpdatePos");
 	
 					// Now update all the positions of the following lines...
 					for (auto i = Line.begin(++Idx); *i; i++)
 						(*i)->Start += Len;
 				}
 				else
 				{
 					// Clear all lines to the end of the doc...
 					for (auto i = Line.begin(Idx); *i; i++)
 						delete *i;
 					Line.Length(Idx);
 				}
 			}
 			else
 			{
 				// If wrap is on then this can happen when an Insert happens before the 
 				// OnPulse event has laid out the new text. Probably not a good thing in
 				// non-wrap mode			
 				if (WrapType == TEXTED_WRAP_NONE)
 				{
 					LTextLine *l = *Line.rbegin();
 					printf("%s:%i - Insert error: no cur, At=%i, Size=%i, Lines=%i, WrapType=%i\n",
 						_FL, (int)At, (int)Size, (int)Line.Length(), (int)WrapType);
 					if (l)
 						printf("Last=%i, %i\n", (int)l->Start, (int)l->Len);
 				}
 			}
 
 			#ifdef _DEBUG
 			// Prof.Add("Validate");
 			// ValidateLines();
 			#endif
 
 			if (AdjustStylePos)
 				AdjustStyles(At, Len);
 
 			Dirty = true;
 			if (PourEnabled)
 			{
 				Prof.Add("PourText");
 				PourText(At, Len);
 				Prof.Add("PourStyle");
 				auto Start = LCurrentTime();
 				PourStyle(At, Len);
 				auto End = LCurrentTime();
 				if (End - Start > 1000)
 				{
 					PourStyle(At, Len);
 				}
 			}
 			SendNotify(LNotifyDocChanged);
 
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool LTextView3::Delete(size_t At, ssize_t Len)
 {
 	bool Status = false;
 
 	LAssert(InThread());
 
 	if (!ReadOnly)
 	{
 		// limit input
 		At = MAX(At, 0);
 		At = MIN((ssize_t)At, Size);
 		Len = MIN(Size-(ssize_t)At, Len);
 
 		if (Len > 0)
 		{
 			int HasNewLine = 0;
 
 			for (int i=0; i<Len; i++)
 			{
 				if (Text[At + i] == '\n')
 					HasNewLine++;
 			}
 
 			// do delete
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView3Undo> Obj(new LTextView3Undo(this));
 				LTextView3Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(At, Len, UndoDelete);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			memmove(Text+At, Text+(At+Len), (Size-At-Len) * sizeof(char16));
 			Size -= Len;
 			Text[Size] = 0;
 
 			if (WrapType == TEXTED_WRAP_NONE)
 			{
 				ssize_t Idx = -1;
 				LTextLine *Cur = GetTextLine(At, &Idx);
 				if (Cur)
 				{
 					Cur->r.ZOff(-1, -1);
 
 					// Delete some lines...
 					for (int i=0; i<HasNewLine; i++)
 					{
 						LTextLine *l = Line[Idx + 1];
 						delete l;
 						Line.DeleteAt(Idx + 1);
 					}
 
 					// Correct the current line's length
 					Cur->CalcLen(Text);
 
 					// Shift all further lines down...
 					for (auto i = Line.begin(Idx + 1); *i; i++)
 						(*i)->Start -= Len;
 				}
 			}
 			else
 			{
 				ssize_t Index;
 				LTextLine *Cur = GetTextLine(At, &Index);
 				if (Cur)
 				{
 					for (auto i = Line.begin(Index); *i; i++)
 						delete *i;
 					Line.Length(Index);
 				}
 			}
 			
 
 			Dirty = true;
 			Status = true;
 
 			#ifdef _DEBUG
 			// ValidateLines();
 			#endif
 
 			if (AdjustStylePos)
 				AdjustStyles(At, -Len);
 
 			if (PourEnabled)
 			{
 				PourText(At, -Len);
 				PourStyle(At, -Len);
 			}
 			
 			if (Cursor >= (ssize_t)At && Cursor <= (ssize_t)At + Len)
 			{
 				SetCaret(At, false, HasNewLine != 0);
 			}
 
 			// Handle repainting in flowed mode, when the line starts change
 			if (WrapType == TEXTED_WRAP_REFLOW)
 			{
 				ssize_t Index;
 				LTextLine *Cur = GetTextLine(At, &Index);
 				if (Cur)
 				{
 					LRect r = Cur->r;
 					r.x2 = GetClient().x2;
 					r.y2 = GetClient().y2;
 					Invalidate(&r);
 				}
 			}
 
 			SendNotify(LNotifyDocChanged);
 			Status = true;
 		}
 	}
 
 	return Status;
 }
 
 void LTextView3::DeleteSelection(char16 **Cut)
 {
 	if (SelStart >= 0)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		if (Cut)
 		{
 			*Cut = NewStrW(Text + Min, Max - Min);
 		}
 
 		Delete(Min, Max - Min);
 		SetCaret(Min, false, true);
 	}
 }
 
 List<LTextView3::LTextLine>::I LTextView3::GetTextLineIt(ssize_t Offset, ssize_t *Index)
 {
 	int i = 0;
 
 	for (auto It = Line.begin(); It != Line.end(); It++)
 	{
 		auto l = *It;
 
 		if (Offset >= l->Start && Offset <= l->Start+l->Len)
 		{
 			if (Index)
 				*Index = i;
 
 			return It;
 		}
 
 		i++;
 	}
 
 	return Line.end();
 }
 
 int64 LTextView3::Value()
 {
 	auto n = Name();
 	#ifdef _MSC_VER
 	return (n) ? _atoi64(n) : 0;
 	#else
 	return (n) ? atoll(n) : 0;
 	#endif
 }
 
 void LTextView3::Value(int64 i)
 {
 	char Str[32];
 	sprintf_s(Str, sizeof(Str), LPrintfInt64, i);
 	Name(Str);
 }
 
 LString LTextView3::operator[](ssize_t LineIdx)
 {
 	if (LineIdx <= 0 || LineIdx > (ssize_t)GetLines())
 		return LString();
 
 	LTextLine *Ln = Line[LineIdx-1];
 	if (!Ln)
 		return LString();
 
 	LString s(Text + Ln->Start, Ln->Len);
 	return s; 
 }
 
 const char *LTextView3::Name()
 {
 	UndoQue.Empty();
 	DeleteArray(TextCache);
 	TextCache = WideToUtf8(Text);
 
 	return TextCache;
 }
 
 bool LTextView3::Name(const char *s)
 {
 	if (InThread())
 	{
 		UndoQue.Empty();
 		DeleteArray(TextCache);
 		DeleteArray(Text);
 		Line.DeleteObjects();
 		Style.Empty();
 
 		LAssert(LIsUtf8(s));
 		Text = Utf8ToWide(s);
 		if (!Text)
 		{
 			Text = new char16[1];
 			if (Text) *Text = 0;
 		}
 
 		Size = Text ? StrlenW(Text) : 0;
 		Alloc = Size + 1;
 		Cursor = MIN(Cursor, Size);
 		if (Text)
 		{
 			// Remove '\r's
 			char16 *o = Text;
 			for (char16 *i=Text; *i; i++)
 			{
 				if (*i != '\r')
 				{
 					*o++ = *i;
 				}
 				else Size--;
 			}
 			*o++ = 0;
 		}
 		
 		// update everything else
 		d->SetDirty(0, Size);
 		PourText(0, Size);
 		PourStyle(0, Size);
 		UpdateScrollBars();
 		Invalidate();
 	}
 	else if (d->Lock(_FL))
 	{
 		if (IsAttached())
 		{
 			d->SetName = s;
 			PostEvent(M_TEXT_UPDATE_NAME);
 		}
 		else LAssert(!"Can't post event to detached/virtual window.");
 		d->Unlock();
 	}
 
 	return true;
 }
 
 const char16 *LTextView3::NameW()
 {
 	return Text;
 }
 
 const char16 *LTextView3::TextAtLine(size_t Index)
 {
 	if (Index >= Line.Length())
 		return NULL;
 
 	auto ln = Line[Index];
 	return Text + ln->Start;	
 }
 
 bool LTextView3::NameW(const char16 *s)
 {
 	DeleteArray(Text);
 	Size = s ? StrlenW(s) : 0;
 	Alloc = Size + 1;
 	Text = new char16[Alloc];
 	Cursor = MIN(Cursor, Size);
 	if (Text)
 	{
 		memcpy(Text, s, Size * sizeof(char16));
 
 		// remove LF's
 		int In = 0, Out = 0;
 		CrLf = false;
 		for (; In<Size; In++)
 		{
 			if (Text[In] != '\r')
 			{
 				Text[Out++] = Text[In];
 			}
 			else
 			{
 				CrLf = true;
 			}
 		}
 		Size = Out;
 		Text[Size] = 0;
 
 	}
 
 	// update everything else
 	Line.DeleteObjects();
 	Style.Empty();
 	d->SetDirty(0, Size);
 	PourText(0, Size);
 	PourStyle(0, Size);
 	UpdateScrollBars();
 	Invalidate();
 
 	return true;
 }
 
 LRange LTextView3::GetSelectionRange()
 {
 	LRange r;
 	if (HasSelection())
 	{
 		r.Start = MIN(SelStart, SelEnd);
 		ssize_t End = MAX(SelStart, SelEnd);
 		r.Len = End - r.Start;
 	}
 	return r;
 }
 
 char *LTextView3::GetSelection()
 {
 	LRange s = GetSelectionRange();
 	if (s.Len > 0)
 	{
 		return (char*)LNewConvertCp("utf-8", Text + s.Start, LGI_WideCharset, s.Len*sizeof(Text[0]) );
 	}
 
 	return 0;
 }
 
 bool LTextView3::HasSelection()
 {
 	return (SelStart >= 0) && (SelStart != SelEnd);
 }
 
 void LTextView3::SelectAll()
 {
 	SelStart = 0;
 	SelEnd = Size;
 	Invalidate();
 }
 
 void LTextView3::UnSelectAll()
 {
 	bool Update = HasSelection();
 
 	SelStart = -1;
 	SelEnd = -1;
 
 	if (Update)
 	{
 		Invalidate();
 	}
 }
 
 size_t LTextView3::GetLines()
 {
 	return Line.Length();
 }
 
 void LTextView3::GetTextExtent(int &x, int &y)
 {
 	PourText(0, Size);
 
 	x = MaxX + d->rPadding.x1;
 	y = (int)(Line.Length() * LineY);
 }
 
 bool LTextView3::GetLineColumnAtIndex(LPoint &Pt, ssize_t Index)
 {
 	ssize_t FromIndex = 0;
 	LTextLine *From = GetTextLine(Index < 0 ? Cursor : Index, &FromIndex);
 	if (!From)
 		return false;
 
 	Pt.x = (int) (Cursor - From->Start);
 	Pt.y = (int) FromIndex;
 	return true;
 }
 
 ssize_t LTextView3::GetCaret(bool Cur)
 {
 	if (Cur)
 	{
 		return Cursor;
 	}
 
 	return 0;
 }
 
 ssize_t LTextView3::IndexAt(int x, int y)
 {
 	LTextLine *l = Line.ItemAt(y);
 	if (l)
 	{
 		return l->Start + MIN(x, l->Len);
 	}
 
 	return 0;
 }
 
 bool LTextView3::ScrollToOffset(size_t Off)
 {
 	bool ForceFullUpdate = false;
 	ssize_t ToIndex = 0;
 	LTextLine *To = GetTextLine(Off, &ToIndex);
 	if (To)
 	{
 		LRect Client = GetClient();
 		int DisplayLines = Client.Y() / LineY;
 
 		if (VScroll)
 		{
 			if (ToIndex < VScroll->Value())
 			{
 				// Above the visible region...
 				if (d->CenterCursor)
 				{
 					ssize_t i = ToIndex - (DisplayLines >> 1);
 					VScroll->Value(MAX(0, i));
 				}
 				else
 				{
 					VScroll->Value(ToIndex);
 				}
 				ForceFullUpdate = true;
 			}
 
 			if (ToIndex >= VScroll->Value() + DisplayLines)
 			{
 				int YOff = d->CenterCursor ? DisplayLines >> 1 : DisplayLines;
 			
 				ssize_t v = MIN(ToIndex - YOff + 1, (ssize_t)Line.Length() - DisplayLines);
 				if (v != VScroll->Value())
 				{
 					// Below the visible region
 					VScroll->Value(v);
 					ForceFullUpdate = true;
 				}
 			}
 		}
 		else
 		{
 			d->VScrollCache = ToIndex;
 		}
 	}
 
 	return ForceFullUpdate;
 }
 
 void LTextView3::SetCaret(size_t i, bool Select, bool ForceFullUpdate)
 {
     // int _Start = LCurrentTime();
 	Blink = true;
 
 	// Bound the new cursor position to the document
 	if ((ssize_t)i > Size) i = Size;
 
 	// Store the old selection and cursor
 	ssize_t s = SelStart, e = SelEnd, c = Cursor;
 	
 	// If there is going to be a selected area
 	if (Select && i != SelStart)
 	{
 		// Then set the start
 		if (SelStart < 0)
 		{
 			// We are starting a new selection
 			SelStart = Cursor;
 		}
 
 		// And end
 		SelEnd = i;
 	}
 	else
 	{
 		// Clear the selection
 		SelStart = SelEnd = -1;
 	}
 
 	ssize_t FromIndex = 0;
 	LTextLine *From = GetTextLine(Cursor, &FromIndex);
 
 	Cursor = i;
 
 	// check the cursor is on the screen
 	ForceFullUpdate |= ScrollToOffset(Cursor);
 
 	// check whether we need to update the screen
 	ssize_t ToIndex = 0;
 	LTextLine *To = GetTextLine(Cursor, &ToIndex);
 	if (ForceFullUpdate ||
 		!To ||
 		!From)
 	{
 		// need full update
 		Invalidate();
 	}
 	else if
 	(
 		(
 			SelStart != s
 			||
 			SelEnd != e
 		)
 	)
 	{
 		// Update just the selection bounds
 		LRect Client = GetClient();
 		size_t Start, End;
 		if (SelStart >= 0 && s >= 0)
 		{
 			// Selection has changed, union the before and after regions
 			Start = MIN(Cursor, c);
 			End = MAX(Cursor, c);
 		}
 		else if (SelStart >= 0)
 		{
 			// Selection created...
 			Start = MIN(SelStart, SelEnd);
 			End = MAX(SelStart, SelEnd);
 		}
 		else if (s >= 0)
 		{
 			// Selection removed...
 			Start = MIN(s, e);
 			End = MAX(s, e);
 		}
 		else return;
 
 		auto SLine = GetTextLine(Start);
 		auto ELine = GetTextLine(End);
 		LRect u;
 		if (SLine && ELine)
 		{
 			if (SLine->r.Valid())
 			{
 				u = DocToScreen(SLine->r);
 			}
 			else
 				u.Set(0, 0, Client.X()-1, 1); // Start of visible page 
 			
 			LRect b(0, Client.Y()-1, Client.X()-1, Client.Y()-1);
 			if (ELine->r.Valid())
 			{
 				b = DocToScreen(ELine->r);
 			}
 			else
 			{
 				b.Set(0, Client.Y()-1, Client.X()-1, Client.Y()-1);
 			}
 			u.Union(&b);
 			
 			u.x1 = 0;
 			u.x2 = X();
 		}
 		else
 		{
 			/*
 			printf("%s,%i - Couldn't get SLine and ELine: %i->%p, %i->%p\n",
 				_FL,
 				(int)Start, SLine,
 				(int)End, ELine);
 			*/
 			u = Client;
 		}
 
 		Invalidate(&u);			
 	}
 	else if (Cursor != c)
 	{
 		// just the cursor has moved
 
 		// update the line the cursor moved to
 		LRect r = To->r;
 		r.Offset(-ScrollX, d->rPadding.y1-DocOffset);
 		r.x2 = X();
 		Invalidate(&r);
 
 		if (To != From)
 		{
 			// update the line the cursor came from,
 			// if it's a different line from the "to"
 			r = From->r;
 			r.Offset(-ScrollX, d->rPadding.y1-DocOffset);
 			r.x2 = X();
 			Invalidate(&r);
 		}
 	}
 
 	if (c != Cursor)
 	{
 		// Send off notify
 		SendNotify(LNotifyCursorChanged);
 	}
 
 //int _Time = LCurrentTime() - _Start;
 //printf("Setcursor=%ims\n", _Time);
 }
 
 void LTextView3::SetBorder(int b)
 {
 }
 
 bool LTextView3::Cut()
 {
 	bool Status = false;
 	char16 *Txt16 = 0;
 	
 	DeleteSelection(&Txt16);
 	if (Txt16)
 	{
 		#ifdef WIN32
 		Txt16 = ConvertToCrLf(Txt16);
 		#endif
 		char *Txt8 = (char*)LNewConvertCp(LAnsiToLgiCp(), Txt16, LGI_WideCharset);
 
 		LClipBoard Clip(this);
 
 		Clip.Text(Txt8);
 		Status = Clip.TextW(Txt16, false);
 		
 		DeleteArray(Txt8);
 		DeleteArray(Txt16);
 	}
 
 	return Status;
 }
 
 bool LTextView3::Copy()
 {
 	bool Status = true;
 
 printf("txt copy\n");
 
 	if (SelStart >= 0)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		#ifdef WIN32
 		char16 *Txt16 = NewStrW(Text+Min, Max-Min);
 		Txt16 = ConvertToCrLf(Txt16);
 		char *Txt8 = (char*)LNewConvertCp(LAnsiToLgiCp(), Txt16, LGI_WideCharset);
 		#else
 		char *Txt8 = (char*)LNewConvertCp("utf-8", Text+Min, LGI_WideCharset, (Max-Min)*sizeof(*Text));
 		#endif
 
 		LClipBoard Clip(this);
 		
 		Clip.Text(Txt8);
 		#ifdef WIN32
 		Clip.TextW(Txt16, false);
 		DeleteArray(Txt16);
 		#endif
 		
 		DeleteArray(Txt8);
 	}
 	else LgiTrace("%s:%i - No selection.\n", _FL);
 
 	return Status;
 }
 
 bool LTextView3::Paste()
 {
 	LClipBoard Clip(this);
 
 	LAutoWString Mem;
 	char16 *t = Clip.TextW();
 	if (!t) // ala Win9x
 	{
 		char *s = Clip.Text();
 		if (s)
 		{
 			Mem.Reset(Utf8ToWide(s));
 			t = Mem;
 		}
 	}
 	
 	if (!t)
 		return false;
 
 	if (SelStart >= 0)
 	{
 		DeleteSelection();
 	}
 
 	// remove '\r's
 	char16 *s = t, *d = t;
 	for (; *s; s++)
 	{
 		if (*s != '\r')
 		{
 			*d++ = *s;
 		}
 	}
 	*d++ = 0;
 
 	// insert text
 	ssize_t Len = StrlenW(t);
 	Insert(Cursor, t, Len);
 	SetCaret(Cursor+Len, false, true); // Multiline
 	
 	return true;
 }
 
 void LTextView3::ClearDirty(std::function<void(bool)> OnStatus, bool Ask, const char *FileName)
 {
 	if (Dirty)
 	{
 		int Answer = (Ask) ? LgiMsg(this,
 									LLoadString(L_TEXTCTRL_ASK_SAVE, "Do you want to save your changes to this document?"),
 									LLoadString(L_TEXTCTRL_SAVE, "Save"),
 									MB_YESNOCANCEL) : IDYES;
 		if (Answer == IDYES)
 		{
 			auto DoSave = [&](bool ok)
 			{
 				Save(FileName);				
 				if (OnStatus)
 					OnStatus(ok);
 			};
 			
 			if (!FileName)
 			{
 				LFileSelect *Select = new LFileSelect;
 				Select->Parent(this);
 				Select->Save([&FileName, &DoSave](auto Select, auto ok)
 				{
 					if (ok)
 						FileName = Select->Name();					
 					DoSave(ok);
 					delete Select;
 				});
 			}
 			else DoSave(true);
 		}
 		else if (Answer == IDCANCEL)
 		{
 			if (OnStatus)
 				OnStatus(false);
 			return;
 		}
 	}
 
 	if (OnStatus)
 		OnStatus(true);
 }
 
 bool LTextView3::Open(const char *Name, const char *CharSet)
 {
 	bool Status = false;
 	LFile f;
 
 	if (f.Open(Name, O_READ|O_SHARE))
 	{
 		DeleteArray(Text);
 		int64 Bytes = f.GetSize();
 		if (Bytes < 0 || Bytes & 0xffff000000000000LL)
 		{
 			LgiTrace("%s:%i - Invalid file size: " LPrintfInt64 "\n", _FL, Bytes);
 			return false;
 		}
 			
 		SetCaret(0, false);
 		Line.DeleteObjects();
 		
 		char *c8 = new char[Bytes + 4];
 		if (c8)
 		{
 			if (f.Read(c8, (int)Bytes) == Bytes)
 			{
 				char *DataStart = c8;
 
 				c8[Bytes] = 0;
 				c8[Bytes+1] = 0;
 				c8[Bytes+2] = 0;
 				c8[Bytes+3] = 0;
 				
 				if ((uchar)c8[0] == 0xff && (uchar)c8[1] == 0xfe)
 				{
 					// utf-16
 					if (!CharSet)
 					{
 						CharSet = "utf-16";
 						DataStart += 2;
 					}
 				}
 				
 				// Convert to unicode first....
 				if (Bytes == 0)
 				{
 					Text = new char16[1];
 					if (Text) Text[0] = 0;
 				}
 				else
 				{
 					Text = (char16*)LNewConvertCp(LGI_WideCharset, DataStart, CharSet ? CharSet : DefaultCharset);
 				}
 				
 				if (Text)
 				{
 					// Remove LF's
 					char16 *In = Text, *Out = Text;
 					CrLf = false;
 					Size = 0;
 					while (*In)
 					{
 						if (*In >= ' ' ||
 							*In == '\t' ||
 							*In == '\n')
 						{
 							*Out++ = *In;
 							Size++;
 						}
 						else if (*In == '\r')
 						{
 							CrLf = true;
 						}
 						In++;
 					}
 					Size = (int) (Out - Text);
 					*Out = 0;
 
 					Alloc = Size + 1;
 					Dirty = false;
 					
 					if (Text && Text[0] == 0xfeff) // unicode byte order mark
 					{
 						memmove(Text, Text+1, Size * sizeof(*Text));
 						Size--;
 					}
 
 					PourText(0, Size);
 					PourStyle(0, Size);
 					UpdateScrollBars(true);
 					
 					Status = true;
 				}
 			}
 
 			DeleteArray(c8);
 		}
 		else
 		{
 			Alloc = Size = 0;
 		}
 
 		Invalidate();
 	}
 
 	return Status;
 }
 
 template<typename T>
 bool WriteToStream(LFile &out, T *in, size_t len, bool CrLf)
 {
 	if (!in)
 		return false;
 	
 	if (CrLf)
 	{
 		int BufLen = 1 << 20;
 		LAutoPtr<T,true> Buf(new T[BufLen]);
 		T *b = Buf;
 		T *e = Buf + BufLen;
 		T *c = in;
 		T *end = c + len;
 		
 		while (c < end)
 		{
 			if (b > e - 16)
 			{
 				auto Bytes = (b - Buf) * sizeof(T);
 				if (out.Write(Buf, Bytes) != Bytes)
 					return false;
 				
 				b = Buf;
 			}
 			
 			if (*c == '\n')
 			{
 				*b++ = '\r';
 				*b++ = '\n';
 			}
 			else
 			{
 				*b++ = *c;
 			}
 			c++;
 		}
 
 		auto Bytes = (b - Buf) * sizeof(T);
 		if (out.Write(Buf, Bytes) != Bytes)
 			return false;
 	}
 	else
 	{
 		auto Bytes = len * sizeof(T);
 		if (out.Write(in, Bytes) != Bytes)
 			return false;
 	}
 
 	return true;
 }
 
 bool LTextView3::Save(const char *Name, const char *CharSet)
 {
 	LFile f;
 	LString TmpName;
 	bool Status = false;
 	
 	d->LastError.Empty();
 
 	if (f.Open(Name, O_WRITE))
 	{
 		if (f.SetSize(0) != 0)
 		{
 			// Can't resize file, fall back to renaming it and 
 			// writing a new file...
 			f.Close();
 			TmpName = Name;
 			TmpName += ".tmp";
 			if (!FileDev->Move(Name, TmpName))
 			{
 				LgiTrace("%s:%i - Failed to move '%s'.\n", _FL, Name);
 				return false;
 			}
 
 			if (!f.Open(Name, O_WRITE))
 			{
 				LgiTrace("%s:%i - Failed to open '%s' for writing.\n", _FL, Name);
 				return false;
 			}
 		}
 
 		if (Text)
 		{
 			auto InSize = Size * sizeof(char16);
 			if (CharSet && !Stricmp(CharSet, "utf-16"))
 			{
 				if (sizeof(*Text) == 2)
 				{
 					// No conversion needed...
 					Status = WriteToStream(f, Text, Size, CrLf);
 				}
 				else
 				{
 					// 32->16 convert
 					LAutoPtr<uint16_t,true> c16((uint16_t*)LNewConvertCp(CharSet, Text, LGI_WideCharset, InSize));
 					if (c16)
 						Status = WriteToStream(f, c16.Get(), Strlen(c16.Get()), CrLf);
 				}
 			}
 			else if (CharSet && !Stricmp(CharSet, "utf-32"))
 			{
 				if (sizeof(*Text) == 4)
 				{
 					// No conversion needed...
 					Status = WriteToStream(f, Text, Size, CrLf);
 				}
 				else
 				{
 					// 16->32 convert
 					LAutoPtr<uint32_t,true> c32((uint32_t*)LNewConvertCp(CharSet, Text, LGI_WideCharset, InSize));
 					if (c32)
 						Status = WriteToStream(f, c32.Get(), Strlen(c32.Get()), CrLf);
 				}
 			}
 			else
 			{
 				LAutoString c8((char*)LNewConvertCp(CharSet ? CharSet : DefaultCharset, Text, LGI_WideCharset, InSize));
 				if (c8)
 					Status = WriteToStream(f, c8.Get(), strlen(c8), CrLf);
 			}
 
 			if (Status)
 				Dirty = false;
 		}
 	}
 	else
 	{
 		int Err = f.GetError();
 		LString sErr = LErrorCodeToString(Err);		
 		d->LastError.Printf("Failed to open '%s' for writing: %i - %s\n", Name, Err, sErr.Get());
 	}
 
 	if (TmpName)
 		FileDev->Delete(TmpName);
 
 	return Status;
 }
 
 const char *LTextView3::GetLastError()
 {
 	return d->LastError;
 }
 
 void LTextView3::UpdateScrollBars(bool Reset)
 {
 	if (!VScroll)
 		return;
 
 	LRect Before = GetClient();
 
 	int DisplayLines = Y() / LineY;
 	ssize_t Lines = std::max(PartialPourLines, Line.Length());
 	VScroll->SetRange(Lines);
 	if (VScroll)
 	{
 		VScroll->SetPage(DisplayLines);
 			
 		ssize_t Max = Lines - DisplayLines + 1;
 		bool Inval = false;
 		if (VScroll->Value() > Max)
 		{
 			VScroll->Value(Max);
 			Inval = true;
 		}
 
 		if (Reset)
 		{
 			VScroll->Value(0);
 			SelStart = SelEnd = -1;
 		}
 		else if (d->VScrollCache >= 0)
 		{
 			VScroll->Value(d->VScrollCache);
 			d->VScrollCache = -1;
 			SelStart = SelEnd = -1;
 		}
 
 		LRect After = GetClient();
 
 		if (Before != After && GetWrapType())
 		{
 			d->SetDirty(0, Size);
 			Inval = true;
 		}
 			
 		if (Inval)
 		{
 			Invalidate();
 		}
 	}
 }
 
 void LTextView3::DoCase(std::function<void(bool)> Callback, bool Upper)
 {
 	if (Text)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		if (Min < Max)
 		{
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView3Undo> Obj(new LTextView3Undo(this));
 				LTextView3Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(Min, Max - Min, UndoChange);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			for (ssize_t i=Min; i<Max; i++)
 			{
 				if (Upper)
 				{
 					if (Text[i] >= 'a' && Text[i] <= 'z')
 						Text[i] = Text[i] - 'a' + 'A';
 				}
 				else
 				{
 					if (Text[i] >= 'A' && Text[i] <= 'Z')
 						Text[i] = Text[i] - 'A' + 'a';
 				}
 			}
 
 			Dirty = true;
 			d->SetDirty(Min, 0);
 			Invalidate();
 
 			SendNotify(LNotifyDocChanged);
 		}
 	}
 	
 	if (Callback)
 		Callback(Text != NULL);
 }
 
 ssize_t LTextView3::GetLine()
 {
 	ssize_t Idx = 0;
 	GetTextLine(Cursor, &Idx);
 	return Idx + 1;
 }
 
 void LTextView3::SetLine(int64_t i, bool select)
 {
 	LTextLine *l = Line.ItemAt(i - 1);
 	if (l)
 	{
 		d->CenterCursor = true;
 		SetCaret(l->Start, select);
 		d->CenterCursor = false;
 	}
 }
 
 void LTextView3::DoGoto(std::function<void(bool)> Callback)
 {
 	LInput *Dlg = new LInput(this, "", LLoadString(L_TEXTCTRL_GOTO_LINE, "Goto line:"), "Text");	
 	Dlg->DoModal([this, Dlg, Callback](auto d, auto code)
 	{
 		auto ok = code == IDOK && Dlg->GetStr();
 		if (ok)
 			SetLine(Dlg->GetStr().Int());
 		if (Callback)
 			Callback(ok);
 		delete Dlg;
 	});
 }
 
 LDocFindReplaceParams *LTextView3::CreateFindReplaceParams()
 {
 	return new LDocFindReplaceParams3;
 }
 
 void LTextView3::SetFindReplaceParams(LDocFindReplaceParams *Params)
 {
 	if (Params)
 	{
 		if (d->OwnFindReplaceParams)
 		{
 			DeleteObj(d->FindReplaceParams);
 		}
 		
 		d->OwnFindReplaceParams = false;
 		d->FindReplaceParams = (LDocFindReplaceParams3*) Params;
 	}
 }
 
 void LTextView3::DoFindNext(std::function<void(bool)> OnStatus)
 {
 	bool Status = false;
 	if (InThread())
 	{
 		if (d->FindReplaceParams->Lock(_FL))
 		{
 			if (d->FindReplaceParams->LastFind)
 				Status = OnFind(d->FindReplaceParams->LastFind,
 								d->FindReplaceParams->MatchWord,
 								d->FindReplaceParams->MatchCase,
 								d->FindReplaceParams->SelectionOnly,
 								d->FindReplaceParams->SearchUpwards);
 							
 			d->FindReplaceParams->Unlock();
 		}
 	}
 	else if (IsAttached())
 	{
 		Status = PostEvent(M_TEXTVIEW_FIND);
 	}
 	if (OnStatus)
 		OnStatus(Status);
 }
 
 void LTextView3::DoFind(std::function<void(bool)> Callback)
 {
 	LString u;
 
 	if (HasSelection())
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		u = LString(Text + Min, Max - Min);
 	}
 	else
 	{
 		u = d->FindReplaceParams->LastFind.Get();
 	}
 
-	LFindDlg Dlg(this, [View=this, Params=d->FindReplaceParams, Callback](LFindReplaceCommon *Dlg, int Action)
-	{
-		if (Params &&
-			Params->Lock(_FL))
+	auto Dlg = new LFindDlg(this, [this, Params=d->FindReplaceParams, Callback](auto Dlg, auto Action)
 		{
-			Params->MatchWord = Dlg->MatchWord;
-			Params->MatchCase = Dlg->MatchCase;
-			Params->SelectionOnly = Dlg->SelectionOnly;
-			Params->SearchUpwards = Dlg->SearchUpwards;
-			Params->LastFind.Reset(Utf8ToWide(Dlg->Find));
+			if (Params &&
+				Params->Lock(_FL))
+			{
+				Params->MatchWord = Dlg->MatchWord;
+				Params->MatchCase = Dlg->MatchCase;
+				Params->SelectionOnly = Dlg->SelectionOnly;
+				Params->SearchUpwards = Dlg->SearchUpwards;
+				Params->LastFind.Reset(Utf8ToWide(Dlg->Find));
 		
-			Params->Unlock();
-		}
-
-		View->DoFindNext([View, Callback](bool ok)
-		{
-			View->Focus(true);
-			if (Callback)
-				Callback(ok);
-		});
-	}, u);
-
-	Dlg.DoModal(NULL);
+				Params->Unlock();
+			}
+
+			DoFindNext([this, Callback](bool ok)
+			{
+				Focus(true);
+				if (Callback)
+					Callback(ok);
+			});
+		},
+		u);
+
+	Dlg->DoModal(NULL);
 }
 
 void LTextView3::DoReplace(std::function<void(bool)> Callback)
 {
 	bool SingleLineSelection = false;
 	SingleLineSelection = HasSelection();
 	if (SingleLineSelection)
 	{
 		LRange Sel = GetSelectionRange();
 		for (ssize_t i = Sel.Start; i < Sel.End(); i++)
 		{
 			if (Text[i] == '\n')
 			{
 				SingleLineSelection = false;
 				break;
 			}
 		}
 	}
 
-	char *LastFind8 = SingleLineSelection ? GetSelection() : WideToUtf8(d->FindReplaceParams->LastFind);
-	char *LastReplace8 = WideToUtf8(d->FindReplaceParams->LastReplace);
+	LAutoString LastFind8(SingleLineSelection ? GetSelection() : WideToUtf8(d->FindReplaceParams->LastFind));
+	LAutoString LastReplace8(WideToUtf8(d->FindReplaceParams->LastReplace));
 	
-	LReplaceDlg Dlg(this,
-		[&](LFindReplaceCommon *Dlg, int Action)
+	auto Dlg = new LReplaceDlg(this, [this, LastFind8, LastReplace8](LFindReplaceCommon *Dlg, int Action)
 		{
 			LReplaceDlg *Replace = dynamic_cast<LReplaceDlg*>(Dlg);
 			LAssert(Replace != NULL);
 
-			DeleteArray(LastFind8);
-			DeleteArray(LastReplace8);
-
 			if (Action == IDCANCEL)
 				return;
 
 			if (d->FindReplaceParams->Lock(_FL))
 			{
 				d->FindReplaceParams->LastFind.Reset(Utf8ToWide(Replace->Find));
 				d->FindReplaceParams->LastReplace.Reset(Utf8ToWide(Replace->Replace));
 				d->FindReplaceParams->MatchWord = Replace->MatchWord;
 				d->FindReplaceParams->MatchCase = Replace->MatchCase;
 				d->FindReplaceParams->SelectionOnly = Replace->SelectionOnly;
 					
 				switch (Action)
 				{
 					case IDC_FR_FIND:
 					{
 						OnFind(	d->FindReplaceParams->LastFind,
 								d->FindReplaceParams->MatchWord,
 								d->FindReplaceParams->MatchCase,
 								d->FindReplaceParams->SelectionOnly,
 								d->FindReplaceParams->SearchUpwards);
 						break;
 					}
 					case IDOK:
 					case IDC_FR_REPLACE:
 					{
 						OnReplace(	d->FindReplaceParams->LastFind,
 									d->FindReplaceParams->LastReplace,
 									Action == IDOK,
 									d->FindReplaceParams->MatchWord,
 									d->FindReplaceParams->MatchCase,
 									d->FindReplaceParams->SelectionOnly,
 									d->FindReplaceParams->SearchUpwards);
 						break;
 					}
 				}
 
 				d->FindReplaceParams->Unlock();
 			}
 		},
 		LastFind8,
 		LastReplace8);
 
-	Dlg.MatchWord = d->FindReplaceParams->MatchWord;
-	Dlg.MatchCase = d->FindReplaceParams->MatchCase;
-	Dlg.SelectionOnly = HasSelection();
-
-	Dlg.DoModal(NULL);
+	Dlg->MatchWord = d->FindReplaceParams->MatchWord;
+	Dlg->MatchCase = d->FindReplaceParams->MatchCase;
+	Dlg->SelectionOnly = HasSelection();
+
+	Dlg->DoModal(NULL);
 }
 
 void LTextView3::SelectWord(size_t From)
 {
 	for (SelStart = From; SelStart > 0; SelStart--)
 	{
 		if (strchr(SelectWordDelim, Text[SelStart]))
 		{
 			SelStart++;
 			break;
 		}
 	}
 
 	for (SelEnd = From; SelEnd < Size; SelEnd++)
 	{
 		if (strchr(SelectWordDelim, Text[SelEnd]))
 		{
 			break;
 		}
 	}
 
 	Invalidate();
 }
 
 typedef int (*StringCompareFn)(const char16 *a, const char16 *b, ssize_t n);
 
 ptrdiff_t LTextView3::MatchText(const char16 *Find, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	if (!ValidStrW(Find))
 		return -1;
 
 	ssize_t FindLen = StrlenW(Find);
 		
 	// Setup range to search
 	ssize_t Begin, End;
 	if (SelectionOnly && HasSelection())
 	{
 		Begin = MIN(SelStart, SelEnd);
 		End = MAX(SelStart, SelEnd);
 	}
 	else
 	{
 		Begin = 0;
 		End = Size;
 	}
 
 	// Look through text...
 	ssize_t i;
 	bool Wrap = false;
 	if (Cursor > End - FindLen)
 	{
 		Wrap = true;
 		if (SearchUpwards)
 			i = End - FindLen;
 		else
 			i = Begin;
 	}
 	else
 	{
 		i = Cursor;
 	}
 		
 	if (i < Begin) i = Begin;
 	if (i > End) i = End;
 	
 	StringCompareFn CmpFn = MatchCase ? StrncmpW : StrnicmpW;
 	char16 FindCh = MatchCase ? Find[0] : toupper(Find[0]);
 
 	for (; SearchUpwards ? i >= Begin : i <= End; i += SearchUpwards ? -1 : 1)
 	{
 		if
 		(
 			(MatchCase ? Text[i] : toupper(Text[i]))
 			==
 			FindCh
 		)
 		{
 			char16 *Possible = Text + i;
 
 			if (CmpFn(Possible, Find, FindLen) == 0)
 			{
 				if (MatchWord)
 				{
 					// Check boundaries
 							
 					if (Possible > Text) // Check off the start
 					{
 						if (!IsWordBoundry(Possible[-1]))
 							continue;
 					}
 					if (i + FindLen < Size) // Check off the end
 					{
 						if (!IsWordBoundry(Possible[FindLen]))
 							continue;
 					}
 				}
 						
 				/* What was this even supposed to do?
 				LRange r(Possible - Text, FindLen);
 				if (!r.Overlap(Cursor))
 				*/
 				return i;
 			}
 		}
 				
 		if (!Wrap && (i + 1 > End - FindLen))
 		{
 			Wrap = true;
 			i = Begin;
 			End = Cursor;
 		}
 	}
 	
 	return -1;
 }
 
 bool LTextView3::OnFind(const char16 *Find, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	THREAD_CHECK();
 
 	// Not sure what this is doing???
 	if (HasSelection() &&
 		SelEnd < SelStart)
 	{
 		Cursor = SelStart;
 	}
 
 	#if FEATURE_HILIGHT_ALL_MATCHES
 
 	// Clear existing styles for matches
 	for (StyleIter s = Style.begin(); s != Style.end(); )
 	{
 		if (s->Owner == STYLE_FIND_MATCHES)
 			Style.Delete(s);
 		else
 			s++;
 	}
 
 	ssize_t FindLen = StrlenW(Find);
 	ssize_t FirstLoc = MatchText(Find, MatchWord, MatchCase, false, SearchUpwards), Loc;
 	if (FirstLoc >= 0)
 	{
 		SetCaret(FirstLoc, false);
 		SetCaret(FirstLoc + FindLen, true);
 	}
 
 	ssize_t Old = Cursor;
 	if (!SearchUpwards)
 		Cursor += FindLen;
 	
 	while ((Loc = MatchText(Find, MatchWord, MatchCase, false, false)) != FirstLoc)
 	{
 		LAutoPtr<LStyle> s(new LStyle(STYLE_FIND_MATCHES));
 		s->Start = Loc;
 		s->Len = FindLen;
 		s->Fore = LColour(L_FOCUS_SEL_FORE);
 		s->Back = LColour(L_FOCUS_SEL_BACK).Mix(LColour(L_WORKSPACE));
 		InsertStyle(s);
 
 		Cursor = Loc + FindLen;
 	}
 
 	Cursor = Old;
 	ScrollToOffset(Cursor);
 	Invalidate();
 
 	#else
 
 	ssize_t Loc = MatchText(Find, MatchWord, MatchCase, SelectionOnly, SearchUpwards);
 	if (Loc >= 0)
 	{
 		SetCaret(Loc, false);
 		SetCaret(Loc + StrlenW(Find), true);
 		return true;
 	}
 
 	#endif
 
 	return false;
 }
 
 bool LTextView3::OnReplace(const char16 *Find, const char16 *Replace, bool All, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	THREAD_CHECK();
 
 	if (ValidStrW(Find))
 	{
 		// int Max = -1;
 		ssize_t FindLen = StrlenW(Find);
 		ssize_t ReplaceLen = StrlenW(Replace);
 		// size_t OldCursor = Cursor;
 		ptrdiff_t First = -1;
 
 		while (true)
 		{
 			ptrdiff_t Loc = MatchText(Find, MatchWord, MatchCase, SelectionOnly, SearchUpwards);
 			if (First < 0)
 			{
 				First = Loc;
 			}
 			else if (Loc == First)
 			{
 				break;
 			}
 			
 			if (Loc >= 0)
 			{
 				ssize_t OldSelStart = SelStart;
 				ssize_t OldSelEnd = SelEnd;
 				
 				Delete(Loc, FindLen);
 				Insert(Loc, Replace, ReplaceLen);
 				
 				SelStart = OldSelStart;
 				SelEnd = OldSelEnd - FindLen + ReplaceLen;
 				Cursor = Loc + ReplaceLen;
 			}
 			if (!All)
 			{
 				return Loc >= 0;
 			}
 			if (Loc < 0) break;
 		}
 	}	
 	
 	return false;
 }
 
 ssize_t LTextView3::SeekLine(ssize_t Offset, GTextViewSeek Where)
 {
 	THREAD_CHECK();
 
 	switch (Where)
 	{
 		case PrevLine:
 		{
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 			
 			if (Offset > 0)
 				Offset--;
 			
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 
 			if (Offset > 0)
 				Offset++;
 			break;
 		}
 		case NextLine:
 		{
 			for (; Offset < Size && Text[Offset] != '\n'; Offset++)
 				;
 
 			Offset++;
 			break;
 		}
 		case StartLine:
 		{
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 
 			if (Offset > 0)
 				Offset++;
 			break;
 		}
  		case EndLine:
 		{
 			for (; Offset < Size && Text[Offset] != '\n'; Offset++)
 				;
 			break;
 		}
 		default:
 		{
 			LAssert(false);
 			break;
 		}
 	}
 
 	return Offset;
 }
 
 bool LTextView3::OnMultiLineTab(bool In)
 {
 	bool Status = false;
 	ssize_t Min = MIN(SelStart, SelEnd);
 	ssize_t Max = MAX(SelStart, SelEnd), i;
 
 	Min = SeekLine(Min, StartLine);
 
 	int Ls = 0;
 	LArray<ssize_t> p;
 	for (i=Min; i<Max && i<Size; i=SeekLine(i, NextLine))
 	{
 		p.Add(i);
 		Ls++;
 	}
 	if (Max < i)
 	{
 		Max = SeekLine(Max, EndLine);
 	}
 
 	PourEnabled = false;
 
 	ssize_t *Indexes = p.AddressOf(0);
 	if (!Indexes)
 		return false;
 
 	UndoCur = new LTextView3Undo(this);
 
 	for (i=Ls-1; i>=0; i--)
 	{
 		if (In)
 		{
 			// <-
 			ssize_t n = Indexes[i], Space = 0;
 			for (; Space<IndentSize && n<Size; n++)
 			{
 				if (Text[n] == 9)
 				{
 					Space += IndentSize;
 				}
 				else if (Text[n] == ' ')
 				{
 					Space += 1;
 				}
 				else
 				{
 					break;
 				}
 			}
 
 			ssize_t Chs = n-Indexes[i];
 			Delete(Indexes[i], Chs);
 			Max -= Chs;
 		}
 		else
 		{
 			// ->
 			ssize_t Len = Indexes[i];
 			for (; Text[Len] != '\n' && Len<Size; Len++);
 			if (Len > Indexes[i])
 			{
 				if (HardTabs)
 				{
 					char16 Tab[] = {'\t', 0};
 					Insert(Indexes[i], Tab, 1);
 					Max++;
 				}
 				else
 				{
 					char16 *Sp = new char16[IndentSize];
 					if (Sp)
 					{
 						for (int n=0; n<IndentSize; n++)
 							Sp[n] = ' ';
 						Insert(Indexes[i], Sp, IndentSize);
 						Max += IndentSize;
 					}
 				}
 			}
 		}
 	}
 
 	if (UndoCur->Changes.Length())
 	{
 		UndoQue += UndoCur;
 		UndoCur = NULL;
 	}
 	else
 	{
 		DeleteObj(UndoCur);
 	}
 
 	SelStart = Min;
 	SelEnd = Cursor = Max;
 
 	PourEnabled = true;
 	PourText(Min, Max - Min);
 	PourStyle(Min, Max - Min);
 	
 	d->SetDirty(Min, Max-Min);
 	Invalidate();
 	Status = true;
 
 	return Status;
 }
 
 void LTextView3::OnSetHidden(int Hidden)
 {
 }
 
 void LTextView3::OnPosChange()
 {
 	static bool Processing = false;
 
 	if (!Processing)
 	{
 		Processing = true;
 		LLayout::OnPosChange();
 
 		LRect c = GetClient();
 		bool ScrollYNeeded = c.Y() < (std::max(PartialPourLines, Line.Length()) * LineY);
 		bool ScrollChange = ScrollYNeeded ^ (VScroll != NULL);
 		if (ScrollChange)
 		{
 			#if 0
 			auto Client = GetClient();
 			LgiTrace("%s:%i - %p::SetScrollBars(%i) cliy=%i content=%i partial=%i\n",
 				_FL, this, ScrollYNeeded, Client.Y(), (Line.Length() * LineY), PartialPour);
 			#endif
 			SetScrollBars(false, ScrollYNeeded);
 		}
 		UpdateScrollBars();
 
 		if (GetWrapType() && d->PourX != X())
 		{
 			d->PourX = X();
 			d->SetDirty(0, Size);
 		}
 		Processing = false;
 	}
 }
 
 int LTextView3::WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 {
 	Formats.Supports("text/uri-list");
 	Formats.Supports("text/html");
 	Formats.Supports("UniformResourceLocatorW");
 	return Formats.Length() ? DROPEFFECT_COPY : DROPEFFECT_NONE;
 }
 
 int LTextView3::OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 {
 	int Status = DROPEFFECT_NONE;
 	
 	for (unsigned i=0; i<Data.Length(); i++)
 	{
 		LDragData &dd = Data[i];
 		if (dd.Data.Length() <= 0)
 			continue;
 		
 		if (dd.IsFormat("text/html") || dd.IsFormat("UniformResourceLocatorW"))
 		{
 			LVariant *Data = &dd.Data[0];
 			LAssert(dd.Data.Length() == 1); // Impl multiple data entries if this asserts.
 			if (Data->IsBinary())
 			{
 				OsChar *e = (OsChar*) ((char*)Data->Value.Binary.Data + Data->Value.Binary.Length);
 				OsChar *s = (OsChar*) Data->Value.Binary.Data;
 				int len = 0;
 				while (s < e && s[len])
 				{
 					len++;
 				}
 				
 				LAutoWString w
 				(
 					(char16*)LNewConvertCp
 					(
 						LGI_WideCharset,
 						s,
 						(
 							sizeof(OsChar) == 1
 							?
 							"utf-8"
 							:
 							LGI_WideCharset
 						),
 						len * sizeof(*s)
 					)
 				);
 				
 				Insert(Cursor, w, len);
 				Invalidate();
 				return DROPEFFECT_COPY;
 			}
 		}
 		else if (dd.IsFileDrop())
 		{
 			// We don't directly handle file drops... pass up to the parent
 			bool FoundTarget = false;
 			for (LViewI *p = GetParent(); p; p = p->GetParent())
 			{
 				LDragDropTarget *t = p->DropTarget();
 				if (t)
 				{
 					Status = t->OnDrop(Data, Pt, KeyState);
 					if (Status != DROPEFFECT_NONE)
 					{
 						FoundTarget = true;
 						break;
 					}
 				}
 			}
 			if (!FoundTarget)
 			{
 				auto Wnd = GetWindow();
 				if (Wnd)
 				{
 					LDropFiles files(dd);
 					Wnd->OnReceiveFiles(files);
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 void LTextView3::OnCreate()
 {
 	SetWindow(this);
 	DropTarget(true);
 
 	#ifndef WINDOWS
 		if (Ctrls.Length() == 0)
 			SetPulse(PULSE_TIMEOUT);
 		Ctrls.Add(this);
 	#else
 		SetPulse(PULSE_TIMEOUT);
 	#endif
 }
 
 void LTextView3::OnEscape(LKey &K)
 {
 }
 
 bool LTextView3::OnMouseWheel(double l)
 {
 	if (VScroll)
 	{
 		int64 NewPos = VScroll->Value() + (int)l;
 		NewPos = limit(NewPos, 0, (ssize_t)GetLines());
 		VScroll->Value(NewPos);
 		Invalidate();
 	}
 	
 	return true;
 }
 
 void LTextView3::OnFocus(bool f)
 {
 	Invalidate();
 }
 
 ssize_t LTextView3::HitText(int x, int y, bool Nearest)
 {
 	if (!Text)
 		return 0;
 
 	bool Down = y >= 0;
 	int Y = (VScroll) ? (int)VScroll->Value() : 0;
 	auto It = Line.begin(Y);
 	if (It != Line.end())
 		y += (*It)->r.y1;
 
 	while (It != Line.end())
 	{
 		auto l = *It;
 
 		if (l->r.Overlap(x, y))
 		{
 			// Over a line
 			int At = x - l->r.x1;
 			ssize_t Char = 0;
 				
 			LDisplayString Ds(Font, MapText(Text + l->Start, l->Len), l->Len, 0);
 			Char = Ds.CharAt(At, Nearest ? LgiNearest : LgiTruncate);
 
 			return l->Start + Char;
 		}
 		else if (y >= l->r.y1 && y <= l->r.y2)
 		{
 			// Click horizontally before of after line
 			if (x < l->r.x1)
 			{
 				return l->Start;
 			}
 			else if (x > l->r.x2)
 			{
 				return l->Start + l->Len;
 			}
 		}
 			
 		if (Down)
 			It++;
 		else
 			It--;
 		Y++;
 	}
 
 	// outside text area
 	if (Down)
 	{
 		It = Line.rbegin();
 		if (It != Line.end())
 		{
 			if (y > (*It)->r.y2)
 			{
 				// end of document
 				return Size;
 			}
 		}
 	}
 
 	return 0;
 }
 
 void LTextView3::Undo()
 {
 	int Old = UndoQue.GetPos();
 	UndoQue.Undo();
 	if (Old && !UndoQue.GetPos())
 	{
 		Dirty = false;
 		SendNotify(LNotifyDocChanged);
 	}
 }
 
 void LTextView3::Redo()
 {
 	UndoQue.Redo();
 }
 
 void LTextView3::DoContextMenu(LMouse &m)
 {
 	LSubMenu RClick;
 	LAutoString ClipText;
 	{
 		LClipBoard Clip(this);
 		ClipText.Reset(NewStr(Clip.Text()));
 	}
 
 	LStyle *s = HitStyle(HitText(m.x, m.y, true));
 	if (s)
 	{
 		if (OnStyleMenu(s, &RClick))
 		{
 			RClick.AppendSeparator();
 		}
 	}
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_CUT, "Cut"), IDM_CUT, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_COPY, "Copy"), IDM_COPY, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_PASTE, "Paste"), IDM_PASTE, ClipText != 0);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem("Copy All", IDM_COPY_ALL, true);
 	RClick.AppendItem("Select All", IDM_SELECT_ALL, true);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_UNDO, "Undo"), IDM_UNDO, UndoQue.CanUndo());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_REDO, "Redo"), IDM_REDO, UndoQue.CanRedo());
 	RClick.AppendSeparator();
 
 	auto i = RClick.AppendItem(LLoadString(L_TEXTCTRL_FIXED, "Fixed Width Font"), IDM_FIXED, true);
 	if (i) i->Checked(GetFixedWidthFont());
 
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_AUTO_INDENT, "Auto Indent"), IDM_AUTO_INDENT, true);
 	if (i) i->Checked(AutoIndent);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_SHOW_WHITESPACE, "Show Whitespace"), IDM_SHOW_WHITE, true);
 	if (i) i->Checked(ShowWhiteSpace);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_HARD_TABS, "Hard Tabs"), IDM_HARD_TABS, true);
 	if (i) i->Checked(HardTabs);
 	
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_INDENT_SIZE, "Indent Size"), IDM_INDENT_SIZE, true);
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_TAB_SIZE, "Tab Size"), IDM_TAB_SIZE, true);
 
 	if (Environment)
 		Environment->AppendItems(&RClick, NULL);
 
 	int Id = 0;
 	m.ToScreen();
 	switch (Id = RClick.Float(this, m))
 	{
 		case IDM_FIXED:
 		{
 			SetFixedWidthFont(!GetFixedWidthFont());							
 			SendNotify(LNotifyFixedWidthChanged);
 			break;
 		}
 		case IDM_CUT:
 		{
 			Cut();
 			break;
 		}
 		case IDM_COPY:
 		{
 			Copy();
 			break;
 		}
 		case IDM_PASTE:
 		{
 			Paste();
 			break;
 		}
 		case IDM_COPY_ALL:
 		{
 			SelectAll();
 			Copy();
 			break;
 		}
 		case IDM_SELECT_ALL:
 		{
 			SelectAll();
 			break;
 		}
 		case IDM_UNDO:
 		{
 			Undo();
 			break;
 		}
 		case IDM_REDO:
 		{
 			Redo();
 			break;
 		}
 		case IDM_AUTO_INDENT:
 		{
 			AutoIndent = !AutoIndent;
 			break;
 		}
 		case IDM_SHOW_WHITE:
 		{
 			ShowWhiteSpace = !ShowWhiteSpace;
 			Invalidate();
 			break;
 		}
 		case IDM_HARD_TABS:
 		{
 			HardTabs = !HardTabs;
 			break;
 		}
 		case IDM_INDENT_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", IndentSize);
 			
 			LInput *i = new LInput(this, s, "Indent Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto code)
 			{
 				if (code)
 					IndentSize = atoi(i->GetStr());
 				delete i;
 			});
 			break;
 		}
 		case IDM_TAB_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", TabSize);
 			
 			LInput *i = new LInput(this, s, "Tab Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto code)
 			{
 				SetTabSize(atoi(i->GetStr()));
 				delete i;
 			});
 			break;
 		}
 		default:
 		{
 			if (s)
 			{
 				OnStyleMenuClick(s, Id);
 			}
 
 			if (Environment)
 			{
 				Environment->OnMenu(this, Id, 0);
 			}
 			break;
 		}
 	}
 }
 
 bool LTextView3::OnStyleClick(LStyle *style, LMouse *m)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			if
 			(
 				(!m)
 				||
 				(m->Left() && m->Down() && m->Double())
 			)
 			{
 				LString s(Text + style->Start, style->Len);
 				if (s)
 					OnUrl(s);
 				return true;
 			}
 			break;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 bool LTextView3::OnStyleMenu(LStyle *style, LSubMenu *m)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			LString s(Text + style->Start, style->Len);
 			if (LIsValidEmail(s))
 				m->AppendItem(LLoadString(L_TEXTCTRL_EMAIL_TO, "New Email to..."), IDM_NEW, true);
 			else
 				m->AppendItem(LLoadString(L_TEXTCTRL_OPENURL, "Open URL"), IDM_OPEN, true);
 
 			m->AppendItem(LLoadString(L_TEXTCTRL_COPYLINK, "Copy link location"), IDM_COPY_URL, true);
 			return true;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 void LTextView3::OnStyleMenuClick(LStyle *style, int i)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			LString s(Text + style->Start, style->Len);
 
 			switch (i)
 			{
 				case IDM_NEW:
 				case IDM_OPEN:
 				{
 					if (s)
 						OnUrl(s);
 					break;
 				}
 				case IDM_COPY_URL:
 				{
 					if (s)
 					{
 						LClipBoard Clip(this);
 						Clip.Text(s);
 					}
 					break;
 				}
 			}
 			break;
 		}
 		default:
 			break;
 	}
 }
 
 void LTextView3::OnMouseClick(LMouse &m)
 {
 	bool Processed = false;
 
 	m.x += ScrollX;
 
 	if (m.Down())
 	{
 		if (m.IsContextMenu())
 		{
 			DoContextMenu(m);
 			return;
 		}
 		else if (m.Left())
 		{
 			Focus(true);
 
 			ssize_t Hit = HitText(m.x, m.y, true);
 			if (Hit >= 0)
 			{
 				SetCaret(Hit, m.Shift());
 
 				LStyle *s = HitStyle(Hit);
 				if (s)
 					Processed = OnStyleClick(s, &m);
 			}
 
 			if (!Processed && m.Double())
 			{
 				d->WordSelectMode = Cursor;
 				SelectWord(Cursor);
 			}
 			else
 			{
 				d->WordSelectMode = -1;
 			}
 		}
 	}
 
 	if (!Processed)
 	{
 		Capture(m.Down());
 	}
 }
 
 int LTextView3::OnHitTest(int x, int y)
 {
 	#ifdef WIN32
 	if (GetClient().Overlap(x, y))
 	{
 		return HTCLIENT;
 	}
 	#endif
 	return LView::OnHitTest(x, y);
 }
 
 void LTextView3::OnMouseMove(LMouse &m)
 {
 	m.x += ScrollX;
 
 	ssize_t Hit = HitText(m.x, m.y, true);
 	if (IsCapturing())
 	{
 		if (d->WordSelectMode < 0)
 		{
 			SetCaret(Hit, m.Left());
 		}
 		else
 		{
 			ssize_t Min = Hit < d->WordSelectMode ? Hit : d->WordSelectMode;
 			ssize_t Max = Hit > d->WordSelectMode ? Hit : d->WordSelectMode;
 
 			for (SelStart = Min; SelStart > 0; SelStart--)
 			{
 				if (strchr(SelectWordDelim, Text[SelStart]))
 				{
 					SelStart++;
 					break;
 				}
 			}
 
 			for (SelEnd = Max; SelEnd < Size; SelEnd++)
 			{
 				if (strchr(SelectWordDelim, Text[SelEnd]))
 				{
 					break;
 				}
 			}
 
 			Cursor = SelEnd;
 			Invalidate();
 		}
 	}
 }
 
 LCursor LTextView3::GetCursor(int x, int y)
 {
 	LRect c = GetClient();
 	c.Offset(-c.x1, -c.y1);
 	LStyle *s = NULL;
 	if (c.Overlap(x, y))
 	{
 		ssize_t Hit = HitText(x, y, true);
 		s = HitStyle(Hit);
 	}
 
 	return s ? s->Cursor : LCUR_Ibeam;
 }
 
 int LTextView3::GetColumn()
 {
 	int x = 0;
 	LTextLine *l = GetTextLine(Cursor);
 	if (l)
 	{
 		for (ssize_t i=l->Start; i<Cursor; i++)
 		{
 			if (Text[i] == '\t')
 			{
 				x += TabSize - (x % TabSize);
 			}
 			else
 			{
 				x++;
 			}
 		}
 	}
 	return x;
 }
 
 int LTextView3::SpaceDepth(char16 *Start, char16 *End)
 {
 	int Depth = 0;
 	while (Start < End)
 	{
 		if (*Start == '\t')
 			Depth += IndentSize - (Depth % IndentSize);
 		else if (*Start == ' ')
 			Depth ++;
 		else break;
 		Start++;
 	}
 	return Depth;
 }
 
 bool LTextView3::OnKey(LKey &k)
 {
 	if (k.Down())
 	{
 		Blink = true;
 	}
 
 	// k.Trace("LTextView3::OnKey");
 
 	if (k.IsContextMenu())
 	{
 		LMouse m;
 		m.x = CursorPos.x1;
 		m.y = CursorPos.y1 + (CursorPos.Y() >> 1);
 		m.Target = this;
 		DoContextMenu(m);
 	}
 	else if (k.IsChar)
 	{
 		switch (k.vkey)
 		{
 			default:
 			{
 				// process single char input
 				if
 				(
 					!GetReadOnly()
 					&&
 					(
 						(k.c16 >= ' ' || k.vkey == LK_TAB)
 						&&
 						k.c16 != 127
 					)
 				)
 				{
 					if (k.Down())
 					{
 						// letter/number etc
 						if (SelStart >= 0)
 						{
 							bool MultiLine = false;
 							if (k.vkey == LK_TAB)
 							{
 								size_t Min = MIN(SelStart, SelEnd), Max = MAX(SelStart, SelEnd);
 								for (size_t i=Min; i<Max; i++)
 								{
 									if (Text[i] == '\n')
 									{
 										MultiLine = true;
 									}
 								}
 							}
 							if (MultiLine)
 							{
 								if (OnMultiLineTab(k.Shift()))
 								{
 									return true;
 								}
 							}
 							else
 							{
 								DeleteSelection();
 							}
 						}
 						
 						LTextLine *l = GetTextLine(Cursor);
 						size_t Len = (l) ? l->Len : 0;
 						
 						if (l && k.vkey == LK_TAB && (!HardTabs || IndentSize != TabSize))
 						{
 							int x = GetColumn();							
 							int Add = IndentSize - (x % IndentSize);
 							
 							if (HardTabs && ((x + Add) % TabSize) == 0)
 							{
 								int Rx = x;
 								size_t Remove;
 								for (Remove = Cursor; Text[Remove - 1] == ' ' && Rx % TabSize != 0; Remove--, Rx--);
 								ssize_t Chars = (ssize_t)Cursor - Remove;
 								Delete(Remove, Chars);
 								Insert(Remove, &k.c16, 1);
 								Cursor = Remove + 1;
 								
 								Invalidate();
 							}
 							else
 							{							
 								char16 *Sp = new char16[Add];
 								if (Sp)
 								{
 									for (int n=0; n<Add; n++) Sp[n] = ' ';
 									if (Insert(Cursor, Sp, Add))
 									{
 										l = GetTextLine(Cursor);
 										size_t NewLen = (l) ? l->Len : 0;
 										SetCaret(Cursor + Add, false, Len != NewLen - 1);
 									}
 									DeleteArray(Sp);
 								}
 							}
 						}
 						else
 						{
 							char16 In = k.GetChar();
 
 							if (In == '\t' &&
 								k.Shift() &&
 								Cursor > 0)
 							{
 								l = GetTextLine(Cursor);
 								if (Cursor > l->Start)
 								{
 									if (Text[Cursor-1] == '\t')
 									{
 										Delete(Cursor - 1, 1);
 										SetCaret(Cursor, false, false);
 									}
 									else if (Text[Cursor-1] == ' ')
 									{
 										ssize_t Start = (ssize_t)Cursor - 1;
 										while (Start >= l->Start && strchr(" \t", Text[Start-1]))
 											Start--;
 										int Depth = SpaceDepth(Text + Start, Text + Cursor);
 										int NewDepth = Depth - (Depth % IndentSize);
 										if (NewDepth == Depth && NewDepth > 0)
 											NewDepth -= IndentSize;
 										int Use = 0;
 										while (SpaceDepth(Text + Start, Text + Start + Use + 1) < NewDepth)
 											Use++;
 										Delete(Start + Use, Cursor - Start - Use);
 										SetCaret(Start + Use, false, false);
 									}
 								}
 								
 							}
 							else if (In && Insert(Cursor, &In, 1))
 							{
 								l = GetTextLine(Cursor);
 								size_t NewLen = (l) ? l->Len : 0;
 								SetCaret(Cursor + 1, false, Len != NewLen - 1);
 							}
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			case LK_RETURN:
 			#if defined MAC
 			case LK_KEYPADENTER:
 			#endif
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Down() && k.IsChar)
 				{
 					OnEnter(k);
 				}
 				return true;
 				break;
 			}
 			case LK_BACKSPACE:
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Ctrl())
 				{
 				    // Ctrl+H
 				}
 				else if (k.Down())
 				{
 					if (SelStart >= 0)
 					{
 						// delete selection
 						DeleteSelection();
 					}
 					else
 					{						
 						char Del = Cursor > 0 ? Text[Cursor-1] : 0;
 						
 						if (Del == ' ' && (!HardTabs || IndentSize != TabSize))
 						{
 							// Delete soft tab
 							int x = GetColumn();
 							int Max = x % IndentSize;
 							if (Max == 0) Max = IndentSize;
 							ssize_t i;
 							for (i=Cursor-1; i>=0; i--)
 							{
 								if (Max-- <= 0 || Text[i] != ' ')
 								{
 									i++;
 									break;
 								}
 							}
 							
 							if (i < 0) i = 0;
 							
 							if (i < Cursor - 1)
 							{
 								ssize_t Del = (ssize_t)Cursor - i;
 								Delete(i, Del);
 								// SetCursor(i, false, false);
 								// Invalidate();
 								break;
 							}
 						}
 						else if (Del == '\t' && HardTabs && IndentSize != TabSize)
 						{
 							int x = GetColumn();
 							Delete(--Cursor, 1);
 							
 							for (int c=GetColumn(); c<x-IndentSize; c=GetColumn())
 							{
 								int Add = IndentSize + (c % IndentSize);
 								if (Add)
 								{
 									char16 *s = new char16[Add];
 									if (s)
 									{
 										for (int n=0; n<Add; n++) s[n] = ' ';
 										Insert(Cursor, s, Add);
 										Cursor += Add;
 										DeleteArray(s);
 									}
 								}
 								else break;
 							}
 							
 							Invalidate();
 							break;
 						}
 
 
 						if (Cursor > 0)
 						{
 							Delete(Cursor - 1, 1);
 						}
 					}
 				}
 				return true;
 				break;
 			}
 		}
 	}
 	else // not a char
 	{
 		switch (k.vkey)
 		{
 			case LK_TAB:
 				return true;
 			case LK_RETURN:
 			{
 				return !GetReadOnly();
 			}
 			case LK_BACKSPACE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Alt())
 					{
 						if (k.Down())
 						{
 							if (k.Ctrl())
 							{
 								Redo();
 							}
 							else
 							{
 								Undo();
 							}
 						}
 					}
 					else if (k.Ctrl())
 					{
 						if (k.Down())
 						{
 							ssize_t Start = Cursor;
 							while (IsWhiteSpace(Text[Cursor-1]) && Cursor > 0)
 								Cursor--;
 
 							while (!IsWhiteSpace(Text[Cursor-1]) && Cursor > 0)
 								Cursor--;
 
 							Delete(Cursor, Start - Cursor);
 							Invalidate();
 						}
 					}
 
 					return true;
 				}
 				break;
 			}
 			case LK_F3:
 			{
 				if (k.Down())
 				{
 					DoFindNext(NULL);
 				}
 				return true;
 				break;
 			}
 			case LK_LEFT:
 			{
 				if (k.Down())
 				{
 					if (SelStart >= 0 &&
 						!k.Shift())
 					{
 						SetCaret(MIN(SelStart, SelEnd), false);
 					}
 					else if (Cursor > 0)
 					{
 						ssize_t n = Cursor;
 
 						#ifdef MAC
 						if (k.System())
 						{
 							goto Jump_StartOfLine;
 						}
 						else
 						if (k.Alt())
 						#else
 						if (k.Ctrl())
 						#endif
 						{
 							// word move/select
 							bool StartWhiteSpace = IsWhiteSpace(Text[n]);
 							bool LeftWhiteSpace = n > 0 && IsWhiteSpace(Text[n-1]);
 
 							if (!StartWhiteSpace ||
 								Text[n] == '\n')
 							{
 								n--;
 							}
 							
 							// Skip ws
 							for (; n > 0 && strchr(" \t", Text[n]); n--)
 								;
 							
 							if (Text[n] == '\n')
 							{
 								n--;
 							}
 							else if (!StartWhiteSpace || !LeftWhiteSpace)
 							{
 								if (IsDelimiter(Text[n]))
 								{
 									for (; n > 0 && IsDelimiter(Text[n]); n--);
 								}
 								else
 								{
 									for (; n > 0; n--)
 									{
 										//IsWordBoundry(Text[n])
 										if (IsWhiteSpace(Text[n]) ||
 											IsDelimiter(Text[n]))
 										{
 											break;
 										}
 									}
 								}
 							}
 							if (n > 0) n++;
 						}
 						else
 						{
 							// single char
 							n--;
 						}
 
 						SetCaret(n, k.Shift());
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_RIGHT:
 			{
 				if (k.Down())
 				{
 					if (SelStart >= 0 &&
 						!k.Shift())
 					{
 						SetCaret(MAX(SelStart, SelEnd), false);
 					}
 					else if (Cursor < Size)
 					{
 						ssize_t n = Cursor;
 
 						#ifdef MAC
 						if (k.System())
 						{
 							goto Jump_EndOfLine;
 						}
 						else if (k.Alt())
 						#else
 						if (k.Ctrl())
 						#endif
 						{
 							// word move/select
 							if (IsWhiteSpace(Text[n]))
 							{
 								for (; n<Size && IsWhiteSpace(Text[n]); n++);
 							}
 							else
 							{
 								if (IsDelimiter(Text[n]))
 								{
 									while (IsDelimiter(Text[n]))
 									{
 										n++;
 									}
 								}
 								else
 								{
 									for (; n<Size; n++)
 									{
 										if (IsWhiteSpace(Text[n]) ||
 											IsDelimiter(Text[n]))
 										{
 											break;
 										}
 									}
 								}
 
 								if (n < Size &&
 									Text[n] != '\n')
 								{
 									if (IsWhiteSpace(Text[n]))
 									{
 										n++;
 									}
 								}
 							}
 						}
 						else
 						{
 							// single char
 							n++;
 						}
 
 						SetCaret(n, k.Shift());
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_UP:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto LTextView3_PageUp;
 					#endif
 					
 					auto It = GetTextLineIt(Cursor);
 					if (It != Line.end())
 					{
 						auto l = *It;
 						It--;
 						if (It != Line.end())
 						{
 							LTextLine *Prev = *It;
 							LDisplayString CurLine(Font, Text + l->Start, Cursor-l->Start);
 							int ScreenX = CurLine.X();
 
 							LDisplayString PrevLine(Font, Text + Prev->Start, Prev->Len);
 							ssize_t CharX = PrevLine.CharAt(ScreenX);
 
 							SetCaret(Prev->Start + MIN(CharX, Prev->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DOWN:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto LTextView3_PageDown;
 					#endif
 
 					auto It = GetTextLineIt(Cursor);
 					if (It != Line.end())
 					{
 						auto l = *It;
 						It++;
 						if (It != Line.end())
 						{
 							LTextLine *Next = *It;
 							LDisplayString CurLine(Font, Text + l->Start, Cursor-l->Start);
 							int ScreenX = CurLine.X();
 							
 							LDisplayString NextLine(Font, Text + Next->Start, Next->Len);
 							ssize_t CharX = NextLine.CharAt(ScreenX);
 
 							SetCaret(Next->Start + MIN(CharX, Next->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_END:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						SetCaret(Size, k.Shift());
 					}
 					else
 					{
 						#ifdef MAC
 						Jump_EndOfLine:
 						#endif
 						LTextLine *l = GetTextLine(Cursor);
 						if (l)
 						{
 							SetCaret(l->Start + l->Len, k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_HOME:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						SetCaret(0, k.Shift());
 					}
 					else
 					{
 						#ifdef MAC
 						Jump_StartOfLine:
 						#endif
 						LTextLine *l = GetTextLine(Cursor);
 						if (l)
 						{
 							char16 *Line = Text + l->Start;
 							char16 *s;
 							char16 SpTab[] = {' ', '\t', 0};
 							for (s = Line; (SubtractPtr(s,Line) < l->Len) && StrchrW(SpTab, *s); s++);
 							ssize_t Whitespace = SubtractPtr(s, Line);
 
 							if (l->Start + Whitespace == Cursor)
 							{
 								SetCaret(l->Start, k.Shift());
 							}
 							else
 							{
 								SetCaret(l->Start + Whitespace, k.Shift());
 							}
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEUP:
 			{
 				#ifdef MAC
 				LTextView3_PageUp:
 				#endif
 				if (k.Down())
 				{
 					LTextLine *l = GetTextLine(Cursor);
 					if (l)
 					{
 						int DisplayLines = Y() / LineY;
 						ssize_t CurLine = Line.IndexOf(l);
 
 						LTextLine *New = Line.ItemAt(MAX(CurLine - DisplayLines, 0));
 						if (New)
 						{
 							SetCaret(New->Start + MIN(Cursor - l->Start, New->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEDOWN:
 			{
 				#ifdef MAC
 				LTextView3_PageDown:
 				#endif
 				if (k.Down())
 				{
 					LTextLine *l = GetTextLine(Cursor);
 					if (l)
 					{
 						int DisplayLines = Y() / LineY;
 						ssize_t CurLine = Line.IndexOf(l);
 
 						LTextLine *New = Line.ItemAt(MIN(CurLine + DisplayLines, (ssize_t)GetLines()-1));
 						if (New)
 						{
 							SetCaret(New->Start + MIN(Cursor - l->Start, New->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_INSERT:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						Copy();
 					}
 					else if (k.Shift())
 					{
 						if (!GetReadOnly())
 						{
 							Paste();
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DELETE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Down())
 					{
 						if (SelStart >= 0)
 						{
 							if (k.Shift())
 							{
 								Cut();
 							}
 							else
 							{
 								DeleteSelection();
 							}
 						}
 						else if (Cursor < Size &&
 								Delete(Cursor, 1))
 						{
 							Invalidate();
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			default:
 			{
 				if (k.c16 == 17) break;
 
 				if (k.CtrlCmd() &&
 					!k.Alt())
 				{
 					switch (k.GetChar())
 					{
 						case 0xbd: // Ctrl+'-'
 						{
 							if (k.Down() &&
 								Font->PointSize() > 1)
 							{
 								Font->PointSize(Font->PointSize() - 1);
 								OnFontChange();
 								Invalidate();
 							}
 							break;
 						}
 						case 0xbb: // Ctrl+'+'
 						{
 							if (k.Down() &&
 								Font->PointSize() < 100)
 							{
 								Font->PointSize(Font->PointSize() + 1);
 								OnFontChange();
 								Invalidate();
 							}
 							break;
 						}
 						case 'a':
 						case 'A':
 						{
 							if (k.Down())
 							{
 								// select all
 								SelStart = 0;
 								SelEnd = Size;
 								Invalidate();
 							}
 							return true;
 							break;
 						}
 						case 'y':
 						case 'Y':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Redo();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'z':
 						case 'Z':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									if (k.Shift())
 									{
 										Redo();
 									}
 									else
 									{
 										Undo();
 									}
 								}
 								return true;
 							}
 							break;
 						}
 						case 'x':
 						case 'X':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Cut();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'c':
 						case 'C':
 						{
 							if (k.Shift())
 								return false;
 							
 							if (k.Down())
 								Copy();
 							return true;
 							break;
 						}
 						case 'v':
 						case 'V':
 						{
 							if (!k.Shift() &&
 								!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Paste();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'f':
 						{
 							if (k.Down())
 							{
 								DoFind(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'g':
 						case 'G':
 						{
 							if (k.Down())
 							{
 								DoGoto(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'h':
 						case 'H':
 						{
 							if (k.Down())
 							{
 								DoReplace(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'u':
 						case 'U':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									DoCase(NULL, k.Shift());
 								}
 								return true;
 							}
 							break;
 						}
 						case LK_RETURN:
 						{
 							if (!GetReadOnly() && !k.Shift())
 							{
 								if (k.Down())
 								{
 									OnEnter(k);
 								}
 								return true;
 							}
 							break;
 						}
 					}
 				}
 				break;
 			}
 		}
 	}
 	
 	return false;
 }
 
 void LTextView3::OnEnter(LKey &k)
 {
 	// enter
 	if (SelStart >= 0)
 	{
 		DeleteSelection();
 	}
 
 	char16 InsertStr[256] = {'\n', 0};
 
 	LTextLine *CurLine = GetTextLine(Cursor);
 	if (CurLine && AutoIndent)
 	{
 		int WsLen = 0;
 		for (;	WsLen < CurLine->Len &&
 				WsLen < (Cursor - CurLine->Start) &&
 				strchr(" \t", Text[CurLine->Start + WsLen]); WsLen++);
 		if (WsLen > 0)
 		{
 			memcpy(InsertStr+1, Text+CurLine->Start, WsLen * sizeof(char16));
 			InsertStr[WsLen+1] = 0;
 		}
 	}
 
 	if (Insert(Cursor, InsertStr, StrlenW(InsertStr)))
 	{
 		SetCaret(Cursor + StrlenW(InsertStr), false, true);
 	}
 }
 
 int LTextView3::TextWidth(LFont *f, char16 *s, int Len, int x, int Origin)
 {
 	int w = x;
 	int Size = f->TabSize();
 
 	for (char16 *c = s; SubtractPtr(c, s) < Len; )
 	{
 		if (*c == 9)
 		{			
 			w = ((((w-Origin) + Size) / Size) * Size) + Origin;
 			c++;
 		}
 		else
 		{
 			char16 *e;
 			for (e = c; SubtractPtr(e, s) < Len && *e != 9; e++);
 			
 			LDisplayString ds(f, c, SubtractPtr(e, c));
 			w += ds.X();
 			c = e;
 		}
 	}
 
 	return w - x;
 }
 
 int LTextView3::ScrollYLine()
 {
 	return (VScroll) ? (int)VScroll->Value() : 0;
 }
 
 int LTextView3::ScrollYPixel()
 {
 	return ScrollYLine() * LineY;
 }
 
 LRect LTextView3::DocToScreen(LRect r)
 {
 	r.Offset(0, d->rPadding.y1 - ScrollYPixel());
 	return r;
 }
 
 void LTextView3::OnPaintLeftMargin(LSurface *pDC, LRect &r, LColour &colour)
 {
 	pDC->Colour(colour);
 	pDC->Rectangle(&r);
 }
 
 void LTextView3::OnPaint(LSurface *pDC)
 {
 	#if LGI_EXCEPTIONS
 	try
 	{
 	#endif
 
 	#if DOUBLE_BUFFER_PAINT
 	LDoubleBuffer MemBuf(pDC);
 	#endif
 
 	#if PROFILE_PAINT
 	char s[256];
 	sprintf_s(s, sizeof(s), "%p::OnPaint Lines=%i Sz=%i", this, (int)Line.Length(), (int)Size);
 	LProfile Prof(s);
 	#endif
 
 		if (d->LayoutDirty)
 		{
 	#if PROFILE_PAINT
 	Prof.Add("PourText");
 	#endif
 			PourText(d->DirtyStart, d->DirtyLen);
 	#if PROFILE_PAINT
 	Prof.Add("PourStyle");
 	#endif
 			PourStyle(d->DirtyStart, d->DirtyLen);
 			
 			d->LayoutDirty = false;
 		}
 
 	#if PROFILE_PAINT
 	Prof.Add("Setup");
 	#endif
 		
 		LRect r = GetClient();
 		r.x2 += ScrollX;
 
 		int Ox, Oy;
 		pDC->GetOrigin(Ox, Oy);
 		pDC->SetOrigin(Ox+ScrollX, Oy);
 		
 		#if 0
 		// Coverage testing...
 		pDC->Colour(Rgb24(255, 0, 255), 24);
 		pDC->Rectangle();
 		#endif
 
 		LSurface *pOut = pDC;
 		bool DrawSel = false;
 		
 		bool HasFocus = Focus();
 		// printf("%s:%i - HasFocus = %i\n", _FL, HasFocus);
 		LColour SelectedText(HasFocus ? LColour(L_FOCUS_SEL_FORE) : LColour(L_NON_FOCUS_SEL_FORE));
 		LColour SelectedBack(HasFocus ? LColour(L_FOCUS_SEL_BACK) : LColour(L_NON_FOCUS_SEL_BACK));
 
 		LCss::ColorDef ForeDef, BkDef;
 		if (GetCss())
 		{
 			ForeDef = GetCss()->Color();
 			BkDef = GetCss()->BackgroundColor();
 		}
 		
 		LColour Fore(ForeDef.Type ==  LCss::ColorRgb ? LColour(ForeDef.Rgb32, 32) : LColour(L_TEXT));
 		LColour Back
 		(
 			/*!ReadOnly &&*/ BkDef.Type == LCss::ColorRgb
 			?
 			LColour(BkDef.Rgb32, 32)
 			:
 			Enabled() ? LColour(L_WORKSPACE) : LColour(L_MED)
 		);
 
 		// LColour Whitespace = Fore.Mix(Back, 0.85f);
 		if (!Enabled())
 		{
 			Fore = LColour(L_LOW);
 			Back = LColour(L_MED);
 		}
 
 		if (Text &&
 			Font)
 		{
 			ssize_t SelMin = MIN(SelStart, SelEnd);
 			ssize_t SelMax = MAX(SelStart, SelEnd);
 
 			// font properties
 			Font->Colour(Fore, Back);
 			// Font->WhitespaceColour(Whitespace);
 			Font->Transparent(false);
 
 			// draw margins
 			pDC->Colour(PAINT_BORDER);
 			// top margin
 			pDC->Rectangle(0, 0, r.x2, d->rPadding.y1-1);
 			// left margin
 			{
 				LRect LeftMargin(0, d->rPadding.y1, d->rPadding.x1-1, r.y2);
 				OnPaintLeftMargin(pDC, LeftMargin, PAINT_BORDER);
 			}
 		
 			// draw lines of text
 			int k = ScrollYLine();
 			auto It = Line.begin(k);
 			LTextLine *l = NULL;
 			int Dy = 0;
 			if (It != Line.end())
 				Dy = -(*It)->r.y1;
 			ssize_t NextSelection = (SelStart != SelEnd) ? SelMin : -1; // offset where selection next changes
 			if (It != Line.end() &&
 				(l = *It) &&
 				SelStart >= 0 &&
 				SelStart < l->Start &&
 				SelEnd > l->Start)
 			{
 				// start of visible area is in selection
 				// init to selection colour
 				DrawSel = true;
 				Font->Colour(SelectedText, SelectedBack);
 				NextSelection = SelMax;
 			}
 
 			StyleIter Si = Style.begin();
 			LStyle *NextStyle = GetNextStyle(Si, (l) ? l->Start : 0);
 
 			DocOffset = (l) ? l->r.y1 : 0;
 
 	#if PROFILE_PAINT
 	Prof.Add("foreach Line loop");
 	#endif
 			// loop through all visible lines
 			int y = d->rPadding.y1;
 			while ((l = *It) &&
 					l->r.y1+Dy < r.Y())
 			{
 				LRect Tr = l->r;
 				Tr.Offset(0, y - Tr.y1);
 				//LRect OldTr = Tr;
 
 				// deal with selection change on beginning of line
 				if (NextSelection == l->Start)
 				{
 					// selection change
 					DrawSel = !DrawSel;
 					NextSelection = (NextSelection == SelMin) ? SelMax : -1;
 				}
 				if (DrawSel)
 				{
 					Font->Colour(SelectedText, SelectedBack);
 				}
 				else
 				{
 					LColour fore = l->c.IsValid() ? l->c : Fore;
 					LColour back = l->Back.IsValid() ? l->Back : Back;
 					Font->Colour(fore, back);
 				}
 
 				// How many chars on this line have we
 				// processed so far:
 				ssize_t Done = 0;
 				bool LineHasSelection =	NextSelection >= l->Start &&
 										NextSelection < l->Start + l->Len;
 
 				// Fractional pixels we have moved so far:
 				int MarginF = d->rPadding.x1 << LDisplayString::FShift;
 				int FX = MarginF;
 				int FY = Tr.y1 << LDisplayString::FShift;
 				
 				// loop through all sections of similar text on a line
 				while (Done < l->Len)
 				{
 					// decide how big this block is
 					int RtlTrailingSpace = 0;
 					ssize_t Cur = l->Start + Done;
 					ssize_t Block = l->Len - Done;
 					
 					// check for style change
 					if (NextStyle &&
 						(ssize_t)NextStyle->End() <= l->Start)
 						NextStyle = GetNextStyle(Si);
 					if (NextStyle)
 					{
 						// start
 						if (l->Overlap(NextStyle->Start) &&
 							NextStyle->Start > Cur &&
 							NextStyle->Start - Cur < Block)
 						{
 							Block = NextStyle->Start - Cur;
 						}
 
 						// end
 						ssize_t StyleEnd = NextStyle->Start + NextStyle->Len;
 						if (l->Overlap(StyleEnd) &&
 							StyleEnd > Cur &&
 							StyleEnd - Cur < Block)
 						{
 							Block = StyleEnd - Cur;
 						}
 					}
 
 					// check for next selection change
 					// this may truncate the style
 					if (NextSelection > Cur &&
 						NextSelection - Cur < Block)
 					{
 						Block = NextSelection - Cur;
 					}
 
 					LAssert(Block != 0);	// sanity check
 					
 					if (NextStyle &&							// There is a style
 						(Cur < SelMin || Cur >= SelMax) &&		// && we're not drawing a selection block
 						Cur >= NextStyle->Start &&				// && we're inside the styled area
 						Cur < NextStyle->Start+NextStyle->Len)
 					{
 						LFont *Sf = NextStyle->Font ? NextStyle->Font : Font;
 						if (Sf)
 						{
 							// draw styled text
 							if (NextStyle->Fore.IsValid())
 								Sf->Fore(NextStyle->Fore);
 							if (NextStyle->Back.IsValid())
 								Sf->Back(NextStyle->Back);
 							else if (l->Back.IsValid())
 								Sf->Back(l->Back);
 							else
 								Sf->Back(Back);								
 
 							Sf->Transparent(false);
 
 							LAssert(l->Start + Done >= 0);
 
 							LDisplayString Ds(	Sf,
 												MapText(Text + (l->Start + Done),
 														Block,
 														RtlTrailingSpace != 0),
 												Block + RtlTrailingSpace);
 							Ds.SetDrawOffsetF(FX - MarginF);
 							Ds.ShowVisibleTab(ShowWhiteSpace);
 							Ds.FDraw(pOut, FX, FY, 0, LineHasSelection);
 
 							if (NextStyle->Decor == LCss::TextDecorSquiggle)
 							{
 								pOut->Colour(NextStyle->DecorColour);
 								int x = FX >> LDisplayString::FShift;
 								int End = x + Ds.X();
 								while (x < End)
 								{
 									pOut->Set(x, Tr.y2-(x%2));
 									x++;
 								}
 							}
 
 							FX += Ds.FX();
 
 							LColour fore = l->c.IsValid() ? l->c : Fore;
 							LColour back = l->Back.IsValid() ? l->Back : Back;
 							Sf->Colour(fore, back);
 						}
 						else LAssert(0);
 					}
 					else
 					{
 						// draw a block of normal text
 						LAssert(l->Start + Done >= 0);
 						
 						LDisplayString Ds(	Font,
 											MapText(Text + (l->Start + Done),
 													Block,
 													RtlTrailingSpace != 0),
 											Block + RtlTrailingSpace);
 						Ds.SetDrawOffsetF(FX - MarginF);
 						Ds.ShowVisibleTab(ShowWhiteSpace);
 						Ds.FDraw(pOut, FX, FY, 0, LineHasSelection);
 						FX += Ds.FX();
 					}
 
 					if (NextStyle &&
 						Cur+Block >= NextStyle->Start+NextStyle->Len)
 					{
 						// end of this styled block
 						NextStyle = GetNextStyle(Si);
 					}
 
 					if (NextSelection == Cur+Block)
 					{
 						// selection change
 						DrawSel = !DrawSel;
 						if (DrawSel)
 						{
 							Font->Colour(SelectedText, SelectedBack);
 						}
 						else
 						{
 							LColour fore = l->c.IsValid() ? l->c : Fore;
 							LColour back = l->Back.IsValid() ? l->Back : Back;
 							Font->Colour(fore, back);
 						}
 						NextSelection = (NextSelection == SelMin) ? SelMax : -1;
 					}
 
 					Done += Block + RtlTrailingSpace;
 				
 				} // end block loop
 
 				Tr.x1 = FX >> LDisplayString::FShift;
 
 				// eol processing
 				ssize_t EndOfLine = l->Start+l->Len;
 				if (EndOfLine >= SelMin && EndOfLine < SelMax)
 				{
 					// draw the '\n' at the end of the line as selected
 					// LColour bk = Font->Back();
 					pOut->Colour(Font->Back());
 					pOut->Rectangle(Tr.x2, Tr.y1, Tr.x2+7, Tr.y2);
 					Tr.x2 += 7;
 				}
 				else Tr.x2 = Tr.x1;
 
 				// draw any space after text
 				pOut->Colour(PAINT_AFTER_LINE);
 				pOut->Rectangle(Tr.x2, Tr.y1, r.x2, Tr.y2);
 
 				// cursor?
 				if (HasFocus)
 				{
 					// draw the cursor if on this line
 					if (Cursor >= l->Start && Cursor <= l->Start+l->Len)
 					{
 						CursorPos.ZOff(1, LineY-1);
 
 						ssize_t At = Cursor-l->Start;
 						
 						LDisplayString Ds(Font, MapText(Text+l->Start, At), At);
 						Ds.ShowVisibleTab(ShowWhiteSpace);
 						int CursorX = Ds.X();
 						CursorPos.Offset(d->rPadding.x1 + CursorX, Tr.y1);
 						
 						if (CanScrollX)
 						{
 							// Cursor on screen check
 							LRect Scr = GetClient();
 							Scr.Offset(ScrollX, 0);
 							LRect Cur = CursorPos;
 							if (Cur.x2 > Scr.x2 - 5) // right edge check
 							{
 								ScrollX = ScrollX + Cur.x2 - Scr.x2 + 40;
 								Invalidate();
 							}
 							else if (Cur.x1 < Scr.x1 && ScrollX > 0)
 							{
 								ScrollX = MAX(0, Cur.x1 - 40);
 								Invalidate();
 							}
 						}
 
 						if (Blink)
 						{
 							LRect c = CursorPos;
 
 							pOut->Colour(!ReadOnly ? Fore : LColour(192, 192, 192));
 							pOut->Rectangle(&c);
 						}
 
 						#if WINNATIVE
 						HIMC hIMC = ImmGetContext(Handle());
 						if (hIMC)
 						{
 							COMPOSITIONFORM Cf;						
 							Cf.dwStyle = CFS_POINT;
 							Cf.ptCurrentPos.x = CursorPos.x1;
 							Cf.ptCurrentPos.y = CursorPos.y1;
 							ImmSetCompositionWindow(hIMC, &Cf);
 							ImmReleaseContext(Handle(), hIMC);
 						}
 						#endif
 					}
 				}
 
 				#if DRAW_LINE_BOXES
 				{
 					uint Style = pDC->LineStyle(LSurface::LineAlternate);
 					LColour Old = pDC->Colour(LColour::Red);
 					pDC->Box(&OldTr);
 					pDC->Colour(Old);
 					pDC->LineStyle(Style);
 
 					LString s;
 					s.Printf("%i, %i", Line.IndexOf(l), l->Start);
 					LDisplayString ds(LSysFont, s);
 					LSysFont->Transparent(true);
 					ds.Draw(pDC, OldTr.x2 + 2, OldTr.y1);
 				}
 				#endif
 
 				y += LineY;
 
 				It++;
 
 			} // end of line loop
 
 			// draw any space under the lines
 			if (y <= r.y2)
 			{
 				pDC->Colour(Back);
 				// pDC->Colour(LColour(255, 0, 255));
 				pDC->Rectangle(d->rPadding.x1, y, r.x2, r.y2);
 			}
 		}
 		else
 		{
 			// default drawing: nothing
 			pDC->Colour(Back);
 			pDC->Rectangle(&r);
 		}
 
 		// _PaintTime = LCurrentTime() - StartTime;
 		#ifdef PAINT_DEBUG
 		if (GetNotify())
 		{
 			char s[256];
 			sprintf_s(s, sizeof(s), "Pour:%i Style:%i Paint:%i ms", _PourTime, _StyleTime, _PaintTime);
 			LMessage m = CreateMsg(DEBUG_TIMES_MSG, 0, (int)s);
 			GetNotify()->OnEvent(&m);
 		}
 		#endif
 		// printf("PaintTime: %ims\n", _PaintTime);
 	
 	#if LGI_EXCEPTIONS
 	}
 	catch (...)
 	{
 		LgiMsg(this, "LTextView3::OnPaint crashed.", "Lgi");
 	}
 	#endif
 }
 
 LMessage::Result LTextView3::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_TEXT_UPDATE_NAME:
 		{
 			if (d->Lock(_FL))
 			{
 				Name(d->SetName);
 				d->SetName.Empty();
 				d->Unlock();
 			}
 			break;
 		}
 		case M_TEXTVIEW_FIND:
 		{
 			if (InThread())
 				DoFindNext(NULL);
 			else
 				LgiTrace("%s:%i - Not in thread.\n", _FL);
 			break;
 		}
 		case M_TEXTVIEW_REPLACE:
 		{
 			// DoReplace();
 			break;
 		}
 		case M_CUT:
 		{
 			Cut();
 			break;
 		}
 		case M_COPY:
 		{
 			Copy();
 			break;
 		}
 		case M_PASTE:
 		{
 			Paste();
 			break;
 		}
 		#if defined WIN32
 		case WM_GETTEXTLENGTH:
 		{
 			return Size;
 		}
 		case WM_GETTEXT:
 		{
 			int Chars = (int)Msg->A();
 			char *Out = (char*)Msg->B();
 			if (Out)
 			{
 				char *In = (char*)LNewConvertCp(LAnsiToLgiCp(), NameW(), LGI_WideCharset, Chars);
 				if (In)
 				{
 					int Len = (int)strlen(In);
 					memcpy(Out, In, Len);
 					DeleteArray(In);
 					return Len;
 				}
 			}
 			return 0;
 		}
 
 		/* This is broken... the IME returns garbage in the buffer. :(
 		case WM_IME_COMPOSITION:
 		{
 			if (Msg->b & GCS_RESULTSTR) 
 			{
 				HIMC hIMC = ImmGetContext(Handle());
 				if (hIMC)
 				{
 					int Size = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0);
 					char *Buf = new char[Size];
 					if (Buf)
 					{
 						ImmGetCompositionString(hIMC, GCS_RESULTSTR, Buf, Size);
 
 						char16 *Utf = (char16*)LNewConvertCp(LGI_WideCharset, Buf, LAnsiToLgiCp(), Size);
 						if (Utf)
 						{
 							Insert(Cursor, Utf, StrlenW(Utf));
 							DeleteArray(Utf);
 						}
 
 						DeleteArray(Buf);
 					}
 
 					ImmReleaseContext(Handle(), hIMC);
 				}
 				return 0;
 			}
 			break;
 		}
 		*/
 		#endif
 	}
 
 	return LLayout::OnEvent(Msg);
 }
 
 int LTextView3::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (Ctrl->GetId() == IDC_VSCROLL && VScroll)
 	{
 		if (n.Type == LNotifyScrollBarCreate)
 		{
 			UpdateScrollBars();
 		}
 			
 		Invalidate();
 	}
 
 	return 0;
 }
 
 void LTextView3::InternalPulse()
 {
 	if (!ReadOnly)
 	{
 		uint64 Now = LCurrentTime();
 		if (!BlinkTs)
 			BlinkTs = Now;
 		else if (Now - BlinkTs > CURSOR_BLINK)
 		{
 			Blink = !Blink;
 
 			LRect p = CursorPos;
 			p.Offset(-ScrollX, 0);
 			Invalidate(&p);
 			BlinkTs = Now;
 		}
 	}
 
 	if (PartialPour)
 		PourText(Size, 0);
 }
 
 void LTextView3::OnPulse()
 {
 	#ifdef WINDOWS
 		InternalPulse();
 	#else
 		for (auto c: Ctrls)
 			c->InternalPulse();
 	#endif
 }
 
 void LTextView3::OnUrl(char *Url)
 {
 	if (Environment)
 		Environment->OnNavigate(this, Url);
 	else
 	{
 		LUri u(Url);
 		bool Email = LIsValidEmail(Url);
 		const char *Proto = Email ? "mailto" : u.sProtocol;
 		LString App = LGetAppForProtocol(Proto);
 		if (App)
 			LExecute(App, Url);
 		else
 			LgiMsg(this, "Failed to find application for protocol '%s'", "Error", MB_OK, Proto);
 	}
 }
 
 bool LTextView3::OnLayout(LViewLayoutInfo &Inf)
 {
 	Inf.Width.Min = 32;
 	Inf.Width.Max = -1;
 
 	Inf.Height.Min = (Font ? Font->GetHeight() : 18) + 4;
 	Inf.Height.Max = -1;
 
 	return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 class LTextView3_Factory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (_stricmp(Class, "LTextView3") == 0)
 		{
 			return new LTextView3(-1, 0, 0, 2000, 2000);
 		}
 
 		return 0;
 	}
 } TextView3_Factory;
diff --git a/src/common/Text/TextView4.cpp b/src/common/Text/TextView4.cpp
--- a/src/common/Text/TextView4.cpp
+++ b/src/common/Text/TextView4.cpp
@@ -1,5512 +1,5510 @@
 #ifdef WIN32
 #include <winsock2.h>
 #include <imm.h>
 #endif
 #include <stdlib.h>
 #include <stdio.h>
 #include <ctype.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/TextView4.h"
 #include "lgi/common/Input.h"
 #include "lgi/common/ScrollBar.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/CssTools.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Mail.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/DropFiles.h"
 #include "ViewPriv.h"
 
 #ifdef _DEBUG
 #define FEATURE_HILIGHT_ALL_MATCHES	1
 #else
 #define FEATURE_HILIGHT_ALL_MATCHES	0
 #endif
 
 #define DefaultCharset              "utf-8"
 #define SubtractPtr(a, b)			((a) - (b))
 
 #define GDCF_UTF8					-1
 #define POUR_DEBUG					0
 #define PROFILE_POUR				0
 #define PROFILE_PAINT				0
 #define DRAW_LINE_BOXES				0
 #define WRAP_POUR_TIMEOUT			90 // ms
 #define PULSE_TIMEOUT				250 // ms
 #define CURSOR_BLINK				1000 // ms
 
 #define ALLOC_BLOCK					64
 #define IDC_VS						1000
 
 enum Cmds
 {
 	IDM_COPY_URL = 100,
 	IDM_AUTO_INDENT,
 	IDM_UTF8,
 	IDM_PASTE_NO_CONVERT,
 	IDM_FIXED,
 	IDM_SHOW_WHITE,
 	IDM_HARD_TABS,
 	IDM_INDENT_SIZE,
 	IDM_TAB_SIZE,
 	IDM_DUMP,
 	IDM_RTL,
 	IDM_COPY_ALL,
 	IDM_SELECT_ALL,
 	#ifndef IDM_OPEN
 		IDM_OPEN,
 	#endif
 	#ifndef IDM_NEW
 		IDM_NEW,
 	#endif
 	#ifndef IDM_COPY
 		IDM_COPY,
 	#endif
 	#ifndef IDM_CUT
 		IDM_CUT,
 	#endif
 	#ifndef IDM_PASTE
 		IDM_PASTE,
 	#endif
 	#ifndef IDM_UNDO
 		IDM_UNDO,
 	#endif
 	#ifndef IDM_REDO
 		IDM_REDO,
 	#endif
 };
 
 #define PAINT_BORDER				Back
 #if DRAW_LINE_BOXES
 	#define PAINT_AFTER_LINE			LColour(240, 240, 240)
 #else
 	#define PAINT_AFTER_LINE			Back
 #endif
 
 #define CODEPAGE_BASE				100
 #define CONVERT_CODEPAGE_BASE		200
 
 #if !defined(WIN32) && !defined(toupper)
 #define toupper(c)					(((c)>='a'&&(c)<='z') ? (c)-'a'+'A' : (c))
 #endif
 
 #define THREAD_CHECK() \
 	if (!InThread()) \
 	{ \
 		LgiTrace("%s:%i - %s called out of thread.\n", _FL, __FUNCTION__); \
 		return false; \
 	}
 
 static char SelectWordDelim[] = " \t\n.,()[]<>=?/\\{}\"\';:+=-|!@#$%^&*";
 #ifndef WINDOWS
 static LArray<LTextView4*> Ctrls;
 #endif
 
 //////////////////////////////////////////////////////////////////////
 class GDocFindReplaceParams4 :
 	public LDocFindReplaceParams,
 	public LMutex
 {
 public:
 	// Find/Replace History
 	LAutoWString LastFind;
 	LAutoWString LastReplace;
 	bool MatchCase;
 	bool MatchWord;
 	bool SelectionOnly;
 	bool SearchUpwards;
 	
 	GDocFindReplaceParams4() : LMutex("GDocFindReplaceParams4")
 	{
 		MatchCase = false;
 		MatchWord = false;
 		SelectionOnly = false;
 		SearchUpwards = false;
 	}
 };
 
 class LTextView4Private : public LCss, public LMutex
 {
 public:
 	LTextView4 *View;
 	LRect rPadding;
 	int PourX;
 	bool LayoutDirty;
 	ssize_t DirtyStart, DirtyLen;
 	LColour UrlColour;
 	bool CenterCursor;
 	ssize_t WordSelectMode;
 	LString Eol;
 	LString LastError;
 	
 	// If the scroll position is set before we get a scroll bar, store the index
 	// here and set it when the LNotifyScrollBarCreate arrives.
 	ssize_t VScrollCache;
 
 	// Find/Replace Params
 	bool OwnFindReplaceParams;
 	GDocFindReplaceParams4 *FindReplaceParams;
 
 	// Map buffer
 	ssize_t MapLen;
 	char16 *MapBuf;
 
 	// <RequiresLocking>
 		// Thread safe Name(char*) impl
 		LString SetName;
 	// </RequiresLocking>
 
 	#ifdef _DEBUG
 	LString PourLog;
 	#endif
 
 	LTextView4Private(LTextView4 *view) : LMutex("LTextView4Private")
 	{
 		View = view;
 		WordSelectMode = -1;
 		PourX = -1;
 		VScrollCache = -1;
 		DirtyStart = DirtyLen = 0;
 		UrlColour.Rgb(0, 0, 255);		
 		LColour::GetConfigColour("colour.L_URL", UrlColour);
 
 		CenterCursor = false;
 		
 		LayoutDirty = true;
 		rPadding.ZOff(0, 0);
 		MapBuf = 0;
 		MapLen = 0;
 		
 		OwnFindReplaceParams = true;
 		FindReplaceParams = new GDocFindReplaceParams4;
 	}
 	
 	~LTextView4Private()
 	{
 		if (OwnFindReplaceParams)
 		{
 			DeleteObj(FindReplaceParams);
 		}
 		
 		DeleteArray(MapBuf);
 	}
 	
 	void SetDirty(ssize_t Start, ssize_t Len = 0)
 	{
 		LayoutDirty = true;
 		DirtyStart = Start;
 		DirtyLen = Len;
 	}
 
 	void OnChange(PropType Prop)
 	{
 		if (Prop == LCss::PropPadding ||
 			Prop == LCss::PropPaddingLeft ||
 			Prop == LCss::PropPaddingRight ||
 			Prop == LCss::PropPaddingTop ||
 			Prop == LCss::PropPaddingBottom)
 		{
 			LCssTools t(this, View->GetFont());
 			rPadding.ZOff(0, 0);
 			rPadding = t.ApplyPadding(rPadding);
 		}
 	}
 };
 
 //////////////////////////////////////////////////////////////////////
 enum UndoType
 {
 	UndoDelete, UndoInsert, UndoChange
 };
 
 struct Change : public LRange
 {
 	UndoType Type;
 	LArray<char16> Txt;
 };
 
 struct LTextView4Undo : public LUndoEvent
 {
 	LTextView4 *View;
 	LArray<Change> Changes;
 
 	LTextView4Undo(LTextView4 *view)
 	{
 		View = view;
 	}
 
 	void AddChange(ssize_t At, ssize_t Len, UndoType Type)
 	{
 		Change &c = Changes.New();
 		c.Start = At;
 		c.Len = Len;
 		c.Txt.Add(View->Text + At, Len);
 		c.Type = Type;
 	}
 
 	void OnChange()
 	{
 		for (auto &c : Changes)
 		{
 			size_t Len = c.Len;
 			if (View->Text)
 			{
 				char16 *t = View->Text + c.Start;
 				for (size_t i=0; i<Len; i++)
 				{
 					char16 n = c.Txt[i];
 					c.Txt[i] = t[i];
 					t[i] = n;
 				}
 			}
 
 			View->d->SetDirty(c.Start, c.Len);
 		}
 	}
 
 	// LUndoEvent
     void ApplyChange()
 	{
 		View->UndoOn = false;
 
 		for (auto &c : Changes)
 		{
 			switch (c.Type)
 			{
 				case UndoInsert:
 				{
 					View->Insert(c.Start, c.Txt.AddressOf(), c.Len);
 					View->Cursor = c.Start + c.Len;
 					break;
 				}
 				case UndoDelete:
 				{
 					View->Delete(c.Start, c.Len);
 					View->Cursor = c.Start;
 					break;
 				}
 				case UndoChange:
 				{
 					OnChange();
 					break;
 				}
 			}
 		}
 
 		View->UndoOn = true;
 		View->Invalidate();
 	}
 
     void RemoveChange()
 	{
 		View->UndoOn = false;
 
 		for (auto &c : Changes)
 		{
 			switch (c.Type)
 			{
 				case UndoInsert:
 				{
 					View->Delete(c.Start, c.Len);
 					break;
 				}
 				case UndoDelete:
 				{
 					View->Insert(c.Start, c.Txt.AddressOf(), c.Len);
 					break;
 				}
 				case UndoChange:
 				{
 					OnChange();				
 					break;
 				}
 			}
 
 			View->Cursor = c.Start;
 		}
 
 		View->UndoOn = true;
 		View->Invalidate();
 	}
 };
 
 void LTextView4::LStyle::RefreshLayout(size_t Start, ssize_t Len)
 {
 	View->PourText(Start, Len);
 	View->PourStyle(Start, Len);
 }
 
 //////////////////////////////////////////////////////////////////////
 LTextView4::LTextView4(	int Id,
 						int x, int y, int cx, int cy,
 						LFontType *FontType)
 	: ResObject(Res_Custom)
 {
 	// init vars
 	LView::d->Css.Reset(d = new LTextView4Private(this));
 	
 	PourEnabled = true;
 	PartialPour = false;
 	AdjustStylePos = true;
 	BlinkTs = 0;
 	LineY = 1;
 	MaxX = 0;
 	TextCache = 0;
 	UndoOn = true;
 	UndoCur = NULL;
 	Font = 0;
 	FixedWidthFont = false;
 	FixedFont = 0;
 	ShowWhiteSpace = false;
 	ObscurePassword = false;
 	TabSize = TAB_SIZE;
 	IndentSize = TAB_SIZE;
 	HardTabs = true;
 	CanScrollX = false;
 	Blink = true;
 
 	// setup window
 	SetId(Id);
 
 	// default options
 	Dirty = false;
 	#if WINNATIVE
 	CrLf = true;
 	SetDlgCode(DLGC_WANTALLKEYS);
 	#else
 	CrLf = false;
 	#endif
 	Underline = NULL;
 	Bold = NULL;
 	d->Padding(LCss::Len(LCss::LenPx, 2));
 
 	#ifdef _DEBUG
 	// debug times
 	_PourTime = 0;
 	_StyleTime = 0;
 	_PaintTime = 0;
 	#endif
 
 	// Data
 	Alloc = ALLOC_BLOCK;
 	Text = new char16[Alloc];
 	if (Text) *Text = 0;
 	Cursor = 0;
 	Size = 0;
 
 	// Display
 	SelStart = SelEnd = -1;
 	DocOffset = 0;
 	ScrollX = 0;
 
 	if (FontType)
 	{
 		Font = FontType->Create();
 	}
 	else
 	{
 		LFontType Type;
 		if (Type.GetSystemFont("Fixed"))
 			Font = Type.Create();
 		else
 			printf("%s:%i - failed to create font.\n", _FL);
 	}
 
 	if (Font)
 	{
 		SetTabStop(true);
 
 		Underline = new LFont;
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			if (d->UrlColour.IsValid())
 				Underline->Fore(d->UrlColour);
 			Underline->Create();
 		}
 		Bold = new LFont;
 		if (Bold)
 		{
 			*Bold = *Font;
 			Bold->Bold(true);
 			Bold->Create();
 		}
 
 		OnFontChange();
 	}
 	else
 	{
 		LgiTrace("%s:%i - Failed to create font, FontType=%p\n", _FL, FontType);
 		Font = LSysFont;
 	}
 
 	CursorPos.ZOff(1, LineY-1);
 	CursorPos.Offset(d->rPadding.x1, d->rPadding.y1);
 
 	LRect r;
 	r.ZOff(cx-1, cy-1);
 	r.Offset(x, y);
 	SetPos(r);
 	LResources::StyleElement(this);
 }
 
 LTextView4::~LTextView4()
 {
 	#ifndef WINDOWS
 	Ctrls.Delete(this);
 	#endif
 	Line.DeleteObjects();
 	Style.Empty();
 
 	DeleteArray(TextCache);
 	DeleteArray(Text);
 
 	if (Font != LSysFont) DeleteObj(Font);
 	DeleteObj(FixedFont);
 	DeleteObj(Underline);
 	DeleteObj(Bold);
 	// 'd' is owned by the LView::Css auto ptr
 }
 
 char16 *LTextView4::MapText(char16 *Str, ssize_t Len, bool RtlTrailingSpace)
 {
 	if (ObscurePassword /*|| ShowWhiteSpace*/ || RtlTrailingSpace)
 	{
 		if (Len > d->MapLen)
 		{
 			DeleteArray(d->MapBuf);
 			d->MapBuf = new char16[Len + RtlTrailingSpace];
 			d->MapLen = Len;
 		}
 
 		if (d->MapBuf)
 		{
 			int n = 0;
 
 			if (RtlTrailingSpace)
 			{
 				d->MapBuf[n++] = ' ';
 				for (int i=0; i<Len; i++)
 				{
 					d->MapBuf[n++] = Str[i];
 				}
 			}
 			else if (ObscurePassword)
 			{
 				for (int i=0; i<Len; i++)
 				{
 					d->MapBuf[n++] = '*';
 				}
 			}
 			/*
 			else if (ShowWhiteSpace)
 			{
 				for (int i=0; i<Len; i++)
 				{
 					if (Str[i] == ' ')
 					{
 						d->MapBuf[n++] = 0xb7;
 					}
 					else if (Str[i] == '\t')
 					{
 						d->MapBuf[n++] = 0x2192;
 					}
 					else
 					{
 						d->MapBuf[n++] = Str[i];
 					}
 				}
 			}
 			*/			
 
 			return d->MapBuf;
 		}
 	}
 
 	return Str;
 }
 
 void LTextView4::SetFixedWidthFont(bool i)
 {
 	if (FixedWidthFont ^ i)
 	{
 		if (i)
 		{
 			LFontType Type;
 			if (Type.GetSystemFont("Fixed"))
 			{
 				LFont *f = FixedFont;
 				FixedFont = Font;
 				Font = f;
 
 				if (!Font)
 				{
 					Font = Type.Create();
 					if (Font)
 					{
 						Font->PointSize(FixedFont->PointSize());
 					}
 				}
 
 				LDocView::SetFixedWidthFont(i);
 			}
 		}
 		else if (FixedFont)
 		{
 			LFont *f = FixedFont;
 			FixedFont = Font;
 			Font = f;
 			LDocView::SetFixedWidthFont(i);
 		}
 
 		OnFontChange();
 		Invalidate();
 	}
 }
 
 void LTextView4::SetReadOnly(bool i)
 {
 	LDocView::SetReadOnly(i);
 
 	#if WINNATIVE
 	SetDlgCode(i ? DLGC_WANTARROWS : DLGC_WANTALLKEYS);
 	#endif
 }
 
 void LTextView4::SetCrLf(bool crlf)
 {
 	CrLf = crlf;
 }
 
 
 void LTextView4::SetTabSize(uint8_t i)
 {
 	TabSize = limit(i, 2, 32);
 	OnFontChange();
 	OnPosChange();
 	Invalidate();
 }
 
 void LTextView4::SetWrapType(LDocWrapType i)
 {
 	LDocView::SetWrapType(i);
 	CanScrollX = i != TEXTED_WRAP_REFLOW;
 
 	OnPosChange();
 	Invalidate();
 }
 
 LFont *LTextView4::GetFont()
 {
 	return Font;
 }
 
 LFont *LTextView4::GetBold()
 {
 	return Bold;
 }
 
 void LTextView4::SetFont(LFont *f, bool OwnIt)
 {
 	if (!f)
 		return;
 	
 	if (OwnIt)
 	{
 		if (Font != LSysFont)
 			DeleteObj(Font);
 		Font = f;
 	}
 	else if (!Font || Font == LSysFont)
 	{
 		Font = new LFont(*f);
 	}
 	else
 	{
 		*Font = *f;
 	}
 
 	if (Font)
 	{
 		if (!Underline)
 			Underline = new LFont;
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			Underline->Create();
 			if (d->UrlColour.IsValid())
 				Underline->Fore(d->UrlColour);
 		}
 
 		if (!Bold)
 			Bold = new LFont;
 		if (Bold)
 		{
 			*Bold = *Font;
 			Bold->Bold(true);
 			Bold->Create();
 		}
 	}
 
 	OnFontChange();
 }
 
 void LTextView4::OnFontChange()
 {
 	if (Font)
 	{
 		// get line height
 		// int OldLineY = LineY;
 		if (!Font->Handle())
 			Font->Create();
 		LineY = Font->GetHeight();
 		if (LineY < 1) LineY = 1;
 
 		// get tab size
 		char Spaces[32];
 		memset(Spaces, 'A', TabSize);
 		Spaces[TabSize] = 0;
 		LDisplayString ds(Font, Spaces);
 		Font->TabSize(ds.X());
 
 		// repour doc
 		d->SetDirty(0, Size);
 
 		// validate blue underline font
 		if (Underline)
 		{
 			*Underline = *Font;
 			Underline->Underline(true);
 			Underline->Create();
 		}
 
 		#if WINNATIVE // Set the IME font.
 		HIMC hIMC = ImmGetContext(Handle());
 		if (hIMC)
 		{
 			COMPOSITIONFORM Cf;						
 			Cf.dwStyle = CFS_POINT;
 			Cf.ptCurrentPos.x = CursorPos.x1;
 			Cf.ptCurrentPos.y = CursorPos.y1;
 
 			LOGFONT FontInfo;
 			GetObject(Font->Handle(), sizeof(FontInfo), &FontInfo);
 			ImmSetCompositionFont(hIMC, &FontInfo);
 
 			ImmReleaseContext(Handle(), hIMC);
 		}
 		#endif
 
 	}
 }
 
 void LTextView4::LogLines()
 {
 	int Idx = 0;
 	LStringPipe p;
 	p.Print("DocSize: %i\n", (int)Size);
 	for (auto i : Line)
 	{
 		p.Print("  [%i]=%p, %i+%i, %s\n", Idx, i, (int)i->Start, (int)i->Len, i->r.GetStr());
 		Idx++;
 	}
 	LgiTrace(p.NewGStr());
 
 	#ifdef _DEBUG
 	if (d->PourLog)
 		LgiTrace("%s", d->PourLog.Get());
 	#endif
 }
 
 bool LTextView4::ValidateLines(bool CheckBox)
 {
 	size_t Pos = 0;
 	char16 *c = Text;
 	size_t Idx = 0;
 	LTextLine *Prev = NULL;
 
 	for (auto l: Line)
 	{
 		if (l->Start != Pos)
 		{
 			LogLines();
 			LAssert(!"Incorrect start.");
 			return false;
 		}
 
 		char16 *e = c;
 		if (WrapType == TEXTED_WRAP_NONE)
 		{
 			while (*e && *e != '\n')
 				e++;
 		}
 		else
 		{
 			char16 *end = Text + l->Start + l->Len;
 			while (*e && *e != '\n' && e < end)
 				e++;
 		}
 			
 		ssize_t Len = e - c;
 		if (l->Len != Len)
 		{
 			LogLines();
 			LAssert(!"Incorrect length.");
 			return false;
 		}
 
 
 		if (CheckBox &&
 			Prev &&
 			Prev->r.y2 != l->r.y1 - 1)
 		{
 			LogLines();
 			LAssert(!"Lines not joined vertically");
 		}
 
 		if (*e)
 		{
 			if (*e == '\n')
 				e++;
 			else if (WrapType == TEXTED_WRAP_REFLOW)
 				e++;
 		}
 		Pos = e - Text;
 		c = e;
 		Idx++;
 		Prev = l;
 	}
 
 	if (WrapType == TEXTED_WRAP_NONE &&
 		Pos != Size)
 	{
 		LogLines();
 		LAssert(!"Last line != end of doc");
 		return false;
 	}
 
 	return true;
 }
 
 int LTextView4::AdjustStyles(ssize_t Start, ssize_t Diff, bool ExtendStyle)
 {
 	int Changes = 0;
 	for (auto &s : Style)
 	{
 		if (s.Start == Start)
 		{
 			if (Diff < 0 || ExtendStyle)
 				s.Len += Diff;
 			else
 				s.Start += Diff;
 			Changes++;
 		}
 		else if (s.Start > Start)
 		{
 			s.Start += Diff;
 			Changes++;
 		}
 	}
 
 	return Changes;
 }
 
 // break array, break out of loop when we hit these chars
 #define ExitLoop(c)	(	(c) == 0 ||								\
 						(c) == '\n' ||							\
 						(c) == ' ' ||							\
 						(c) == '\t'								\
 					)
 
 // extra breaking opportunities
 #define ExtraBreak(c) (	( (c) >= 0x3040 && (c) <= 0x30FF ) ||	\
 						( (c) >= 0x3300 && (c) <= 0x9FAF )		\
 					)
 
 /*
 Prerequisite:
 The Line list must have either the objects with the correct Start/Len or be missing the lines altogether...
 */
 void LTextView4::PourText(size_t Start, ssize_t Length /* == 0 means it's a delete */)
 {
 	#if PROFILE_POUR
 	char _txt[256];
 	sprintf_s(_txt, sizeof(_txt), "%p::PourText Lines=%i Sz=%i", this, (int)Line.Length(), (int)Size);
 	LProfile Prof(_txt);
 	#endif
 
 	LAssert(InThread());
 
 	LRect Client = GetClient();
 	int Mx = Client.X() - d->rPadding.x1 - d->rPadding.x2;
 	int Cy = 0;
 	MaxX = 0;
 
 	ssize_t Idx = -1;
 	LTextLine *Cur = GetTextLine(Start, &Idx);
 	if (!Cur || !Cur->r.Valid())
 	{
 		// Find the last line that has a valid position...
 		for (int64_t mid, s = 0, e = Idx >= 0 ? Idx : Line.Length() - 1; s < e; )
 		{
 			if (e - s <= 1)
 			{
 				if (Line[e]->r.Valid())
 					mid = e;
 				else
 					mid = s;
 
 				Cur = Line[mid];
 				Cy = Cur->r.y1;
 				Idx = mid;
 				break;
 			}
 			else mid = s + ((e - s) >> 1);
 
 			auto sItem = Line[mid];
 			if (sItem->r.Valid())
 				s = mid + 1; // Search Mid->e
 			else
 				e = mid - 1; // Search s->Mid
 		}
 	}
 	if (Cur && !Cur->r.Valid())
 		Cur = NULL;
 	if (Cur)
 	{
 		Cy = Cur->r.y1;
 		Start = Cur->Start;
 		Length = Size - Start;
 	}
 	else
 	{
 		Idx = 0;
 		Start = 0;
 		Length = Size;
 	}
 			
 	if (!Text || !Font || Mx <= 0)
 		return;
 
 	// Tracking vars
 	ssize_t e;
 	int WrapCol = GetWrapAtCol();
 
 	LDisplayString Sp(Font, " ", 1);
 	int WidthOfSpace = Sp.X();
 	if (WidthOfSpace < 1)
 	{
 		printf("%s:%i - WidthOfSpace test failed.\n", _FL);
 		return;
 	}
 
 	// Alright... lets pour!
 	uint64 StartTs = LCurrentTime();
 	if (WrapType == TEXTED_WRAP_NONE)
 	{
 		// Find the dimensions of each line that is missing a rect
 		#if PROFILE_POUR
 		Prof.Add("NoWrap: ExistingLines");
 		#endif
 		#ifdef _DEGBUG
 		LStringPipe Log(1024);
 		Log.Printf("Pour: " LPrintfSizeT ", " LPrintfSSizeT ", partial=%i\n", Start, Length, PartialPour);
 		#endif
 
 		ssize_t Pos = 0;
 		for (; Idx < (ssize_t)Line.Length(); Idx++)
 		{
 			LTextLine *l = Line[Idx];
 
 			#ifdef _DEGBUG
 			Log.Printf("	[%i] exist: r.val=%i\n", Idx, l->r.Valid());
 			#endif
 
 			if (!l->r.Valid()) // If the layout is not valid...
 			{
 				LDisplayString ds(Font, Text + l->Start, l->Len);
 
 				l->r.x1 = d->rPadding.x1;
 				l->r.x2 = l->r.x1 + ds.X();
 
 				MaxX = MAX(MaxX, l->r.X());
 			}
 
 			// Adjust the y position anyway... it's free.
 			l->r.y1 = Cy;
 			l->r.y2 = l->r.y1 + LineY - 1;
 			Cy = l->r.y2 + 1;
 			Pos = l->Start + l->Len;
 			if (Text[Pos] == '\n')
 				Pos++;
 		}
 
 		// Now if we are missing lines as well, create them and lay them out
 		#if PROFILE_POUR
 		Prof.Add("NoWrap: NewLines");
 		#endif
 		while (Pos < Size)
 		{
 			LTextLine *l = new LTextLine;
 			l->Start = Pos;
 			char16 *c = Text + Pos;
 			char16 *e = c;
 			while (*e && *e != '\n')
 				e++;
 			l->Len = e - c;
 
 			#ifdef _DEGBUG
 			Log.Printf("	[%i] new: start=" LPrintfSSizeT ", len=" LPrintfSSizeT "\n", Idx, l->Start, l->Len);
 			#endif
 
 			l->r.x1 = d->rPadding.x1;
 			l->r.y1 = Cy;
 			l->r.y2 = l->r.y1 + LineY - 1;
 			if (l->Len)
 			{
 				LDisplayString ds(Font, Text + l->Start, l->Len);
 				l->r.x2 = l->r.x1 + ds.X();
 			}
 			else
 			{
 				l->r.x2 = l->r.x1;
 			}
 
 			LAssert(l->Len > 0);
 			Line.Add(l);
 
 			if (*e == '\n')
 				e++;
 
 			MaxX = MAX(MaxX, l->r.X());
 			Cy = l->r.y2 + 1;
 			Pos = e - Text;
 			Idx++;
 		}
 
 		#ifdef _DEGBUG
 		d->PourLog = Log.NewGStr();
 		#endif
 		PartialPour = false;
 	}
 	else // Wrap text
 	{
 		int DisplayStart = ScrollYLine();
 		int DisplayLines = 	(Client.Y() + LineY - 1) / LineY;
 		int DisplayEnd = DisplayStart + DisplayLines;
 		
 		// Pouring is split into 2 parts... 
 		// 1) pouring to the end of the displayed text.
 		// 2) pouring from there to the end of the document.
 		//	potentially taking several goes to complete the full pour
 		// This allows the document to display and edit faster..
 		bool PourToDisplayEnd = Line.Length() < DisplayEnd;
 
 		#if 0
 		LgiTrace("Idx=%i, DisplayStart=%i, DisplayLines=%i, DisplayEnd=%i, PourToDisplayEnd=%i\n",
 			Idx, DisplayStart, DisplayLines, DisplayEnd, PourToDisplayEnd);
 		#endif
 
 		if ((ssize_t)Line.Length() > Idx)
 		{
 			for (size_t i=Idx; i<Line.Length(); i++)
 				delete Line[i];
 			Line.Length(Idx);
 			Cur = NULL;
 		}
 
 		int Cx = 0;
 		ssize_t i;
 		for (i=Start; i<Size; i = e)
 		{
 			// seek till next char of interest
 			e = i;
 			int	Width = 0;
 
 			// Find break point
 			if (WrapCol)
 			{
 				// Wrap at column
 					
 				// Find the end of line
 				while (true)
 				{
 					if (e >= Size ||
 						Text[e] == '\n' ||
 						(e-i) >= WrapCol)
 					{
 						break;
 					}
 
 					e++;
 				}
 
 				// Seek back some characters if we are mid word
 				size_t OldE = e;
 				if (e < Size &&
 					Text[e] != '\n')
 				{
 					while (e > i)
 					{
 						if (ExitLoop(Text[e]) ||
 							ExtraBreak(Text[e]))
 						{
 							break;
 						}
 
 						e--;
 					}
 				}
 
 				if (e == i)
 				{
 					// No line break at all, so seek forward instead
 					for (e=OldE; e < Size && Text[e] != '\n'; e++)
 					{
 						if (ExitLoop(Text[e]) ||
 							ExtraBreak(Text[e]))
 							break;
 					}
 				}
 
 				// Calc the width
 				LDisplayString ds(Font, Text + i, e - i);
 				Width = ds.X();
 			}
 			else
 			{
 				// Wrap to edge of screen
 				ssize_t PrevExitChar = -1;
 				int PrevX = -1;
 
 				while (true)
 				{
 					if (e >= Size ||
 						ExitLoop(Text[e]) ||
 						ExtraBreak(Text[e]))
 					{
 						LDisplayString ds(Font, Text + i, e - i);
 						if (ds.X() + Cx > Mx)
 						{
 							if (PrevExitChar > 0)
 							{
 								e = PrevExitChar;
 								Width = PrevX;
 							}
 							else
 							{
 								Width = ds.X();
 							}
 							break;
 						}
 						else if (e >= Size ||
 								Text[e] == '\n')							
 						{
 							Width = ds.X();
 							break;
 						}
 							
 						PrevExitChar = e;
 						PrevX = ds.X();
 					}
 						
 					e++;
 				}
 			}
 
 			// Create layout line
 			LTextLine *l = new LTextLine;
 			if (l)
 			{
 				l->Start = i;
 				l->Len = e - i;
 				l->r.x1 = d->rPadding.x1;
 				l->r.x2 = l->r.x1 + Width - 1;
 
 				l->r.y1 = Cy;
 				l->r.y2 = l->r.y1 + LineY - 1;
 
 				LAssert(l->Len > 0);
 				Line.Add(l);
 				if (PourToDisplayEnd)
 				{
 					if (Line.Length() > DisplayEnd)
 					{
 						// We have reached the end of the displayed area... so
 						// exit out temporarily to display the layout to the user
 						PartialPour = true;
 						break;
 					}
 				}
 				else
 				{
 					// Otherwise check if we are taking too long...
 					if (Line.Length() % 20 == 0)
 					{
 						uint64 Now = LCurrentTime();
 						if (Now - StartTs > WRAP_POUR_TIMEOUT)
 						{
 							PartialPour = true;
 							// LgiTrace("Pour timeout...\n");
 							break;
 						}
 					}
 				}
 					
 				MaxX = MAX(MaxX, l->r.X());
 				Cy += LineY;
 					
 				if (e < Size)
 					e++;
 			}
 		}
 
 		if (i >= Size)
 			PartialPour = false;
 		SendNotify(LNotifyCursorChanged);
 	}
 
 	#ifdef _DEBUG
 	ValidateLines(true);
 	#endif
 	#if PROFILE_POUR
 	Prof.Add("LastLine");
 	#endif
 
 	if (!PartialPour)
 	{
 		auto It = Line.rbegin();
 		LTextLine *Last = It != Line.end() ? *It : NULL;
 		if (!Last ||
 			Last->Start + Last->Len < Size)
 		{
 			auto LastEnd = Last ? Last->End() : 0;
 			LTextLine *l = new LTextLine;
 			if (l)
 			{
 				l->Start = LastEnd;
 				l->Len = Size - LastEnd;
 				l->r.x1 = l->r.x2 = d->rPadding.x1;
 				l->r.y1 = Cy;
 				l->r.y2 = l->r.y1 + LineY - 1;
 
 				Line.Add(l);
 			
 				MaxX = MAX(MaxX, l->r.X());
 				Cy += LineY;
 			}
 		}
 	}
 
 	bool ScrollYNeeded = Client.Y() < (Line.Length() * LineY);
 	bool ScrollChange = ScrollYNeeded ^ (VScroll != NULL);
 	d->LayoutDirty = WrapType != TEXTED_WRAP_NONE && ScrollChange;
 	#if PROFILE_POUR
 	static LString _s;
 	_s.Printf("ScrollBars dirty=%i", d->LayoutDirty);
 	Prof.Add(_s);
 	#endif
 
 	if (ScrollChange)
 	{
 		// LgiTrace("%s:%i - SetScrollBars(%i) %i %i\n", _FL, ScrollYNeeded, Client.Y(), (Line.Length() * LineY));
 		SetScrollBars(false, ScrollYNeeded);
 	}
 	UpdateScrollBars();
 	
 	#if 0 // def _DEBUG
 	if (GetWindow())
 	{
 		static char s[256];
 		sprintf_s(s, sizeof(s), "Pour: %.2f sec", (double)_PourTime / 1000);
 		GetWindow()->PostEvent(M_TEXTVIEW_DEBUG_TEXT, (LMessage::Param)s);
 	}
 	#endif
 
 	#if POUR_DEBUG
 	printf("Lines=%i\n", Line.Length());
 	int Index = 0;
 	for (LTextLine *l=Line.First(); l; l=Line.Next(), Index++)
 	{
 		printf("\t[%i] %i,%i (%s)\n", Index, l->Start, l->Len, l->r.Describe());
 	}
 	#endif
 }
 
 bool LTextView4::InsertStyle(LAutoPtr<LStyle> s)
 {
 	if (!s)
 		return false;
 
 	LAssert(s->Start >= 0);
 	LAssert(s->Len > 0);
 	ssize_t Last = 0;
 	// int n = 0;
 
 	// LgiTrace("StartStyle=%i,%i(%i) %s\n", (int)s->Start, (int)s->Len, (int)(s->Start+s->Len), s->Fore.GetStr());
 
 	if (Style.Length() > 0)
 	{
 		// Optimize for last in the list
 		auto Last = Style.rbegin();
 		if (s->Start >= (ssize_t)Last->End())
 		{
 			Style.Insert(*s);
 			return true;
 		}
 	}
 
 	for (auto i = Style.begin(); i != Style.end(); i++)
 	{
 		if (s->Overlap(*i))
 		{
 			if (s->Owner > i->Owner)
 			{
 				// Fail the insert
 				return false;
 			}
 			else
 			{
 				// Replace mode...
 				*i = *s;
 				return true;
 			}
 		}
 
 		if (s->Start >= Last && s->Start < i->Start)
 		{
 			Style.Insert(*s, i);
 			return true;
 		}
 	}
 
 	Style.Insert(*s);
 	return true;
 }
 
 LTextView4::LStyle *LTextView4::GetNextStyle(StyleIter &s, ssize_t Where)
 {
 	if (Where >= 0)
 		s = Style.begin();
 	else
 		s++;
 
 	while (s != Style.end())
 	{
 		// determine whether style is relevant..
 		// styles in the selected region are ignored
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 		if (SelStart >= 0 &&
 			s->Start >= Min &&
 			s->Start+s->Len < Max)
 		{
 			// style is completely inside selection: ignore
 			s++;
 		}
 		else if (Where >= 0 &&
 			s->Start+s->Len < Where)
 		{
 			s++;
 		}
 		else
 		{
 			return &(*s);
 		}
 	}
 
 	return NULL;
 }
 
 #if 0
 CURSOR_CHAR GetCursor()
 {
 	#ifdef WIN32
 	LArray<int> Ver;
 	int Os = LGetOs(&Ver);
 	if ((Os == LGI_OS_WIN32 || Os == LGI_OS_WIN64) &&
 		Ver[0] >= 5)
 	{
 		return MAKEINTRESOURCE(32649); // hand
 	}
 	else
 	{
 		return IDC_ARROW;
 	}
 	#endif
 	return 0;
 }
 #endif
 
 LTextView4::LStyle *LTextView4::HitStyle(ssize_t i)
 {
 	for (auto &s : Style)
 	{
 		if (i >= s.Start && i < (ssize_t)s.End())
 		{
 			return &s;
 		}
 	}
 
 	return NULL;
 }
 
 void LTextView4::PourStyle(size_t Start, ssize_t EditSize)
 {
 	#ifdef _DEBUG
 	int64 StartTime = LCurrentTime();
 	#endif
 
 	LAssert(InThread());
 
 	if (!Text || Size < 1)
 		return;
 
 	ssize_t Length = MAX(EditSize, 0);
 	if ((ssize_t)Start + Length >= Size)
 		Length = Size - Start; // For deletes, this sizes the edit length within bounds.
 
 	// Expand re-style are to word boundaries before and after the area of change
 	while (Start > 0 && UrlChar(Text[Start-1]))
 	{
 		// Move the start back
 		Start--;
 		Length++;
 	}
 	while ((ssize_t)Start + Length < Size && UrlChar(Text[Start+Length]))
 	{
 		// Move the end back
 		Length++;
 	}
 
 	// Delete all the styles that we own inside the changed area
 	for (StyleIter s = Style.begin(); s != Style.end();)
 	{
 		if (s->Owner == STYLE_NONE)
 		{
 			if (EditSize > 0)
 			{
 				if (s->Overlap(Start, EditSize < 0 ? -EditSize : EditSize))
 				{
 					Style.Delete(s);
 					continue;
 				}
 			}
 			else
 			{
 				if (s->Overlap(Start, -EditSize))
 				{
 					Style.Delete(s);
 					continue;
 				}
 			}
 		}
 
 		s++;
 	}
 
 	if (UrlDetect)
 	{		
 		LArray<LLinkInfo> Links;		
 		LAssert((ssize_t)Start + Length <= Size);		
 		if (LDetectLinks(Links, Text + Start, Length))
 		{
 			for (uint32_t i=0; i<Links.Length(); i++)
 			{
 				LLinkInfo &Inf = Links[i];
                 LAutoPtr<LStyle> Url(new LStyle(STYLE_URL));
 				if (Url)
 				{
 					Url->View = this;
 					Url->Start = Inf.Start + Start;
 					Url->Len = Inf.Len;
 					Url->Font = Underline;
 					Url->Fore = d->UrlColour;
 
 					InsertStyle(Url);
 				}
 			}
 		}
 	}
 
 	#ifdef _DEBUG
 	_StyleTime = LCurrentTime() - StartTime;
 	#endif
 }
 
 bool LTextView4::Insert(size_t At, const char16 *Data, ssize_t Len)
 {
 	static int count = -1;
 	count++;
 
 	LProfile Prof("LTextView4::Insert");
 	Prof.HideResultsIfBelow(1000);
 
 	LAssert(InThread());
 	
 	if (!ReadOnly && Len > 0)
 	{
 		if (!Data)
 			return false;
 
 		// limit input to valid data
 		At = MIN(Size, (ssize_t)At);
 
 		// make sure we have enough memory
 		size_t NewAlloc = Size + Len + 1;
 		NewAlloc += ALLOC_BLOCK - (NewAlloc % ALLOC_BLOCK);
 		if (NewAlloc != Alloc)
 		{
 			char16 *NewText = new char16[NewAlloc];
 			if (NewText)
 			{
 				if (Text)
 				{
 					// copy any existing data across
 					memcpy(NewText, Text, (Size + 1) * sizeof(char16));
 				}
 
 				DeleteArray(Text);
 				Text = NewText;
 				Alloc = NewAlloc;
 			}
 			else
 			{
 				// memory allocation error
 				return false;
 			}
 		}
 		
 		Prof.Add("MemChk");
 
 		if (Text)
 		{
 			// Insert the data
 
 			// Move the section after the insert to make space...
 			memmove(Text+(At+Len), Text+At, (Size-At) * sizeof(char16));
 
 			Prof.Add("Cpy");
 
 			// Copy new data in...
 			memcpy(Text+At, Data, Len * sizeof(char16));
 			Size += Len;
 			Text[Size] = 0; // NULL terminate
 
 			Prof.Add("Undo");
 			
 			// Add the undo object...
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView4Undo> Obj;
 				if (!UndoCur)
 					Obj.Reset(new LTextView4Undo(this));
 				auto u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(At, Len, UndoInsert);
 				else
 					LAssert(!"No undo obj?");
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			// Clear layout info for the new text
 			ssize_t Idx = -1;
 			LTextLine *Cur = NULL;
 			
 			if (Line.Length() == 0)
 			{
 				// Empty doc... set up the first line
 				Line.Add(Cur = new LTextLine);
 				Idx = 0;
 				Cur->Start = 0;
 			}
 			else
 			{
 				Cur = GetTextLine(At, &Idx);
 			}
 
 			if (Cur)
 			{
 				if (WrapType == TEXTED_WRAP_NONE)
 				{
 					// Clear layout for current line...
 					Cur->r.ZOff(-1, -1);
 
 					Prof.Add("NoWrap add lines");
 					
 					// Add any new lines that we need...
 					char16 *e = Text + At + Len;
 					char16 *c;
 					for (c = Text + At; c < e; c++)
 					{
 						if (*c == '\n')
 						{
 							// Set the size of the current line...
 							size_t Pos = c - Text;
 							Cur->Len = Pos - Cur->Start;
 
 							// Create a new line...
 							Cur = new LTextLine();
 							if (!Cur)
 								return false;
 							Cur->Start = Pos + 1;
 							Line.AddAt(++Idx, Cur);
 						}
 					}
 
 					Prof.Add("CalcLen");
 
 					// Make sure the last Line's length is set..
 					Cur->CalcLen(Text);
 
 					Prof.Add("UpdatePos");
 	
 					// Now update all the positions of the following lines...
 					for (size_t i = ++Idx; i < Line.Length(); i++)
 						Line[i]->Start += Len;
 				}
 				else
 				{
 					// Clear all lines to the end of the doc...
 					LgiTrace("ClearLines %i\n", (int)Idx+1);
 					for (size_t i = ++Idx; i < Line.Length(); i++)
 						delete Line[i];
 					Line.Length(Idx);
 				}
 			}
 			else
 			{
 				// If wrap is on then this can happen when an Insert happens before the 
 				// OnPulse event has laid out the new text. Probably not a good thing in
 				// non-wrap mode			
 				if (WrapType == TEXTED_WRAP_NONE)
 				{
 					LTextLine *l = *Line.rbegin();
 					printf("%s:%i - Insert error: no cur, At=%i, Size=%i, Lines=%i, WrapType=%i\n",
 						_FL, (int)At, (int)Size, (int)Line.Length(), (int)WrapType);
 					if (l)
 						printf("Last=%i, %i\n", (int)l->Start, (int)l->Len);
 				}
 			}
 
 			#ifdef _DEBUG
 			// Prof.Add("Validate");
 			// ValidateLines();
 			#endif
 
 			if (AdjustStylePos)
 				AdjustStyles(At, Len);
 
 			Dirty = true;
 			if (PourEnabled)
 			{
 				Prof.Add("PourText");
 				PourText(At, Len);
 				Prof.Add("PourStyle");
 				auto Start = LCurrentTime();
 				PourStyle(At, Len);
 				auto End = LCurrentTime();
 				if (End - Start > 1000)
 				{
 					PourStyle(At, Len);
 				}
 			}
 			SendNotify(LNotifyDocChanged);
 
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool LTextView4::Delete(size_t At, ssize_t Len)
 {
 	bool Status = false;
 
 	LAssert(InThread());
 
 	if (!ReadOnly)
 	{
 		// limit input
 		At = MAX(At, 0);
 		At = MIN((ssize_t)At, Size);
 		Len = MIN(Size-(ssize_t)At, Len);
 
 		if (Len > 0)
 		{
 			int HasNewLine = 0;
 
 			for (int i=0; i<Len; i++)
 			{
 				if (Text[At + i] == '\n')
 					HasNewLine++;
 			}
 
 			// do delete
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView4Undo> Obj(new LTextView4Undo(this));
 				LTextView4Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(At, Len, UndoDelete);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			memmove(Text+At, Text+(At+Len), (Size-At-Len) * sizeof(char16));
 			Size -= Len;
 			Text[Size] = 0;
 
 			if (WrapType == TEXTED_WRAP_NONE)
 			{
 				ssize_t Idx = -1;
 				LTextLine *Cur = GetTextLine(At, &Idx);
 				if (Cur)
 				{
 					Cur->r.ZOff(-1, -1);
 
 					// Delete some lines...
 					for (int i=0; i<HasNewLine; i++)
 					{
 						LTextLine *l = Line[Idx + 1];
 						delete l;
 						Line.DeleteAt(Idx + 1);
 					}
 
 					// Correct the current line's length
 					Cur->CalcLen(Text);
 
 					// Shift all further lines down...
 					for (size_t i = Idx + 1; i < Line.Length(); i++)
 						Line[i]->Start -= Len;
 				}
 			}
 			else
 			{
 				ssize_t Index;
 				LTextLine *Cur = GetTextLine(At, &Index);
 				if (Cur)
 				{
 					for (size_t i = Index; i < Line.Length(); i++)
 						delete Line[i];
 					Line.Length(Index);
 				}
 			}
 			
 
 			Dirty = true;
 			Status = true;
 
 			#ifdef _DEBUG
 			ValidateLines();
 			#endif
 
 			if (AdjustStylePos)
 				AdjustStyles(At, -Len);
 
 			if (PourEnabled)
 			{
 				PourText(At, -Len);
 				PourStyle(At, -Len);
 			}
 			
 			if (Cursor >= (ssize_t)At && Cursor <= (ssize_t)At + Len)
 			{
 				SetCaret(At, false, HasNewLine != 0);
 			}
 
 			// Handle repainting in flowed mode, when the line starts change
 			if (WrapType == TEXTED_WRAP_REFLOW)
 			{
 				ssize_t Index;
 				LTextLine *Cur = GetTextLine(At, &Index);
 				if (Cur)
 				{
 					LRect r = Cur->r;
 					r.x2 = GetClient().x2;
 					r.y2 = GetClient().y2;
 					Invalidate(&r);
 				}
 			}
 
 			SendNotify(LNotifyDocChanged);
 			Status = true;
 		}
 	}
 
 	return Status;
 }
 
 void LTextView4::DeleteSelection(char16 **Cut)
 {
 	if (SelStart >= 0)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		if (Cut)
 		{
 			*Cut = NewStrW(Text + Min, Max - Min);
 		}
 
 		Delete(Min, Max - Min);
 		SetCaret(Min, false, true);
 	}
 }
 
 LArray<LTextView4::LTextLine*>::I LTextView4::GetTextLineIt(ssize_t Offset, ssize_t *Index)
 {
 	if (Line.Length() == 0)
 	{
 		if (Index)
 			*Index = 0;
 		return Line.end();
 	}
 	if (Offset <= 0)
 	{
 		if (Index)
 			*Index = 0;
 		return Line.begin();
 	}
 	else if (Line.Length())
 	{
 		auto l = Line.Last();
 		if (Offset > l->End())
 		{
 			if (Index)
 				*Index = Line.Length() - 1;
 			return Line.begin(Line.Length()-1);
 		}
 	}
 
 	size_t mid = 0, s = 0, e = Line.Length() - 1;
 	while (s < e)
 	{
 		if (e - s <= 1)
 		{
 			if (Line[s]->Overlap(Offset))
 				mid = s;
 			else if (Line[e]->Overlap(Offset))
 				mid = e;
 			else
 			{
 				LAssert(!"Needs to match Line s or e...");
 				break;
 			}
 		}
 		else mid = s + ((e - s) >> 1);
 		
 		auto l = Line[mid];
 		auto end = l->End();
 
 		if (Offset < l->Start)
 			e = mid - 1;
 		else if (Offset > end)
 			s = mid + 1;
 		else
 		{
 			LAssert(Line[mid]->Overlap(Offset));
 			if (Index)
 				*Index = mid;
 			return Line.begin(mid);
 		}
 	}
 
 	LAssert(Line[s]->Overlap(Offset));
 	if (Index)
 		*Index = s;
 	return Line.begin(s);
 }
 
 int64 LTextView4::Value()
 {
 	auto n = Name();
 	#ifdef _MSC_VER
 	return (n) ? _atoi64(n) : 0;
 	#else
 	return (n) ? atoll(n) : 0;
 	#endif
 }
 
 void LTextView4::Value(int64 i)
 {
 	char Str[32];
 	sprintf_s(Str, sizeof(Str), LPrintfInt64, i);
 	Name(Str);
 }
 
 LString LTextView4::operator[](ssize_t LineIdx)
 {
 	if (LineIdx <= 0 || LineIdx > (ssize_t)GetLines())
 		return LString();
 
 	LTextLine *Ln = Line[LineIdx-1];
 	if (!Ln)
 		return LString();
 
 	LString s(Text + Ln->Start, Ln->Len);
 	return s; 
 }
 
 const char *LTextView4::Name()
 {
 	UndoQue.Empty();
 	DeleteArray(TextCache);
 	TextCache = WideToUtf8(Text);
 
 	return TextCache;
 }
 
 bool LTextView4::Name(const char *s)
 {
 	if (InThread())
 	{
 		UndoQue.Empty();
 		DeleteArray(TextCache);
 		DeleteArray(Text);
 		Line.DeleteObjects();
 		Style.Empty();
 
 		LAssert(LIsUtf8(s));
 		Text = Utf8ToWide(s);
 		if (!Text)
 		{
 			Text = new char16[1];
 			if (Text) *Text = 0;
 		}
 
 		Size = Text ? StrlenW(Text) : 0;
 		Alloc = Size + 1;
 		Cursor = MIN(Cursor, Size);
 		if (Text)
 		{
 			// Remove '\r's
 			char16 *o = Text;
 			for (char16 *i=Text; *i; i++)
 			{
 				if (*i != '\r')
 				{
 					*o++ = *i;
 				}
 				else Size--;
 			}
 			*o++ = 0;
 		}
 		
 		// update everything else
 		d->SetDirty(0, Size);
 		PourText(0, Size);
 		PourStyle(0, Size);
 		UpdateScrollBars();
 		Invalidate();
 	}
 	else if (d->Lock(_FL))
 	{
 		if (IsAttached())
 		{
 			d->SetName = s;
 			PostEvent(M_TEXT_UPDATE_NAME);
 		}
 		else LAssert(!"Can't post event to detached/virtual window.");
 		d->Unlock();
 	}
 
 	return true;
 }
 
 const char16 *LTextView4::NameW()
 {
 	return Text;
 }
 
 bool LTextView4::NameW(const char16 *s)
 {
 	DeleteArray(Text);
 	Size = s ? StrlenW(s) : 0;
 	Alloc = Size + 1;
 	Text = new char16[Alloc];
 	Cursor = MIN(Cursor, Size);
 	if (Text)
 	{
 		memcpy(Text, s, Size * sizeof(char16));
 
 		// remove LF's
 		int In = 0, Out = 0;
 		CrLf = false;
 		for (; In<Size; In++)
 		{
 			if (Text[In] != '\r')
 			{
 				Text[Out++] = Text[In];
 			}
 			else
 			{
 				CrLf = true;
 			}
 		}
 		Size = Out;
 		Text[Size] = 0;
 
 	}
 
 	// update everything else
 	Line.DeleteObjects();
 	Style.Empty();
 	d->SetDirty(0, Size);
 	PourText(0, Size);
 	PourStyle(0, Size);
 	UpdateScrollBars();
 	Invalidate();
 
 	return true;
 }
 
 LRange LTextView4::GetSelectionRange()
 {
 	LRange r;
 	if (HasSelection())
 	{
 		r.Start = MIN(SelStart, SelEnd);
 		ssize_t End = MAX(SelStart, SelEnd);
 		r.Len = End - r.Start;
 	}
 	return r;
 }
 
 char *LTextView4::GetSelection()
 {
 	LRange s = GetSelectionRange();
 	if (s.Len > 0)
 	{
 		return (char*)LNewConvertCp("utf-8", Text + s.Start, LGI_WideCharset, s.Len*sizeof(Text[0]) );
 	}
 
 	return 0;
 }
 
 bool LTextView4::HasSelection()
 {
 	return (SelStart >= 0) && (SelStart != SelEnd);
 }
 
 void LTextView4::SelectAll()
 {
 	SelStart = 0;
 	SelEnd = Size;
 	Invalidate();
 }
 
 void LTextView4::UnSelectAll()
 {
 	bool Update = HasSelection();
 
 	SelStart = -1;
 	SelEnd = -1;
 
 	if (Update)
 	{
 		Invalidate();
 	}
 }
 
 size_t LTextView4::GetLines()
 {
 	return Line.Length();
 }
 
 void LTextView4::GetTextExtent(int &x, int &y)
 {
 	PourText(0, Size);
 
 	x = MaxX + d->rPadding.x1;
 	y = (int)(Line.Length() * LineY);
 }
 
 bool LTextView4::GetLineColumnAtIndex(LPoint &Pt, ssize_t Index)
 {
 	ssize_t FromIndex = 0;
 	LTextLine *From = GetTextLine(Index < 0 ? Cursor : Index, &FromIndex);
 	if (!From)
 		return false;
 
 	Pt.x = (int) (Cursor - From->Start);
 	Pt.y = (int) FromIndex;
 	return true;
 }
 
 ssize_t LTextView4::GetCaret(bool Cur)
 {
 	if (Cur)
 	{
 		return Cursor;
 	}
 
 	return 0;
 }
 
 ssize_t LTextView4::IndexAt(int x, int y)
 {
 	LTextLine *l = Line.ItemAt(y);
 	if (l)
 	{
 		return l->Start + MIN(x, l->Len);
 	}
 
 	return 0;
 }
 
 bool LTextView4::ScrollToOffset(size_t Off)
 {
 	bool ForceFullUpdate = false;
 	ssize_t ToIndex = 0;
 	LTextLine *To = GetTextLine(Off, &ToIndex);
 	if (To)
 	{
 		LRect Client = GetClient();
 		int DisplayLines = Client.Y() / LineY;
 
 		if (VScroll)
 		{
 			if (ToIndex < VScroll->Value())
 			{
 				// Above the visible region...
 				if (d->CenterCursor)
 				{
 					ssize_t i = ToIndex - (DisplayLines >> 1);
 					VScroll->Value(MAX(0, i));
 				}
 				else
 				{
 					VScroll->Value(ToIndex);
 				}
 				ForceFullUpdate = true;
 			}
 
 			if (ToIndex >= VScroll->Value() + DisplayLines)
 			{
 				int YOff = d->CenterCursor ? DisplayLines >> 1 : DisplayLines;
 			
 				ssize_t v = MIN(ToIndex - YOff + 1, (ssize_t)Line.Length() - DisplayLines);
 				if (v != VScroll->Value())
 				{
 					// Below the visible region
 					VScroll->Value(v);
 					ForceFullUpdate = true;
 				}
 			}
 		}
 		else
 		{
 			d->VScrollCache = ToIndex;
 		}
 	}
 
 	return ForceFullUpdate;
 }
 
 void LTextView4::SetCaret(size_t i, bool Select, bool ForceFullUpdate)
 {
     // int _Start = LCurrentTime();
 	Blink = true;
 
 	// Bound the new cursor position to the document
 	if ((ssize_t)i > Size) i = Size;
 
 	// Store the old selection and cursor
 	ssize_t s = SelStart, e = SelEnd, c = Cursor;
 	
 	// If there is going to be a selected area
 	if (Select && i != SelStart)
 	{
 		// Then set the start
 		if (SelStart < 0)
 		{
 			// We are starting a new selection
 			SelStart = Cursor;
 		}
 
 		// And end
 		SelEnd = i;
 	}
 	else
 	{
 		// Clear the selection
 		SelStart = SelEnd = -1;
 	}
 
 	ssize_t FromIndex = 0;
 	LTextLine *From = GetTextLine(Cursor, &FromIndex);
 
 	Cursor = i;
 
 	// check the cursor is on the screen
 	ForceFullUpdate |= ScrollToOffset(Cursor);
 
 	// check whether we need to update the screen
 	ssize_t ToIndex = 0;
 	LTextLine *To = GetTextLine(Cursor, &ToIndex);
 	if (ForceFullUpdate ||
 		!To ||
 		!From)
 	{
 		// need full update
 		Invalidate();
 	}
 	else if
 	(
 		(
 			SelStart != s
 			||
 			SelEnd != e
 		)
 	)
 	{
 		// Update just the selection bounds
 		LRect Client = GetClient();
 		size_t Start, End;
 		if (SelStart >= 0 && s >= 0)
 		{
 			// Selection has changed, union the before and after regions
 			Start = MIN(Cursor, c);
 			End = MAX(Cursor, c);
 		}
 		else if (SelStart >= 0)
 		{
 			// Selection created...
 			Start = MIN(SelStart, SelEnd);
 			End = MAX(SelStart, SelEnd);
 		}
 		else if (s >= 0)
 		{
 			// Selection removed...
 			Start = MIN(s, e);
 			End = MAX(s, e);
 		}
 		else return;
 
 		LTextLine *SLine = GetTextLine(Start);
 		LTextLine *ELine = GetTextLine(End);
 		LRect u;
 		if (SLine && ELine)
 		{
 			if (SLine->r.Valid())
 			{
 				u = DocToScreen(SLine->r);
 			}
 			else
 				u.Set(0, 0, Client.X()-1, 1); // Start of visible page 
 			
 			LRect b(0, Client.Y()-1, Client.X()-1, Client.Y()-1);
 			if (ELine->r.Valid())
 			{
 				b = DocToScreen(ELine->r);
 			}
 			else
 			{
 				b.Set(0, Client.Y()-1, Client.X()-1, Client.Y()-1);
 			}
 			u.Union(&b);
 			
 			u.x1 = 0;
 			u.x2 = X();
 		}
 		else
 		{
 			/*
 			printf("%s,%i - Couldn't get SLine and ELine: %i->%p, %i->%p\n",
 				_FL,
 				(int)Start, SLine,
 				(int)End, ELine);
 			*/
 			u = Client;
 		}
 
 		Invalidate(&u);			
 	}
 	else if (Cursor != c)
 	{
 		// just the cursor has moved
 
 		// update the line the cursor moved to
 		LRect r = To->r;
 		r.Offset(-ScrollX, d->rPadding.y1-DocOffset);
 		r.x2 = X();
 		Invalidate(&r);
 
 		if (To != From)
 		{
 			// update the line the cursor came from,
 			// if it's a different line from the "to"
 			r = From->r;
 			r.Offset(-ScrollX, d->rPadding.y1-DocOffset);
 			r.x2 = X();
 			Invalidate(&r);
 		}
 	}
 
 	if (c != Cursor)
 	{
 		// Send off notify
 		SendNotify(LNotifyCursorChanged);
 	}
 
 //int _Time = LCurrentTime() - _Start;
 //printf("Setcursor=%ims\n", _Time);
 }
 
 void LTextView4::SetBorder(int b)
 {
 }
 
 bool LTextView4::Cut()
 {
 	bool Status = false;
 	char16 *Txt16 = 0;
 	
 	DeleteSelection(&Txt16);
 	if (Txt16)
 	{
 		#ifdef WIN32
 		Txt16 = ConvertToCrLf(Txt16);
 		#endif
 		char *Txt8 = (char*)LNewConvertCp(LAnsiToLgiCp(), Txt16, LGI_WideCharset);
 
 		LClipBoard Clip(this);
 
 		Clip.Text(Txt8);
 		Status = Clip.TextW(Txt16, false);
 		
 		DeleteArray(Txt8);
 		DeleteArray(Txt16);
 	}
 
 	return Status;
 }
 
 bool LTextView4::Copy()
 {
 	bool Status = true;
 
 	if (SelStart >= 0)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		#ifdef WIN32
 		char16 *Txt16 = NewStrW(Text+Min, Max-Min);
 		Txt16 = ConvertToCrLf(Txt16);
 		char *Txt8 = (char*)LNewConvertCp(LAnsiToLgiCp(), Txt16, LGI_WideCharset);
 		#else
 		char *Txt8 = (char*)LNewConvertCp("utf-8", Text+Min, LGI_WideCharset, (Max-Min)*sizeof(*Text));
 		#endif
 
 		LClipBoard Clip(this);
 		
 		Clip.Text(Txt8);
 		#ifdef WIN32
 		Clip.TextW(Txt16, false);
 		DeleteArray(Txt16);
 		#endif
 		
 		DeleteArray(Txt8);
 	}
 	else LgiTrace("%s:%i - No selection.\n", _FL);
 
 	return Status;
 }
 
 bool LTextView4::Paste()
 {
 	LClipBoard Clip(this);
 
 	LAutoWString Mem;
 	char16 *t = Clip.TextW();
 	if (!t) // ala Win9x
 	{
 		char *s = Clip.Text();
 		if (s)
 		{
 			Mem.Reset(Utf8ToWide(s));
 			t = Mem;
 		}
 	}
 	
 	if (!t)
 		return false;
 
 	if (SelStart >= 0)
 	{
 		DeleteSelection();
 	}
 
 	// remove '\r's
 	char16 *s = t, *d = t;
 	for (; *s; s++)
 	{
 		if (*s != '\r')
 		{
 			*d++ = *s;
 		}
 	}
 	*d++ = 0;
 
 	// insert text
 	ssize_t Len = StrlenW(t);
 	Insert(Cursor, t, Len);
 	SetCaret(Cursor+Len, false, true); // Multiline
 	
 	return true;
 }
 
 void LTextView4::ClearDirty(std::function<void(bool)> OnStatus, bool Ask, const char *FileName)
 {
 	if (Dirty)
 	{
 		int Answer = (Ask) ? LgiMsg(this,
 									LLoadString(L_TEXTCTRL_ASK_SAVE, "Do you want to save your changes to this document?"),
 									LLoadString(L_TEXTCTRL_SAVE, "Save"),
 									MB_YESNOCANCEL) : IDYES;
 		if (Answer == IDYES)
 		{
 			auto DoSave = [&](bool ok)
 			{
 				Save(FileName);				
 				if (OnStatus)
 					OnStatus(ok);
 			};
 			
 			if (!FileName)
 			{
 				LFileSelect *Select = new LFileSelect;
 				Select->Parent(this);
 				Select->Save([&FileName, &DoSave](auto Select, auto ok)
 				{
 					if (ok)
 						FileName = Select->Name();					
 					DoSave(ok);
 					delete Select;
 				});
 			}
 			else DoSave(true);
 		}
 		else if (Answer == IDCANCEL)
 		{
 			if (OnStatus)
 				OnStatus(false);
 			return;
 		}
 	}
 
 	if (OnStatus)
 		OnStatus(true);
 }
 
 bool LTextView4::Open(const char *Name, const char *CharSet)
 {
 	bool Status = false;
 	LFile f;
 
 	if (f.Open(Name, O_READ|O_SHARE))
 	{
 		DeleteArray(Text);
 		int64 Bytes = f.GetSize();
 		if (Bytes < 0 || Bytes & 0xffff000000000000LL)
 		{
 			LgiTrace("%s:%i - Invalid file size: " LPrintfInt64 "\n", _FL, Bytes);
 			return false;
 		}
 			
 		SetCaret(0, false);
 		Line.DeleteObjects();
 		
 		char *c8 = new char[Bytes + 4];
 		if (c8)
 		{
 			if (f.Read(c8, (int)Bytes) == Bytes)
 			{
 				char *DataStart = c8;
 
 				c8[Bytes] = 0;
 				c8[Bytes+1] = 0;
 				c8[Bytes+2] = 0;
 				c8[Bytes+3] = 0;
 				
 				if ((uchar)c8[0] == 0xff && (uchar)c8[1] == 0xfe)
 				{
 					// utf-16
 					if (!CharSet)
 					{
 						CharSet = "utf-16";
 						DataStart += 2;
 					}
 				}
 				
 				// Convert to unicode first....
 				if (Bytes == 0)
 				{
 					Text = new char16[1];
 					if (Text) Text[0] = 0;
 				}
 				else
 				{
 					Text = (char16*)LNewConvertCp(LGI_WideCharset, DataStart, CharSet ? CharSet : DefaultCharset);
 				}
 				
 				if (Text)
 				{
 					// Remove LF's
 					char16 *In = Text, *Out = Text;
 					CrLf = false;
 					Size = 0;
 					while (*In)
 					{
 						if (*In >= ' ' ||
 							*In == '\t' ||
 							*In == '\n')
 						{
 							*Out++ = *In;
 							Size++;
 						}
 						else if (*In == '\r')
 						{
 							CrLf = true;
 						}
 						In++;
 					}
 					Size = (int) (Out - Text);
 					*Out = 0;
 
 					Alloc = Size + 1;
 					Dirty = false;
 					
 					if (Text && Text[0] == 0xfeff) // unicode byte order mark
 					{
 						memmove(Text, Text+1, Size * sizeof(*Text));
 						Size--;
 					}
 
 					PourText(0, Size);
 					PourStyle(0, Size);
 					UpdateScrollBars(true);
 					
 					Status = true;
 				}
 			}
 
 			DeleteArray(c8);
 		}
 		else
 		{
 			Alloc = Size = 0;
 		}
 
 		Invalidate();
 	}
 
 	return Status;
 }
 
 template<typename T>
 bool WriteToStream(LFile &out, T *in, size_t len, bool CrLf)
 {
 	if (!in)
 		return false;
 	
 	if (CrLf)
 	{
 		int BufLen = 1 << 20;
 		LAutoPtr<T,true> Buf(new T[BufLen]);
 		T *b = Buf;
 		T *e = Buf + BufLen;
 		T *c = in;
 		T *end = c + len;
 		
 		while (c < end)
 		{
 			if (b > e - 16)
 			{
 				auto Bytes = (b - Buf) * sizeof(T);
 				if (out.Write(Buf, Bytes) != Bytes)
 					return false;
 				
 				b = Buf;
 			}
 			
 			if (*c == '\n')
 			{
 				*b++ = '\r';
 				*b++ = '\n';
 			}
 			else
 			{
 				*b++ = *c;
 			}
 			c++;
 		}
 
 		auto Bytes = (b - Buf) * sizeof(T);
 		if (out.Write(Buf, Bytes) != Bytes)
 			return false;
 	}
 	else
 	{
 		auto Bytes = len * sizeof(T);
 		if (out.Write(in, Bytes) != Bytes)
 			return false;
 	}
 
 	return true;
 }
 
 bool LTextView4::Save(const char *Name, const char *CharSet)
 {
 	LFile f;
 	LString TmpName;
 	bool Status = false;
 	
 	d->LastError.Empty();
 
 	if (f.Open(Name, O_WRITE))
 	{
 		if (f.SetSize(0) != 0)
 		{
 			// Can't resize file, fall back to renaming it and 
 			// writing a new file...
 			f.Close();
 			TmpName = Name;
 			TmpName += ".tmp";
 			if (!FileDev->Move(Name, TmpName))
 			{
 				LgiTrace("%s:%i - Failed to move '%s'.\n", _FL, Name);
 				return false;
 			}
 
 			if (!f.Open(Name, O_WRITE))
 			{
 				LgiTrace("%s:%i - Failed to open '%s' for writing.\n", _FL, Name);
 				return false;
 			}
 		}
 
 		if (Text)
 		{
 			auto InSize = Size * sizeof(char16);
 			if (CharSet && !Stricmp(CharSet, "utf-16"))
 			{
 				if (sizeof(*Text) == 2)
 				{
 					// No conversion needed...
 					Status = WriteToStream(f, Text, Size, CrLf);
 				}
 				else
 				{
 					// 32->16 convert
 					LAutoPtr<uint16_t,true> c16((uint16_t*)LNewConvertCp(CharSet, Text, LGI_WideCharset, InSize));
 					if (c16)
 						Status = WriteToStream(f, c16.Get(), Strlen(c16.Get()), CrLf);
 				}
 			}
 			else if (CharSet && !Stricmp(CharSet, "utf-32"))
 			{
 				if (sizeof(*Text) == 4)
 				{
 					// No conversion needed...
 					Status = WriteToStream(f, Text, Size, CrLf);
 				}
 				else
 				{
 					// 16->32 convert
 					LAutoPtr<uint32_t,true> c32((uint32_t*)LNewConvertCp(CharSet, Text, LGI_WideCharset, InSize));
 					if (c32)
 						Status = WriteToStream(f, c32.Get(), Strlen(c32.Get()), CrLf);
 				}
 			}
 			else
 			{
 				LAutoString c8((char*)LNewConvertCp(CharSet ? CharSet : DefaultCharset, Text, LGI_WideCharset, InSize));
 				if (c8)
 					Status = WriteToStream(f, c8.Get(), strlen(c8), CrLf);
 			}
 
 			if (Status)
 				Dirty = false;
 		}
 	}
 	else
 	{
 		int Err = f.GetError();
 		LString sErr = LErrorCodeToString(Err);		
 		d->LastError.Printf("Failed to open '%s' for writing: %i - %s\n", Name, Err, sErr.Get());
 	}
 
 	if (TmpName)
 		FileDev->Delete(TmpName);
 
 	return Status;
 }
 
 const char *LTextView4::GetLastError()
 {
 	return d->LastError;
 }
 
 void LTextView4::UpdateScrollBars(bool Reset)
 {
 	if (VScroll)
 	{
 		LRect Before = GetClient();
 
 		int DisplayLines = Y() / LineY;
 		ssize_t Lines = GetLines();
 		VScroll->SetRange(Lines);
 		if (VScroll)
 		{
 			VScroll->SetPage(DisplayLines);
 			
 			ssize_t Max = Lines - DisplayLines + 1;
 			bool Inval = false;
 			if (VScroll->Value() > Max)
 			{
 				VScroll->Value(Max);
 				Inval = true;
 			}
 
 			if (Reset)
 			{
 				VScroll->Value(0);
 				SelStart = SelEnd = -1;
 			}
 			else if (d->VScrollCache >= 0)
 			{
 				VScroll->Value(d->VScrollCache);
 				d->VScrollCache = -1;
 				SelStart = SelEnd = -1;
 			}
 
 			LRect After = GetClient();
 
 			if (Before != After && GetWrapType())
 			{
 				d->SetDirty(0, Size);
 				Inval = true;
 			}
 			
 			if (Inval)
 			{
 				Invalidate();
 			}
 		}
 	}
 }
 
 void LTextView4::DoCase(std::function<void(bool)> Callback, bool Upper)
 {
 	if (Text)
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		if (Min < Max)
 		{
 			if (UndoOn)
 			{
 				LAutoPtr<LTextView4Undo> Obj(new LTextView4Undo(this));
 				LTextView4Undo *u = UndoCur ? UndoCur : Obj;
 				if (u)
 					u->AddChange(Min, Max - Min, UndoChange);
 				if (Obj)
 					UndoQue += Obj.Release();
 			}
 
 			for (ssize_t i=Min; i<Max; i++)
 			{
 				if (Upper)
 				{
 					if (Text[i] >= 'a' && Text[i] <= 'z')
 						Text[i] = Text[i] - 'a' + 'A';
 				}
 				else
 				{
 					if (Text[i] >= 'A' && Text[i] <= 'Z')
 						Text[i] = Text[i] - 'A' + 'a';
 				}
 			}
 
 			Dirty = true;
 			d->SetDirty(Min, 0);
 			Invalidate();
 
 			SendNotify(LNotifyDocChanged);
 		}
 	}
 	
 	if (Callback)
 		Callback(Text != NULL);
 }
 
 ssize_t LTextView4::GetLine()
 {
 	ssize_t Idx = 0;
 	GetTextLine(Cursor, &Idx);
 	return Idx + 1;
 }
 
 void LTextView4::SetLine(int64_t i)
 {
 	LTextLine *l = Line.ItemAt(i - 1);
 	if (l)
 	{
 		d->CenterCursor = true;
 		SetCaret(l->Start, false);
 		d->CenterCursor = false;
 	}
 }
 
 void LTextView4::DoGoto(std::function<void(bool)> Callback)
 {
 	LInput *Dlg = new LInput(this, "", LLoadString(L_TEXTCTRL_GOTO_LINE, "Goto line:"), "Text");	
 	Dlg->DoModal([this, Dlg, Callback](auto d, auto code)
 	{
 		auto ok = code == IDOK && Dlg->GetStr();
 		if (ok)
 			SetLine(Dlg->GetStr().Int());
 		if (Callback)
 			Callback(ok);
 		delete Dlg;
 	});
 }
 
 LDocFindReplaceParams *LTextView4::CreateFindReplaceParams()
 {
 	return new GDocFindReplaceParams4;
 }
 
 void LTextView4::SetFindReplaceParams(LDocFindReplaceParams *Params)
 {
 	if (Params)
 	{
 		if (d->OwnFindReplaceParams)
 		{
 			DeleteObj(d->FindReplaceParams);
 		}
 		
 		d->OwnFindReplaceParams = false;
 		d->FindReplaceParams = (GDocFindReplaceParams4*) Params;
 	}
 }
 
 void LTextView4::DoFindNext(std::function<void(bool)> Callback)
 {
 	bool Status = false;
 	if (InThread())
 	{
 		if (d->FindReplaceParams->Lock(_FL))
 		{
 			if (d->FindReplaceParams->LastFind)
 				Status = OnFind(d->FindReplaceParams->LastFind,
 								d->FindReplaceParams->MatchWord,
 								d->FindReplaceParams->MatchCase,
 								d->FindReplaceParams->SelectionOnly,
 								d->FindReplaceParams->SearchUpwards);
 							
 			d->FindReplaceParams->Unlock();
 		}
 	}
 	else if (IsAttached())
 	{
 		Status = PostEvent(M_TEXTVIEW_FIND);
 	}
 	if (Callback)
 		Callback(Status);
 }
 
 void LTextView4::DoFind(std::function<void(bool)> Callback)
 {
 	LString u;
 
 	if (HasSelection())
 	{
 		ssize_t Min = MIN(SelStart, SelEnd);
 		ssize_t Max = MAX(SelStart, SelEnd);
 
 		u = LString(Text + Min, Max - Min);
 	}
 	else
 	{
 		u = d->FindReplaceParams->LastFind.Get();
 	}
 
-	LFindDlg Dlg(this, [View=this, Params=d->FindReplaceParams, Callback](LFindReplaceCommon *Dlg, int Action)
-	{
-		if (Params &&
-			Params->Lock(_FL))
+	auto Dlg = new LFindDlg(this, [this, Params=d->FindReplaceParams, Callback](auto Dlg, auto Action)
 		{
-			Params->MatchWord = Dlg->MatchWord;
-			Params->MatchCase = Dlg->MatchCase;
-			Params->SelectionOnly = Dlg->SelectionOnly;
-			Params->SearchUpwards = Dlg->SearchUpwards;
-			Params->LastFind.Reset(Utf8ToWide(Dlg->Find));
+			if (Params &&
+				Params->Lock(_FL))
+			{
+				Params->MatchWord = Dlg->MatchWord;
+				Params->MatchCase = Dlg->MatchCase;
+				Params->SelectionOnly = Dlg->SelectionOnly;
+				Params->SearchUpwards = Dlg->SearchUpwards;
+				Params->LastFind.Reset(Utf8ToWide(Dlg->Find));
 		
-			Params->Unlock();
-		}
-
-		View->DoFindNext([View, Callback](bool ok)
-		{
-			View->Focus(true);
-			if (Callback)
-				Callback(ok);
-		});
-	}, u);
-
-	Dlg.DoModal(NULL);
+				Params->Unlock();
+			}
+
+			DoFindNext([this, Callback](bool ok)
+			{
+				Focus(true);
+				if (Callback)
+					Callback(ok);
+			});
+		},
+		u);
+
+	Dlg->DoModal(NULL);
 }
 
 void LTextView4::DoReplace(std::function<void(bool)> Callback)
 {
 	bool SingleLineSelection = false;
 	SingleLineSelection = HasSelection();
 	if (SingleLineSelection)
 	{
 		LRange Sel = GetSelectionRange();
 		for (ssize_t i = Sel.Start; i < Sel.End(); i++)
 		{
 			if (Text[i] == '\n')
 			{
 				SingleLineSelection = false;
 				break;
 			}
 		}
 	}
 
-	char *LastFind8 = SingleLineSelection ? GetSelection() : WideToUtf8(d->FindReplaceParams->LastFind);
-	char *LastReplace8 = WideToUtf8(d->FindReplaceParams->LastReplace);
+	LAutoString LastFind8(SingleLineSelection ? GetSelection() : WideToUtf8(d->FindReplaceParams->LastFind));
+	LAutoString LastReplace8(WideToUtf8(d->FindReplaceParams->LastReplace));
 	
-	LReplaceDlg Dlg(this,
-		[&](LFindReplaceCommon *Dlg, int Action)
+	auto Dlg = new LReplaceDlg(this,
+		[this](auto Dlg, auto Action)
 		{
 			LReplaceDlg *Replace = dynamic_cast<LReplaceDlg*>(Dlg);
 			LAssert(Replace != NULL);
 
-			DeleteArray(LastFind8);
-			DeleteArray(LastReplace8);
-
 			if (Action == IDCANCEL)
 				return;
 
 			if (d->FindReplaceParams->Lock(_FL))
 			{
 				d->FindReplaceParams->LastFind.Reset(Utf8ToWide(Replace->Find));
 				d->FindReplaceParams->LastReplace.Reset(Utf8ToWide(Replace->Replace));
 				d->FindReplaceParams->MatchWord = Replace->MatchWord;
 				d->FindReplaceParams->MatchCase = Replace->MatchCase;
 				d->FindReplaceParams->SelectionOnly = Replace->SelectionOnly;
 					
 				switch (Action)
 				{
 					case IDC_FR_FIND:
 					{
 						OnFind(	d->FindReplaceParams->LastFind,
 								d->FindReplaceParams->MatchWord,
 								d->FindReplaceParams->MatchCase,
 								d->FindReplaceParams->SelectionOnly,
 								d->FindReplaceParams->SearchUpwards);
 						break;
 					}
 					case IDOK:
 					case IDC_FR_REPLACE:
 					{
 						OnReplace(	d->FindReplaceParams->LastFind,
 									d->FindReplaceParams->LastReplace,
 									Action == IDOK,
 									d->FindReplaceParams->MatchWord,
 									d->FindReplaceParams->MatchCase,
 									d->FindReplaceParams->SelectionOnly,
 									d->FindReplaceParams->SearchUpwards);
 						break;
 					}
 				}
 
 				d->FindReplaceParams->Unlock();
 			}
 		},
 		LastFind8,
 		LastReplace8);
 
-	Dlg.MatchWord = d->FindReplaceParams->MatchWord;
-	Dlg.MatchCase = d->FindReplaceParams->MatchCase;
-	Dlg.SelectionOnly = HasSelection();
-
-	Dlg.DoModal(NULL);
+	Dlg->MatchWord = d->FindReplaceParams->MatchWord;
+	Dlg->MatchCase = d->FindReplaceParams->MatchCase;
+	Dlg->SelectionOnly = HasSelection();
+
+	Dlg->DoModal(NULL);
 }
 
 void LTextView4::SelectWord(size_t From)
 {
 	for (SelStart = From; SelStart > 0; SelStart--)
 	{
 		if (strchr(SelectWordDelim, Text[SelStart]))
 		{
 			SelStart++;
 			break;
 		}
 	}
 
 	for (SelEnd = From; SelEnd < Size; SelEnd++)
 	{
 		if (strchr(SelectWordDelim, Text[SelEnd]))
 		{
 			break;
 		}
 	}
 
 	Invalidate();
 }
 
 typedef int (*StringCompareFn)(const char16 *a, const char16 *b, ssize_t n);
 
 ptrdiff_t LTextView4::MatchText(const char16 *Find, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	if (!ValidStrW(Find))
 		return -1;
 
 	ssize_t FindLen = StrlenW(Find);
 		
 	// Setup range to search
 	ssize_t Begin, End;
 	if (SelectionOnly && HasSelection())
 	{
 		Begin = MIN(SelStart, SelEnd);
 		End = MAX(SelStart, SelEnd);
 	}
 	else
 	{
 		Begin = 0;
 		End = Size;
 	}
 
 	// Look through text...
 	ssize_t i;
 	bool Wrap = false;
 	if (Cursor > End - FindLen)
 	{
 		Wrap = true;
 		if (SearchUpwards)
 			i = End - FindLen;
 		else
 			i = Begin;
 	}
 	else
 	{
 		i = Cursor;
 	}
 		
 	if (i < Begin) i = Begin;
 	if (i > End) i = End;
 	
 	StringCompareFn CmpFn = MatchCase ? StrncmpW : StrnicmpW;
 	char16 FindCh = MatchCase ? Find[0] : toupper(Find[0]);
 
 	for (; SearchUpwards ? i >= Begin : i <= End - FindLen; i += SearchUpwards ? -1 : 1)
 	{
 		if
 		(
 			(MatchCase ? Text[i] : toupper(Text[i]))
 			==
 			FindCh
 		)
 		{
 			char16 *Possible = Text + i;
 
 			if (CmpFn(Possible, Find, FindLen) == 0)
 			{
 				if (MatchWord)
 				{
 					// Check boundaries
 							
 					if (Possible > Text) // Check off the start
 					{
 						if (!IsWordBoundry(Possible[-1]))
 							continue;
 					}
 					if (i + FindLen < Size) // Check off the end
 					{
 						if (!IsWordBoundry(Possible[FindLen]))
 							continue;
 					}
 				}
 						
 				LRange r(Possible - Text, FindLen);
 				if (!r.Overlap(Cursor))
 					return r.Start;
 			}
 		}
 				
 		if (!Wrap && (i + 1 > End - FindLen))
 		{
 			Wrap = true;
 			i = Begin;
 			End = Cursor;
 		}
 	}
 	
 	return -1;
 }
 
 bool LTextView4::OnFind(const char16 *Find, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	THREAD_CHECK();
 
 	// Not sure what this is doing???
 	if (HasSelection() &&
 		SelEnd < SelStart)
 	{
 		Cursor = SelStart;
 	}
 
 	#if FEATURE_HILIGHT_ALL_MATCHES
 
 	// Clear existing styles for matches
 	for (StyleIter s = Style.begin(); s != Style.end(); )
 	{
 		if (s->Owner == STYLE_FIND_MATCHES)
 			Style.Delete(s);
 		else
 			s++;
 	}
 
 	ssize_t FindLen = StrlenW(Find);
 	ssize_t FirstLoc = MatchText(Find, MatchWord, MatchCase, false, SearchUpwards), Loc;
 	if (FirstLoc >= 0)
 	{
 		SetCaret(FirstLoc, false);
 		SetCaret(FirstLoc + FindLen, true);
 	}
 
 	ssize_t Old = Cursor;
 	if (!SearchUpwards)
 		Cursor += FindLen;
 	
 	while ((Loc = MatchText(Find, MatchWord, MatchCase, false, false)) != FirstLoc)
 	{
 		LAutoPtr<LStyle> s(new LStyle(STYLE_FIND_MATCHES));
 		s->Start = Loc;
 		s->Len = FindLen;
 		s->Fore = LColour(L_FOCUS_SEL_FORE);
 		s->Back = LColour(L_FOCUS_SEL_BACK).Mix(LColour(L_WORKSPACE));
 		InsertStyle(s);
 
 		Cursor = Loc + FindLen;
 	}
 
 	Cursor = Old;
 	ScrollToOffset(Cursor);
 	Invalidate();
 
 	#else
 
 	ssize_t Loc = MatchText(Find, MatchWord, MatchCase, SelectionOnly, SearchUpwards);
 	if (Loc >= 0)
 	{
 		SetCaret(Loc, false);
 		SetCaret(Loc + StrlenW(Find), true);
 		return true;
 	}
 
 	#endif
 
 	return false;
 }
 
 bool LTextView4::OnReplace(const char16 *Find, const char16 *Replace, bool All, bool MatchWord, bool MatchCase, bool SelectionOnly, bool SearchUpwards)
 {
 	THREAD_CHECK();
 
 	if (ValidStrW(Find))
 	{
 		// int Max = -1;
 		ssize_t FindLen = StrlenW(Find);
 		ssize_t ReplaceLen = StrlenW(Replace);
 		// size_t OldCursor = Cursor;
 		ptrdiff_t First = -1;
 
 		while (true)
 		{
 			ptrdiff_t Loc = MatchText(Find, MatchWord, MatchCase, SelectionOnly, SearchUpwards);
 			if (First < 0)
 			{
 				First = Loc;
 			}
 			else if (Loc == First)
 			{
 				break;
 			}
 			
 			if (Loc >= 0)
 			{
 				ssize_t OldSelStart = SelStart;
 				ssize_t OldSelEnd = SelEnd;
 				
 				Delete(Loc, FindLen);
 				Insert(Loc, Replace, ReplaceLen);
 				
 				SelStart = OldSelStart;
 				SelEnd = OldSelEnd - FindLen + ReplaceLen;
 				Cursor = Loc + ReplaceLen;
 			}
 			if (!All)
 			{
 				return Loc >= 0;
 			}
 			if (Loc < 0) break;
 		}
 	}	
 	
 	return false;
 }
 
 ssize_t LTextView4::SeekLine(ssize_t Offset, GTextViewSeek Where)
 {
 	THREAD_CHECK();
 
 	switch (Where)
 	{
 		case PrevLine:
 		{
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 			
 			if (Offset > 0)
 				Offset--;
 			
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 
 			if (Offset > 0)
 				Offset++;
 			break;
 		}
 		case NextLine:
 		{
 			for (; Offset < Size && Text[Offset] != '\n'; Offset++)
 				;
 
 			Offset++;
 			break;
 		}
 		case StartLine:
 		{
 			for (; Offset > 0 && Text[Offset] != '\n'; Offset--)
 				;
 
 			if (Offset > 0)
 				Offset++;
 			break;
 		}
  		case EndLine:
 		{
 			for (; Offset < Size && Text[Offset] != '\n'; Offset++)
 				;
 			break;
 		}
 		default:
 		{
 			LAssert(false);
 			break;
 		}
 	}
 
 	return Offset;
 }
 
 bool LTextView4::OnMultiLineTab(bool In)
 {
 	bool Status = false;
 	ssize_t Min = MIN(SelStart, SelEnd);
 	ssize_t Max = MAX(SelStart, SelEnd), i;
 
 	Min = SeekLine(Min, StartLine);
 
 	int Ls = 0;
 	LArray<ssize_t> p;
 	for (i=Min; i<Max && i<Size; i=SeekLine(i, NextLine))
 	{
 		p.Add(i);
 		Ls++;
 	}
 	if (Max < i)
 	{
 		Max = SeekLine(Max, EndLine);
 	}
 
 	PourEnabled = false;
 
 	ssize_t *Indexes = p.AddressOf(0);
 	if (!Indexes)
 		return false;
 
 	UndoCur = new LTextView4Undo(this);
 
 	for (i=Ls-1; i>=0; i--)
 	{
 		if (In)
 		{
 			// <-
 			ssize_t n = Indexes[i], Space = 0;
 			for (; Space<IndentSize && n<Size; n++)
 			{
 				if (Text[n] == 9)
 				{
 					Space += IndentSize;
 				}
 				else if (Text[n] == ' ')
 				{
 					Space += 1;
 				}
 				else
 				{
 					break;
 				}
 			}
 
 			ssize_t Chs = n-Indexes[i];
 			Delete(Indexes[i], Chs);
 			Max -= Chs;
 		}
 		else
 		{
 			// ->
 			ssize_t Len = Indexes[i];
 			for (; Text[Len] != '\n' && Len<Size; Len++);
 			if (Len > Indexes[i])
 			{
 				if (HardTabs)
 				{
 					char16 Tab[] = {'\t', 0};
 					Insert(Indexes[i], Tab, 1);
 					Max++;
 				}
 				else
 				{
 					char16 *Sp = new char16[IndentSize];
 					if (Sp)
 					{
 						for (int n=0; n<IndentSize; n++)
 							Sp[n] = ' ';
 						Insert(Indexes[i], Sp, IndentSize);
 						Max += IndentSize;
 					}
 				}
 			}
 		}
 	}
 
 	if (UndoCur->Changes.Length())
 	{
 		UndoQue += UndoCur;
 		UndoCur = NULL;
 	}
 	else
 	{
 		DeleteObj(UndoCur);
 	}
 
 	SelStart = Min;
 	SelEnd = Cursor = Max;
 
 	PourEnabled = true;
 	PourText(Min, Max - Min);
 	PourStyle(Min, Max - Min);
 	
 	d->SetDirty(Min, Max-Min);
 	Invalidate();
 	Status = true;
 
 	return Status;
 }
 
 void LTextView4::OnSetHidden(int Hidden)
 {
 }
 
 void LTextView4::OnPosChange()
 {
 	static bool Processing = false;
 
 	if (!Processing)
 	{
 		Processing = true;
 		LLayout::OnPosChange();
 
 		LRect c = GetClient();
 		bool ScrollYNeeded = c.Y() < (Line.Length() * LineY);
 		bool ScrollChange = ScrollYNeeded ^ (VScroll != NULL);
 		if (ScrollChange)
 		{
 			// printf("%s:%i - SetScrollBars(%i)\n", _FL, ScrollYNeeded);
 			SetScrollBars(false, ScrollYNeeded);
 		}
 		UpdateScrollBars();
 
 		if (GetWrapType() && d->PourX != X())
 		{
 			d->PourX = X();
 			d->SetDirty(0, Size);
 		}
 		Processing = false;
 	}
 }
 
 int LTextView4::WillAccept(LDragFormats &Formats, LPoint Pt, int KeyState)
 {
 	Formats.Supports("text/uri-list");
 	Formats.Supports("text/html");
 	Formats.Supports("UniformResourceLocatorW");
 	return Formats.Length() ? DROPEFFECT_COPY : DROPEFFECT_NONE;
 }
 
 int LTextView4::OnDrop(LArray<LDragData> &Data, LPoint Pt, int KeyState)
 {
 	int Status = DROPEFFECT_NONE;
 	
 	for (unsigned i=0; i<Data.Length(); i++)
 	{
 		LDragData &dd = Data[i];
 		if (dd.Data.Length() <= 0)
 			continue;
 		
 		if (dd.IsFormat("text/html") || dd.IsFormat("UniformResourceLocatorW"))
 		{
 			LVariant *Data = &dd.Data[0];
 			LAssert(dd.Data.Length() == 1); // Impl multiple data entries if this asserts.
 			if (Data->IsBinary())
 			{
 				OsChar *e = (OsChar*) ((char*)Data->Value.Binary.Data + Data->Value.Binary.Length);
 				OsChar *s = (OsChar*) Data->Value.Binary.Data;
 				int len = 0;
 				while (s < e && s[len])
 				{
 					len++;
 				}
 				
 				LAutoWString w
 				(
 					(char16*)LNewConvertCp
 					(
 						LGI_WideCharset,
 						s,
 						(
 							sizeof(OsChar) == 1
 							?
 							"utf-8"
 							:
 							LGI_WideCharset
 						),
 						len * sizeof(*s)
 					)
 				);
 				
 				Insert(Cursor, w, len);
 				Invalidate();
 				return DROPEFFECT_COPY;
 			}
 		}
 		else if (dd.IsFileDrop())
 		{
 			// We don't directly handle file drops... pass up to the parent
 			bool FoundTarget = false;
 			for (LViewI *p = GetParent(); p; p = p->GetParent())
 			{
 				LDragDropTarget *t = p->DropTarget();
 				if (t)
 				{
 					Status = t->OnDrop(Data, Pt, KeyState);
 					if (Status != DROPEFFECT_NONE)
 					{
 						FoundTarget = true;
 						break;
 					}
 				}
 			}
 			if (!FoundTarget)
 			{
 				auto Wnd = GetWindow();
 				if (Wnd)
 				{
 					LDropFiles files(dd);
 					Wnd->OnReceiveFiles(files);
 				}
 			}
 		}
 	}
 
 	return Status;
 }
 
 void LTextView4::OnCreate()
 {
 	SetWindow(this);
 	DropTarget(true);
 
 	#ifndef WINDOWS
 	if (Ctrls.Length() == 0)
 	#endif
 		SetPulse(PULSE_TIMEOUT);
 	#ifndef WINDOWS
 	Ctrls.Add(this);
 	#endif
 }
 
 void LTextView4::OnEscape(LKey &K)
 {
 }
 
 bool LTextView4::OnMouseWheel(double l)
 {
 	if (VScroll)
 	{
 		int64 NewPos = VScroll->Value() + (int)l;
 		NewPos = limit(NewPos, 0, (ssize_t)GetLines());
 		VScroll->Value(NewPos);
 		Invalidate();
 	}
 	
 	return true;
 }
 
 void LTextView4::OnFocus(bool f)
 {
 	Invalidate();
 }
 
 ssize_t LTextView4::HitText(int x, int y, bool Nearest)
 {
 	if (!Text)
 		return 0;
 
 	bool Down = y >= 0;
 	auto Y = VScroll ? VScroll->Value() : 0;
 	if (Y < (ssize_t)Line.Length())
 		y += Line[Y]->r.y1;
 
 	while (Y>=0 && Y<(ssize_t)Line.Length())
 	{
 		auto l = Line[Y];
 
 		if (l->r.Overlap(x, y))
 		{
 			// Over a line
 			int At = x - l->r.x1;
 			ssize_t Char = 0;
 				
 			LDisplayString Ds(Font, MapText(Text + l->Start, l->Len), l->Len, 0);
 			Char = Ds.CharAt(At, Nearest ? LgiNearest : LgiTruncate);
 
 			return l->Start + Char;
 		}
 		else if (y >= l->r.y1 && y <= l->r.y2)
 		{
 			// Click horizontally before of after line
 			if (x < l->r.x1)
 				return l->Start;
 			else if (x > l->r.x2)
 				return l->Start + l->Len;
 		}
 			
 		if (Down)
 			Y++;
 		else
 			Y--;
 	}
 
 	// outside text area
 	if (Down)
 	{
 		if (Line.Length())
 		{
 			if (y > Line.Last()->r.y2)
 			{
 				// end of document
 				return Size;
 			}
 		}
 	}
 
 	return 0;
 }
 
 void LTextView4::Undo()
 {
 	int Old = UndoQue.GetPos();
 	UndoQue.Undo();
 	if (Old && !UndoQue.GetPos())
 	{
 		Dirty = false;
 		SendNotify(LNotifyDocChanged);
 	}
 }
 
 void LTextView4::Redo()
 {
 	UndoQue.Redo();
 }
 
 void LTextView4::DoContextMenu(LMouse &m)
 {
 	LSubMenu RClick;
 	LAutoString ClipText;
 	{
 		LClipBoard Clip(this);
 		ClipText.Reset(NewStr(Clip.Text()));
 	}
 
 	LStyle *s = HitStyle(HitText(m.x, m.y, true));
 	if (s)
 	{
 		if (OnStyleMenu(s, &RClick))
 		{
 			RClick.AppendSeparator();
 		}
 	}
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_CUT, "Cut"), IDM_CUT, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_COPY, "Copy"), IDM_COPY, HasSelection());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_PASTE, "Paste"), IDM_PASTE, ClipText != 0);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem("Copy All", IDM_COPY_ALL, true);
 	RClick.AppendItem("Select All", IDM_SELECT_ALL, true);
 	RClick.AppendSeparator();
 
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_UNDO, "Undo"), IDM_UNDO, UndoQue.CanUndo());
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_REDO, "Redo"), IDM_REDO, UndoQue.CanRedo());
 	RClick.AppendSeparator();
 
 	auto i = RClick.AppendItem(LLoadString(L_TEXTCTRL_FIXED, "Fixed Width Font"), IDM_FIXED, true);
 	if (i) i->Checked(GetFixedWidthFont());
 
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_AUTO_INDENT, "Auto Indent"), IDM_AUTO_INDENT, true);
 	if (i) i->Checked(AutoIndent);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_SHOW_WHITESPACE, "Show Whitespace"), IDM_SHOW_WHITE, true);
 	if (i) i->Checked(ShowWhiteSpace);
 	
 	i = RClick.AppendItem(LLoadString(L_TEXTCTRL_HARD_TABS, "Hard Tabs"), IDM_HARD_TABS, true);
 	if (i) i->Checked(HardTabs);
 	
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_INDENT_SIZE, "Indent Size"), IDM_INDENT_SIZE, true);
 	RClick.AppendItem(LLoadString(L_TEXTCTRL_TAB_SIZE, "Tab Size"), IDM_TAB_SIZE, true);
 
 	if (Environment)
 		Environment->AppendItems(&RClick, NULL);
 
 	int Id = 0;
 	m.ToScreen();
 	switch (Id = RClick.Float(this, m))
 	{
 		case IDM_FIXED:
 		{
 			SetFixedWidthFont(!GetFixedWidthFont());							
 			SendNotify(LNotifyFixedWidthChanged);
 			break;
 		}
 		case IDM_CUT:
 		{
 			Cut();
 			break;
 		}
 		case IDM_COPY:
 		{
 			Copy();
 			break;
 		}
 		case IDM_PASTE:
 		{
 			Paste();
 			break;
 		}
 		case IDM_COPY_ALL:
 		{
 			SelectAll();
 			Copy();
 			break;
 		}
 		case IDM_SELECT_ALL:
 		{
 			SelectAll();
 			break;
 		}
 		case IDM_UNDO:
 		{
 			Undo();
 			break;
 		}
 		case IDM_REDO:
 		{
 			Redo();
 			break;
 		}
 		case IDM_AUTO_INDENT:
 		{
 			AutoIndent = !AutoIndent;
 			break;
 		}
 		case IDM_SHOW_WHITE:
 		{
 			ShowWhiteSpace = !ShowWhiteSpace;
 			Invalidate();
 			break;
 		}
 		case IDM_HARD_TABS:
 		{
 			HardTabs = !HardTabs;
 			break;
 		}
 		case IDM_INDENT_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", IndentSize);
 			
 			LInput *i = new LInput(this, s, "Indent Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto code)
 			{
 				if (code)
 					IndentSize = atoi(i->GetStr());
 				delete i;
 			});
 			break;
 		}
 		case IDM_TAB_SIZE:
 		{
 			char s[32];
 			sprintf_s(s, sizeof(s), "%i", TabSize);
 			
 			LInput *i = new LInput(this, s, "Tab Size:", "Text");
 			i->DoModal([this, i](auto dlg, auto code)
 			{
 				SetTabSize(atoi(i->GetStr()));
 				delete i;
 			});
 			break;
 		}
 		default:
 		{
 			if (s)
 			{
 				OnStyleMenuClick(s, Id);
 			}
 
 			if (Environment)
 			{
 				Environment->OnMenu(this, Id, 0);
 			}
 			break;
 		}
 	}
 }
 
 bool LTextView4::OnStyleClick(LStyle *style, LMouse *m)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			if
 			(
 				(!m)
 				||
 				(m->Left() && m->Down() && m->Double())
 			)
 			{
 				LString s(Text + style->Start, style->Len);
 				if (s)
 					OnUrl(s);
 				return true;
 			}
 			break;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 bool LTextView4::OnStyleMenu(LStyle *style, LSubMenu *m)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			LString s(Text + style->Start, style->Len);
 			if (LIsValidEmail(s))
 				m->AppendItem(LLoadString(L_TEXTCTRL_EMAIL_TO, "New Email to..."), IDM_NEW, true);
 			else
 				m->AppendItem(LLoadString(L_TEXTCTRL_OPENURL, "Open URL"), IDM_OPEN, true);
 
 			m->AppendItem(LLoadString(L_TEXTCTRL_COPYLINK, "Copy link location"), IDM_COPY_URL, true);
 			return true;
 		}
 		default:
 			break;
 	}
 
 	return false;
 }
 
 void LTextView4::OnStyleMenuClick(LStyle *style, int i)
 {
 	switch (style->Owner)
 	{
 		case STYLE_URL:
 		{
 			LString s(Text + style->Start, style->Len);
 
 			switch (i)
 			{
 				case IDM_NEW:
 				case IDM_OPEN:
 				{
 					if (s)
 						OnUrl(s);
 					break;
 				}
 				case IDM_COPY_URL:
 				{
 					if (s)
 					{
 						LClipBoard Clip(this);
 						Clip.Text(s);
 					}
 					break;
 				}
 			}
 			break;
 		}
 		default:
 			break;
 	}
 }
 
 void LTextView4::OnMouseClick(LMouse &m)
 {
 	bool Processed = false;
 
 	m.x += ScrollX;
 
 	if (m.Down())
 	{
 		if (!m.IsContextMenu())
 		{
 			Focus(true);
 
 			ssize_t Hit = HitText(m.x, m.y, true);
 			if (Hit >= 0)
 			{
 				SetCaret(Hit, m.Shift());
 
 				LStyle *s = HitStyle(Hit);
 				if (s)
 					Processed = OnStyleClick(s, &m);
 			}
 
 			if (!Processed && m.Double())
 			{
 				d->WordSelectMode = Cursor;
 				SelectWord(Cursor);
 			}
 			else
 			{
 				d->WordSelectMode = -1;
 			}
 		}
 		else
 		{
 			DoContextMenu(m);
 			return;
 		}
 	}
 
 	if (!Processed)
 	{
 		Capture(m.Down());
 	}
 }
 
 int LTextView4::OnHitTest(int x, int y)
 {
 	#ifdef WIN32
 	if (GetClient().Overlap(x, y))
 	{
 		return HTCLIENT;
 	}
 	#endif
 	return LView::OnHitTest(x, y);
 }
 
 void LTextView4::OnMouseMove(LMouse &m)
 {
 	m.x += ScrollX;
 
 	ssize_t Hit = HitText(m.x, m.y, true);
 	if (IsCapturing())
 	{
 		if (d->WordSelectMode < 0)
 		{
 			SetCaret(Hit, m.Left());
 		}
 		else
 		{
 			ssize_t Min = Hit < d->WordSelectMode ? Hit : d->WordSelectMode;
 			ssize_t Max = Hit > d->WordSelectMode ? Hit : d->WordSelectMode;
 
 			for (SelStart = Min; SelStart > 0; SelStart--)
 			{
 				if (strchr(SelectWordDelim, Text[SelStart]))
 				{
 					SelStart++;
 					break;
 				}
 			}
 
 			for (SelEnd = Max; SelEnd < Size; SelEnd++)
 			{
 				if (strchr(SelectWordDelim, Text[SelEnd]))
 				{
 					break;
 				}
 			}
 
 			Cursor = SelEnd;
 			Invalidate();
 		}
 	}
 }
 
 LCursor LTextView4::GetCursor(int x, int y)
 {
 	LRect c = GetClient();
 	c.Offset(-c.x1, -c.y1);
 	LStyle *s = NULL;
 	if (c.Overlap(x, y))
 	{
 		ssize_t Hit = HitText(x, y, true);
 		s = HitStyle(Hit);
 	}
 
 	return s ? s->Cursor : LCUR_Ibeam;
 }
 
 int LTextView4::GetColumn()
 {
 	int x = 0;
 	LTextLine *l = GetTextLine(Cursor);
 	if (l)
 	{
 		for (ssize_t i=l->Start; i<Cursor; i++)
 		{
 			if (Text[i] == '\t')
 			{
 				x += TabSize - (x % TabSize);
 			}
 			else
 			{
 				x++;
 			}
 		}
 	}
 	return x;
 }
 
 int LTextView4::SpaceDepth(char16 *Start, char16 *End)
 {
 	int Depth = 0;
 	while (Start < End)
 	{
 		if (*Start == '\t')
 			Depth += IndentSize - (Depth % IndentSize);
 		else if (*Start == ' ')
 			Depth ++;
 		else break;
 		Start++;
 	}
 	return Depth;
 }
 
 bool LTextView4::OnKey(LKey &k)
 {
 	if (k.Down())
 	{
 		Blink = true;
 	}
 
 	// k.Trace("LTextView4::OnKey");
 
 	if (k.IsContextMenu())
 	{
 		LMouse m;
 		m.x = CursorPos.x1;
 		m.y = CursorPos.y1 + (CursorPos.Y() >> 1);
 		m.Target = this;
 		DoContextMenu(m);
 	}
 	else if (k.IsChar)
 	{
 		switch (k.vkey)
 		{
 			default:
 			{
 				// process single char input
 				if
 				(
 					!GetReadOnly()
 					&&
 					(
 						(k.c16 >= ' ' || k.vkey == LK_TAB)
 						&&
 						k.c16 != 127
 					)
 				)
 				{
 					if (k.Down())
 					{
 						// letter/number etc
 						if (SelStart >= 0)
 						{
 							bool MultiLine = false;
 							if (k.vkey == LK_TAB)
 							{
 								size_t Min = MIN(SelStart, SelEnd), Max = MAX(SelStart, SelEnd);
 								for (size_t i=Min; i<Max; i++)
 								{
 									if (Text[i] == '\n')
 									{
 										MultiLine = true;
 									}
 								}
 							}
 							if (MultiLine)
 							{
 								if (OnMultiLineTab(k.Shift()))
 								{
 									return true;
 								}
 							}
 							else
 							{
 								DeleteSelection();
 							}
 						}
 						
 						LTextLine *l = GetTextLine(Cursor);
 						size_t Len = (l) ? l->Len : 0;
 						
 						if (l && k.vkey == LK_TAB && (!HardTabs || IndentSize != TabSize))
 						{
 							int x = GetColumn();							
 							int Add = IndentSize - (x % IndentSize);
 							
 							if (HardTabs && ((x + Add) % TabSize) == 0)
 							{
 								int Rx = x;
 								size_t Remove;
 								for (Remove = Cursor; Text[Remove - 1] == ' ' && Rx % TabSize != 0; Remove--, Rx--);
 								ssize_t Chars = (ssize_t)Cursor - Remove;
 								Delete(Remove, Chars);
 								Insert(Remove, &k.c16, 1);
 								Cursor = Remove + 1;
 								
 								Invalidate();
 							}
 							else
 							{							
 								char16 *Sp = new char16[Add];
 								if (Sp)
 								{
 									for (int n=0; n<Add; n++) Sp[n] = ' ';
 									if (Insert(Cursor, Sp, Add))
 									{
 										l = GetTextLine(Cursor);
 										size_t NewLen = (l) ? l->Len : 0;
 										SetCaret(Cursor + Add, false, Len != NewLen - 1);
 									}
 									DeleteArray(Sp);
 								}
 							}
 						}
 						else
 						{
 							char16 In = k.GetChar();
 
 							if (In == '\t' &&
 								k.Shift() &&
 								Cursor > 0)
 							{
 								l = GetTextLine(Cursor);
 								if (Cursor > l->Start)
 								{
 									if (Text[Cursor-1] == '\t')
 									{
 										Delete(Cursor - 1, 1);
 										SetCaret(Cursor, false, false);
 									}
 									else if (Text[Cursor-1] == ' ')
 									{
 										ssize_t Start = (ssize_t)Cursor - 1;
 										while (Start >= l->Start && strchr(" \t", Text[Start-1]))
 											Start--;
 										int Depth = SpaceDepth(Text + Start, Text + Cursor);
 										int NewDepth = Depth - (Depth % IndentSize);
 										if (NewDepth == Depth && NewDepth > 0)
 											NewDepth -= IndentSize;
 										int Use = 0;
 										while (SpaceDepth(Text + Start, Text + Start + Use + 1) < NewDepth)
 											Use++;
 										Delete(Start + Use, Cursor - Start - Use);
 										SetCaret(Start + Use, false, false);
 									}
 								}
 								
 							}
 							else if (In && Insert(Cursor, &In, 1))
 							{
 								l = GetTextLine(Cursor);
 								size_t NewLen = (l) ? l->Len : 0;
 								SetCaret(Cursor + 1, false, Len != NewLen - 1);
 							}
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			case LK_RETURN:
 			#if defined MAC
 			case LK_KEYPADENTER:
 			#endif
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Down() && k.IsChar)
 				{
 					OnEnter(k);
 				}
 				return true;
 				break;
 			}
 			case LK_BACKSPACE:
 			{
 				if (GetReadOnly())
 					break;
 
 				if (k.Ctrl())
 				{
 				    // Ctrl+H
 				}
 				else if (k.Down())
 				{
 					if (SelStart >= 0)
 					{
 						// delete selection
 						DeleteSelection();
 					}
 					else
 					{						
 						char Del = Cursor > 0 ? Text[Cursor-1] : 0;
 						
 						if (Del == ' ' && (!HardTabs || IndentSize != TabSize))
 						{
 							// Delete soft tab
 							int x = GetColumn();
 							int Max = x % IndentSize;
 							if (Max == 0) Max = IndentSize;
 							ssize_t i;
 							for (i=Cursor-1; i>=0; i--)
 							{
 								if (Max-- <= 0 || Text[i] != ' ')
 								{
 									i++;
 									break;
 								}
 							}
 							
 							if (i < 0) i = 0;
 							
 							if (i < Cursor - 1)
 							{
 								ssize_t Del = (ssize_t)Cursor - i;
 								Delete(i, Del);
 								// SetCursor(i, false, false);
 								// Invalidate();
 								break;
 							}
 						}
 						else if (Del == '\t' && HardTabs && IndentSize != TabSize)
 						{
 							int x = GetColumn();
 							Delete(--Cursor, 1);
 							
 							for (int c=GetColumn(); c<x-IndentSize; c=GetColumn())
 							{
 								int Add = IndentSize + (c % IndentSize);
 								if (Add)
 								{
 									char16 *s = new char16[Add];
 									if (s)
 									{
 										for (int n=0; n<Add; n++) s[n] = ' ';
 										Insert(Cursor, s, Add);
 										Cursor += Add;
 										DeleteArray(s);
 									}
 								}
 								else break;
 							}
 							
 							Invalidate();
 							break;
 						}
 
 
 						if (Cursor > 0)
 						{
 							Delete(Cursor - 1, 1);
 						}
 					}
 				}
 				return true;
 				break;
 			}
 		}
 	}
 	else // not a char
 	{
 		switch (k.vkey)
 		{
 			case LK_TAB:
 				return true;
 			case LK_RETURN:
 			{
 				return !GetReadOnly();
 			}
 			case LK_BACKSPACE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Alt())
 					{
 						if (k.Down())
 						{
 							if (k.Ctrl())
 							{
 								Redo();
 							}
 							else
 							{
 								Undo();
 							}
 						}
 					}
 					else if (k.Ctrl())
 					{
 						if (k.Down())
 						{
 							ssize_t Start = Cursor;
 							while (IsWhiteSpace(Text[Cursor-1]) && Cursor > 0)
 								Cursor--;
 
 							while (!IsWhiteSpace(Text[Cursor-1]) && Cursor > 0)
 								Cursor--;
 
 							Delete(Cursor, Start - Cursor);
 							Invalidate();
 						}
 					}
 
 					return true;
 				}
 				break;
 			}
 			case LK_F3:
 			{
 				if (k.Down())
 				{
 					DoFindNext(NULL);
 				}
 				return true;
 				break;
 			}
 			case LK_LEFT:
 			{
 				if (k.Down())
 				{
 					if (SelStart >= 0 &&
 						!k.Shift())
 					{
 						SetCaret(MIN(SelStart, SelEnd), false);
 					}
 					else if (Cursor > 0)
 					{
 						ssize_t n = Cursor;
 
 						#ifdef MAC
 						if (k.System())
 						{
 							goto Jump_StartOfLine;
 						}
 						else
 						if (k.Alt())
 						#else
 						if (k.Ctrl())
 						#endif
 						{
 							// word move/select
 							bool StartWhiteSpace = IsWhiteSpace(Text[n]);
 							bool LeftWhiteSpace = n > 0 && IsWhiteSpace(Text[n-1]);
 
 							if (!StartWhiteSpace ||
 								Text[n] == '\n')
 							{
 								n--;
 							}
 							
 							// Skip ws
 							for (; n > 0 && strchr(" \t", Text[n]); n--)
 								;
 							
 							if (Text[n] == '\n')
 							{
 								n--;
 							}
 							else if (!StartWhiteSpace || !LeftWhiteSpace)
 							{
 								if (IsDelimiter(Text[n]))
 								{
 									for (; n > 0 && IsDelimiter(Text[n]); n--);
 								}
 								else
 								{
 									for (; n > 0; n--)
 									{
 										//IsWordBoundry(Text[n])
 										if (IsWhiteSpace(Text[n]) ||
 											IsDelimiter(Text[n]))
 										{
 											break;
 										}
 									}
 								}
 							}
 							if (n > 0) n++;
 						}
 						else
 						{
 							// single char
 							n--;
 						}
 
 						SetCaret(n, k.Shift());
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_RIGHT:
 			{
 				if (k.Down())
 				{
 					if (SelStart >= 0 &&
 						!k.Shift())
 					{
 						SetCaret(MAX(SelStart, SelEnd), false);
 					}
 					else if (Cursor < Size)
 					{
 						ssize_t n = Cursor;
 
 						#ifdef MAC
 						if (k.System())
 						{
 							goto Jump_EndOfLine;
 						}
 						else if (k.Alt())
 						#else
 						if (k.Ctrl())
 						#endif
 						{
 							// word move/select
 							if (IsWhiteSpace(Text[n]))
 							{
 								for (; n<Size && IsWhiteSpace(Text[n]); n++);
 							}
 							else
 							{
 								if (IsDelimiter(Text[n]))
 								{
 									while (IsDelimiter(Text[n]))
 									{
 										n++;
 									}
 								}
 								else
 								{
 									for (; n<Size; n++)
 									{
 										if (IsWhiteSpace(Text[n]) ||
 											IsDelimiter(Text[n]))
 										{
 											break;
 										}
 									}
 								}
 
 								if (n < Size &&
 									Text[n] != '\n')
 								{
 									if (IsWhiteSpace(Text[n]))
 									{
 										n++;
 									}
 								}
 							}
 						}
 						else
 						{
 							// single char
 							n++;
 						}
 
 						SetCaret(n, k.Shift());
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_UP:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto LTextView4_PageUp;
 					#endif
 					
 					auto It = GetTextLineIt(Cursor);
 					if (It != Line.end())
 					{
 						auto l = *It;
 						It--;
 						if (It != Line.end())
 						{
 							LTextLine *Prev = *It;
 							LDisplayString CurLine(Font, Text + l->Start, Cursor-l->Start);
 							int ScreenX = CurLine.X();
 
 							LDisplayString PrevLine(Font, Text + Prev->Start, Prev->Len);
 							ssize_t CharX = PrevLine.CharAt(ScreenX);
 
 							SetCaret(Prev->Start + MIN(CharX, Prev->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DOWN:
 			{
 				if (k.Alt())
 					return false;
 
 				if (k.Down())
 				{
 					#ifdef MAC
 					if (k.Ctrl())
 						goto LTextView4_PageDown;
 					#endif
 
 					auto It = GetTextLineIt(Cursor);
 					if (It != Line.end())
 					{
 						auto l = *It;
 						It++;
 						if (It != Line.end())
 						{
 							LTextLine *Next = *It;
 							LDisplayString CurLine(Font, Text + l->Start, Cursor-l->Start);
 							int ScreenX = CurLine.X();
 							
 							LDisplayString NextLine(Font, Text + Next->Start, Next->Len);
 							ssize_t CharX = NextLine.CharAt(ScreenX);
 
 							SetCaret(Next->Start + MIN(CharX, Next->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_END:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						SetCaret(Size, k.Shift());
 					}
 					else
 					{
 						#ifdef MAC
 						Jump_EndOfLine:
 						#endif
 						LTextLine *l = GetTextLine(Cursor);
 						if (l)
 						{
 							SetCaret(l->Start + l->Len, k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_HOME:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						SetCaret(0, k.Shift());
 					}
 					else
 					{
 						#ifdef MAC
 						Jump_StartOfLine:
 						#endif
 						LTextLine *l = GetTextLine(Cursor);
 						if (l)
 						{
 							char16 *Line = Text + l->Start;
 							char16 *s;
 							char16 SpTab[] = {' ', '\t', 0};
 							for (s = Line; (SubtractPtr(s,Line) < l->Len) && StrchrW(SpTab, *s); s++);
 							ssize_t Whitespace = SubtractPtr(s, Line);
 
 							if (l->Start + Whitespace == Cursor)
 							{
 								SetCaret(l->Start, k.Shift());
 							}
 							else
 							{
 								SetCaret(l->Start + Whitespace, k.Shift());
 							}
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEUP:
 			{
 				#ifdef MAC
 				LTextView4_PageUp:
 				#endif
 				if (k.Down())
 				{
 					LTextLine *l = GetTextLine(Cursor);
 					if (l)
 					{
 						int DisplayLines = Y() / LineY;
 						ssize_t CurLine = Line.IndexOf(l);
 
 						LTextLine *New = Line.ItemAt(MAX(CurLine - DisplayLines, 0));
 						if (New)
 						{
 							SetCaret(New->Start + MIN(Cursor - l->Start, New->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_PAGEDOWN:
 			{
 				#ifdef MAC
 				LTextView4_PageDown:
 				#endif
 				if (k.Down())
 				{
 					LTextLine *l = GetTextLine(Cursor);
 					if (l)
 					{
 						int DisplayLines = Y() / LineY;
 						ssize_t CurLine = Line.IndexOf(l);
 
 						LTextLine *New = Line.ItemAt(MIN(CurLine + DisplayLines, (ssize_t)GetLines()-1));
 						if (New)
 						{
 							SetCaret(New->Start + MIN(Cursor - l->Start, New->Len), k.Shift());
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_INSERT:
 			{
 				if (k.Down())
 				{
 					if (k.Ctrl())
 					{
 						Copy();
 					}
 					else if (k.Shift())
 					{
 						if (!GetReadOnly())
 						{
 							Paste();
 						}
 					}
 				}
 				return true;
 				break;
 			}
 			case LK_DELETE:
 			{
 				if (!GetReadOnly())
 				{
 					if (k.Down())
 					{
 						if (SelStart >= 0)
 						{
 							if (k.Shift())
 							{
 								Cut();
 							}
 							else
 							{
 								DeleteSelection();
 							}
 						}
 						else if (Cursor < Size &&
 								Delete(Cursor, 1))
 						{
 							Invalidate();
 						}
 					}
 					return true;
 				}
 				break;
 			}
 			default:
 			{
 				if (k.c16 == 17) break;
 
 				if (k.CtrlCmd() &&
 					!k.Alt())
 				{
 					switch (k.GetChar())
 					{
 						case 0xbd: // Ctrl+'-'
 						{
 							if (k.Down() &&
 								Font->PointSize() > 1)
 							{
 								Font->PointSize(Font->PointSize() - 1);
 								OnFontChange();
 								Invalidate();
 							}
 							break;
 						}
 						case 0xbb: // Ctrl+'+'
 						{
 							if (k.Down() &&
 								Font->PointSize() < 100)
 							{
 								Font->PointSize(Font->PointSize() + 1);
 								OnFontChange();
 								Invalidate();
 							}
 							break;
 						}
 						case 'a':
 						case 'A':
 						{
 							if (k.Down())
 							{
 								// select all
 								SelStart = 0;
 								SelEnd = Size;
 								Invalidate();
 							}
 							return true;
 							break;
 						}
 						case 'y':
 						case 'Y':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Redo();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'z':
 						case 'Z':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									if (k.Shift())
 									{
 										Redo();
 									}
 									else
 									{
 										Undo();
 									}
 								}
 								return true;
 							}
 							break;
 						}
 						case 'x':
 						case 'X':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Cut();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'c':
 						case 'C':
 						{
 							if (k.Shift())
 								return false;
 							
 							if (k.Down())
 								Copy();
 							return true;
 							break;
 						}
 						case 'v':
 						case 'V':
 						{
 							if (!k.Shift() &&
 								!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									Paste();
 								}
 								return true;
 							}
 							break;
 						}
 						case 'f':
 						{
 							if (k.Down())
 							{
 								DoFind(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'g':
 						case 'G':
 						{
 							if (k.Down())
 							{
 								DoGoto(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'h':
 						case 'H':
 						{
 							if (k.Down())
 							{
 								DoReplace(NULL);
 							}
 							return true;
 							break;
 						}
 						case 'u':
 						case 'U':
 						{
 							if (!GetReadOnly())
 							{
 								if (k.Down())
 								{
 									DoCase(NULL, k.Shift());
 								}
 								return true;
 							}
 							break;
 						}
 						case LK_RETURN:
 						{
 							if (!GetReadOnly() && !k.Shift())
 							{
 								if (k.Down())
 								{
 									OnEnter(k);
 								}
 								return true;
 							}
 							break;
 						}
 					}
 				}
 				break;
 			}
 		}
 	}
 	
 	return false;
 }
 
 void LTextView4::OnEnter(LKey &k)
 {
 	// enter
 	if (SelStart >= 0)
 	{
 		DeleteSelection();
 	}
 
 	char16 InsertStr[256] = {'\n', 0};
 
 	LTextLine *CurLine = GetTextLine(Cursor);
 	if (CurLine && AutoIndent)
 	{
 		int WsLen = 0;
 		for (;	WsLen < CurLine->Len &&
 				WsLen < (Cursor - CurLine->Start) &&
 				strchr(" \t", Text[CurLine->Start + WsLen]); WsLen++);
 		if (WsLen > 0)
 		{
 			memcpy(InsertStr+1, Text+CurLine->Start, WsLen * sizeof(char16));
 			InsertStr[WsLen+1] = 0;
 		}
 	}
 
 	if (Insert(Cursor, InsertStr, StrlenW(InsertStr)))
 	{
 		SetCaret(Cursor + StrlenW(InsertStr), false, true);
 	}
 }
 
 int LTextView4::TextWidth(LFont *f, char16 *s, int Len, int x, int Origin)
 {
 	int w = x;
 	int Size = f->TabSize();
 
 	for (char16 *c = s; SubtractPtr(c, s) < Len; )
 	{
 		if (*c == 9)
 		{			
 			w = ((((w-Origin) + Size) / Size) * Size) + Origin;
 			c++;
 		}
 		else
 		{
 			char16 *e;
 			for (e = c; SubtractPtr(e, s) < Len && *e != 9; e++);
 			
 			LDisplayString ds(f, c, SubtractPtr(e, c));
 			w += ds.X();
 			c = e;
 		}
 	}
 
 	return w - x;
 }
 
 int LTextView4::ScrollYLine()
 {
 	return (VScroll) ? (int)VScroll->Value() : 0;
 }
 
 int LTextView4::ScrollYPixel()
 {
 	return ScrollYLine() * LineY;
 }
 
 LRect LTextView4::DocToScreen(LRect r)
 {
 	r.Offset(0, d->rPadding.y1 - ScrollYPixel());
 	return r;
 }
 
 void LTextView4::OnPaintLeftMargin(LSurface *pDC, LRect &r, LColour &colour)
 {
 	pDC->Colour(colour);
 	pDC->Rectangle(&r);
 }
 
 void LTextView4::OnPaint(LSurface *pDC)
 {
 	#if LGI_EXCEPTIONS
 	try
 	{
 	#endif
 
 	#if PROFILE_PAINT
 	char s[256];
 	sprintf_s(s, sizeof(s), "%p::OnPaint Lines=%i Sz=%i", this, (int)Line.Length(), (int)Size);
 	LProfile Prof(s);
 	#endif
 
 		if (d->LayoutDirty)
 		{
 	#if PROFILE_PAINT
 	Prof.Add("PourText");
 	#endif
 			PourText(d->DirtyStart, d->DirtyLen);
 	#if PROFILE_PAINT
 	Prof.Add("PourStyle");
 	#endif
 			PourStyle(d->DirtyStart, d->DirtyLen);
 			
 			d->LayoutDirty = false;
 		}
 
 	#if PROFILE_PAINT
 	Prof.Add("Setup");
 	#endif
 		
 		LRect r = GetClient();
 		r.x2 += ScrollX;
 
 		int Ox, Oy;
 		pDC->GetOrigin(Ox, Oy);
 		pDC->SetOrigin(Ox+ScrollX, Oy);
 		
 		#if 0
 		// Coverage testing...
 		pDC->Colour(Rgb24(255, 0, 255), 24);
 		pDC->Rectangle();
 		#endif
 
 		LSurface *pOut = pDC;
 		bool DrawSel = false;
 		
 		bool HasFocus = Focus();
 		// printf("%s:%i - HasFocus = %i\n", _FL, HasFocus);
 		LColour SelectedText(HasFocus ? LColour(L_FOCUS_SEL_FORE) : LColour(L_NON_FOCUS_SEL_FORE));
 		LColour SelectedBack(HasFocus ? LColour(L_FOCUS_SEL_BACK) : LColour(L_NON_FOCUS_SEL_BACK));
 
 		LCss::ColorDef ForeDef, BkDef;
 		if (GetCss())
 		{
 			ForeDef = GetCss()->Color();
 			BkDef = GetCss()->BackgroundColor();
 		}
 		
 		LColour Fore(ForeDef.Type ==  LCss::ColorRgb ? LColour(ForeDef.Rgb32, 32) : LColour(L_TEXT));
 		LColour Back
 		(
 			/*!ReadOnly &&*/ BkDef.Type == LCss::ColorRgb
 			?
 			LColour(BkDef.Rgb32, 32)
 			:
 			Enabled() ? LColour(L_WORKSPACE) : LColour(L_MED)
 		);
 
 		// LColour Whitespace = Fore.Mix(Back, 0.85f);
 		if (!Enabled())
 		{
 			Fore = LColour(L_LOW);
 			Back = LColour(L_MED);
 		}
 
 		#ifdef DOUBLE_BUFFER_PAINT
 		LMemDC *pMem = new LMemDC;
 		pOut = pMem;
 		#endif
 		if (Text &&
 			Font
 			#ifdef DOUBLE_BUFFER_PAINT
 			&&
 			pMem &&
 			pMem->Create(r.X()-d->rPadding.x1, LineY, GdcD->GetBits())
 			#endif
 			)
 		{
 			ssize_t SelMin = MIN(SelStart, SelEnd);
 			ssize_t SelMax = MAX(SelStart, SelEnd);
 
 			// font properties
 			Font->Colour(Fore, Back);
 			// Font->WhitespaceColour(Whitespace);
 			Font->Transparent(false);
 
 			// draw margins
 			pDC->Colour(PAINT_BORDER);
 			// top margin
 			pDC->Rectangle(0, 0, r.x2, d->rPadding.y1-1);
 			// left margin
 			{
 				LRect LeftMargin(0, d->rPadding.y1, d->rPadding.x1-1, r.y2);
 				OnPaintLeftMargin(pDC, LeftMargin, PAINT_BORDER);
 			}
 		
 			// draw lines of text
 			int k = ScrollYLine();
 			LTextLine *l = NULL;
 			int Dy = 0;
 			if (k < Line.Length())
 				Dy = -Line[k]->r.y1;
 			ssize_t NextSelection = (SelStart != SelEnd) ? SelMin : -1; // offset where selection next changes
 			if (k < Line.Length() &&
 				(l = Line[k]) &&
 				SelStart >= 0 &&
 				SelStart < l->Start &&
 				SelEnd > l->Start)
 			{
 				// start of visible area is in selection
 				// init to selection colour
 				DrawSel = true;
 				Font->Colour(SelectedText, SelectedBack);
 				NextSelection = SelMax;
 			}
 
 			StyleIter Si = Style.begin();
 			LStyle *NextStyle = GetNextStyle(Si, (l) ? l->Start : 0);
 
 			DocOffset = (l) ? l->r.y1 : 0;
 
 	#if PROFILE_PAINT
 	Prof.Add("foreach Line loop");
 	#endif
 			// loop through all visible lines
 			int y = d->rPadding.y1;
 			while (	k < Line.Length() &&
 					(l = Line[k]) &&
 					l->r.y1+Dy < r.Y())
 			{
 				LRect Tr = l->r;
 				#ifdef DOUBLE_BUFFER_PAINT
 				Tr.Offset(-Tr.x1, -Tr.y1);
 				#else
 				Tr.Offset(0, y - Tr.y1);
 				#endif
 				//LRect OldTr = Tr;
 
 				// deal with selection change on beginning of line
 				if (NextSelection == l->Start)
 				{
 					// selection change
 					DrawSel = !DrawSel;
 					NextSelection = (NextSelection == SelMin) ? SelMax : -1;
 				}
 				if (DrawSel)
 				{
 					Font->Colour(SelectedText, SelectedBack);
 				}
 				else
 				{
 					LColour fore = l->c.IsValid() ? l->c : Fore;
 					LColour back = l->Back.IsValid() ? l->Back : Back;
 					Font->Colour(fore, back);
 				}
 
 				// How many chars on this line have we
 				// processed so far:
 				ssize_t Done = 0;
 				bool LineHasSelection =	NextSelection >= l->Start &&
 										NextSelection < l->Start + l->Len;
 
 				// Fractional pixels we have moved so far:
 				int MarginF = d->rPadding.x1 << LDisplayString::FShift;
 				int FX = MarginF;
 				int FY = Tr.y1 << LDisplayString::FShift;
 				
 				// loop through all sections of similar text on a line
 				while (Done < l->Len)
 				{
 					// decide how big this block is
 					int RtlTrailingSpace = 0;
 					ssize_t Cur = l->Start + Done;
 					ssize_t Block = l->Len - Done;
 					
 					// check for style change
 					if (NextStyle &&
 						(ssize_t)NextStyle->End() <= l->Start)
 						NextStyle = GetNextStyle(Si);
 					if (NextStyle)
 					{
 						// start
 						if (l->Overlap(NextStyle->Start) &&
 							NextStyle->Start > Cur &&
 							NextStyle->Start - Cur < Block)
 						{
 							Block = NextStyle->Start - Cur;
 						}
 
 						// end
 						ssize_t StyleEnd = NextStyle->Start + NextStyle->Len;
 						if (l->Overlap(StyleEnd) &&
 							StyleEnd > Cur &&
 							StyleEnd - Cur < Block)
 						{
 							Block = StyleEnd - Cur;
 						}
 					}
 
 					// check for next selection change
 					// this may truncate the style
 					if (NextSelection > Cur &&
 						NextSelection - Cur < Block)
 					{
 						Block = NextSelection - Cur;
 					}
 
 					LAssert(Block != 0);	// sanity check
 					
 					if (NextStyle &&							// There is a style
 						(Cur < SelMin || Cur >= SelMax) &&		// && we're not drawing a selection block
 						Cur >= NextStyle->Start &&				// && we're inside the styled area
 						Cur < NextStyle->Start+NextStyle->Len)
 					{
 						LFont *Sf = NextStyle->Font ? NextStyle->Font : Font;
 						if (Sf)
 						{
 							// draw styled text
 							if (NextStyle->Fore.IsValid())
 								Sf->Fore(NextStyle->Fore);
 							if (NextStyle->Back.IsValid())
 								Sf->Back(NextStyle->Back);
 							else if (l->Back.IsValid())
 								Sf->Back(l->Back);
 							else
 								Sf->Back(Back);								
 
 							Sf->Transparent(false);
 
 							LAssert(l->Start + Done >= 0);
 
 							LDisplayString Ds(	Sf,
 												MapText(Text + (l->Start + Done),
 														Block,
 														RtlTrailingSpace != 0),
 												Block + RtlTrailingSpace);
 							Ds.SetDrawOffsetF(FX - MarginF);
 							Ds.ShowVisibleTab(ShowWhiteSpace);
 							Ds.FDraw(pOut, FX, FY, 0, LineHasSelection);
 
 							if (NextStyle->Decor == LCss::TextDecorSquiggle)
 							{
 								pOut->Colour(NextStyle->DecorColour);
 								int x = FX >> LDisplayString::FShift;
 								int End = x + Ds.X();
 								while (x < End)
 								{
 									pOut->Set(x, Tr.y2-(x%2));
 									x++;
 								}
 							}
 
 							FX += Ds.FX();
 
 							LColour fore = l->c.IsValid() ? l->c : Fore;
 							LColour back = l->Back.IsValid() ? l->Back : Back;
 							Sf->Colour(fore, back);
 						}
 						else LAssert(0);
 					}
 					else
 					{
 						// draw a block of normal text
 						LAssert(l->Start + Done >= 0);
 						
 						LDisplayString Ds(	Font,
 											MapText(Text + (l->Start + Done),
 													Block,
 													RtlTrailingSpace != 0),
 											Block + RtlTrailingSpace);
 						Ds.SetDrawOffsetF(FX - MarginF);
 						Ds.ShowVisibleTab(ShowWhiteSpace);
 						Ds.FDraw(pOut, FX, FY, 0, LineHasSelection);
 						FX += Ds.FX();
 					}
 
 					if (NextStyle &&
 						Cur+Block >= NextStyle->Start+NextStyle->Len)
 					{
 						// end of this styled block
 						NextStyle = GetNextStyle(Si);
 					}
 
 					if (NextSelection == Cur+Block)
 					{
 						// selection change
 						DrawSel = !DrawSel;
 						if (DrawSel)
 						{
 							Font->Colour(SelectedText, SelectedBack);
 						}
 						else
 						{
 							LColour fore = l->c.IsValid() ? l->c : Fore;
 							LColour back = l->Back.IsValid() ? l->Back : Back;
 							Font->Colour(fore, back);
 						}
 						NextSelection = (NextSelection == SelMin) ? SelMax : -1;
 					}
 
 					Done += Block + RtlTrailingSpace;
 				
 				} // end block loop
 
 				Tr.x1 = FX >> LDisplayString::FShift;
 
 				// eol processing
 				ssize_t EndOfLine = l->Start+l->Len;
 				if (EndOfLine >= SelMin && EndOfLine < SelMax)
 				{
 					// draw the '\n' at the end of the line as selected
 					// LColour bk = Font->Back();
 					pOut->Colour(Font->Back());
 					pOut->Rectangle(Tr.x2, Tr.y1, Tr.x2+7, Tr.y2);
 					Tr.x2 += 7;
 				}
 				else Tr.x2 = Tr.x1;
 
 				// draw any space after text
 				pOut->Colour(PAINT_AFTER_LINE);
 				pOut->Rectangle(Tr.x2, Tr.y1, r.x2, Tr.y2);
 
 				// cursor?
 				if (HasFocus)
 				{
 					// draw the cursor if on this line
 					if (Cursor >= l->Start && Cursor <= l->Start+l->Len)
 					{
 						CursorPos.ZOff(1, LineY-1);
 
 						ssize_t At = Cursor-l->Start;
 						
 						LDisplayString Ds(Font, MapText(Text+l->Start, At), At);
 						Ds.ShowVisibleTab(ShowWhiteSpace);
 						int CursorX = Ds.X();
 						CursorPos.Offset(d->rPadding.x1 + CursorX, Tr.y1);
 						
 						if (CanScrollX)
 						{
 							// Cursor on screen check
 							LRect Scr = GetClient();
 							Scr.Offset(ScrollX, 0);
 							LRect Cur = CursorPos;
 							if (Cur.x2 > Scr.x2 - 5) // right edge check
 							{
 								ScrollX = ScrollX + Cur.x2 - Scr.x2 + 40;
 								Invalidate();
 							}
 							else if (Cur.x1 < Scr.x1 && ScrollX > 0)
 							{
 								ScrollX = MAX(0, Cur.x1 - 40);
 								Invalidate();
 							}
 						}
 
 						if (Blink)
 						{
 							LRect c = CursorPos;
 							#ifdef DOUBLE_BUFFER_PAINT
 							c.Offset(-d->rPadding.x1, -y);
 							#endif
 
 							pOut->Colour(!ReadOnly ? Fore : LColour(192, 192, 192));
 							pOut->Rectangle(&c);
 						}
 
 						#if WINNATIVE
 						HIMC hIMC = ImmGetContext(Handle());
 						if (hIMC)
 						{
 							COMPOSITIONFORM Cf;						
 							Cf.dwStyle = CFS_POINT;
 							Cf.ptCurrentPos.x = CursorPos.x1;
 							Cf.ptCurrentPos.y = CursorPos.y1;
 							ImmSetCompositionWindow(hIMC, &Cf);
 							ImmReleaseContext(Handle(), hIMC);
 						}
 						#endif
 					}
 				}
 
 				#if DRAW_LINE_BOXES
 				{
 					uint Style = pDC->LineStyle(LSurface::LineAlternate);
 					LColour Old = pDC->Colour(LColour::Red);
 					pDC->Box(&OldTr);
 					pDC->Colour(Old);
 					pDC->LineStyle(Style);
 
 					LString s;
 					s.Printf("%i, %i", Line.IndexOf(l), l->Start);
 					LDisplayString ds(LSysFont, s);
 					LSysFont->Transparent(true);
 					ds.Draw(pDC, OldTr.x2 + 2, OldTr.y1);
 				}
 				#endif
 
 				#ifdef DOUBLE_BUFFER_PAINT
 				// dump to screen
 				pDC->Blt(d->rPadding.x1, y, pOut);
 				#endif
 				y += LineY;
 
 				k++;
 
 			} // end of line loop
 
 			// draw any space under the lines
 			if (y <= r.y2)
 			{
 				pDC->Colour(Back);
 				// pDC->Colour(LColour(255, 0, 255));
 				pDC->Rectangle(d->rPadding.x1, y, r.x2, r.y2);
 			}
 
 			#ifdef DOUBLE_BUFFER_PAINT
 			DeleteObj(pMem);
 			#endif
 		}
 		else
 		{
 			// default drawing: nothing
 			pDC->Colour(Back);
 			pDC->Rectangle(&r);
 		}
 
 		// _PaintTime = LCurrentTime() - StartTime;
 		#ifdef PAINT_DEBUG
 		if (GetNotify())
 		{
 			char s[256];
 			sprintf_s(s, sizeof(s), "Pour:%i Style:%i Paint:%i ms", _PourTime, _StyleTime, _PaintTime);
 			LMessage m = CreateMsg(DEBUG_TIMES_MSG, 0, (int)s);
 			GetNotify()->OnEvent(&m);
 		}
 		#endif
 		// printf("PaintTime: %ims\n", _PaintTime);
 	
 	#if LGI_EXCEPTIONS
 	}
 	catch (...)
 	{
 		LgiMsg(this, "LTextView4::OnPaint crashed.", "Lgi");
 	}
 	#endif
 }
 
 LMessage::Result LTextView4::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_TEXT_UPDATE_NAME:
 		{
 			if (d->Lock(_FL))
 			{
 				Name(d->SetName);
 				d->SetName.Empty();
 				d->Unlock();
 			}
 			break;
 		}
 		case M_TEXTVIEW_FIND:
 		{
 			if (InThread())
 				DoFindNext(NULL);
 			else
 				LgiTrace("%s:%i - Not in thread.\n", _FL);
 			break;
 		}
 		case M_TEXTVIEW_REPLACE:
 		{
 			// DoReplace();
 			break;
 		}
 		case M_CUT:
 		{
 			Cut();
 			break;
 		}
 		case M_COPY:
 		{
 			Copy();
 			break;
 		}
 		case M_PASTE:
 		{
 			Paste();
 			break;
 		}
 		#if defined WIN32
 		case WM_GETTEXTLENGTH:
 		{
 			return Size;
 		}
 		case WM_GETTEXT:
 		{
 			int Chars = (int)Msg->A();
 			char *Out = (char*)Msg->B();
 			if (Out)
 			{
 				char *In = (char*)LNewConvertCp(LAnsiToLgiCp(), NameW(), LGI_WideCharset, Chars);
 				if (In)
 				{
 					int Len = (int)strlen(In);
 					memcpy(Out, In, Len);
 					DeleteArray(In);
 					return Len;
 				}
 			}
 			return 0;
 		}
 
 		/* This is broken... the IME returns garbage in the buffer. :(
 		case WM_IME_COMPOSITION:
 		{
 			if (Msg->b & GCS_RESULTSTR) 
 			{
 				HIMC hIMC = ImmGetContext(Handle());
 				if (hIMC)
 				{
 					int Size = ImmGetCompositionString(hIMC, GCS_RESULTSTR, NULL, 0);
 					char *Buf = new char[Size];
 					if (Buf)
 					{
 						ImmGetCompositionString(hIMC, GCS_RESULTSTR, Buf, Size);
 
 						char16 *Utf = (char16*)LNewConvertCp(LGI_WideCharset, Buf, LAnsiToLgiCp(), Size);
 						if (Utf)
 						{
 							Insert(Cursor, Utf, StrlenW(Utf));
 							DeleteArray(Utf);
 						}
 
 						DeleteArray(Buf);
 					}
 
 					ImmReleaseContext(Handle(), hIMC);
 				}
 				return 0;
 			}
 			break;
 		}
 		*/
 		#endif
 	}
 
 	return LLayout::OnEvent(Msg);
 }
 
 int LTextView4::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (Ctrl->GetId() == IDC_VSCROLL && VScroll)
 	{
 		if (n.Type == LNotifyScrollBarCreate)
 		{
 			UpdateScrollBars();
 		}
 			
 		Invalidate();
 	}
 
 	return 0;
 }
 
 void LTextView4::InternalPulse()
 {
 	if (!ReadOnly)
 	{
 		uint64 Now = LCurrentTime();
 		if (!BlinkTs)
 			BlinkTs = Now;
 		else if (Now - BlinkTs > CURSOR_BLINK)
 		{
 			Blink = !Blink;
 
 			LRect p = CursorPos;
 			p.Offset(-ScrollX, 0);
 			Invalidate(&p);
 			BlinkTs = Now;
 		}
 	}
 
 	if (PartialPour)
 		PourText(Size, 0);
 }
 
 void LTextView4::OnPulse()
 {
 	#ifdef WINDOWS
 	InternalPulse();
 	#else
 	for (auto c: Ctrls)
 		c->InternalPulse();
 	#endif
 }
 
 void LTextView4::OnUrl(char *Url)
 {
 	if (Environment)
 		Environment->OnNavigate(this, Url);
 	else
 	{
 		LUri u(Url);
 		bool Email = LIsValidEmail(Url);
 		const char *Proto = Email ? "mailto" : u.sProtocol;
 		LString App = LGetAppForProtocol(Proto);
 		if (App)
 			LExecute(App, Url);
 		else
 			LgiMsg(this, "Failed to find application for protocol '%s'", "Error", MB_OK, Proto);
 	}
 }
 
 bool LTextView4::OnLayout(LViewLayoutInfo &Inf)
 {
 	Inf.Width.Min = 32;
 	Inf.Width.Max = -1;
 
 	Inf.Height.Min = (Font ? Font->GetHeight() : 18) + 4;
 	Inf.Height.Max = -1;
 
 	return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 class LTextView4_Factory : public LViewFactory
 {
 	LView *NewView(const char *Class, LRect *Pos, const char *Text)
 	{
 		if (_stricmp(Class, "LTextView4") == 0)
 		{
 			return new LTextView4(-1, 0, 0, 2000, 2000);
 		}
 
 		return 0;
 	}
 }	TextView4_Factory;