diff --git a/Ide/src/IdeDoc.cpp b/Ide/src/IdeDoc.cpp
--- a/Ide/src/IdeDoc.cpp
+++ b/Ide/src/IdeDoc.cpp
@@ -1,2127 +1,2125 @@
 #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 "lgi/common/PopupNotification.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));
 }
 	
 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;
 
 	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);
 					snprintf(m, sizeof(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();
 			s = s.Strip();
 			if (s.Length() > 2)
 				App->FindSymbol(Doc->AddDispatch(), s);
 		}
 		
 		return LPopupList<FindSymResult>::OnNotify(Ctrl, n);
 	}
 };
 
 void FilterFiles(LArray<ProjectNode*> &Perfect, LArray<ProjectNode*> &Nodes, LString InputStr, int Platforms)
 {
 	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];
 		if (! (Pn->GetPlatforms() & Platforms) )
 			continue;
 
 		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, App->GetPlatform());
 		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();
 
 	// LPopupNotification::Message(Doc->GetWindow(), "Saved");
 
 	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();
 }
 
 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())
 		{
 			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);
 	}
 
 	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;
 
 	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)
+				SetClean([this](bool ok)
 				{
 					if (ok)
-					{
-						LAssert(!"Impl close doc.");
-					}
+						delete this;
 				});
 
 				// 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/ResourceEditor/src/LgiResApp.cpp b/ResourceEditor/src/LgiResApp.cpp
--- a/ResourceEditor/src/LgiResApp.cpp
+++ b/ResourceEditor/src/LgiResApp.cpp
@@ -1,4725 +1,4728 @@
 /*
 **	FILE:			LgiRes.cpp
 **	AUTHOR:			Matthew Allen
 **	DATE:			3/8/99
 **	DESCRIPTION:	Lgi Resource Editor
 **
 **	Copyright (C) 1999, Matthew Allen
 **		fret@memecode.com
 */
 
 #include <stdlib.h>
 
 #include "LgiResEdit.h"
 #include "LgiRes_Dialog.h"
 #include "LgiRes_Menu.h"
 
 #include "lgi/common/About.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/ProgressDlg.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/Token.h"
 #include "lgi/common/DataDlg.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/StatusBar.h"
 
 #include "resdefs.h"
 
 char AppName[]					= "Lgi Resource Editor";
 char HelpFile[]					= "Help.html";
 char OptionsFileName[]			= "Options.r";
 char TranslationStrMagic[]		= "LgiRes.String";
 #define VIEW_PULSE_RATE			100
 
 #ifndef DIALOG_X
 #define DIALOG_X				1.56
 #define DIALOG_Y				1.85
 #define CTRL_X					1.50
 #define CTRL_Y					1.64
 #endif
 
 enum Ctrls
 {
 	IDC_HBOX = 100,
 	IDC_VBOX,
 };
 
 const char *TypeNames[] = {
     "",
 	"Css",
 	"Dialog",
 	"String",
 	"Menu",
 	0};
 
 //////////////////////////////////////////////////////////////////////////////
 ResFileFormat GetFormat(const char *File)
 {
 	ResFileFormat Format = Lr8File;
 	char *Ext = LGetExtension(File);
 	if (Ext)
 	{
 		if (stricmp(Ext, "lr") == 0) Format = CodepageFile;
 		else if (stricmp(Ext, "xml") == 0) Format = XmlFile;
 	}
 	return Format;
 }
 
 char *EncodeXml(const char *Str, int Len)
 {
 	char *Ret = 0;
 	
 	if (Str)
 	{
 		LStringPipe p;
 		
 		const char *s = Str;
 		for (const char *e = Str; e && *e && (Len < 0 || ((e-Str) < Len)); )
 		{
 			switch (*e)
 			{
 				case '<':
 				{
 					p.Push(s, e-s);
 					p.Push("&lt;");
 					s = ++e;
 					break;
 				}
 				case '>':
 				{
 					p.Push(s, e-s);
 					p.Push("&gt;");
 					s = ++e;
 					break;
 				}
 				case '&':
 				{
 					p.Push(s, e-s);
 					p.Push("&amp;");
 					s = ++e;
 					break;
 				}
 				case '\\':
 				{
 					if (e[1] == 'n')
 					{
 						// Newline
 						p.Push(s, e-s);
 						p.Push("\n");
 						s = (e += 2);
 						break;
 					}
 					
 					// fall thru
 				}
 				case '\'':
 				case '\"':
 				case '/':
 				{
 					// Convert to entity
 					p.Push(s, e-s);
 					
 					char b[32];
 					snprintf(b, sizeof(b), "&#%i;", *e);
 					p.Push(b);
 
 					s = ++e;
 					break;
 				}
 				default:
 				{
 					// Regular character
 					e++;
 					break;
 				}
 			}
 		}	
 		p.Push(s);
 		
 		Ret = p.NewStr();
 	}
 
 	return Ret;
 }
 
 char *DecodeXml(const char *Str, int Len)
 {
 	if (Str)
 	{
 		LStringPipe p;
 		
 		const char *s = Str;
 		for (const char *e = Str; e && *e && (Len < 0 || ((e-Str) < Len)); )
 		{
 			switch (*e)
 			{
 				case '&':
 				{
 					// Store string up to here
 					p.Push(s, e-s);
 
 					e++;
 					if (*e == '#')
 					{
 						// Numerical
 						e++;
 						if (*e == 'x' || *e == 'X')
 						{
 							// Hex
 							e++;
 							
 							char16 c = htoi(e);
 							char *c8 = WideToUtf8(&c, 1);
 							if (c8)
 							{
 								p.Push(c8);
 								DeleteArray(c8);
 							}
 						}
 						else if (isdigit(*e))
 						{
 							// Decimal
 							char16 c = atoi(e);
 							char *c8 = WideToUtf8(&c, 1);
 							if (c8)
 							{
 								p.Push(c8);
 								DeleteArray(c8);
 							}
 						}
 						else
 						{
 							LAssert(0);
 						}
 
 						while (*e && *e != ';') e++;
 					}
 					else if (isalpha(*e))
 					{
 						// named entity
 						const char *Name = e;
 						while (*e && *e != ';') e++;
 						auto Len = e - Name;
 						if (Len == 3 && strnicmp(Name, "amp", Len) == 0)
 						{
 							p.Push("&");
 						}
 						else if (Len == 2 && strnicmp(Name, "gt", Len) == 0)
 						{
 							p.Push(">");
 						}
 						else if (Len == 2 && strnicmp(Name, "lt", Len) == 0)
 						{
 							p.Push("<");
 						}
 						else
 						{
 							// Unsupported entity
 							LAssert(0);
 						}
 					}
 					else
 					{
 						LAssert(0);
 						while (*e && *e != ';') e++;
 					}
 					
 					s = ++e;
 					break;
 				}
 				case '\n':
 				{
 					p.Push(s, e-s);
 					p.Push("\\n");
 					s = ++e;
 					break;
 				}
 				default:
 				{
 					e++;
 					break;
 				}
 			}
 		}
 
 		p.Push(s);
 		
 		return p.NewStr();	
 	}
 	
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 Resource::Resource(AppWnd *w, int t, bool enabled)
 {
 	AppWindow = w;
 	ResType = t;
 	Item = 0;
 	SysObject = false;
 
 	LAssert(AppWindow);
 }
 
 Resource::~Resource()
 {
 	AppWindow->OnResourceDelete(this);
 	if (Item)
 	{
 		Item->Obj = 0;
 		DeleteObj(Item);
 	}
 }
 
 bool Resource::IsSelected()
 {
 	return Item?Item->Select():false;
 }
 
 bool Resource::Attach(LViewI *Parent)
 {
 	LView *w = Wnd();
 	if (w)
 	{
 		return w->Attach(Parent);
 	}
 	return false;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 ResFolder::ResFolder(AppWnd *w, int t, bool enabled) :
 	Resource(w, t, enabled)
 {
 	Wnd()->Name("<untitled>");
 	Wnd()->Enabled(enabled);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 ObjTreeItem::ObjTreeItem(Resource *Object)
 {
 	if ((Obj = Object))
 	{
 		Obj->Item = this;
 		
 		if (dynamic_cast<ResFolder*>(Object))
 		    SetImage(ICON_FOLDER);
 		else
 		{
 		    int t = Object->Type();
 		    switch (t)
 		    {
 		        case TYPE_CSS: SetImage(ICON_CSS); break;
 		        case TYPE_DIALOG: SetImage(ICON_DIALOG); break;
 		        case TYPE_STRING: SetImage(ICON_STRING); break;
 		        case TYPE_MENU: SetImage(ICON_MENU); break;
 		    }
 		}
 	}
 }
 
 ObjTreeItem::~ObjTreeItem()
 {
 	if (Obj)
 	{
 		Obj->Item = 0;
 		DeleteObj(Obj);
 	}
 }
 
 const char *ObjTreeItem::GetText(int i)
 {
 	if (Obj)
 	{
 		int Type = Obj->Type();
 		if (Type > 0)
 			return Obj->Wnd()->Name();
 		else
 			return TypeNames[-Type];
 	}
 
 	return "#NO_OBJ";
 }
 
 void ObjTreeItem::OnSelect()
 {
 	if (Obj)
 	{
 		Obj->App()->OnResourceSelect(Obj);
 	}
 }
 
 void ObjTreeItem::OnMouseClick(LMouse &m)
 {
 	if (!Obj) return;
 	if (m.IsContextMenu())
 	{
 		Tree->Select(this);
 		LSubMenu RClick;
 
 		if (Obj->Wnd()->Enabled())
 		{
 			if (Obj->Type() > 0)
 			{
 				// Resource
 				RClick.AppendItem("Delete", IDM_DELETE, !Obj->SystemObject());
 				RClick.AppendItem("Rename", IDM_RENAME, !Obj->SystemObject());
 			}
 			else
 			{
 				// Folder
 				RClick.AppendItem("New", IDM_NEW, true);
 				RClick.AppendSeparator();
 				auto Insert = RClick.AppendSub("Import from...");
 				if (Insert)
 				{
 					Insert->AppendItem("Lgi File", IDM_IMPORT, true);
 					Insert->AppendItem("Win32 Resource Script", IDM_IMPORT_WIN32, false);
 				}
 			}
 
 			// Custom entries
 			if (!Obj->SystemObject())
 			{
 				Obj->OnRightClick(&RClick);
 			}
 		}
 		else
 		{
 			RClick.AppendItem("Not implemented", 0, false);
 		}
 
 		if (Tree->GetMouse(m, true))
 		{
 			int Cmd = 0;
 			switch (Cmd = RClick.Float(Tree, m.x, m.y))
 			{
 				case IDM_NEW:
 				{
 					SerialiseContext Ctx;
 					Obj->App()->NewObject(Ctx, 0, -Obj->Type());
 					break;
 				}
 				case IDM_DELETE:
 				{
 					Obj->App()->SetDirty(true, [this](auto ok)
 					{
 						if (ok)
 							Obj->App()->DelObject(Obj);
 					});
 					break;
 				}
 				case IDM_RENAME:
 				{
 					auto Dlg = new LInput(Tree, GetText(), "Enter the name for the object", "Object Name");
 					Dlg->DoModal([this, Dlg](auto dlg, auto id)
 					{
 						if (id)
 						{
 							Obj->Wnd()->Name(Dlg->GetStr());
 							Update();
 							Obj->App()->SetDirty(true, NULL);
 						}
 						delete dlg;
 					});
 					break;
 				}
 				case IDM_IMPORT:
 				{
 					auto Select = new LFileSelect(Obj->App());
 					Select->Type("Text", "*.txt");
 					Select->Open([&](auto dlg, auto status)
 					{
 						if (status)
 						{
 							LFile F;
 							if (F.Open(dlg->Name(), O_READ))
 							{
 								SerialiseContext Ctx;
 								Resource *Res = Obj->App()->NewObject(Ctx, 0, -Obj->Type());
 								if (Res)
 								{
 									// TODO
 									// Res->Read();
 								}
 							}
 							else
 							{
 								LgiMsg(Obj->App(), "Couldn't open file for reading.");
 							}
 						}
 						delete dlg;
 					});
 					break;
 				}
 				case IDM_IMPORT_WIN32:
 				{
 					/*
 					List<ResDialog> l;
 					if (ImportWin32Dialogs(l, MainWnd))
 					{
 						for (ResDialog *r = l.First(); r; r = l.Next())
 						{
 							Obj->App()->InsertObject(TYPE_DIALOG, r);
 						}
 					}
 					*/
 					break;
 				}
 				default:
 				{
 					Obj->OnCommand(Cmd);
 					break;
 				}
 			}
 		}
 	}
 }
 
 //////////////////////////////////////////////////////////////////////////////
 FieldView::FieldView(AppWnd *app) : Fields(NextId, true)
 {
 	NextId = 100;
 	App = app;
 	Source = 0;
 	Ignore = true;
 
 	SetTabStop(true);
 	Sunken(true);
 	#ifdef WIN32
 	SetExStyle(GetExStyle() | WS_EX_CONTROLPARENT);
 	#endif
 }
 
 FieldView::~FieldView()
 {
 }
 
 void FieldView::Serialize(bool Write)
 {
 	if (!Source)
 		return;
 
 	Ignore = !Write;
 	
 	Fields.SetMode(Write ? FieldTree::UiToObj : FieldTree::ObjToUi);
 	Fields.SetView(this);
 	Source->Serialize(Fields);
 
 	/*
 	for (DataDlgField *f=Fields.First(); f; f=Fields.Next())
 	{
 		LViewI *v;
 		if (GetViewById(f->GetCtrl(), v))
 		{
 			switch (f->GetType())
 			{
 				case DATA_STR:
 				{
 					if (Write) // Ctrl -> Options
 					{
 						char *s = v->Name();
 						Options->Set(f->GetOption(), s);
 					}
 					else // Options -> Ctrl
 					{
 						char *s = 0;
 						Options->Get(f->GetOption(), s);
 						v->Name(s?s:(char*)"");
 					}
 					break;
 				}
 				case DATA_BOOL:
 				case DATA_INT:
 				{
 					if (Write) // Ctrl -> Options
 					{
 						char *s = v->Name();
 						if (s && (s = strchr(s, '\'')))
 						{
 							s++;
 
 							char *e = strchr(s, '\'');
 							int i = 0;
 							if (e - s == 4)
 							{
 								memcpy(&i, s, 4);
 								i = LgiSwap32(i);
 								Options->Set(f->GetOption(), i);
 							}
 						}
 						else
 						{
 							int i = v->Value();
 							Options->Set(f->GetOption(), i);
 						}
 					}
 					else // Options -> Ctrl
 					{
 						int i = 0;
 						Options->Get(f->GetOption(), i);
 						if (i != -1 && (i & 0xff000000) != 0)
 						{
 							char m[8];
 							i = LgiSwap32(i);
 							sprintf(m, "'%04.4s'", &i);
 							v->Name(m);
 						}
 						else
 						{
 							v->Value(i);
 						}
 					}
 					break;
 				}
 				case DATA_FLOAT:
 				case DATA_PASSWORD:
 				case DATA_STR_SYSTEM:
 				default:
 				{
 					LAssert(0);
 					break;
 				}
 			}
 		}
 		else LAssert(0);
 	}
 	*/
 
 	Ignore = false;
 }
 
 class TextViewEdit : public LTextView3
 {
 public:
     bool Multiline;
 
 	TextViewEdit(	int Id,
 					int x,
 					int y,
 					int cx,
 					int cy,
 					LFontType *FontInfo = 0) :
 		LTextView3(Id, x, y, cx, cy, FontInfo)
 	{
 	    Multiline = false;
 		#ifdef WIN32
 		SetDlgCode(DLGC_WANTARROWS | DLGC_WANTCHARS);
 		#endif
 	}
 
 	bool OnKey(LKey &k)
 	{
 		if (!Multiline && (k.c16 == '\t' || k.c16 == LK_RETURN))
 		{
 			return false;
 		}
 
 		return LTextView3::OnKey(k);
 	}
 };
 
 class Hr : public LView
 {
 public:
 	Hr(int x1, int y, int x2)
 	{
 		LRect r(x1, y, x2, y+1);
 		SetPos(r);
 	}
 
 	void OnPaint(LSurface *pDC)
 	{
 		LRect c = GetClient();
 		LThinBorder(pDC, c, DefaultSunkenEdge);
 	}
 
 	bool OnLayout(LViewLayoutInfo &Inf)
 	{
 		if (Inf.Width.Min)
 			Inf.Height.Min = Inf.Height.Max = 2;
 		else
 			Inf.Width.Min = Inf.Width.Max = -1;
 		return true;
 	}
 };
 
 void FieldView::OnDelete(FieldSource *s)
 {
 	if (Source != NULL && Source == s)
 	{
 		// Clear fields
 		Source->_FieldView = 0;
 		Fields.Empty();
 
 		// remove all children
 		LViewI *c;
 		while ((c = Children[0]))
 		{
 			c->Detach();
 			DeleteObj(c);
 		}
 		
 		Source = NULL;
 	}
 }
 
 void FieldView::OnSelect(FieldSource *s)
 {
 	Ignore = true;
 
 	OnDelete(Source);
 	
 	if (Source)
 	{
 		// Clear fields
 		Source->_FieldView = 0;
 		Fields.Empty();
 
 		// remove all children
 		LViewI *c;
 		while ((c = Children[0]))
 		{
 			c->Detach();
 			DeleteObj(c);
 		}
 		
 		Source = 0;
 	}
 
 	if (s)
 	{
 		// Add new fields
 		Source = s;
 		Source->_FieldView = AddDispatch();
 
 		if (Source->GetFields(Fields))
 		{
 			LFontType Sys;
 			Sys.GetSystemFont("System");
 
 			LTableLayout *t = new LTableLayout(IDC_TABLE);
 
 			int Row = 0;
 			LLayoutCell *Cell;
 
 			LArray<FieldTree::FieldArr*> a;
 			Fields.GetAll(a);
 			for (int i=0; i<a.Length(); i++)
 			{
 				FieldTree::FieldArr *b = a[i];
 				for (int n=0; n<b->Length(); n++, Row++)
 				{
 					FieldTree::Field *c = (*b)[n];
 
 					switch (c->Type)
 					{
 						case DATA_STR:
 						case DATA_FLOAT:
 						case DATA_INT:
 						case DATA_FILENAME:
 						{
 							Cell = t->GetCell(0, Row);
 							Cell->VerticalAlign(LCss::VerticalMiddle);
 							Cell->Add(new LTextLabel(-1, 0, 0, -1, -1, c->Label));
 
 							TextViewEdit *Tv;
 							Cell = t->GetCell(1, Row, true, c->Type == DATA_FILENAME ? 1 : 2);
 							Cell->Add(Tv = new TextViewEdit(c->Id, 0, 0, 100, 20, &Sys));
 							if (Tv)
 							{
 								Tv->Multiline = c->Multiline;
 								Tv->GetCss(true)->Height(LCss::Len(LCss::LenPx, c->Multiline ? LSysFont->GetHeight() * 8 : LSysFont->GetHeight() + 8));
 								Tv->SetWrapType(TEXTED_WRAP_NONE);
 								Tv->Sunken(true);
 							}
 
 							if (c->Type == DATA_FILENAME)
 							{
 								Cell = t->GetCell(2, Row);
 								Cell->Add(new LButton(-c->Id, 0, 0, 21, 21, "..."));
 							}
 							break;
 						}
 						case DATA_BOOL:
 						{
 							Cell = t->GetCell(1, Row, true, 2);
 							Cell->Add(new LCheckBox(c->Id, 0, 0, -1, -1, c->Label));
 							break;
 						}
 						default:
 							LAssert(!"Impl me.");
 							break;
 					}
 				}
 
 				if (i < a.Length() - 1)
 				{
 					Cell = t->GetCell(0, Row++, true, 3);
 					Cell->Add(new Hr(0, 0, X()-1));
 				}
 			}
 
 			AddView(t);
 			OnPosChange();
 			AttachChildren();
 			Invalidate();
 		}
 
 		Serialize(false);
 		Ignore = false;
 	}
 }
 
 void FieldView::OnPosChange()
 {
 	LRect c = GetClient();
 	c.Inset(6, 6);
 
 	LViewI *v;
 	if (GetViewById(IDC_TABLE, v))
 		v->SetPos(c);
 }
 
 LMessage::Result FieldView::OnEvent(LMessage *m)
 {
 	switch (m->Msg())
 	{
 		case M_OBJECT_CHANGED:
 		{
 			FieldSource *Src = (FieldSource*)m->A();
 			if (Src == Source)
 			{
 				Fields.SetMode(FieldTree::ObjToUi);
 				Fields.SetView(this);
 				Serialize(false);
 			}
 			else LAssert(0);
 			break;
 		}
 	}
 
 	return LLayout::OnEvent(m);
 }
 
 int FieldView::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (!Ignore)
 	{
 		LTextView3 *Tv = dynamic_cast<LTextView3*>(Ctrl);
 		if (Tv && n.Type == LNotifyCursorChanged)
 		{
 			return 0;
 		}
 
 		LArray<FieldTree::FieldArr*> a;
 		Fields.GetAll(a);
 		for (int i=0; i<a.Length(); i++)
 		{
 			FieldTree::FieldArr *b = a[i];
 			for (int n=0; n<b->Length(); n++)
 			{
 				FieldTree::Field *c = (*b)[n];
 				if (c->Id == Ctrl->GetId())
 				{
 					// Write the value back to the objects
 					Fields.SetMode(FieldTree::UiToObj);
 					Fields.SetView(this);
 					Source->Serialize(Fields);
 
 					return 0;
 				}
 				else if (c->Id == -Ctrl->GetId())
 				{
 					auto s = new LFileSelect(this);
 					s->Open([&](auto dlg, auto status)
 					{
 						if (status)
 						{
 							auto File = App->GetCurFile();
 							if (File)
 							{
 								LFile::Path p = File;
 								p--;
 								auto Rel = LMakeRelativePath(p, dlg->Name());
 								if (Rel)
 									SetCtrlName(c->Id, Rel);
 								else
 									SetCtrlName(c->Id, dlg->Name());
 							}
 							else SetCtrlName(c->Id, dlg->Name());
 
 							Fields.SetMode(FieldTree::UiToObj);
 							Fields.SetView(this);
 							Source->Serialize(Fields);
 						}
 						delete dlg;
 					});
 				}
 			}
 		}
 	}
 
 	return 0;
 }
 
 void FieldView::OnPaint(LSurface *pDC)
 {
 	pDC->Colour(L_MED);
 	pDC->Rectangle();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 ObjContainer::ObjContainer(AppWnd *w) :
 	LTree(100, 0, 0, 100, 100, "LgiResObjTree")
 {
 	Window = w;
 	Sunken(true);
 
 	Insert(Style   = new ObjTreeItem( new ResFolder(Window, -TYPE_CSS)));
 	Insert(Dialogs = new ObjTreeItem( new ResFolder(Window, -TYPE_DIALOG)));
 	Insert(Strings = new ObjTreeItem( new ResFolder(Window, -TYPE_STRING)));
 	Insert(Menus   = new ObjTreeItem( new ResFolder(Window, -TYPE_MENU)));
 
 	const char *IconFile = "_icons.gif";
 	auto f = LFindFile(IconFile);
 	LAssert(f);
 	if (f)
 	{
 		Images = LLoadImageList(f, 16, 16);
 		LAssert(Images);
 		if (Images)
 			SetImageList(Images, false);
 		else
 			LgiTrace("%s:%i - failed to load '%s'\n", _FL, IconFile);
 	}
 }
 
 ObjContainer::~ObjContainer()
 {
 	DeleteObj(Images);
 }
 
 bool ObjContainer::AppendChildren(ObjTreeItem *Res, List<Resource> &Lst)
 {
 	bool Status = true;
 	if (Res)
 	{
 		LTreeItem *Item = Res->GetChild();
 		while (Item)
 		{
 			ObjTreeItem *i = dynamic_cast<ObjTreeItem*>(Item);
 			if (i) Lst.Insert(i->GetObj());
 			else Status = false;
 			Item = Item->GetNext();
 		}
 	}
 	return Status;
 }
 
 Resource *ObjContainer::CurrentResource()
 {
 	ObjTreeItem *Item = dynamic_cast<ObjTreeItem*>(Selection());
 	if (!Item)
 		return NULL;
 	
 	return Item->GetObj();
 }
 
 bool ObjContainer::ListObjects(List<Resource> &Lst)
 {
 	bool Status = AppendChildren(Style, Lst);
 	Status &= AppendChildren(Dialogs, Lst);
 	Status &= AppendChildren(Strings, Lst);
 	Status &= AppendChildren(Menus, Lst);
 	return Status;
 }
 
 //////////////////////////////////////////////////////////////////////////////
 #ifdef WIN32
 int Icon = IDI_ICON1;
 #else
 const char *Icon = "icon64.png";
 #endif
 
 AppWnd::AppWnd() :
 	LDocApp<LOptionsFile>(AppName, Icon)
 {
 	ShowLanguages.Add("en", true);
 	SetQuitOnClose(true);
 
 	if (_Create())
 	{
 		LVariant Langs;
 		if (GetOptions()->GetValue(OPT_ShowLanguages, Langs))
 		{
 			ShowLanguages.Empty();
 			LToken L(Langs.Str(), ",");
 			for (int i=0; i<L.Length(); i++)
 			{
 				ShowLanguages.Add(L[i], true);
 			}
 		}
 		
 		auto scale = GetDpiScale();
 		GOOBER_SIZE *= scale.x;
 		GOOBER_BORDER *= scale.y;
 	}
 	else printf("%s:%i - _Create failed.\n", _FL);
 }
 
 AppWnd::~AppWnd()
 {
 	OnResourceSelect(NULL);
     Objs->Empty();
 	_Destroy();
 }
 
 void AppWnd::OnCreate()
 {
 	if (_LoadMenu("IDM_MENU"))
 	{
 		if (_FileMenu)
 		{
 			int n = 6;
 			_FileMenu->AppendSeparator(n++);
 			_FileMenu->AppendItem("Import Win32 Script", IDM_IMPORT_WIN32, true, n++);
 			_FileMenu->AppendItem("Import LgiRes Language", IDM_IMPORT_LANG, true, n++);
 			_FileMenu->AppendItem("Compare To File...", IDM_COMPARE, true, n++);
 			_FileMenu->AppendSeparator(n++);
 			_FileMenu->AppendItem("Properties", IDM_PROPERTIES, true, n++);
 		}
 
 		ViewMenu = Menu->FindSubMenu(IDM_VIEW);
 		LAssert(ViewMenu);
 	}
 	else LgiTrace("%s:%i - _LoadMenu failed.\n", _FL);
 
 	Status = 0;
 	StatusInfo[0] = StatusInfo[1] = 0;
 
 	HBox = new LBox(IDC_HBOX);
 	if (HBox)
 	{
 		HBox->GetCss(true)->Padding("5px");
 
 		VBox = new LBox(IDC_VBOX, true);
 		if (VBox)
 		{
 			HBox->AddView(VBox);
 			VBox->AddView(Objs = new ObjContainer(this));
 			if (Objs)
 			{
 				Objs->AskImage(true);
 				Objs->AskText(true);
 			}
 			VBox->AddView(Fields = new FieldView(this));
 			VBox->Value(200);
 		}
 
 		HBox->Value(240);
 		HBox->Attach(this);
 	}
 
 	DropTarget(true);
 
 	LString Open;
 	if (LAppInst->GetOption("o", Open))
 		LoadLgi(Open);
 }
 
 void AppWnd::OnLanguagesChange(LLanguageId Lang, bool Add, bool Update)
 {
 	bool Change = false;
 
 	if (Lang)
 	{
 		// Update the list....
 		bool Has = false;
 		for (int i=0; i<Languages.Length(); i++)
 		{
 			if (stricmp(Languages[i]->Id, Lang) == 0)
 			{
 				Has = true;
 
 				if (!Add)
 				{
 					Languages.DeleteAt(i);
 					Change = true;
 				}
 				break;
 			}
 		}
 
 		if (Add && !Has)
 		{
 			Change = true;
 			Languages.Add(LFindLang(Lang));
 		}
 	}
 
 	// Update the menu...
 	if (ViewMenu && (Change || Update))
 	{
 		// Remove existing language menu items
 		while (ViewMenu->RemoveItem(2));
 
 		// Add new ones
 		int n = 0;
 		for (int i=0; i<Languages.Length(); i++, n++)
 		{
 			LLanguage *Lang = Languages[i];
 			if (Lang)
 			{
 				auto Item = ViewMenu->AppendItem(Lang->Name, IDM_LANG_BASE + n, true);
 				if (Item)
 				{
 					if (CurLang == i)
 					{
 						Item->Checked(true);
 					}
 				}
 			}
 		}
 	}
 }
 
 bool AppWnd::ShowLang(LLanguageId Lang)
 {
 	return ShowLanguages.Find(Lang) != 0;
 }
 
 void AppWnd::ShowLang(LLanguageId Lang, bool Show)
 {
 	// Apply change
 	if (Show)
 	{
 		OnLanguagesChange(Lang, true);
 		ShowLanguages.Add(Lang, true);
 	}
 	else
 	{
 		ShowLanguages.Delete(Lang);
 	}
 
 	// Store the setting for next time
 	LStringPipe p;
 	// const char *L;
 	// for (bool i = ShowLanguages.First(&L); i; i = ShowLanguages.Next(&L))
 	for (auto i : ShowLanguages)
 	{
 		if (p.GetSize()) p.Push(",");
 		p.Push(i.key);
 	}
 	char *Langs = p.NewStr();
 	if (Langs)
 	{
 		LVariant v;
 		GetOptions()->SetValue(OPT_ShowLanguages, v = Langs);
 		DeleteArray(Langs);
 	}
 
 	// Update everything
 	List<Resource> res;
 	if (ListObjects(res))
 	{
 		for (auto r: res)
 		{
 			r->OnShowLanguages();
 		}
 	}
 }
 
 LLanguage *AppWnd::GetCurLang()
 {
 	if (CurLang >= 0 && CurLang < Languages.Length())
 		return Languages[CurLang];
 
 	return LFindLang("en");
 }
 
 void AppWnd::SetCurLang(LLanguage *L)
 {
 	for (int i=0; i<Languages.Length(); i++)
 	{
 		if (Languages[i]->Id == L->Id)
 		{
 			// Set new current
 			CurLang = i;
 
 			// Update everything
 			List<Resource> res;
 			if (ListObjects(res))
 			{
 				for (auto r: res)
 				{
 					r->OnShowLanguages();
 				}
 			}
 
 			break;
 		}
 	}
 }
 
 LArray<LLanguage*> *AppWnd::GetLanguages()
 {
 	return &Languages;
 }
 
 class Test : public LView
 {
 	COLOUR c;
 
 public:
 	Test(COLOUR col, int x1, int y1, int x2, int y2)
 	{
 		c = col;
 		LRect r(x1, y1, x2, y2);
 		SetPos(r);
 		_BorderSize = 1;
 		Sunken(true);
 	}
 	
 	void OnPaint(LSurface *pDC)
 	{
 		pDC->Colour(c, 24);
 		pDC->Rectangle();
 	}
 };
 
 LMessage::Result AppWnd::OnEvent(LMessage *m)
 {
 	switch (m->Msg())
 	{
 		case M_CHANGE:
 		{
 			LAutoPtr<LNotification> note((LNotification*)m->B());
 			return OnNotify((LViewI*) m->A(), *note);
 		}
 		case M_DESCRIBE:
 		{
 			char *Text = (char*) m->A();
 			if (Text)
 			{
 				SetStatusText(Text, STATUS_NORMAL);
 			}
 			break;
 		}
 	}
 
 	return LDocApp<LOptionsFile>::OnEvent(m);
 }
 
 void _CountGroup(ResStringGroup *Grp, int &Words, int &Multi)
 {
 	for (auto s: *Grp->GetStrs())
 	{
 		if (s->Items.Length() > 1)
 		{
 			Multi++;
 
 			char *e = s->Get("en");
 			if (e)
 			{
 				LToken t(e, " ");
 				Words += t.Length();
 			}
 		}
 	}
 }
 
 int AppWnd::OnCommand(int Cmd, int Event, OsView Handle)
 {
 	SerialiseContext Ctx;
 	switch (Cmd)
 	{
 		case IDM_SHOW_LANG:
 		{
 			auto Dlg = new ShowLanguagesDlg(this);
 			Dlg->DoModal([](auto dlg, auto ctrlId)
 			{
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_NEW_CSS:
 		{
 			NewObject(Ctx, 0, TYPE_CSS);
 			break;
 		}
 		case IDM_NEW_DIALOG:
 		{
 			NewObject(Ctx, 0, TYPE_DIALOG);
 			break;
 		}
 		case IDM_NEW_STRING_GRP:
 		{
 			NewObject(Ctx, 0, TYPE_STRING);
 			break;
 		}
 		case IDM_NEW_MENU:
 		{
 			NewObject(Ctx, 0, TYPE_MENU);
 			break;
 		}
 		case IDM_CLOSE:
 		{
 			Empty();
 			break;
 		}
 		case IDM_IMPORT_WIN32:
 		{
 			LoadWin32();
 			break;
 		}
 		case IDM_IMPORT_LANG:
 		{
 			ImportLang();
 			break;
 		}
 		case IDM_COMPARE:
 		{
 			Compare();
 			break;
 		}
 		case IDM_PROPERTIES:
 		{
 			List<Resource> l;
 			if (Objs->ListObjects(l))
 			{
 				int Dialogs = 0;
 				int Strings = 0;
 				int Menus = 0;
 				int Words = 0;
 				int MultiLingual = 0;
 
 				for (auto r: l)
 				{
 					switch (r->Type())
 					{
 						case TYPE_DIALOG:
 						{
 							Dialogs++;
 							break;
 						}
 						case TYPE_STRING:
 						{
 							ResStringGroup *Grp = dynamic_cast<ResStringGroup*>(r);
 							if (Grp)
 							{
 								Strings += Grp->GetStrs()->Length();
 								_CountGroup(Grp, Words, MultiLingual);
 							}
 							break;
 						}
 						case TYPE_MENU:
 						{
 							Menus++;
 							
 							ResMenu *Menu = dynamic_cast<ResMenu*>(r);
 							if (Menu)
 							{
 								if (Menu->Group)
 								{
 									Strings += Menu->Group->GetStrs()->Length();
 									_CountGroup(Menu->Group, Words, MultiLingual);
 								}
 							}
 							break;
 						}
 					}
 				}
 
 				LgiMsg(	this,
 						"This file contains:\n"
 						"\n"
 						"   Dialogs: %i\n"
 						"   Menus: %i\n"
 						"   Strings: %i\n"
 						"      Multi-lingual: %i\n"
 						"         Words: %i",
 						AppName,
 						MB_OK,
 						Dialogs,
 						Menus,
 						Strings,
 						MultiLingual,
 						Words);
 			}
 			break;
 		}
 		case IDM_EXIT:
 		{
 			LCloseApp();
 			break;
 		}
 		case IDM_FIND:
 		{
 			auto s = new Search(this);
 			s->DoModal([&](auto dlg, auto id)
 			{
 				if (id)
 					new Results(this, s);
 				delete dlg;
 			});
 			break;
 		}
 		case IDM_NEXT:
 		{
 			LgiMsg(this, "Not implemented :(", AppName);
 			break;
 		}
 		case IDM_CUT:
 		{
 			auto Focus = LAppInst->GetFocus();
 			if (Focus)
 			{
 				Focus->PostEvent(M_CUT);
 			}
 			else
 			{
 				Resource *r = Objs->CurrentResource();
 				if (r)
 					r->Copy(true);
 			}
 			break;
 		}
 		case IDM_COPY:
 		{
 			auto Focus = LAppInst->GetFocus();
 			if (Focus)
 			{
 				Focus->PostEvent(M_COPY);
 			}
 			else
 			{
 				Resource *r = Objs->CurrentResource();
 				if (r)
 					r->Copy(false);
 			}
 			break;
 		}
 		case IDM_PASTE:
 		{
 			auto Focus = LAppInst->GetFocus();
 			if (Focus)
 			{
 				Focus->PostEvent(M_PASTE);
 			}
 			else
 			{
 				Resource *r = Objs->CurrentResource();
 				if (r)
 					r->Paste();
 			}
 			break;
 		}
 		case IDM_TABLELAYOUT_TEST:
 		{
 			OpenTableLayoutTest(this);			
 			break;
 		}
 		case IDM_HELP:
 		{
 			char ExeName[MAX_PATH_LEN];
 			sprintf_s(ExeName, sizeof(ExeName), "%s", LGetExePath().Get());
 
 			while (strchr(ExeName, DIR_CHAR) && strlen(ExeName) > 3)
 			{
 				char p[256];
 				LMakePath(p, sizeof(p), ExeName, "index.html");
 				if (!LFileExists(p))
 				{
 					LMakePath(p, sizeof(p), ExeName, "help");
 					LMakePath(p, sizeof(p), p, "index.html");
 				}
 				if (LFileExists(p))
 				{
 					LExecute(HelpFile, NULL, ExeName);
 					break;
 				}
 				
 				LTrimDir(ExeName);
 			}
 			break;
 		}
 		case IDM_SHOW_SHORTCUTS:
 		{
 			if (!ShortCuts)
 			{
 				ShortCuts = new ShortCutView(this);
 			}
 			if (ShortCuts)
 			{
 				auto res = Objs->CurrentResource();
 				if (res)
 					ShortCuts->OnResource(res);
 			}
 			break;
 		}
 		case IDM_ABOUT:
 		{
 			LAbout Dlg(	this,
 						AppName,
 						APP_VER,
 						"\nLgi Resource Editor (lr8 files).",
 						"icon64.png",
 						"http://www.memecode.com/lgi/res",
 						"fret@memecode.com");
 			break;
 		}
 		default:
 		{
 			int Idx = Cmd - IDM_LANG_BASE;
 			if (Idx >= 0 && Idx < Languages.Length())
 			{
 				// Deselect the old lang
 				auto Item = ViewMenu ? ViewMenu->ItemAt(CurLang + 2) : 0;
 				if (Item)
 				{
 					Item->Checked(false);
 				}
 
 				// Set the current
 				CurLang = Idx;
 
 				// Set the new lang's menu item
 				Item = ViewMenu ? ViewMenu->ItemAt(CurLang + 2) : 0;
 				if (Item)
 				{
 					Item->Checked(true);
 				}
 
 				// Update everything
 				List<Resource> res;
 				if (ListObjects(res))
 				{
 					for (auto r: res)
 					{
 						r->OnShowLanguages();
 					}
 				}
 			}
 			break;
 		}
 	}
 
 	return LDocApp<LOptionsFile>::OnCommand(Cmd, Event, Handle);
 }
 
 int AppWnd::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		default:
 		{
 			break;
 		}
 	}
 	return 0;
 }
 
 void AppWnd::FindStrings(List<ResString> &Strs, char *Define, int *CtrlId)
 {
 	if (Objs)
 	{
 		List<Resource> l;
 		if (Objs->ListObjects(l))
 		{
 			for (auto r: l)
 			{
 				StringList *s = r->GetStrs();
 				if (s)
 				{
 					for (auto Str: *s)
 					{
 						if (Define && ValidStr(Str->GetDefine()))
 						{
 							if (strcmp(Define, Str->GetDefine()) == 0)
 							{
 								Strs.Insert(Str);
 								continue;
 							}
 						}
 
 						if (CtrlId)
 						{
 							if (*CtrlId == Str->GetId())
 							{
 								Strs.Insert(Str);
 								continue;
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 }
 
 int AppWnd::GetUniqueCtrlId()
 {
 	int Max = 0;
 
 	if (Objs)
 	{
 		List<Resource> l;
 		if (Objs->ListObjects(l))
 		{
 			LHashTbl<IntKey<int>, int> t;
 			for (auto r: l)
 			{
 				StringList *sl = r->GetStrs();
 				if (sl)
 				{
 					for (auto s: *sl)
 					{
 						if (s->GetId() > 0 &&
 						    !t.Find(s->GetId()))
 						{
 							t.Add(s->GetId(), s->GetId());
 						}
 
 						Max = MAX(s->GetId(), Max);
 					}
 				}
 			}
 
 			int i = 500;
 			while (true)
 			{
 				if (t.Find(i))
 				{
 					i++;
 				}
 				else
 				{
 					return i;
 				}
 			}
 		}
 	}
 
 	return Max + 1;
 }
 
 int AppWnd::GetUniqueStrRef(int	Start)
 {
 	if (!Objs)
 		return -1;
 
 	List<Resource> l;
 	if (!Objs->ListObjects(l))
 		return -1;
 
 	LHashTbl<IntKey<int>, ResString*> Map;
 	LArray<ResString*> Dupes;
 
 	for (auto r: l)
 	{
 		ResStringGroup *Grp = r->GetStringGroup();
 		if (Grp)
 		{
 			List<ResString>::I it = Grp->GetStrs()->begin();
 			for (ResString *s = *it; s; s = *++it)
 			{
 			    if (s->GetRef())
 			    {
 				    ResString *Existing = Map.Find(s->GetRef());
 				    if (Existing)
 				    {
 					    // These get their ref's reset to a unique value as a side
 					    // effect of this function...
 					    Dupes.Add(s);
 				    }
 				    else
 				    {
 					    Map.Add(s->GetRef(), s);
 				    }
 				}
 				else
 				{
 				    // auto Idx = Grp->GetStrs()->IndexOf(s);
 				    LAssert(!"No string ref?");
 				}
 			}			
 		}
 	}
 
 	for (int i=Start; true; i++)
 	{
 		if (!Map.Find(i))
 		{
 			if (Dupes.Length())
 			{
 				ResString *s = Dupes[0];
 				Dupes.DeleteAt(0);
 				s->SetRef(i);
 
 				SetDirty(true, NULL);
 			}
 			else
 			{
 				return i;
 			}
 		}
 	}
 
 	return -1;
 }
 
 ResString *AppWnd::GetStrFromRef(int Ref)
 {
 	ResString *Str = 0;
 
 	if (Objs)
 	{
 		List<Resource> l;
 		if (Objs->ListObjects(l))
 		{
 			for (auto r: l)
 			{
 				ResStringGroup *Grp = dynamic_cast<ResStringGroup*>(r);
 				if (Grp)
 				{
 					if ((Str = Grp->FindRef(Ref)))
 						break;
 				}
 			}
 		}
 	}
 
 	return Str;
 }
 
 ResStringGroup *AppWnd::GetDialogSymbols()
 {
 	if (Objs)
 	{
 		List<Resource> l;
 		if (Objs->ListObjects(l))
 		{
 			for (auto r: l)
 			{
 				ResStringGroup *Grp = dynamic_cast<ResStringGroup*>(r);
 				if (Grp)
 				{
 					auto ObjName = Grp->Wnd()->Name();
 					if (ObjName && stricmp(ObjName, StrDialogSymbols) == 0)
 					{
 						return Grp;
 					}
 				}
 			}
 		}
 	}
 
 	return NULL;
 }
 
 void AppWnd::OnReceiveFiles(LArray<const char*> &Files)
 {
 	auto f = Files.Length() ? Files[0] : 0;
 	if (f)
 	{
 		_OpenFile(f, false, NULL);
 	}
 }
 
 void AppWnd::SetStatusText(char *Text, int Pane)
 {
 	if (Pane >= 0 && Pane < STATUS_MAX && StatusInfo[Pane])
 	{
 		StatusInfo[Pane]->Name(Text);
 	}
 }
 
 Resource *AppWnd::NewObject(SerialiseContext ctx, LXmlTag *load, int Type, bool Select)
 {
 	Resource *r = 0;
 	ObjTreeItem *Dir = 0;
 
 	switch (Type)
 	{
 		case TYPE_CSS:
 		{
 			r = new ResCss(this);
 			Dir = Objs->Style;
 			break;
 		}
 		case TYPE_DIALOG:
 		{
 			r = new ResDialog(this);
 			Dir = Objs->Dialogs;
 			break;
 		}
 		case TYPE_STRING:
 		{
 			r = new ResStringGroup(this);
 			Dir = Objs->Strings;
 			break;
 		}
 		case TYPE_MENU:
 		{
 			r = new ResMenu(this);
 			Dir = Objs->Menus;
   			break;
 		}
 	}
 
 	if (r)
 	{
 		ObjTreeItem *Item = new ObjTreeItem(r);
 		if (Item)
 		{
 			Dir->Insert(Item);
 			Dir->Update();
 			Dir->Expanded(true);
 		
 			if (Select)
 			{
 				Objs->Select(Item);
 			}
 		}
 
 		r->Create(load, &ctx);
 
 		if (Item)
 		{
 			Item->Update();
 		}
 
 		SetDirty(true, NULL);
 	}
 
 	return r;
 }
 
 bool AppWnd::InsertObject(int Type, Resource *r, bool Select)
 {
 	bool Status = false;
 	if (r)
 	{
 		ObjTreeItem *Dir = 0;
 
 		switch (Type)
 		{
 			case TYPE_CSS:
 			{
 				Dir = Objs->Style;
 				break;
 			}
 			case TYPE_DIALOG:
 			{
 				Dir = Objs->Dialogs;
 				break;
 			}
 			case TYPE_STRING:
 			{
 				Dir = Objs->Strings;
 				break;
 			}
 			case TYPE_MENU:
 			{
 				Dir = Objs->Menus;
 				break;
 			}
 		}
 
 		if (Dir)
 		{
 			ObjTreeItem *Item = new ObjTreeItem(r);
 			if (Item)
 			{
 				const char *Name = Item->GetText();
 
 				r->Item = Item;
 				Dir->Insert(Item, (Name && Name[0] == '_') ? 0 : -1);
 				Dir->Update();
 				Dir->Expanded(true);
 				
 				if (Select)
 				{
 					Objs->Select(Item);
 				}
 
 				Status = true;
 			}
 		}
 	}
 
 	return Status;
 }
 
 void AppWnd::DelObject(Resource *r)
 {
 	OnResourceSelect(0);
 	DeleteObj(r);
 }
 
 ObjTreeItem *GetTreeItem(LTreeItem *ti, Resource *r)
 {
 	for (LTreeItem *i=ti->GetChild(); i; i=i->GetNext())
 	{
 		ObjTreeItem *o = dynamic_cast<ObjTreeItem*>(i);
 		if (o)
 		{
 			if (o->GetObj() == r) return o;
 		}
 
 		o = GetTreeItem(i, r);
 		if (o) return o;
 	}
 	
 	return 0;
 }
 
 ObjTreeItem *GetTreeItem(LTree *ti, Resource *r)
 {
 	for (LTreeItem *i=ti->GetChild(); i; i=i->GetNext())
 	{
 		ObjTreeItem *o = dynamic_cast<ObjTreeItem*>(i);
 		if (o)
 		{
 			if (o->GetObj() == r) return o;
 		}
 
 		o = GetTreeItem(i, r);
 		if (o) return o;
 	}
 	
 	return 0;
 }
 
 void AppWnd::GotoObject(ResString *s,
 						ResStringGroup *g,
 						ResDialog *d,
 						ResMenuItem *m,
 						ResDialogCtrl *c)
 {
 	if (s)
 	{
 		Resource *Res = 0;
 		if (g)
 		{
 			Res = g;
 		}
 		else if (d)
 		{
 			Res = d;
 		}
 		else if (m)
 		{
 			Res = m->GetMenu();
 		}
 		if (Res)
 		{
 			ObjTreeItem *ti = GetTreeItem(Objs, Res);
 			if (ti)
 			{
 				ti->Select(true);
 				
 				if (g)
 				{
 					s->GetList()->Select(0);
 					s->ScrollTo();
 					s->Select(true);
 				}
 				else if (d)
 				{
 					d->SelectCtrl(c);
 				}
 				else if (m)
 				{
 					for (LTreeItem *i=m; i; i=i->GetParent())
 					{
 						i->Expanded(true);
 					}
 					m->Select(true);
 					m->ScrollTo();
 				}
 			}
 			else
 			{
 				printf("%s:%i - couldn't find resources tree item\n", _FL);
 			}
 		}
 	}
 }
 
 bool AppWnd::ListObjects(List<Resource> &Lst)
 {
 	if (Objs)
 	{
 		return Objs->ListObjects(Lst);
 	}
 
 	return false;
 }
 
 void AppWnd::OnObjChange(FieldSource *r)
 {
 	if (Fields)
 	{
 		Fields->Serialize(false);
 		SetDirty(true, NULL);
 	}
 }
 
 void AppWnd::OnObjSelect(FieldSource *r)
 {
 	if (Fields)
 		Fields->OnSelect(r);
 }
 
 void AppWnd::OnObjDelete(FieldSource *r)
 {
 	if (Fields)
 	{
 		Fields->OnDelete(r);
 	}
 }
 
 void AppWnd::OnResourceDelete(Resource *r)
 {
 	auto v = GetShortCutView();
 	if (v)
 		v->OnResource(NULL);
 }
 
 void AppWnd::OnResourceSelect(Resource *r)
 {
 	if (LastRes)
 	{
 		OnObjSelect(NULL);
 		if (ContentView)
 		{
 			ContentView->Detach();
 			DeleteObj(ContentView);
 		}
 		LastRes = NULL;
 	}
 	
 	if (r)
 	{
 		ContentView = r->CreateUI();
 		if (ContentView)
 		{
 			if (HBox)
 				ContentView->Attach(HBox);
 			LastRes = r;
 		}
 
 		auto v = GetShortCutView();
 		if (v)
 			v->OnResource(r);
 	}
 }
 
 char *TagName(LXmlTag *t)
 {
 	static char Buf[1024];
 	LArray<LXmlTag*> Tags;
 	for (; t; t = t->Parent)
 	{
 		Tags.AddAt(0, t);
 	}
 	Buf[0] = 0;
 	for (int i=0; i<Tags.Length(); i++)
 	{
 		if (i) strcat(Buf, ".");
 		strcat(Buf, Tags[i]->GetTag());
 	}
 	return Buf;
 }
 
 class ResCompare : public LWindow, public LResourceLoad
 {
 	LList *Lst;
 
 public:
 	ResCompare(const char *File1, const char *File2)
 	{
 		Lst = 0;
 		LRect p;
 		LAutoString n;
 
 		if (LoadFromResource(IDD_COMPARE, this, &p, &n))
 		{
 			SetPos(p);
 			Name(n);
 			MoveToCenter();
 			GetViewById(IDC_DIFFS, Lst);
 
 			if (Attach(0))
 			{
 				Visible(true);
 				AttachChildren();
 
 				LXmlTag *t1 = new LXmlTag;
 				LXmlTag *t2 = new LXmlTag;
 				if (t1 && File1)
 				{
 					LFile f;
 					if (f.Open(File1, O_READ))
 					{
 						LXmlTree x(GXT_NO_ENTITIES);
 						if (!x.Read(t1, &f, 0))
 						{
 							DeleteObj(t1);
 						}
 					}
 					else
 					{
 						DeleteObj(t1);
 					}
 				}
 				if (t2 && File2)
 				{
 					LFile f;
 					if (f.Open(File2, O_READ))
 					{
 						LXmlTree x(GXT_NO_ENTITIES);
 						if (!x.Read(t2, &f, 0))
 						{
 							DeleteObj(t2);
 						}
 					}
 					else
 					{
 						DeleteObj(t2);
 					}
 				}
 
 				if (Lst && t1 && t2)
 				{
 					Lst->Enabled(false);
 					Compare(t1, t2);
 					Lst->Enabled(true);
 				}
 
 				DeleteObj(t1);
 				DeleteObj(t2);
 			}
 		}
 	}
 
 	void Compare(LXmlTag *t1, LXmlTag *t2)
 	{
 		char s[1024];
 
 		if (stricmp(t1->GetTag(), t2->GetTag()) != 0)
 		{
 			snprintf(s, sizeof(s), "Different Tag: '%s' <-> '%s'", t1->GetTag(), t2->GetTag());
 			LListItem *i = new LListItem;
 			if (i)
 			{
 				i->SetText(s);
 				i->SetText(TagName(t1), 1);
 				Lst->Insert(i);
 			}
 		}
 
 		LHashTbl<StrKey<char,false>,LXmlAttr*> a;
 		for (int i=0; i<t1->Attr.Length(); i++)
 		{
 			LXmlAttr *a1 = &t1->Attr[i];
 			a.Add(a1->GetName(), a1);
 		}
 
 		for (int n=0; n<t2->Attr.Length(); n++)
 		{
 			LXmlAttr *a2 = &t2->Attr[n];
 			LXmlAttr *a1 = (LXmlAttr*) a.Find(a2->GetName());
 			if (a1)
 			{
 				if (strcmp(a1->GetValue(), a2->GetValue()) != 0)
 				{
 					snprintf(s, sizeof(s), "Different Attr Value: '%s' <-> '%s'", a1->GetValue(), a2->GetValue());
 					LListItem *i = new LListItem;
 					if (i)
 					{
 						i->SetText(s);
 						snprintf(s, sizeof(s), "%s.%s", TagName(t1), a1->GetName());
 						i->SetText(s, 1);
 						Lst->Insert(i);
 					}
 				}
 
 				a.Delete(a2->GetName());
 			}
 			else
 			{
 				snprintf(s, sizeof(s), "[Right] Missing Attr: '%s' = '%s'", a2->GetName(), a2->GetValue());
 				LListItem *i = new LListItem;
 				if (i)
 				{
 					i->SetText(s);
 					i->SetText(TagName(t1), 1);
 					Lst->Insert(i);
 				}
 			}
 		}
 
 		// char *Key;
 		// for (void *v = a.First(&Key); v; v = a.Next(&Key))
 		for (auto v : a)
 		{
 			LXmlAttr *a1 = v.value;
 			snprintf(s, sizeof(s), "[Left] Missing Attr: '%s' = '%s'", a1->GetName(), a1->GetValue());
 			LListItem *i = new LListItem;
 			if (i)
 			{
 				i->SetText(s);
 				i->SetText(TagName(t1), 1);
 				Lst->Insert(i);
 			}
 		}
 
 		if (t1->IsTag("string-group"))
 		{
 			LArray<LXmlTag*> r1, r2;
 			for (auto t: t1->Children)
 			{
 				char *Ref;
 				if ((Ref = t->GetAttr("ref")))
 				{
 					int r = atoi(Ref);
 					if (r)
 					{
 						r1[r] = t;
 					}
 				}
 			}
 			for (auto t: t2->Children)
 			{
 				char *Ref;
 				if ((Ref = t->GetAttr("ref")))
 				{
 					int r = atoi(Ref);
 					if (r)
 					{
 						r2[r] = t;
 					}
 				}
 			}
 
 			auto Max = MAX(r1.Length(), r2.Length());
 			for (int i = 0; i<Max; i++)
 			{
 				if (r1[i] && r2[i])
 				{
 					Compare(r1[i], r2[i]);
 				}
 				else if (r1[i])
 				{
 					snprintf(s, sizeof(s), "[Right] Missing String: Ref=%s, Def=%s", r1[i]->GetAttr("ref"), r1[i]->GetAttr("Define"));
 					LListItem *n = new LListItem;
 					if (n)
 					{
 						n->SetText(s);
 						n->SetText(TagName(r1[i]), 1);
 						Lst->Insert(n);
 					}
 				}
 				else if (r2[i])
 				{
 					snprintf(s, sizeof(s), "[Left] Missing String: Ref=%s, Def=%s", r2[i]->GetAttr("ref"), r2[i]->GetAttr("Define"));
 					LListItem *n = new LListItem;
 					if (n)
 					{
 						n->SetText(s);
 						n->SetText(TagName(r2[i]), 1);
 						Lst->Insert(n);
 					}
 				}
 			}
 		}
 		else
 		{
 			LXmlTag *c1 = t1->Children[0];
 			LXmlTag *c2 = t2->Children[0];
 			while (c1 && c2)
 			{
 				Compare(c1, c2);
 				c1 = t1->Children[0];
 				c2 = t2->Children[0];
 			}
 		}
 	}
 
 	void OnPosChange()
 	{
 		LRect c = GetClient();
 		if (Lst)
 		{
 			c.Inset(7, 7);
 			Lst->SetPos(c);
 		}
 	}
 };
 
 void AppWnd::Compare()
 {
 	auto s = new LFileSelect(this);
 	s->Type("Lgi Resource", "*.lr8");
 	s->Open([&](auto dlg, auto status)
 	{
 		if (status)
 			new ResCompare(GetCurFile(), dlg->Name());
 		delete dlg;
 	});
 }
 
 void AppWnd::ImportLang()
 {
 	// open dialog
 	auto Select = new LFileSelect(this);
 	Select->Type("Lgi Resources", "*.lr8;*.xml");
 	Select->Open([&](auto dlg, auto status)
 	{
 		if (status)
 		{
 			LFile F;
 			if (F.Open(dlg->Name(), O_READ))
 			{
 				SerialiseContext Ctx;
 				Ctx.Format = GetFormat(dlg->Name());
 
 				// convert file to Xml objects
 				LXmlTag *Root = new LXmlTag;
 				if (Root)
 				{
 					LXmlTree Tree(GXT_NO_ENTITIES);
 					if (Tree.Read(Root, &F, 0))
 					{
 						List<ResMenu> Menus;
 						List<ResStringGroup> Groups;
 						for (auto t: Root->Children)
 						{
 							if (t->IsTag("menu"))
 							{
 								ResMenu *Menu = new ResMenu(this);
 								if (Menu && Menu->Read(t, Ctx))
 								{
 									Menus.Insert(Menu);
 								}
 								else break;
 							}
 							else if (t->IsTag("string-group"))
 							{
 								ResStringGroup *g = new ResStringGroup(this);
 								if (g && g->Read(t, Ctx))
 								{
 									Groups.Insert(g);
 								}
 								else break;
 							}
 						}
 					
 						Ctx.PostLoad(this);
 
 						bool HasData = false;
 						for (auto g: Groups)
 						{
 							g->SetLanguages();
 
 							if (g->GetStrs()->Length() > 0 &&
 								g->GetLanguages() > 0)
 							{
 								HasData = true;
 							}
 						}
 
 						if (HasData)
 						{
 							List<LLanguage> Langs;
 							for (auto g: Groups)
 							{
 								for (int i=0; i<g->GetLanguages(); i++)
 								{
 									LLanguage *Lang = g->GetLanguage(i);
 									if (Lang)
 									{
 										bool Has = false;
 										for (auto l: Langs)
 										{
 											if (stricmp((char*)l, (char*)Lang) == 0)
 											{
 												Has = true;
 												break;
 											}
 										}
 										if (!Has)
 										{
 											Langs.Insert(Lang);
 										}
 									}
 								}
 							}
 
 							auto Dlg = new LangDlg(this, Langs);
 							Dlg->DoModal([&](auto dlg, auto id)
 							{
 								if (id == IDOK && Dlg->Lang)
 								{
 									LStringPipe Errors;
 							
 									int Matches = 0;
 									int NotFound = 0;
 									int Imported = 0;
 									int Different = 0;
 							
 									for (auto g: Groups)
 									{
 										List<ResString>::I Strings = g->GetStrs()->begin();
 										for (ResString *s=*Strings; s; s=*++Strings)
 										{
 											ResString *d = GetStrFromRef(s->GetRef());
 											if (d)
 											{
 												Matches++;
 
 												char *Str = s->Get(Dlg->Lang->Id);
 												char *Dst = d->Get(Dlg->Lang->Id);
 												if
 												(
 													(
 														Str &&
 														Dst &&
 														strcmp(Dst, Str) != 0
 													)
 													||
 													(
 														(Str != 0) ^
 														(Dst != 0)
 													)
 												)
 												{
 													Different++;
 													d->Set(Str, Dlg->Lang->Id);
 													Imported++;
 												}
 											}
 											else
 											{
 												NotFound++;
 										
 												char e[256];
 												snprintf(e, sizeof(e), "String ref=%i (%s)\n", s->GetRef(), s->GetDefine());
 												Errors.Push(e);
 											}
 										}
 									}
 
 									List<Resource> Lst;
 									if (ListObjects(Lst))
 									{
 										for (auto m: Menus)
 										{
 											// find matching menu in our list
 											ResMenu *Match = 0;
 											for (auto r: Lst)
 											{
 												ResMenu *n = dynamic_cast<ResMenu*>(r);
 												if (n && stricmp(n->Name(), m->Name()) == 0)
 												{
 													Match = n;
 													break;
 												}
 											}
 
 											if (Match)
 											{
 												// match strings
 												List<ResString> *Src = m->GetStrs();
 												List<ResString> *Dst = Match->GetStrs();
 										
 												for (auto s: *Src)
 												{
 													bool FoundRef = false;
 													for (auto d: *Dst)
 													{
 														if (s->GetRef() == d->GetRef())
 														{
 															FoundRef = true;
 
 															char *Str = s->Get(Dlg->Lang->Id);
 															if (Str)
 															{
 																char *Dst = d->Get(Dlg->Lang->Id);
 																if (!Dst || strcmp(Dst, Str))
 																{
 																	Different++;
 																}
 
 																d->Set(Str, Dlg->Lang->Id);
 																Imported++;
 															}
 															break;
 														}
 													}
 													if (!FoundRef)
 													{
 														NotFound++;
 
 														char e[256];
 														snprintf(e, sizeof(e), "MenuString ref=%i (%s)\n", s->GetRef(), s->GetDefine());
 														Errors.Push(e);
 													}
 												}
 
 												Match->SetLanguages();
 											}
 										}
 
 										for (auto r: Lst)
 										{
 											ResStringGroup *StrRes = dynamic_cast<ResStringGroup*>(r);
 											if (StrRes)
 											{
 												StrRes->SetLanguages();
 											}
 										}
 									}
 
 									char *ErrorStr = Errors.NewStr();
 							
 									LgiMsg(	this,
 											"Imported: %i\n"
 											"Matched: %i\n"
 											"Not matched: %i\n"
 											"Different: %i\n"
 											"Total: %i\n"
 											"\n"
 											"Import complete.\n"
 											"\n%s",
 											AppName,
 											MB_OK,
 											Imported,
 											Matches,
 											NotFound,
 											Different,
 											Matches + NotFound,
 											ErrorStr?ErrorStr:(char*)"");
 								}
 
 								delete dlg;
 							});
 						}
 						else
 						{
 							LgiMsg(this, "No language information to import", AppName, MB_OK);
 						}
 
 						// Groups.DeleteObjects();
 						// Menus.DeleteObjects();
 					}
 					else
 					{
 						LgiMsg(this, "Failed to parse XML from file.\nError: %s", AppName, MB_OK, Tree.GetErrorMsg());
 					}
 
 					DeleteObj(Root);
 				}
 			}
 		}
 
 		delete dlg;
 	});
 }
 
 bool AppWnd::Empty()
 {
 	// Delete any existing objects
 	List<Resource> l;
 	if (ListObjects(l))
 	{
 		for (auto It = l.begin(); It != l.end(); )
 		{
 			auto r = *It;
 			if (r->SystemObject())
 				l.Delete(It);
 			else
 				It++;
 		}
 
 		for (auto r: l)
 		{
 			DelObject(r);
 		}
 	}
 
 	return true;
 }
 
-bool AppWnd::OpenFile(const char *FileName, bool Ro)
+void AppWnd::OpenFile(const char *FileName, bool Ro, std::function<void(bool status)> Callback)
 {
+	bool Status = false;
+
 	if (stristr(FileName, ".lr8") ||
 		stristr(FileName, ".xml"))
 	{
-		return LoadLgi(FileName);
+		Status = LoadLgi(FileName);
 	}
 	else if (stristr(FileName, ".rc"))
 	{
 		LoadWin32(FileName);
-		return true;
+		Status = true;
 	}
 
-	return false;
+	if (Callback)
+		Callback(Status);
 }
 
 void AppWnd::SaveFile(const char *FileName, std::function<void(LString fileName, bool status)> Callback)
 {
 	if (stristr(FileName, ".lr8") ||
 		stristr(FileName, ".xml"))
 	{
 		auto r = SaveLgi(FileName);
 		if (Callback)
 			Callback(FileName, r);
 		return;
 	}
 
 	if (Callback)
 		Callback(FileName, false);
 }
 
 void AppWnd::GetFileTypes(LFileSelect *Dlg, bool Write)
 {
 	Dlg->Type("Lgi Resources", "*.lr8;*.xml");
 	if (!Write)
 	{
 		Dlg->Type("All Files", LGI_ALL_FILES);
 	}
 }
 
 // Lgi load/save
 bool AppWnd::TestLgi(bool Quite)
 {
 	bool Status = true;
 
 	List<Resource> l;
 	if (ListObjects(l))
 	{
 		ErrorCollection Errors;
 		for (auto r: l)
 		{
 			Status &= r->Test(&Errors);
 		}
 
 		if (Errors.StrErr.Length() > 0)
 		{
 			LStringPipe Sample;
 			for (int i=0; i<Errors.StrErr.Length(); i++)
 			{
 				ResString *s = Errors.StrErr[i].Str;
 				Sample.Print("Ref=%i, %s: %s\n",
 							s->GetRef(),
 							s->GetDefine(),
 							Errors.StrErr[i].Msg.Get());
 			}
 			char *Sam = Sample.NewStr();
 			LgiMsg(this, "%i strings have errors.\n\n%s", AppName, MB_OK, Errors.StrErr.Length(), Sam);
 			DeleteArray(Sam);
 		}
 		else if (!Quite)
 		{
 			LgiMsg(this, "Object are all ok.", AppName);
 		}
 	}
 
 	return Status;
 }
 
 #define PROFILE_LOAD	0
 #if PROFILE_LOAD
 #define PROF(s) prof.Add(s)
 #else
 #define PROF(s)
 #endif
 
 bool AppWnd::LoadLgi(const char *FileName)
 {
 #if PROFILE_LOAD
 LProfile prof("LoadLgi");
 #endif
 
 	Empty();
 
 	if (!FileName)
 		return false;
 
 PROF("fOpen");
 	LFile f;
 	if (!f.Open(FileName, O_READ))
 		return false;
 
 PROF("prog");
 	LAutoPtr<LProgressDlg> Progress(new LProgressDlg(this));
 
 	Progress->SetDescription("Initializing...");
 	Progress->SetType("Tags");
 
 	LAutoPtr<LXmlTag> Root(new LXmlTag);
 	if (!Root)
 		return false;
 
 	// convert file to Xml objects
 	LXmlTree Xml(0);
 		
 	Progress->SetDescription("Lexing...");
 		
 PROF("xml.read");
 	if (!Xml.Read(Root, &f, 0))
 	{
 		LgiMsg(this, "Xml read failed: %s", AppName, MB_OK, Xml.GetErrorMsg());
 		return false;
 	}
 
 	Progress->SetRange(Root->Children.Length());
 
 PROF("xml to objs");
 	// convert Xml list into objects
 	SerialiseContext Ctx;
 	for (auto t: Root->Children)
 	{
 		Progress->Value(Root->Children.IndexOf(t));
 
 		int RType = 0;
 		if (t->IsTag("dialog"))
 			RType = TYPE_DIALOG;
 		else if (t->IsTag("string-group"))
 			RType = TYPE_STRING;
 		else if (t->IsTag("menu"))
 			RType = TYPE_MENU;
 		else if (t->IsTag("style"))
 			RType = TYPE_CSS;
 		else
 			LAssert(!"Unexpected tag");
 
 		if (RType > 0)
 			NewObject(Ctx, t, RType, false);
 	}
 					
 PROF("postload");
 	Ctx.PostLoad(this);
 
 PROF("sort");
 	SortDialogs();
 
 PROF("test");
 	TestLgi();
 
 PROF("scan langs");
 	// Scan for languages and update the view lang menu
 	Languages.Length(0);
 	LHashTbl<ConstStrKey<char,false>, LLanguage*> Langs;
 	if (!ViewMenu)
 		return false;
 
 PROF("remove menu items");
 	// Remove existing language menu items
 	while (ViewMenu->RemoveItem(1));
 	ViewMenu->AppendSeparator();
 
 PROF("enum objs");
 	// Enumerate all languages
 	List<Resource> res;
 	if (ListObjects(res))
 	{
 		for (auto r: res)
 		{
 			ResStringGroup *Sg = r->IsStringGroup();
 			if (Sg)
 			{
 				for (int i=0; i<Sg->GetLanguages(); i++)
 				{
 					LLanguage *Lang = Sg->GetLanguage(i);
 					if (Lang)
 					{
 						Langs.Add(Lang->Id, Lang);
 					}
 				}									
 			}
 		}
 	}
 
 PROF("update langs");
 	// Update languages array
 	int n = 0;
 	for (auto i : Langs)
 	{
 		Languages.Add(i.value);
 		auto Item = ViewMenu->AppendItem(i.value->Name, IDM_LANG_BASE + n, true);
 		if (Item && i.value->IsEnglish())
 		{
 			Item->Checked(true);
 			CurLang = n;
 		}
 		n++;
 	}
 
 PROF("none menu");
 	if (Languages.Length() == 0)
 		ViewMenu->AppendItem("(none)", -1, false);
 
 	return true;
 }
 
 void SerialiseContext::PostLoad(AppWnd *App)
 {
 	for (int i=0; i<FixId.Length(); i++)
 	{
 		ResString *s = FixId[i];
 		int Id = App->GetUniqueCtrlId();
 		s->SetId(Id);
 		Log.Print("Repaired CtrlId of string ref %i to %i\n", s->GetRef(), Id);
 	}
 	
 	LAutoString a(Log.NewStr());
 	if (ValidStr(a))
 	{
 		LgiMsg(App, "%s", "Load Warnings", MB_OK, a.Get());
 	}
 }
 
 int DialogNameCompare(ResDialog *a, ResDialog *b, NativeInt Data)
 {
 	const char *A = (a)?a->Name():0;
 	const char *B = (b)?b->Name():0;
 	if (A && B) return stricmp(A, B);
 	return -1;
 }
 
 void AppWnd::SortDialogs()
 {
 	List<Resource> Lst;
 	if (ListObjects(Lst))
 	{
 		List<ResDialog> Dlgs;
 		for (auto r: Lst)
 		{
 			ResDialog *Dlg = dynamic_cast<ResDialog*>(r);
 			if (Dlg)
 			{
 				Dlgs.Insert(Dlg);
 				Dlg->Item->Remove();
 			}
 		}
 
 		Dlgs.Sort(DialogNameCompare);
 
 		for (auto d: Dlgs)
 		{
 			Objs->Dialogs->Insert(d->Item);
 		}
 	}
 }
 
 class ResTreeNode
 {
 public:
 	char *Str;
 	ResTreeNode *a, *b;
 	ResTreeNode(char *s)
 	{
 		a = b = 0;
 		Str = s;
 	}
 
 	~ResTreeNode()
 	{
 		DeleteArray(Str);
 		DeleteObj(a);
 		DeleteObj(b);
 	}
 
 	void Enum(List<char> &l)
 	{
 		if (a)
 		{
 			a->Enum(l);
 		}
 
 		if (Str)
 		{
 			l.Insert(Str);
 		}
 
 		if (b)
 		{
 			b->Enum(l);
 		}
 	}
 
 	bool Add(char *s)
 	{
 		int Comp = (Str && s) ? stricmp(Str, s) : -1;
 		if (Comp == 0)
 		{
 			return false;
 		}
 
 		if (Comp < 0)
 		{
 			if (a)
 			{
 				return a->Add(s);
 			}
 			else
 			{
 				a = new ResTreeNode(s);
 			}
 		}
 
 		if (Comp > 0)
 		{
 			if (b)
 			{
 				return b->Add(s);
 			}
 			else
 			{
 				b = new ResTreeNode(s);
 			}
 		}
 		return true;
 	}
 };
 
 class ResTree {
 
 	ResTreeNode *Root;
 
 public:
 	ResTree()
 	{
 		Root = 0;
 	}
 
 	~ResTree()
 	{
 		DeleteObj(Root);
 	}
 
 	bool Add(char *s)
 	{
 		if (s)
 		{
 			if (!Root)
 			{
 				Root = new ResTreeNode(NewStr(s));
 				return true;
 			}
 			else
 			{
 				return Root->Add(NewStr(s));
 			}
 		}
 
 		return false;
 	}
 
 	void Enum(List<char> &l)
 	{
 		if (Root)
 		{
 			Root->Enum(l);
 		}
 	}
 };
 
 const char *HeaderStr = "// This file generated by LgiRes\r\n\r\n";
 	
 struct DefinePair
 {
 	char *Name;
 	int Value;
 };
 
 int PairCmp(DefinePair *a, DefinePair *b)
 {
 	return a->Value - b->Value;
 }
 
 bool AppWnd::WriteDefines(LStream &Defs)
 {
 	bool Status = false;
 	ResTree Tree;
 
 	// Empty file
 	Defs.Write(HeaderStr, strlen(HeaderStr));
 
 	// make a unique list of #define's
 	List<Resource> Lst;
 	if (ListObjects(Lst))
 	{
 		LHashTbl<StrKey<char>,int> Def;
 		LHashTbl<StrKey<char>,char*> Ident;
 
 		for (auto r: Lst)
 		{
 			List<ResString> *StrList = r->GetStrs();
 			if (StrList)
 			{
 				Status = true;
 				List<ResString>::I sl = StrList->begin();
 				for (ResString *s = *sl; s; s = *++sl)
 				{
 					if (ValidStr(s->GetDefine()))
 					{
 						if (stricmp(s->GetDefine(), "IDOK") == 0)
 						{
 							s->SetId(IDOK);
 						}
 						else if (stricmp(s->GetDefine(), "IDCANCEL") == 0)
 						{
 							s->SetId(IDCANCEL);
 						}
 						else if (stricmp(s->GetDefine(), "IDC_STATIC") == 0)
 						{
 							s->SetId(-1);
 						}
 						else if (stricmp(s->GetDefine(), "-1") == 0)
 						{
 							s->SetDefine(0);
 						}
 						else
 						{
 							// Remove dupe ID's
 							char IdStr[32];
 							snprintf(IdStr, sizeof(IdStr), "%i", s->GetId());
 							char *Define;
 							if ((Define = Ident.Find(IdStr)))
 							{
 								if (strcmp(Define, s->GetDefine()))
 								{
 									List<ResString> n;
 									FindStrings(n, s->GetDefine());
 									int NewId = GetUniqueCtrlId();
 									for (auto Ns: n)
 									{
 										Ns->SetId(NewId);
 									}
 								}
 							}
 							else
 							{
 								Ident.Add(IdStr, s->GetDefine());
 							}
 
 							// Make all define's the same
 							int CtrlId;
 							if ((CtrlId = Def.Find(s->GetDefine())))
 							{
 								// Already there...
 								s->SetId(CtrlId);
 							}
 							else
 							{
 								// Add...
 								LAssert(s->GetId());
 								if (s->GetId())
 									Def.Add(s->GetDefine(), s->GetId());
 							}
 						}
 					}
 				}
 			}
 		}
 
 		// write the list out
 		LArray<DefinePair> Pairs;
 		// char *s = 0;
 		// for (int i = Def.First(&s); i; i = Def.Next(&s))
 		for (auto i : Def)
 		{
 			if (ValidStr(i.key) &&
 				stricmp(i.key, "IDOK") != 0 &&
 				stricmp(i.key, "IDCANCEL") != 0 &&
 				stricmp(i.key, "IDC_STATIC") != 0 &&
 				stricmp(i.key, "-1") != 0)
 			{
 				DefinePair &p = Pairs.New();
 				p.Name = i.key;
 				p.Value = i.value;
 			}
 		}
 
 		Pairs.Sort(PairCmp);
 
 		for (int n=0; n<Pairs.Length(); n++)
 		{
 			DefinePair &p = Pairs[n];
 			auto Tabs = (43 - strlen(p.Name)) / 4;
 			char Tab[32];
 			ZeroObj(Tab);
 			for (size_t n=0; n<Tabs; n++) Tab[n] = '\t';
 
 			char s[4];
 			memcpy(s, &p.Value, 4);
 			#define IsPrintable(c) ((uint8_t)(c)>=' ' && (uint8_t)(c) <= 127)
 			if (IsPrintable(s[0]) &&
 				IsPrintable(s[1]) &&
 				IsPrintable(s[2]) &&
 				IsPrintable(s[3]))
 			{
 				#ifndef __BIG_ENDIAN__
 				int32 i = LgiSwap32(p.Value);
 				memcpy(s, &i, 4);
 				#endif
 				Defs.Print("#define %s%s'%04.4s'\r\n", p.Name, Tab, s);
 			}
 			else
 				Defs.Print("#define %s%s%i\r\n", p.Name, Tab, p.Value);
 		}
 	}
 
 	return Status;
 }
 
 bool AppWnd::SaveLgi(const char *FileName)
 {
 	bool Status = false;
 
 	if (!TestLgi())
 	{
 		if (LgiMsg(this, "Do you want to save the file with errors?", AppName, MB_YESNO) == IDNO)
 			return false;
 	}
 
 	// Rename the existing file to 'xxxxxx.bak'
 	if (LFileExists(FileName))
 	{
 		char Bak[MAX_PATH_LEN];
 		strcpy_s(Bak, sizeof(Bak), FileName);
 		char *e = LGetExtension(Bak);
 		if (e)
 		{
 			strcpy(e, "bak");
 			if (LFileExists(Bak))
 				FileDev->Delete(Bak, false);
 
 			FileDev->Move(FileName, Bak);
 		}
 	}
 
 	// Save the file to xml
 	if (FileName)
 	{
 		LFile f;
 		LFile::Path DefsName = FileName;
 		DefsName += "../resdefs.h";
 
 		LStringPipe Defs;
 
 		if (f.Open(FileName, O_WRITE))
 		{
 			SerialiseContext Ctx;
 			
 			f.SetSize(0);
 			Defs.SetSize(0);
 			Defs.Print("// Generated by LgiRes\r\n\r\n");
 
 			List<Resource> l;
 			if (ListObjects(l))
 			{
 				// Remove all duplicate symbol Id's from the dialogs
 				for (auto r: l)
 				{
 					ResDialog *Dlg = dynamic_cast<ResDialog*>(r);
 					if (Dlg)
 						Dlg->CleanSymbols();
 				}
 
 				// write defines
 				WriteDefines(Defs);
 
 				LXmlTag Root("resources");
 				// Write all string lists out first so that when we load objects
 				// back in again the strings will already be loaded and can
 				// be referenced
 				for (auto r: l)
 				{
 					if (r->Type() == TYPE_STRING)
 					{
 						LXmlTag *c = new LXmlTag;
 						if (c && r->Write(c, Ctx))
 						{
 							Root.InsertTag(c);
 						}
 						else
 						{
 							LAssert(0);
 							DeleteObj(c);
 						}
 					}
 				}
 
 				// now write the rest of the objects out
 				for (auto r: l)
 				{
 					if (r->Type() != TYPE_STRING)
 					{
 						LXmlTag *c = new LXmlTag;
 						if (c && r->Write(c, Ctx))
 						{
 							Root.InsertTag(c);
 						}
 						else
 						{
 							r->Write(c, Ctx);
 							LAssert(0);
 							DeleteObj(c);
 						}
 					}
 				}
 
 				// Set the offset type.
 				//
 				// Older versions of LgiRes stored the dialog's controls at a fixed
 				// offset (3,17) from where they should've been. That was fixed, but
 				// to differentiate between the 2 systems, we store a tag at the
 				// root element.
 				Root.SetAttr("Offset", 1);
 
 				LXmlTree Tree(GXT_NO_ENTITIES);
 				Status = Tree.Write(&Root, &f);
 				if (Status)
 				{
 					// Also write the header... but only if it's changed...
 					auto DefsContent = Defs.NewLStr();
 					LAutoString OldDefsContent(LReadTextFile(DefsName));
 					if (Strcmp(DefsContent.Get(), OldDefsContent.Get()))
 					{
 						LFile DefsFile;
 						if (!DefsFile.Open(DefsName, O_WRITE))
 							goto FileErrorMsg;
 
 						DefsFile.SetSize(0);
 						DefsFile.Write(DefsContent);
 					}
 				}
 			}
 		}
 		else
 		{
 			FileErrorMsg:
 			LgiMsg(this,
 					"Couldn't open these files for output:\n"
 					"\t%s\n"
 					"\t%s\n"
 					"\n"
 					"Maybe they are read only or locked by another application.",
 					AppName,
 					MB_OK,
 					FileName,
 					DefsName.GetFull().Get());
 		}
 	}
 
 	return Status;
 }
 
 // Win32 load/save
 #define ADJUST_CTRLS_X				2
 #define ADJUST_CTRLS_Y				12
 
 #define IMP_MODE_SEARCH				0
 #define IMP_MODE_DIALOG				1
 #define IMP_MODE_DLG_CTRLS			2
 #define IMP_MODE_STRINGS			3
 #define IMP_MODE_MENU				4
 
 class ImportDefine
 {
 public:
 	char *Name;
 	char *Value;
 
 	ImportDefine()
 	{
 		Name = Value = 0;
 	}
 
 	ImportDefine(char *Line)
 	{
 		Name = Value = 0;
 		if (Line && *Line == '#')
 		{
 			Line++;
 			if (strnicmp(Line, "define", 6) == 0)
 			{
 				Line += 6;
 				Line = LSkipDelim(Line);
 				char *Start = Line;
 				const char *WhiteSpace = " \r\n\t";
 				while (*Line && !strchr(WhiteSpace, *Line))
 				{
 					Line++;
 				}
 
 				Name = NewStr(Start, Line-Start);
 				Line = LSkipDelim(Line);
 				Start = Line;
 				while (*Line && !strchr(WhiteSpace, *Line))
 				{
 					Line++;
 				}
 				if (Start != Line)
 				{
 					Value = NewStr(Start, Line-Start);
 				}
 			}
 		}
 	}
 
 	~ImportDefine()
 	{
 		DeleteArray(Name);
 		DeleteArray(Value);
 	}
 };
 
 class DefineList : public List<ImportDefine>
 {
 	int NestLevel;
 
 public:
 	bool Defined;
 	List<char> IncludeDirs;
 
 	DefineList()
 	{
 		Defined = true;
 		NestLevel = 0;
 	}
 
 	~DefineList()
 	{
 		for (auto i: *this)
 		{
 			DeleteObj(i);
 		}
 
 		for (auto c: IncludeDirs)
 		{
 			DeleteArray(c);
 		}
 	}
 	
 	void DefineSymbol(const char *Name, const char *Value = 0)
 	{
 		ImportDefine *Def = new ImportDefine;
 		if (Def)
 		{
 			Def->Name = NewStr(Name);
 			if (Value) Def->Value = NewStr(Value);
 			Insert(Def);
 		}
 	}
 
 	ImportDefine *GetDefine(char *Name)
 	{
 		if (Name)
 		{
 			for (auto i: *this)
 			{
 				if (i->Name && stricmp(i->Name, Name) == 0)
 				{
 					return i;
 				}
 			}
 		}
 		return NULL;
 	}
 
 	void ProcessLine(char *Line)
 	{
 		if (NestLevel > 16)
 		{
 			return;
 		}
 
 		if (Line && *Line == '#')
 		{
 			Line++;
 			LToken T(Line);
 
 			if (T.Length() > 0)
 			{
 				if (stricmp(T[0], "define") == 0) // #define
 				{
 					ImportDefine *Def = new ImportDefine(Line-1);
 					if (Def)
 					{
 						if (Def->Name)
 						{
 							Insert(Def);
 						}
 						else
 						{
 							DeleteObj(Def);
 						}
 					}
 				}
 				else if (stricmp(T[0], "include") == 0) // #include
 				{
 					NestLevel++;
 
 					LFile F;
 					if (T.Length() > 1)
 					{
 						for (auto IncPath: IncludeDirs)
 						{
 							char FullPath[256];
 
 							strcpy(FullPath, IncPath);
 							if (FullPath[strlen(FullPath)-1] != DIR_CHAR)
 							{
 								strcat(FullPath, DIR_STR);
 							}
 							strcat(FullPath, T[1]);
 
 							if (F.Open(FullPath, O_READ))
 							{
 								char Line[1024];
 								while (!F.Eof())
 								{
 									F.ReadStr(Line, sizeof(Line));
 									char *p = LSkipDelim(Line);
 									if (*p == '#')
 									{
 										ProcessLine(p);
 									}
 								}
 
 								break;
 							}
 						}
 					}
 
 					NestLevel--;
 				}
 				else if (stricmp(T[0], "if") == 0) // #if
 				{
 				}
 				else if (stricmp(T[0], "ifdef") == 0) // #if
 				{
 					if (T.Length() > 1)
 					{
 						Defined = GetDefine(T[1]) != 0;
 					}
 				}
 				else if (stricmp(T[0], "endif") == 0) // #endif
 				{
 					Defined = true;
 				}
 				else if (stricmp(T[0], "pragma") == 0)
 				{
 					ImportDefine *Def = new ImportDefine;
 					if (Def)
 					{
 						char *Str = Line + 7;
 						char *First = strchr(Str, '(');
 						char *Second = (First) ? strchr(First+1, ')') : 0;
 						if (First && Second)
 						{
 							Insert(Def);
 							Def->Name = NewStr(Str, First-Str);
 							First++;
 							Def->Value = NewStr(First, Second-First);
 						}
 						else
 						{
 							DeleteObj(Def);
 						}
 					}
 				}
 				else if (stricmp(T[0], "undef") == 0)
 				{
 				}
 			}
 		}
 		// else it's not for us anyway
 	}
 };
 
 void TokLine(LArray<char*> &T, char *Line)
 {
 	if (Line)
 	{
 		// Exclude comments
 		for (int k=0; Line[k]; k++)
 		{
 			if (Line[k] == '/' && Line[k+1] == '/')
 			{
 				Line[k] = 0;
 				break;
 			}
 		}
 		
 		// Break into tokens
 		for (const char *s = Line; s && *s; )
 		{
 			while (*s && strchr(" \t", *s)) s++;
 			char *t = LTokStr(s);
 			if (t)
 				T.Add(t);
 			else break;
 		}
 	}
 }
 
 
 
 void AppWnd::LoadWin32(const char *FileName)
 {
 	bool Status = false;
 	LHashTbl<ConstStrKey<char,false>,bool> CtrlNames;
 	CtrlNames.Add("LTEXT", true);
 	CtrlNames.Add("EDITTEXT", true);
 	CtrlNames.Add("COMBOBOX", true);
 	CtrlNames.Add("SCROLLBAR", true);
 	CtrlNames.Add("GROUPBOX", true);
 	CtrlNames.Add("PUSHBUTTON", true);
 	CtrlNames.Add("DEFPUSHBUTTON", true);
 	CtrlNames.Add("CONTROL", true);
 	CtrlNames.Add("ICON", true);
 	CtrlNames.Add("LISTBOX", true);
 
 	Empty();
 
 	auto Load = [&](const char *FileName)
 	{
 		if (!FileName)
 			return;
 
 		LProgressDlg Progress(this);
 
 		Progress.SetDescription("Initializing...");
 		Progress.SetType("K");
 		Progress.SetScale(1.0/1024.0);
 
 		char *FileTxt = LReadTextFile(FileName);
 		if (FileTxt)
 		{
 			LToken Lines(FileTxt, "\r\n");
 			DeleteArray(FileTxt);
 
 			DefineList Defines;
 			ResStringGroup *String = new ResStringGroup(this);
 			int Mode = IMP_MODE_SEARCH;
 
 			// Language
 			char *Language = 0;
 			LLanguageId LanguageId = 0;
 
 			// Dialogs
 			List<ResDialog> DlLList;
 			CtrlDlg *Dlg = 0;
 
 			// Menus
 			ResDialog *Dialog = 0;
 			ResMenu *Menu = 0;
 			List<ResMenu> Menus;
 			ResMenuItem *MenuItem[32];
 			int MenuLevel = 0;
 			bool MenuNewLang = false;
 			int MenuNextItem = 0;
 
 			// Include defines
 			char IncPath[256];
 			strcpy(IncPath, FileName);
 			LTrimDir(IncPath);
 			Defines.IncludeDirs.Insert(NewStr(IncPath));
 
 			Defines.DefineSymbol("_WIN32");
 			Defines.DefineSymbol("IDC_STATIC", "-1");
 
 			DoEvery Ticker(200);
 			Progress.SetDescription("Reading resources...");
 			Progress.SetRange(Lines.Length());
 
 			if (String)
 			{
 				InsertObject(TYPE_STRING, String, false);
 			}
 
 			for (int CurLine = 0; CurLine < Lines.Length(); CurLine++)
 			{
 				if (Ticker.DoNow())
 				{
 					Progress.Value(CurLine);
 				}
 				
 				// Skip white space
 				char *Line = Lines[CurLine];
 				char *p = LSkipDelim(Line);
 				Defines.ProcessLine(Line);
 
 				// Tokenize
 				LArray<char*> T;
 				TokLine(T, Line);
 
 				// Process line
 				if (Defines.Defined)
 				{
 					switch (Mode)
 					{
 						case IMP_MODE_SEARCH:
 						{
 							DeleteObj(Dialog);
 							Dlg = 0;
 							if (*p != '#')
 							{
 								if (T.Length() > 1 &&
 									(stricmp(T[1], "DIALOG") == 0 ||
 									 stricmp(T[1], "DIALOGEX") == 0))
 								{
 									Mode = IMP_MODE_DIALOG;
 									Dialog = new ResDialog(this);
 									if (Dialog)
 									{
 										Dialog->Create(NULL, NULL);
 										Dialog->Name(T[0]);
 
 										auto It = Dialog->IterateViews();
 										Dlg = dynamic_cast<CtrlDlg*>(It[0]);
 										if (Dlg)
 										{
 											int Pos[4] = {0, 0, 0, 0};
 											int i = 0;
 											for (; i<T.Length() && !LIsNumber(T[i]); i++)
 												;
 											for (int n=0; n<4; n++)
 											{
 												if (i+n<T.Length() && LIsNumber(T[i+n]))
 												{
 													Pos[n] = atoi(T[i+n]);
 												}
 												else
 												{
 													break;
 												}
 											}
 
 											LRect r(Pos[0], Pos[1], Pos[0]+(Pos[2]*DIALOG_X), Pos[1]+(Pos[3]*DIALOG_Y));
 											r.Offset(7, 7);
 											Dlg->ResDialogCtrl::SetPos(r);
 											Dlg->GetStr()->SetDefine(T[0]);
 											ImportDefine *Def = Defines.GetDefine(T[0]);
 											if (Def)
 											{
 												Dlg->GetStr()->SetId(atoi(Def->Value));
 											}
 										}
 									}
 									break;
 								}
 
 								if (T.Length() > 1 &&
 									stricmp(T[1], "MENU") == 0)
 								{
 									ZeroObj(MenuItem);
 									Mode = IMP_MODE_MENU;
 									Menu = 0;
 
 									// Check for preexisting menu in another language
 									MenuNewLang = false;
 									for (auto m: Menus)
 									{
 										if (stricmp(m->Name(), T[0]) == 0)
 										{
 											MenuNewLang = true;
 											Menu = m;
 											break;
 										}
 									}
 
 									// If it doesn't preexist then create it
 									if (!Menu)
 									{
 										Menu = new ResMenu(this);
 										if (Menu)
 										{
 											Menus.Insert(Menu);
 											Menu->Create(NULL, NULL);
 											Menu->Name(T[0]);
 										}
 									}
 									break;
 								}
 
 								if (T.Length() > 0 &&
 									stricmp(T[0], "STRINGTABLE") == 0)
 								{
 									Mode = IMP_MODE_STRINGS;
 									if (String)
 									{
 										String->Name("_Win32 Imports_");
 									}
 									break;
 								}
 
 								if (T.Length() > 2 &&
 									stricmp(T[0], "LANGUAGE") == 0)
 								{
 									LanguageId = 0;
 									DeleteArray(Language);
 									char *Language = NewStr(T[1]);
 									if (Language)
 									{
 										LLanguage *Info = LFindLang(0, Language);
 										if (Info)
 										{
 											LanguageId = Info->Id;
 											ResDialog::AddLanguage(Info->Id);
 										}
 									}
 									break;
 								}
 							}
 							break;
 						}
 						case IMP_MODE_DIALOG:
 						{
 							if (T.Length() > 0 && Dlg)
 							{
 								if (stricmp(T[0], "CAPTION") == 0)
 								{
 									char *Caption = T[1];
 									if (Caption)
 									{
 										Dlg->GetStr()->Set(Caption, LanguageId);
 									}
 								}
 								else if (stricmp(T[0], "BEGIN") == 0)
 								{
 									Mode = IMP_MODE_DLG_CTRLS;
 								}
 							}
 							break;
 						}
 						case IMP_MODE_DLG_CTRLS:
 						{
 							char *Type = T[0];
 							if (!Type) break;
 
 							if (stricmp(Type, "end") != 0)
 							{
 								// Add wrapped content to the token array.
 								char *Next = Lines[CurLine+1];
 								if (Next)
 								{
 									Next = LSkipDelim(Next);
 									char *NextTok = LTokStr((const char*&)Next);
 									if (NextTok)
 									{
 										if (stricmp(NextTok, "END") != 0 &&
 											!CtrlNames.Find(NextTok))
 										{
 											TokLine(T, Lines[++CurLine]);
 										}
 
 										DeleteArray(NextTok);
 									}
 								}
 							}
 							
 							// Process controls
 							if (stricmp(Type, "LTEXT") == 0)
 							{
 								if (T.Length() >= 7)
 								{
 									CtrlText *Ctrl = new CtrlText(Dialog, 0);
 									if (Ctrl)
 									{
 										Ctrl->GetStr()->Set(T[1], LanguageId);
 										Ctrl->GetStr()->SetDefine(T[2]);
 										ImportDefine *Def = Defines.GetDefine(T[2]);
 										if (Def)
 										{
 											Ctrl->GetStr()->SetId(atoi(Def->Value));
 										}
 
 										LRect r;
 										r.ZOff(atoi(T[5])*CTRL_X, atoi(T[6])*CTRL_Y);
 										r.Offset(atoi(T[3])*CTRL_X+ADJUST_CTRLS_X, atoi(T[4])*CTRL_Y+ADJUST_CTRLS_Y);
 										Ctrl->ResDialogCtrl::SetPos(r);
 
 										Dlg->AddView(Ctrl);
 									}
 								}
 							}
 							else if (stricmp(Type, "EDITTEXT") == 0)
 							{
 								if (T.Length() >= 7)
 								{
 									CtrlEditbox *Ctrl = new CtrlEditbox(Dialog, 0);
 									if (Ctrl)
 									{
 										Ctrl->GetStr()->SetDefine(T[1]);
 										ImportDefine *Def = Defines.GetDefine(T[1]);
 										if (Def)
 										{
 											Ctrl->GetStr()->SetId(atoi(Def->Value));
 										}
 
 										LRect r;
 										r.ZOff(atoi(T[4])*CTRL_X, atoi(T[5])*CTRL_Y);
 										r.Offset(atoi(T[2])*CTRL_X+ADJUST_CTRLS_X, atoi(T[3])*CTRL_Y+ADJUST_CTRLS_Y);
 										Ctrl->ResDialogCtrl::SetPos(r);
 
 										Dlg->AddView(Ctrl);
 									}
 								}
 							}
 							else if (stricmp(Type, "COMBOBOX") == 0)
 							{
 								if (T.Length() >= 6)
 								{
 									CtrlComboBox *Ctrl = new CtrlComboBox(Dialog, 0);
 									if (Ctrl)
 									{
 										Ctrl->GetStr()->SetDefine(T[1]);
 										ImportDefine *Def = Defines.GetDefine(T[1]);
 										if (Def)
 										{
 											Ctrl->GetStr()->SetId(atoi(Def->Value));
 										}
 
 										LRect r;
 										r.ZOff(atoi(T[4])*CTRL_X, atoi(T[5])*CTRL_Y);
 										r.Offset(atoi(T[2])*CTRL_X+ADJUST_CTRLS_X, atoi(T[3])*CTRL_Y+ADJUST_CTRLS_Y);
 										Ctrl->ResDialogCtrl::SetPos(r);
 
 										Dlg->AddView(Ctrl);
 									}
 								}
 							}
 							else if (stricmp(Type, "SCROLLBAR") == 0)
 							{
 								if (T.Length() == 6)
 								{
 									CtrlScrollBar *Ctrl = new CtrlScrollBar(Dialog, 0);
 									if (Ctrl)
 									{
 										Ctrl->GetStr()->SetDefine(T[1]);
 										ImportDefine *Def = Defines.GetDefine(T[1]);
 										if (Def)
 										{
 											Ctrl->GetStr()->SetId(atoi(Def->Value));
 										}
 
 										LRect r;
 										r.ZOff(atoi(T[4])*CTRL_X, atoi(T[5])*CTRL_Y);
 										r.Offset(atoi(T[2])*CTRL_X+ADJUST_CTRLS_X, atoi(T[3])*CTRL_Y+ADJUST_CTRLS_Y);
 										Ctrl->ResDialogCtrl::SetPos(r);
 
 										Dlg->AddView(Ctrl);
 									}
 								}
 							}
 							else if (stricmp(Type, "GROUPBOX") == 0)
 							{
 								if (T.Length() >= 7)
 								{
 									CtrlGroup *Ctrl = new CtrlGroup(Dialog, 0);
 									if (Ctrl)
 									{
 										Ctrl->GetStr()->Set(T[1], LanguageId);
 										Ctrl->GetStr()->SetDefine(T[2]);
 										ImportDefine *Def = Defines.GetDefine(T[2]);
 										if (Def)
 										{
 											Ctrl->GetStr()->SetId(atoi(Def->Value));
 										}
 
 										LRect r;
 										r.ZOff(atoi(T[5])*CTRL_X, atoi(T[6])*CTRL_Y);
 										r.Offset(atoi(T[3])*CTRL_X+ADJUST_CTRLS_X, atoi(T[4])*CTRL_Y+ADJUST_CTRLS_Y);
 										Ctrl->ResDialogCtrl::SetPos(r);
 
 										Dlg->AddView(Ctrl);
 									}
 								}
 							}
 							else if (stricmp(Type, "PUSHBUTTON") == 0 ||
 									 stricmp(Type, "DEFPUSHBUTTON") == 0)
 							{
 								if (T.Length() >= 7)
 								{
 									CtrlButton *Ctrl = new CtrlButton(Dialog, 0);
 									if (Ctrl)
 									{
 										Ctrl->GetStr()->Set(T[1], LanguageId);
 										Ctrl->GetStr()->SetDefine(T[2]);
 										ImportDefine *Def = Defines.GetDefine(T[2]);
 										if (Def)
 										{
 											Ctrl->GetStr()->SetId(atoi(Def->Value));
 										}
 
 										LRect r;
 										r.ZOff(atoi(T[5])*CTRL_X, atoi(T[6])*CTRL_Y);
 										r.Offset(atoi(T[3])*CTRL_X+ADJUST_CTRLS_X, atoi(T[4])*CTRL_Y+ADJUST_CTRLS_Y);
 										Ctrl->ResDialogCtrl::SetPos(r);
 
 										Dlg->AddView(Ctrl);
 									}
 								}
 							}
 							else if (stricmp(Type, "CONTROL") == 0)
 							{
 								if (T.Length() >= 7)
 								{
 									char *Caption = T[1];
 									char *Id = T[2];
 									char *Type = T[3];
 									bool Checkbox = false;
 									bool Radio = false;
 									bool Done = false;
 
 									// loop through styles
 									int i;
 									for (i=4; !Done && i<T.Length(); i++)
 									{
 										Done = true;
 										if (stricmp(T[i], "BS_AUTOCHECKBOX") == 0)
 										{
 											Checkbox = true;
 										}
 										else if (stricmp(T[i], "BS_AUTORADIOBUTTON") == 0)
 										{
 											Radio = true;
 										}
 
 										if (i<T.Length()-1 && stricmp(T[i+1], "|") == 0)
 										{
 											// next token is an || operator
 											i++;
 											Done = false; // read through more styles
 										}
 									}
 
 									LRect r(0, 0, 0, 0);
 									if (i + 3 < T.Length() && Type)
 									{
 										ResDialogCtrl *Ctrl = 0;
 										if (stricmp(Type, "Button") == 0)
 										{
 											if (Radio)
 											{
 												Ctrl = new CtrlRadio(Dialog, 0);
 											}
 											else if (Checkbox)
 											{
 												Ctrl = new CtrlCheckbox(Dialog, 0);
 											}
 										}
 										else if (stricmp(Type, "SysListView32") == 0)
 										{
 											Ctrl = new CtrlList(Dialog, 0);
 										}
 
 										if (Ctrl)
 										{
 											r.ZOff(atoi(T[i+2])*CTRL_X, atoi(T[i+3])*CTRL_Y);
 											r.Offset(atoi(T[i])*CTRL_X+ADJUST_CTRLS_X, atoi(T[i+1])*CTRL_Y+ADJUST_CTRLS_Y);
 											Ctrl->SetPos(r);
 
 											if (Caption) Ctrl->GetStr()->Set(Caption, LanguageId);
 											if (Id) Ctrl->GetStr()->SetDefine(Id);
 											ImportDefine *Def = Defines.GetDefine(Id);
 											if (Def)
 											{
 												Ctrl->GetStr()->SetId(atoi(Def->Value));
 											}
 
 											Dlg->AddView(Ctrl->View());
 										}
 									}
 								}
 							}
 							else if (stricmp(Type, "ICON") == 0)
 							{
 								if (T.Length() >= 7)
 								{
 									CtrlBitmap *Ctrl = new CtrlBitmap(Dialog, 0);
 									if (Ctrl)
 									{
 										Ctrl->GetStr()->SetDefine(T[1]);
 										ImportDefine *Def = Defines.GetDefine(T[1]);
 										if (Def)
 										{
 											Ctrl->GetStr()->SetId(atoi(Def->Value));
 										}
 
 										LRect r;
 										r.ZOff(atoi(T[5])*CTRL_X, atoi(T[6])*CTRL_Y);
 										r.Offset(atoi(T[3])*CTRL_X+ADJUST_CTRLS_X, atoi(T[4])*CTRL_Y+ADJUST_CTRLS_Y);
 										Ctrl->ResDialogCtrl::SetPos(r);
 
 										Dlg->AddView(Ctrl->View());
 									}
 								}
 							}
 							else if (stricmp(Type, "LISTBOX") == 0)
 							{
 								if (T.Length() >= 7)
 								{
 									CtrlList *Ctrl = new CtrlList(Dialog, 0);
 									if (Ctrl)
 									{
 										Ctrl->GetStr()->SetDefine(T[1]);
 										ImportDefine *Def = Defines.GetDefine(T[1]);
 										if (Def)
 										{
 											Ctrl->GetStr()->SetId(atoi(Def->Value));
 										}
 
 										LRect r;
 										r.ZOff(atoi(T[4])*CTRL_X, atoi(T[5])*CTRL_Y);
 										r.Offset(atoi(T[2])*CTRL_X+ADJUST_CTRLS_X, atoi(T[3])*CTRL_Y+ADJUST_CTRLS_Y);
 										Ctrl->ResDialogCtrl::SetPos(r);
 
 										Dlg->AddView(Ctrl);
 									}
 								}
 							}
 							else if (stricmp(Type, "END") == 0)
 							{
 								// search for an existing dialog resource in
 								// another language
 								ResDialog *Match = 0;
 								CtrlDlg *MatchObj = 0;
 								for (auto d: DlLList)
 								{
 									auto It = d->IterateViews();
 									LViewI *Wnd = It[0];
 									if (Wnd)
 									{
 										CtrlDlg *Obj = dynamic_cast<CtrlDlg*>(Wnd);
 										if (Obj)
 										{
 											if (Obj->GetStr()->GetId() == Dlg->GetStr()->GetId())
 											{
 												MatchObj = Obj;
 												Match = d;
 												break;
 											}
 										}
 									}
 								}
 
 								if (Match)
 								{
 									// Merge the controls from "Dlg" to "MatchObj"
 									List<ResDialogCtrl> Old;
 									List<ResDialogCtrl> New;
 									
 									Dlg->ListChildren(New);
 									MatchObj->ListChildren(Old);
 
 									// add the language strings for the caption
 									// without clobbering the languages already
 									// present
 									for (auto s: Dlg->GetStr()->Items)
 									{
 										if (!MatchObj->GetStr()->Get(s->GetLang()))
 										{
 											MatchObj->GetStr()->Set(s->GetStr(), s->GetLang());
 										}
 									}
 
 									for (auto c: New)
 									{
 										ResDialogCtrl *MatchCtrl = 0;
 
 										// try matching by Id
 										{
 											for (auto Mc: Old)
 											{
 												if (Mc->GetStr()->GetId() == c->GetStr()->GetId() &&
 													Mc->GetStr()->GetId() > 0)
 												{
 													MatchCtrl = Mc;
 													break;
 												}
 											}
 										}
 
 										// ok no Id match, match by location and type
 										if (!MatchCtrl)
 										{
 											List<ResDialogCtrl> Overlapping;
 											for (auto Mc: Old)
 											{
 												LRect a = Mc->View()->GetPos();
 												LRect b = c->View()->GetPos();
 												LRect c = a;
 												c.Bound(&b);
 												if (c.Valid())
 												{
 													int Sa = a.X() * a.Y();
 													int Sb = b.X() * b.Y();
 													int Sc = c.X() * c.Y();
 													int Total = Sa + Sb - Sc;
 													double Amount = (double) Sc / (double) Total;
 													if (Amount > 0.5)
 													{
 														// mostly similar in size
 														Overlapping.Insert(Mc);
 													}
 												}
 											}
 
 											if (Overlapping.Length() == 1)
 											{
 												MatchCtrl = Overlapping[0];
 											}
 										}
 
 										if (MatchCtrl)
 										{
 											// woohoo we are cool
 											for (auto s: c->GetStr()->Items)
 											{
 												MatchCtrl->GetStr()->Set(s->GetStr(), s->GetLang());
 											}
 										}
 									}
 
 									// Delete the duplicate
 									OnObjSelect(0);
 									DeleteObj(Dialog);
 								}
 								else
 								{
 									// Insert the dialog
 									InsertObject(TYPE_DIALOG, Dialog, false);
 									DlLList.Insert(Dialog);
 								}
 
 								Dialog = 0;
 								Dlg = 0;
 								Status = true;
 								Mode = IMP_MODE_SEARCH;
 							}
 							break;
 						}
 						case IMP_MODE_STRINGS:
 						{
 							if (stricmp(T[0], "BEGIN") == 0)
 							{
 							}
 							else if (stricmp(T[0], "END") == 0)
 							{
 								Status = true;
 								Mode = IMP_MODE_SEARCH;
 							}
 							else
 							{
 								if (T.Length() > 1)
 								{
 									ResString *Str = String->FindName(T[0]);
 									if (!Str)
 									{
 										Str = String->CreateStr();
 										if (Str)
 										{
 											ImportDefine *Def = Defines.GetDefine(T[0]);
 											if (Def)
 											{
 												Str->SetId(atoi(Def->Value));
 											}
 
 											Str->SetDefine(T[0]);
 											Str->UnDuplicate();
 										}
 									}
 
 									if (Str)
 									{
 										// get the language
 										LLanguage *Lang = LFindLang(Language);
 										LLanguageId SLang = (Lang) ? Lang->Id : (char*)"en";
 										StrLang *s = 0;
 
 										// look for language present in string object
 										for (auto ss: Str->Items)
 										{
 											if (*ss == SLang)
 											{
 												s = ss;
 												break;
 											}
 										}
 										
 										// if not present then add it
 										if (!s)
 										{
 											s = new StrLang;
 											if (s)
 											{
 												Str->Items.Insert(s);
 												s->SetLang(SLang);
 											}
 										}
 
 										// set the value
 										if (s)
 										{
 											s->SetStr(T[1]);
 										}
 									}
 								}
 							}
 
 							break;
 						}
 						case IMP_MODE_MENU:
 						{
 							if (T.Length() >= 1)
 							{
 								if (stricmp(T[0], "BEGIN") == 0)
 								{
 									MenuLevel++;
 								}
 								else if (stricmp(T[0], "END") == 0)
 								{
 									MenuLevel--;
 									if (MenuLevel == 0)
 									{
 										Status = true;
 										Mode = IMP_MODE_SEARCH;
 										Menu->SetLanguages();
 
 										if (!MenuNewLang)
 										{
 											InsertObject(TYPE_MENU, Menu, false);
 										}
 
 										Menu = 0;
 									}
 								}
 								else
 								{
 									ResMenuItem *i = 0;
 									char *Text = T[1];
 									if (Text)
 									{
 										if (stricmp(T[0], "POPUP") == 0)
 										{
 											if (MenuNewLang)
 											{
 												LTreeItem *Ri = 0;
 												if (MenuItem[MenuLevel])
 												{
 													Ri = MenuItem[MenuLevel]->GetNext();
 												}
 												else
 												{
 													if (MenuLevel == 1)
 													{
 														Ri = Menu->ItemAt(0);
 													}
 													else if (MenuItem[MenuLevel-1])
 													{
 														Ri = MenuItem[MenuLevel-1]->GetChild();
 													}
 												}
 
 												if (Ri)
 												{
 													// Seek up to the next submenu
 													while (!Ri->GetChild())
 													{
 														Ri = Ri->GetNext();
 													}
 
 													i = dynamic_cast<ResMenuItem*>(Ri);
 													// char *si = i->Str.Get("en");
 													if (i)
 													{
 														MenuItem[MenuLevel] = i;
 													}
 												}
 											}
 											else
 											{
 												MenuItem[MenuLevel] = i = new ResMenuItem(Menu);
 											}
 
 											if (i)
 											{
 												LLanguage *Lang = LFindLang(Language);
 												i->GetStr()->Set(Text, (Lang) ? Lang->Id : (char*)"en");
 											}
 
 											MenuNextItem = 0;
 										}
 										else if (stricmp(T[0], "MENUITEM") == 0)
 										{
 											if (MenuNewLang)
 											{
 												if (MenuItem[MenuLevel-1] && T.Length() > 2)
 												{
 													ImportDefine *id = Defines.GetDefine(T[2]);
 													if (id)
 													{
 														int Id = atoi(id->Value);
 
 														int n = 0;
 														for (LTreeItem *o = MenuItem[MenuLevel-1]->GetChild(); o; o = o->GetNext(), n++)
 														{
 															ResMenuItem *Res = dynamic_cast<ResMenuItem*>(o);
 															if (Res && Res->GetStr()->GetId() == Id)
 															{
 																i = Res;
 																break;
 															}
 														}
 													}
 												}
 
 												MenuNextItem++;
 											}
 											else
 											{
 												i = new ResMenuItem(Menu);
 											}
 
 											if (i)
 											{
 												if (stricmp(Text, "SEPARATOR") == 0)
 												{
 													// Set separator
 													i->Separator(true);
 												}
 												else
 												{
 													if (!MenuNewLang)
 													{
 														// Set Id
 														i->GetStr()->SetDefine(T[2]);
 														if (i->GetStr()->GetDefine())
 														{
 															ImportDefine *id = Defines.GetDefine(i->GetStr()->GetDefine());
 															if (id)
 															{
 																i->GetStr()->SetId(atoi(id->Value));
 																i->GetStr()->UnDuplicate();
 															}
 														}
 													}
 
 													// Set Text
 													LLanguage *Lang = LFindLang(Language);
 													i->GetStr()->Set(Text, (Lang) ? Lang->Id : (char*)"en");
 												}
 											}
 										}
 									}
 
 									if (i && !MenuNewLang)
 									{
 										if (MenuLevel == 1)
 										{
 											Menu->Insert(i);
 										}
 										else if (MenuItem[MenuLevel-1])
 										{
 											MenuItem[MenuLevel-1]->Insert(i);
 										}
 									}
 								}
 							}
 
 							break;
 						}
 					}
 				}
 
 				T.DeleteArrays();
 			}
 
 			DeleteObj(Dialog);
 
 			if (String->Length() > 0)
 			{
 				String->SetLanguages();
 			}
 		}
 
 		Invalidate();
 	};
 
 	if (FileName)
 		Load(FileName);
 	else
 	{
 		auto Select = new LFileSelect(this);
 		Select->Type("Win32 Resource Script", "*.rc");
 		Select->Open([&](auto dlg, auto status)
 		{
 			if (status)
 				Load(dlg->Name());
 			delete dlg;
 		});
 	}
 }
 
 bool AppWnd::SaveWin32()
 {
 	return false;
 }
 
 /////////////////////////////////////////////////////////////////////////
 ResFrame::ResFrame(Resource *child)
 {
 	Child = child;
 	Name("ResFrame");
 }
 
 ResFrame::~ResFrame()
 {
 	if (Child)
 	{
 		Child->App()->OnObjSelect(NULL);
 		Child->Wnd()->Detach();
 	}
 }
 
 void ResFrame::OnFocus(bool b)
 {
 	Child->Wnd()->Invalidate();
 }
 
 bool ResFrame::Attach(LViewI *p)
 {
 	bool Status = LLayout::Attach(p);
 	if (Status && Child)
 	{
 		Child->Attach(this);
 		Child->Wnd()->Visible(true);
 	}
 	return Status;
 }
 
 bool ResFrame::Pour(LRegion &r)
 {
 	LRect *Best = FindLargest(r);
 	if (Best)
 	{
 		SetPos(*Best);
 		return true;
 	}
 	return false;
 }
 
 bool ResFrame::OnKey(LKey &k)
 {
 	bool Status = false;
 	
 	if (k.Down() && Child)
 	{
 		switch (k.c16)
 		{
 			case LK_DELETE:
 			{
 				if (k.Shift())
 				{
 					Child->Copy(true);
 				}
 				else
 				{
 					Child->Delete();
 				}
 				Status = true;
 				break;
 			}
 			case 'x':
 			case 'X':
 			{
 				if (k.Ctrl())
 				{
 					Child->Copy(true);
 					Status = true;
 				}
 				break;
 			}
 			case 'c':
 			case 'C':
 			{
 				if (k.Ctrl())
 				{
 					Child->Copy();
 					Status = true;
 				}
 				break;
 			}
 			case LK_INSERT:
 			{
 				if (k.Ctrl())
 				{
 					Child->Copy();
 				}
 				else if (k.Shift())
 				{
 					Child->Paste();
 				}
 				Status = true;
 				break;
 			}
 			case 'v':
 			case 'V':
 			{
 				if (k.Ctrl())
 				{
 					Child->Paste();
 					Status = true;
 				}
 				break;
 			}
 		}
 	}
 
 	return Child->Wnd()->OnKey(k) || Status;
 }
 
 void ResFrame::OnPaint(LSurface *pDC)
 {
 	// Draw nice frame
 	LRect r(0, 0, X()-1, Y()-1);
 	LThinBorder(pDC, r, DefaultRaisedEdge);
 	pDC->Colour(L_MED);
 	LFlatBorder(pDC, r, 4);
 	LWideBorder(pDC, r, DefaultSunkenEdge);
 
 	// Set the child to the client area
 	Child->Wnd()->SetPos(r);
 
 	// Draw the dialog & controls
 	LView::OnPaint(pDC);
 }
 
 ////////////////////////////////////////////////////////////////////
 LgiFunc char *_LgiGenLangLookup();
 #include "lgi/common/AutoPtr.h"
 #include "lgi/common/Variant.h"
 #include "lgi/common/Css.h"
 #include "lgi/common/TableLayout.h"
 
 class Foo : public LLayoutCell
 {
 public:
 	Foo()
 	{
 		TextAlign(AlignLeft);
 	}
 
 	bool Add(LView *v) { return false; }
 	bool Remove(LView *v) { return false; }
 };
 
 //////////////////////////////////////////////////////////////////////
 ShortCutView::ShortCutView(AppWnd *app)
 {
 	App = app;
 	LRect r(0, 0, 500, 600);
 	SetPos(r);
 	MoveSameScreen(App);
 	Name("Dialog Shortcuts");
 	if (Attach(0))
 	{
 		Lst = new LList(100, 0, 0, 100, 100);
 		Lst->Attach(this);
 		Lst->SetPourLargest(true);
 		Lst->AddColumn("Key", 50);
 		Lst->AddColumn("Ref", 80);
 		Lst->AddColumn("CtrlId", 80);
 		Lst->AddColumn("Name", 150);
 
 		Visible(true);
 	}
 }
 
 ShortCutView::~ShortCutView()
 {
 	App->OnCloseView(this);
 }
 
 enum ShortCutCol
 {
 	ColKey,
 	ColRefId,
 	ColCtrlId,
 	ColName
 };
 
 void FindMenuKeys(LList *out, ResMenu *menu)
 {
 	if (!out || !menu)
 		return;
 
 	LArray<ResMenuItem*> items;
 	menu->EnumItems(items);
 	for (auto i: items)
 	{
 		auto sc = i->Shortcut();
 		if (sc)
 		{
 			auto item = new LListItem(sc);
 
 			LString ref, ctrl;
 			ref.Printf("%i", i->GetStr()->GetRef());
 			ctrl.Printf("%i", i->GetStr()->GetId());
 			
 			item->SetText(ref, ColRefId);
 			item->SetText(ctrl, ColCtrlId);
 			item->SetText(i->GetStr()->Get(), ColName);
 			item->_UserPtr = i;
 
 			out->Insert(item);
 		}
 	}
 }
 
 void FindShortCuts(LList *Out, LViewI *In)
 {
 	for (auto c: In->IterateViews())
 	{
 		auto rdc = dynamic_cast<ResDialogCtrl*>(c);
 		if (!rdc || !rdc->GetStr())
 			continue;
 
 		auto n = rdc->GetStr()->Get();
 		if (n)
 		{
 			char *a = strchr(n, '&');
 			if (a && a[1] != '&')
 			{
 				LListItem *li = new LListItem;
 
 				LString s(++a, 1);
 
 				LString ref, ctrl;
 				ref.Printf("%i", rdc->GetStr()->GetRef());
 				ctrl.Printf("%i", rdc->GetStr()->GetId());
 				
 				li->SetText(s.Upper(), ColKey);
 				li->SetText(ref, ColRefId);
 				li->SetText(ctrl, ColCtrlId);
 				li->SetText(rdc->GetClass(), ColName);
 				
 				li->_UserPtr = rdc;
 				
 				Out->Insert(li);
 			}
 		}
 
 		FindShortCuts(Out, c);
 	}
 }
 
 int ShortCutView::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	if (Ctrl->GetId() == Lst->GetId())
 	{
 		switch (n.Type)
 		{
 			case LNotifyItemClick:
 			{
 				auto li = Lst->GetSelected();
 				if (!li)
 					break;
 
 				LString s = li->GetText(1);
 
 				ResObject *c = (ResObject*) li->_UserPtr;
 				if (!c)
 					break;
 
 				if (auto ctrl = dynamic_cast<ResDialogCtrl*>(c))
 					App->GotoObject(ctrl->GetStr(), NULL, ctrl->GetDlg(), NULL, ctrl);
 				else if (auto mi = dynamic_cast<ResMenuItem*>(c))
 					App->GotoObject(mi->GetStr(), NULL, NULL, mi, NULL);
 				else
 					LAssert(!"Impl me.");
 				break;
 			}
 			default:
 				break;
 		}
 	}
 
 	return LWindow::OnNotify(Ctrl, n);
 }
 
 void ShortCutView::OnResource(Resource *r)
 {
 	Lst->Empty();
 	
 	if (!r)
 		return;
 
 	if (auto dlg = dynamic_cast<ResDialog*>(r))
 		FindShortCuts(Lst, dlg);
 	else if (auto menu = dynamic_cast<ResMenu*>(r))
 		FindMenuKeys(Lst, menu);
 	
 	Lst->Sort(0);
 	Lst->ResizeColumnsToContent();
 }
 
 ShortCutView *AppWnd::GetShortCutView()
 {
 	return ShortCuts;
 }
 
 void AppWnd::OnCloseView(ShortCutView *v)
 {
 	if (v == ShortCuts)
 		ShortCuts = NULL;
 }
 
 //////////////////////////////////////////////////////////////////////
 void TestFunc()
 {
 	/*
 	Foo c;
 	uint32 *p = (uint32*)&c;
 	p++;
 	p = (uint32*)(*p);
 	void *method = (void*)p[2];
 
 	for (int i=0; i<16; i++)
 	{
 		printf("[%i]=%p\n", i, p[i]);
 	}
 
 	c.OnChange(LCss::PropBackground);
 	*/
 }
 
 int LgiMain(OsAppArguments &AppArgs)
 {
 	LApp a(AppArgs, "LgiRes");
 	if (a.IsOk())
 	{
 		if ((a.AppWnd = new AppWnd))
 		{
 			TestFunc();
 			a.AppWnd->Visible(true);
 			a.Run();
 		}
 	}
 
 	return 0;
 }
 
diff --git a/ResourceEditor/src/LgiResEdit.h b/ResourceEditor/src/LgiResEdit.h
--- a/ResourceEditor/src/LgiResEdit.h
+++ b/ResourceEditor/src/LgiResEdit.h
@@ -1,899 +1,899 @@
 /*hdr
 **      FILE:           LgiRes.h
 **      AUTHOR:         Matthew Allen
 **      DATE:           22/10/00
 **      DESCRIPTION:    Resource Editor App Header
 **
 */
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Net.h"
 #include "lgi/common/DocApp.h"
 #include "lgi/common/Properties.h"
 #include "lgi/common/Variant.h"
 #include "lgi/common/DataDlg.h"
 #include "lgi/common/OptionsFile.h"
 
 #include "resource.h"
 #include "lgi/common/Tree.h"
 #include "lgi/common/Box.h"
 #include "lgi/common/EventTargetThread.h"
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Defines
 
 // version
 #define APP_VER						"4.1"
 
 // window messages
 #define	IDM_UNDO					201
 #define	IDM_REDO					202
 /*
 #define	IDM_CUT						203
 #define	IDM_COPY					204
 #define	IDM_PASTE					205
 */
 
 #define	IDM_DELETE					300
 #define	IDM_RENAME					301
 #define	IDM_SETTINGS				302
 #define	IDM_IMPORT					303
 #define	IDM_IMPORT_WIN32			304
 #define	IDM_EXPORT					305
 #define	IDM_EXPORT_WIN32			306
 #define	IDM_NEW_LANG				307
 #define	IDM_DELETE_LANG				308
 #define	IDM_IMPORT_LANG				309
 #define	IDM_PROPERTIES				310
 #define IDM_NEW_SUB					311
 #define IDM_NEW_ITEM				312
 #define IDM_DELETE_ITEM				313
 #define IDM_MOVE_LEFT				314
 #define IDM_MOVE_RIGHT				315
 #define IDM_SET_LANG				316
 #define IDM_TAB_ORDER				317
 #define	IDM_DUMP					318
 #define IDM_COPY_TEXT				319
 #define IDM_PASTE_TEXT				320
 #define IDM_NEW_ID					321
 #define IDM_COMPARE					322
 #define IDM_MOVE_UP					324
 #define IDM_MOVE_DOWN				325
 #define IDM_REF_EQ_ID				326
 #define IDM_ID_EQ_REF				327
 #define IDM_UP						328
 #define IDM_DOWN					329
 #define IDM_SET_OK					330
 #define IDM_SET_CANCEL				331
 
 #define IDM_LANG_BASE				2000
 
 #define	IDC_TABLE					999
 #define	IDC_CHAT_MSG				1000
 
 #define	STATUS_NORMAL				0
 #define	STATUS_INFO					1
 #define	STATUS_MAX					2
 
 #define VAL_Ref						"Ref"
 #define VAL_Id						"Id"
 #define VAL_Define					"Define"
 #define VAL_Tag						"Tag"
 #define VAL_Text					"Text"
 #define VAL_CellClass				"CellClass"
 #define VAL_CellStyle				"CellStyle"
 #define VAL_Text					"Text"
 #define VAL_Pos						"Pos"
 #define VAL_x1						"x1"
 #define VAL_y1						"y1"
 #define VAL_x2						"x2"
 #define VAL_y2						"y2"
 #define VAL_Visible					"Visible"
 #define VAL_Enabled					"Enabled"
 #define VAL_Class                   "Class"
 #define VAL_Style                   "Style"
 #define VAL_VerticalAlign			"valign"
 #define VAL_HorizontalAlign			"align"
 #define VAL_Children				"children"
 #define VAL_Span					"span"
 #define VAL_Image					"image"
 #define VAL_Toggle					"toggle"
 
 // Misc
 class AppWnd;
 #define	MainWnd						((AppWnd*)LApp::ObjInstance()->AppWnd)
 
 // App
 enum ObjectTypes {
     TYPE_CSS = 1,
     TYPE_DIALOG,
     TYPE_STRING,
     TYPE_MENU
 };
 
 enum IconTypes {
     ICON_FOLDER,
     ICON_IMAGE,
     ICON_ICON,
     ICON_CURSOR,
     ICON_DIALOG,
     ICON_STRING,
     ICON_MENU,
     ICON_DISABLED,
     ICON_CSS
 };
 
 #define OPT_ShowLanguages			"ShowLang"
 
 #define StrDialogSymbols			"_Dialog Symbols_"
 extern char TranslationStrMagic[];
 extern char AppName[];
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Functions
 extern char *EncodeXml(const char *s, int l = -1);
 extern char *DecodeXml(const char *s, int l = -1);
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 // Classes
 class AppWnd;
 class ObjTreeItem;
 class ResString;
 typedef List<ResString> StringList;
 class ResMenu;
 class ResDialog;
 class ResStringGroup;
 class ResMenuItem;
 
 struct ErrorInfo
 {
 	ResString *Str;
 	LAutoString Msg;
 };
 
 class ErrorCollection
 {
 public:
 	LArray<ErrorInfo> StrErr;
 };
 
 struct SerialiseContext
 {
 	ResFileFormat Format;
 	LStringPipe Log;
 	LArray<ResString*> FixId;
 	
 	SerialiseContext() : Log(512)
 	{
 		Format = Lr8File;
 	}
 	
 	void PostLoad(AppWnd *App);
 };
 
 class Resource
 {
 	friend class AppWnd;
 	friend class ObjTreeItem;
 
 protected:
 	int ResType;
 	AppWnd *AppWindow;
 	ObjTreeItem *Item;
 	bool SysObject;
 
 public:
 	Resource(AppWnd *w, int t = 0, bool enabled = true);
 	virtual ~Resource();
 
 	AppWnd *App() { return AppWindow; }
 	bool SystemObject() { return SysObject; }
 	void SystemObject(bool i) { SysObject = i; }
 	bool IsSelected();
 
 	virtual LView *Wnd() { return NULL; }
 	virtual bool Attach(LViewI *Parent);
 	virtual int Type() { return ResType; }
 	virtual void Type(int i) { ResType = i; }
 	virtual void Create(LXmlTag *load, SerialiseContext *ctx) = 0; // called when users creates
 	virtual ResStringGroup *GetStringGroup() { return 0; }
 	
 	// Sub classes
 	virtual ResStringGroup *IsStringGroup() { return 0; }
 	virtual ResDialog *IsDialog() { return 0; }
 	virtual ResMenu *IsMenu() { return 0; }
 	
 	// Serialization
 	virtual bool Test(ErrorCollection *e) = 0;
 	virtual bool Read(LXmlTag *t, SerialiseContext &Ctx) = 0;
 	virtual bool Write(LXmlTag *t, SerialiseContext &Ctx) = 0;
 	virtual StringList *GetStrs() { return NULL; }
 
 	// Clipboard
 	virtual void Delete() {}
 	virtual void Copy(bool Delete = false) {}
 	virtual void Paste() {}
 
 	// UI
 	virtual LView *CreateUI() { return 0; }
 	virtual void OnRightClick(LSubMenu *RClick) {}
 	virtual void OnCommand(int Cmd) {}
 	virtual void OnShowLanguages() {}
 };
 
 class ResFolder : public Resource, public LView
 {
 public:
 	ResFolder(AppWnd *w, int t, bool enabled = true);
 	LView *Wnd() { return dynamic_cast<LView*>(this); }
 
 	void Create(LXmlTag *load, SerialiseContext *ctx) { LAssert(0); }
 	bool Test(ErrorCollection *e) { return false; }
 	bool Read(LXmlTag *t, SerialiseContext &Ctx) { return false; }
 	bool Write(LXmlTag *t, SerialiseContext &Ctx) { return false; }
 };
 
 class ResFrame : public LLayout
 {
 	Resource *Child;
 
 public:
 	ResFrame(Resource *child);
 	~ResFrame();
 
 	bool Pour(LRegion &r);
 	bool OnKey(LKey &k);
 	void OnPaint(LSurface *pDC);
 	bool Attach(LViewI *p);
 	void OnFocus(bool b);
 };
 
 class ObjTreeItem : public LTreeItem
 {
 	friend class Resource;
 
 	Resource *Obj;
 
 public:
 	ObjTreeItem(Resource *Object);
 	~ObjTreeItem();
 
 	Resource *GetObj() { return Obj; }
 	const char *GetText(int i=0);
 	void OnSelect();
 	void OnMouseClick(LMouse &m);
 };
 
 class ObjContainer : public LTree
 {
 	friend class AppWnd;
 
 	ObjTreeItem *Style = NULL;
 	ObjTreeItem *Dialogs = NULL;
 	ObjTreeItem *Strings = NULL;
 	ObjTreeItem *Menus = NULL;
 
 	LImageList *Images = NULL;
 	AppWnd *Window = NULL;
 
 	bool AppendChildren(ObjTreeItem *Item, List<Resource> &Lst);
 
 public:
 	ObjContainer(AppWnd *w);
 	~ObjContainer();
 
 	Resource *CurrentResource();
 	bool ListObjects(List<Resource> &Lst);
 };
 
 class FieldTree
 {
 public:
 	enum FieldMode
 	{
 		None,
 		UiToObj,
 		ObjToUi,
 		ObjToStore,
 		StoreToObj,
 	};
 
 	struct Field
 	{
 		// Global
 		FieldTree *Tree;
 		LAutoString Label;
 		LAutoString Name;
 		int Type;
 		int Id;
 		bool Multiline;
 		void *Token;
 
 		Field(FieldTree *tree)
 		{
 			Tree = tree;
 			Type = 0;
 			Id = 0;
 			Token = 0;
 			Multiline = false;
 		}
 	};
 
 	typedef LArray<Field*> FieldArr;
 
 protected:
 	int &NextId;
 	FieldMode Mode;
 	LViewI *View;
 	LDom *Store;
 	bool Deep;
 
 	LHashTbl<PtrKey<void*>, FieldArr*> f;
 
 	FieldArr *Get(void *Token, bool Create = false)
 	{
 		FieldArr *a = f.Find(Token);
 		if (!a)
 		{
 			if (Create)
 				f.Add(Token, a = new FieldArr);
 			else
 				LAssert(0);
 		}
 		return a;
 	}
 
 	Field *GetField(void *Token, const char *FieldName)
 	{
 		if (!Token || !FieldName) return 0;
 
 		FieldArr *a = Get(Token);
 		if (!a) return 0;
 
 		for (int i=0; i<a->Length(); i++)
 		{
 			if (!stricmp((*a)[i]->Name, FieldName))
 				return (*a)[i];
 		}
 
 		return 0;
 	}
 
 public:
 	FieldTree(int &next, bool deep) : NextId(next)
 	{
 		Mode = None;
 		View = 0;
 		Store = 0;
 		Deep = deep;
 	}
 
 	~FieldTree()
 	{
 		Empty();
 	}
 
 	FieldMode GetMode()
 	{
 		return Mode;
 	}
 	
 	bool GetDeep()
 	{
 		return Deep;
 	}
 
 	void SetMode(FieldMode m)
 	{
 		Mode = m;
 	}
 
 	void SetView(LViewI *v)
 	{
 		View = v;
 	}
 
 	void SetStore(LDom *p)
 	{
 		Store = p;
 	}
 
 	void Empty()
 	{
 		// for (FieldArr *a = f.First(); a; a = f.Next())
 		for (auto a : f)
 		{
 			a.value->DeleteObjects();
 		}
 		f.DeleteObjects();
 		View = 0;
 	}
 
 	void Insert(void *Token, int Type, int Reserved, const char *Name, const char *Label, int Idx = -1, bool Multiline = false)
 	{
 		FieldArr *a = Get(Token, true);
 		if (!a) return;
 
 		Field *n = new Field(this);
 		if (n)
 		{
 			n->Token = Token;
 			n->Label.Reset(NewStr(Label));
 			n->Name.Reset(NewStr(Name));
 			n->Id = NextId++;
 			n->Type = Type;
 			n->Multiline = Multiline;
 			a->Add(n);
 		}
 	}
 
 	void Serialize(void *Token, const char *FieldName, int &i)
 	{
 		Field *f = GetField(Token, FieldName);
 		if (!f) return;
 		LVariant v;
 
 		switch (Mode)
 		{
 			case ObjToUi:
 				View->SetCtrlValue(f->Id, i);
 				break;
 			case UiToObj:
 				i = (int)View->GetCtrlValue(f->Id);
 				break;
 			case StoreToObj:
 				if (Store->GetValue(FieldName, v))
 					i = v.CastInt32();
 				break;
 			case ObjToStore:
 				Store->SetValue(FieldName, v = i);
 				break;
 			default:
 				LAssert(0);
 		}
 	}
 
 	void Serialize(void *Token, const char *FieldName, bool &b, int Default = -1)
 	{
 		Field *f = GetField(Token, FieldName);
 		if (!f) return;
 		LVariant i;
 
 		switch (Mode)
 		{
 			case ObjToUi:
 				View->SetCtrlValue(f->Id, b);
 				break;
 			case UiToObj:
 				b = View->GetCtrlValue(f->Id);
 				break;
 			case StoreToObj:
 			{
 				if (Store->GetValue(FieldName, i))
 				{
 					b = i.CastInt32() != 0;
 				}
 				break;
 			}
 			case ObjToStore:
 				if (Default < 0 || (bool)Default != b)
 					Store->SetValue(FieldName, i = b);
 				break;
 			default:
 				LAssert(0);
 		}
 	}
 
 	void Serialize(void *Token, const char *FieldName, char *&s)
 	{
 		Field *f = GetField(Token, FieldName);
 		if (!f) return;
 		LVariant v;
 
 		switch (Mode)
 		{
 			case ObjToUi:
 				View->SetCtrlName(f->Id, s);
 				break;
 			case UiToObj:
 			{
 				DeleteArray(s);
 				auto t = View->GetCtrlName(f->Id);
 				if (ValidStr(t))
 					s = NewStr(t);
 				break;
 			}
 			case StoreToObj:
 			{
 				DeleteArray(s);
 				if (Store->GetValue(FieldName, v))
 					s = v.ReleaseStr();
 				break;
 			}
 			case ObjToStore:
 				Store->SetValue(FieldName, v = s);
 				break;
 			default:
 				LAssert(0);
 		}
 	}
 
 	void Serialize(void *Token, const char *FieldName, LAutoString &s)
 	{
 		Field *f = GetField(Token, FieldName);
 		if (!f) return;
 		LVariant v;
 
 		switch (Mode)
 		{
 			case ObjToUi:
 				View->SetCtrlName(f->Id, s);
 				break;
 			case UiToObj:
 			{
 				auto t = View->GetCtrlName(f->Id);
 				s.Reset(ValidStr(t) ? NewStr(t) : 0);
 				break;
 			}
 			case StoreToObj:
 			{
 				s.Reset(Store->GetValue(FieldName, v) ? v.ReleaseStr() : 0);
 				break;
 			}
 			case ObjToStore:
 				Store->SetValue(FieldName, v = s);
 				break;
 			default:
 				LAssert(0);
 		}
 	}
 
 	void Serialize(void *Token, const char *FieldName, LString &s)
 	{
 		Field *f = GetField(Token, FieldName);
 		if (!f) return;
 		LVariant v;
 
 		switch (Mode)
 		{
 			case ObjToUi:
 				View->SetCtrlName(f->Id, s);
 				break;
 			case UiToObj:
 				s = View->GetCtrlName(f->Id);
 				break;
 			case StoreToObj:
 				if (Store->GetValue(FieldName, v))
 					s = v.Str();
 				else
 					s.Empty();
 				break;
 			case ObjToStore:
 				Store->SetValue(FieldName, v = s.Get());
 				break;
 			default:
 				LAssert(0);
 		}
 	}
 
 	void Serialize(void *Token, const char *FieldName, LRect &r)
 	{
 		Field *f = GetField(Token, FieldName);
 		if (!f) return;
 		LVariant v;
 
 		switch (Mode)
 		{
 			case ObjToUi:
 				View->SetCtrlName(f->Id, r.GetStr());
 				break;
 			case UiToObj:
 			{
 				r.SetStr(View->GetCtrlName(f->Id));
 				break;
 			}
 			case StoreToObj:
 			{
 				if (Store->GetValue(FieldName, v))
 				{
 					r.SetStr(v.Str());
 				}
 				break;
 			}
 			case ObjToStore:
 			{
 				Store->SetValue(FieldName, v = r.GetStr());
 				break;
 			}
 			default:
 				LAssert(0);
 		}
 	}
 
 	static int FieldArrCmp(FieldArr **a, FieldArr **b)
 	{
 		return (**a)[0]->Id - (**b)[0]->Id;
 	}
 
 	void GetAll(LArray<FieldArr*> &Fields)
 	{
 		// for (FieldArr *a = f.First(0); a; a = f.Next(0))
 		for (auto a : f)
 		{
 			Fields.Add(a.value);
 		}
 		Fields.Sort(FieldArrCmp);
 	}
 };
 
 #define M_OBJECT_CHANGED (M_USER + 4567)
 class FieldSource
 {
 	friend class FieldView;
 	int _FieldView;
 
 public:
 	FieldSource()
 	{
 		_FieldView = -1;
 	}
 	
 	virtual ~FieldSource() {}
 
 	virtual bool GetFields(FieldTree &Fields) = 0;
 	virtual bool Serialize(FieldTree &Fields) = 0;
 	
 	void OnFieldChange()
 	{
 		if (_FieldView >= 0)
 			PostThreadEvent(_FieldView, M_OBJECT_CHANGED, (LMessage::Param)this);
 	}
 };
 
 #include "LgiRes_Dialog.h"
 
 class FieldView : public LLayout
 {
 protected:
 	FieldSource *Source;
 	FieldTree Fields;
 	int NextId;
 	bool Ignore;
 	AppWnd *App;
 
 public:
 	FieldView(AppWnd *app);
 	~FieldView();
 
 	void Serialize(bool Write);
 
 	void OnPosChange();
 	void OnSelect(FieldSource *s);
 	void OnDelete(FieldSource *s);
 	LMessage::Result OnEvent(LMessage *m);
 	void OnPaint(LSurface *pDC);
 	int OnNotify(LViewI *Ctrl, LNotification n);
 };
 
 class ShortCutView : public LWindow
 {
 	AppWnd *App;
 	LList *Lst;
 
 public:
 	ShortCutView(AppWnd *app);
 	~ShortCutView();
 
 	void OnResource(Resource *r);
 	int OnNotify(LViewI *Ctrl, LNotification n);
 };
 
 #include "LgiRes_String.h"
 
 class AppWnd : public LDocApp<LOptionsFile>
 {
 protected:
 	// UI
 	LBox			*HBox = NULL;
 	LBox			*VBox = NULL;
 	LView			*ContentView = NULL;
 
 	LSubMenu		*Edit = NULL;
 	LSubMenu		*Help = NULL;
 	LSubMenu		*ViewMenu = NULL;
 
 	LStatusBar		*Status = NULL;
 	LStatusPane		*StatusInfo[STATUS_MAX];
 
 	ShortCutView	*ShortCuts = NULL;
 
 	// App
 	ObjContainer	*Objs = NULL;
 	Resource		*LastRes = NULL;
 	FieldView		*Fields = NULL;
 	
 	// Languages
 	int				CurLang = -1;
 	LArray<LLanguage*> Languages;
 	LHashTbl<ConstStrKey<char,false>, bool> ShowLanguages;
 
 	void SortDialogs();
 	void GetFileTypes(LFileSelect *Dlg, bool Write);
 
 public:
 	AppWnd();
 	~AppWnd();
 
 	// Languages
 	bool ShowLang(LLanguageId Lang);
 	void ShowLang(LLanguageId Lang, bool Show);
 	LLanguage *GetCurLang();
 	void SetCurLang(LLanguage *L);
 	LArray<LLanguage*> *GetLanguages();
 	void OnLanguagesChange(LLanguageId Lang, bool Add, bool Update = false);
 
 	// ---------------------------------------------------------------------
 	// Application
 	Resource *NewObject(SerialiseContext ctx, LXmlTag *load, int Type, bool Select = true);
 	bool InsertObject(int Type, Resource *r, bool Select = true);
 	void DelObject(Resource *r);
 	bool ListObjects(List<Resource> &Lst);
 	int GetUniqueStrRef(int Start = 1);
 	int GetUniqueCtrlId();
 	void FindStrings(List<ResString> &Strs, char *Define = 0, int *CtrlId = 0);
 	ResString *GetStrFromRef(int Ref);
 	ResStringGroup *GetDialogSymbols();
 
 	bool Empty();
 	void OnObjChange(FieldSource *r);
 	void OnObjSelect(FieldSource *r);
 	void OnObjDelete(FieldSource *r);
 	void OnResourceSelect(Resource *r);
 	void OnResourceDelete(Resource *r);
 	void GotoObject(class ResString *s,
 					ResStringGroup *g,
 					ResDialog *d,
 					ResMenuItem *m,
 					ResDialogCtrl *c);
 	
 	ShortCutView *GetShortCutView();
 	void OnCloseView(ShortCutView *v);
 
 	// ---------------------------------------------------------------------
 	// Methods
 	void SetStatusText(char *Text, int Pane = 0);
 	bool TestLgi(bool Quite = true);
 	bool LoadLgi(const char *FileName = 0);
 	bool SaveLgi(const char *FileName = 0);
 	void LoadWin32(const char *FileName = 0);
 	bool SaveWin32();
 	void ImportLang();
 	void Compare();
 	bool WriteDefines(LStream &Defs);
 
-	bool OpenFile(const char *FileName, bool Ro);
+	void OpenFile(const char *FileName, bool Ro, std::function<void(bool status)> Callback);
 	void SaveFile(const char *FileName, std::function<void(LString fileName, bool status)> Callback);
 
 	// ---------------------------------------------------------------------
 	// Window
 	int OnNotify(LViewI *Ctrl, LNotification n);
 	LMessage::Result OnEvent(LMessage *m);
 	int OnCommand(int Cmd, int Event, OsView Handle);
 	void OnReceiveFiles(LArray<const char*> &Files);
 	void OnCreate();
 };
 
 #define INVALID_INT			-10000
 #define NEW_UI				1
 
 struct SearchParams
 {
 	LString::Array Text;
 	#if NEW_UI
 	bool LimitToText;
 	bool LimitToDefine;
 	#else
 	LString Define;
 	#endif
 	LLanguageId InLang;
 	LLanguageId NotInLang;
 	int Ref;
 	int CtrlId;
 
 	SearchParams()
 	{
 		InLang = NULL;
 		NotInLang = NULL;
 		Ref = INVALID_INT;
 		CtrlId = INVALID_INT;
 		#if NEW_UI
 		LimitToText = false;
 		LimitToDefine = false;
 		#else
 		#endif
 	}
 };
 
 class SearchThread : public LEventTargetThread
 {
 	List<Resource> Res;
 	AppWnd *App;
 	LList *Results;
 	SearchParams Params;
 	LCancel State;
 
 	bool HasContent(char *s);
 	class Result *Test(class ResString *s);
 	class Result *Test(class ResMenuItem *mi);
 
 public:
 	SearchThread(AppWnd *app, LList *results);
 
 	void Search(SearchParams &p);
 	LMessage::Result OnEvent(LMessage *Msg);
 };
 
 class Search : public LDialog, public SearchParams
 {
 	AppWnd *App;
 	LAutoPtr<SearchThread> Thread;
 	void OnCheck();
 
 public:
 	Search(AppWnd *app);
 	int OnNotify(LViewI *c, LNotification n);
 };
 
 class Results : public LWindow
 {
 	class ResultsPrivate *d;
 
 public:
 	Results(AppWnd *app, Search *search);
 	~Results();
 
 	void OnPosChange();
 	int OnNotify(LViewI *v, LNotification n);
 
 };
 
 class ShowLanguagesDlg : public LDialog
 {
 	class ShowLanguagesDlgPriv *d;
 
 public:
 	ShowLanguagesDlg(AppWnd *app);
 	~ShowLanguagesDlg();
 
 	int OnNotify(LViewI *v, LNotification n);
 };
 
 class ResCss : public Resource, public LLayout
 {
     friend class ResCssUi;
     
 protected:
 	class ResCssUi *Ui;
 	LAutoString Style;
 
 public:
 	ResCss(AppWnd *w, int type = TYPE_CSS);
 	~ResCss();
 
 	void Create(LXmlTag *Load, SerialiseContext *Ctx);
 	LView *Wnd() { return dynamic_cast<LView*>(this); }
 	void OnShowLanguages();
 
 	// Resource
 	LView *CreateUI();
 	void OnRightClick(LSubMenu *RClick);
 	void OnCommand(int Cmd);
 	int OnCommand(int Cmd, int Event, OsView hWnd);
 
 	// Serialize
 	bool Test(ErrorCollection *e);
 	bool Read(LXmlTag *t, SerialiseContext &Ctx);
 	bool Write(LXmlTag *t, SerialiseContext &Ctx);
 };
 
 extern void OpenTableLayoutTest(LViewI *p);
diff --git a/include/lgi/common/Mru.h b/include/lgi/common/Mru.h
--- a/include/lgi/common/Mru.h
+++ b/include/lgi/common/Mru.h
@@ -1,70 +1,70 @@
 #ifndef __GMRU_H
 #define __GMRU_H
 
 #include <functional>
 
 #ifdef HAS_PROPERTIES
 #include "GProperties.h"
 #endif
 #include "lgi/common/FileSelect.h"
 
 // Message defines
 #define	IDM_OPEN			15000
 #define	IDM_SAVEAS			15001
 
 // Classes
 class LgiClass LMru
 {
 private:
 	class LMruPrivate *d;
 	void _Update();
 
 protected:
 	virtual void _OpenFile(const char *File, bool ReadOnly, std::function<void(bool)> Callback);
 	virtual void _SaveFile(const char *File, std::function<void(LString, bool)> Callback);
 
 	virtual const char *_GetCurFile();
 	virtual void GetFileTypes(LFileSelect *Dlg, bool Write);
 	virtual LFileType *GetSelectedType();
 	void DoFileDlg(LAutoPtr<LFileSelect> Select, bool Open, std::function<void(bool)> OnSelect);
 
 	/// This method converts the storage reference (which can contain user/pass credentials) 
 	/// between the display, raw and stored forms. Display and Raw are used at runtime and
 	/// the stored form is written to disk.
 	///
 	/// The implementor should fill in any NULL strings by converting from the supplied forms.
 	/// The caller must supply either the Raw or Stored form.
 	virtual bool SerializeEntry
 	(
 		/// The displayable version of the reference (this should have any passwords blanked out)
 		LString *Display,
 		/// The form passed to the client software to open/save. (passwords NOT blanked)
 		LString *Raw,
 		/// The form safe to write to disk, if a password is present it must be encrypted.
 		LString *Stored
 	);
 
 
 public:
 	LMru();
 	virtual ~LMru();
 
 	// Impl
 	bool Set(LSubMenu *parent, int size = -1);
 	const char *AddFile(const char *FileName, bool Update = true);
 	void RemoveFile(const char *FileName, bool Update = true);
 	LMessage::Result OnEvent(LMessage *Msg);
 	void OnCommand(int Cmd, std::function<void(bool)> OnStatus);
 
 	// Serialization
 	bool Serialize(LDom *Store, const char *Prefix, bool Write);
 	#ifdef HAS_PROPERTIES
 	bool Serialize(ObjProperties *Store, char *Prefix, bool Write);
 	#endif
 
 	// Events
-	virtual bool OpenFile(const char *FileName, bool ReadOnly) = 0;
+	virtual void OpenFile(const char *FileName, bool ReadOnly, std::function<void(bool status)> Callback) = 0;
 	virtual void SaveFile(const char *FileName, std::function<void(LString fileName, bool status)> Callback) = 0;
 };
 
 #endif
diff --git a/src/common/Lgi/Mru.cpp b/src/common/Lgi/Mru.cpp
--- a/src/common/Lgi/Mru.cpp
+++ b/src/common/Lgi/Mru.cpp
@@ -1,472 +1,476 @@
 #include <stdio.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Mru.h"
 #include "lgi/common/Variant.h"
 #include "lgi/common/Menu.h"
 
 ////////////////////////////////////////////////////////////////////
 #define DEBUG_LOG				0
 #define M_MRU_BASE				(M_USER+0x3500)
 
 struct LMruEntry
 {
 	LString Display;
 	LString Raw;
 };
 
 class LMruPrivate
 {
 public:
 	int Size = 10;
 	LArray<LMruEntry*> Items;
 	LSubMenu *Parent = NULL;
 	LFileType *SelectedType = NULL;
 
 	LMruPrivate()	
 	{
 	}
 
 	~LMruPrivate()	
 	{
 		Items.DeleteObjects();
 	}
 };	
 
 ////////////////////////////////////////////////////////////////////
 LMru::LMru()
 {
 	d = new LMruPrivate;
 }
 
 LMru::~LMru()
 {
 	DeleteObj(d);
 }
 
 bool LMru::SerializeEntry
 (
 	/// The displayable version of the reference (this should have any passwords blanked out)
 	LString *Display,
 	/// The form passed to the client software to open/save. (passwords NOT blanked)
 	LString *Raw,
 	/// The form safe to write to disk, if a password is present it must be encrypted.
 	LString *Stored
 )
 {
 	if (Raw && Raw->Get())
 	{
 		if (Stored)
 			*Stored = *Raw;
 		if (Display)
 			*Display = *Raw;
 	}
 	else if (Stored && Stored->Get())
 	{
 		if (Display)
 			*Display = *Stored;
 		if (Raw)
 			*Raw = *Stored;
 	}
 	
 	return true;
 }
 
 void LMru::GetFileTypes(LFileSelect *Dlg, bool Write)
 {
 	Dlg->Type("All Files", LGI_ALL_FILES);
 }
 
 const char *LMru::_GetCurFile()
 {
 	if (d->Items.Length())
 		return d->Items[0]->Raw;
 	return NULL;
 }
 
 LFileType *LMru::GetSelectedType()
 {
 	return d->SelectedType;
 }
 
 void LMru::_OpenFile(const char *File, bool ReadOnly, std::function<void(bool)> Callback)
 {
-	bool Status = OpenFile(File, ReadOnly);
-	if (Status)
-		AddFile(File, true);
-	else
-		RemoveFile(File);
-	if (Callback)
-		Callback(Status);
+	OpenFile(File,
+			ReadOnly,
+			[this, File=LString(File), Callback](auto status)
+			{
+				if (status)
+					AddFile(File, true);
+				else
+					RemoveFile(File);
+				if (Callback)
+					Callback(status);
+			});
 }
 
 void LMru::_SaveFile(const char *FileName, std::function<void(LString, bool)> Callback)
 {
 	if (!FileName)
 	{
 		if (Callback) Callback(LString(), false);
 		return;
 	}
 
 	LString File = FileName;
 	
 	LFileType *st;
 	if (!LFileExists(File) &&
 		(st = GetSelectedType()) &&
 		st->Extension())
 	{
 		auto Cur = LGetExtension(File);
 		if (!Cur)
 		{
 			// extract extension
 			LString::Array a = LString(st->Extension()).Split(LGI_PATH_SEPARATOR);
 			for (auto e: a)
 			{
 				LString::Array p = e.RSplit(".", 1);
 				if (!p.Last().Equals("*"))
 				{
 					// bung the extension from the file type if not there
 					File += ".";
 					File += p.Last();
 					break;
 				}
 			}
 		}
 	}
 	
 	SaveFile(File, [this, Callback](auto fileName, auto Status)
 	{
 		if (Status)
 			AddFile(fileName);
 		else
 			RemoveFile(fileName);
 		if (Callback)
 			Callback(fileName, Status);
 	});
 }
 
 void LMru::_Update()
 {
 	if (d->Items.Length() > d->Size)
 		d->Items.Length(d->Size);
 
 	if (d->Parent)
 	{
 		// remove existing items.
 		d->Parent->Empty();
 
 		// add current items
 		if (d->Items.Length() > 0)
 		{
 			for (int i=0; i<d->Items.Length(); i++)
 			{
 				LMruEntry *c = d->Items[i];
 				d->Parent->AppendItem(c->Display ? c->Display : c->Raw, M_MRU_BASE + i, true);
 			}
 		}
 		else
 		{
 			d->Parent->AppendItem("(none)", -1, false);
 		}
 	}
 }
 
 bool LMru::Set(LSubMenu *parent, int size)
 {
 	d->Parent = parent;
 	if (size > 0)
 		d->Size = size;
 	_Update();
 
 	return true;
 }
 
 const char *LMru::AddFile(const char *FileName, bool Update)
 {
 	#if DEBUG_LOG
 	LgiTrace("%s:%i - AddFile(%s,%i)\n", _FL, FileName, Update);
 	#endif
 	if (!FileName)
 		return NULL;
 
 	auto Status = FileName;
 	LMruEntry *c = NULL;
 	for (int i=0; i<d->Items.Length(); i++)
 	{
 		LMruEntry *e = d->Items[i];
 		#if DEBUG_LOG
 		LgiTrace("[%i] cmp '%s' '%s'\n", i, e->Raw.Get(), FileName);
 		#endif
 		if (!LFileCompare(e->Raw, FileName))
 		{
 			// exact string being added.. just move to the top
 			// no need to reallocate
 			
 			if (strcmp(e->Raw, FileName) &&
 				e->Raw.Length() == strlen(FileName))
 			{
 				e->Raw = FileName; // This fixes any changes in case...
 				#if DEBUG_LOG
 				LgiTrace("Updating raw case\n");
 				#endif
 			}
 			else
 			{
 				#if DEBUG_LOG
 				LgiTrace("Moving to the top\n");
 				#endif
 			}
 			
 			d->Items.DeleteAt(i, true);
 			d->Items.AddAt(0, e);
 			c = e;
 			break;
 		}
 	}
 
 	if (!c)
 	{
 		c = new LMruEntry;
 		c->Raw = FileName;
 		if (SerializeEntry(&c->Display, &c->Raw, NULL))
 		{
 			#if DEBUG_LOG
 			LgiTrace("Adding new entry %s %s\n", c->Raw.Get(), c->Display.Get());
 			#endif
 			d->Items.AddAt(0, c);
 		}
 		else
 		{
 			LAssert(0);
 		}
 	}
 
 	if (Update)
 	{
 		// update
 		_Update();
 	}
 
 	return Status;
 }
 
 void LMru::RemoveFile(const char *FileName, bool Update)
 {
 	// remove from list if there
 	for (int i=0; i<d->Items.Length(); i++)
 	{
 		LMruEntry *e = d->Items[i];
 		if (stricmp(e->Raw, FileName) == 0)
 		{
 			d->Items.DeleteAt(i);
 			DeleteObj(e);
 			break;
 		}
 	}
 
 	if (Update)
 	{
 		_Update();
 	}
 }
 
 void LMru::DoFileDlg(LAutoPtr<LFileSelect> FileSelect, bool Open, std::function<void(bool)> OnSelect)
 {
 	if (!FileSelect)
 	{
 		LAssert(!"No select dialog.");
 		return;
 	}
 
 	auto Select = FileSelect.Release();
 	GetFileTypes(Select, false);
 	Select->ShowReadOnly(Open);
 
 	auto Cb = [this, Open, OnSelect](auto s, bool ok)
 	{
 		if (ok)
 		{
 			d->SelectedType = s->TypeAt(s->SelectedType());
 			if (Open)
 			{
 				_OpenFile(s->Name(), s->ReadOnly(), [OnSelect](auto ok)
 				{
 					if (OnSelect)
 						OnSelect(ok);
 				});
 			}
 			else
 			{
 				_SaveFile(s->Name(), [OnSelect](auto fn, auto ok)
 				{
 					if (OnSelect)
 						OnSelect(ok);
 				});
 			}
 		}
 		else if (OnSelect)
 		{
 			OnSelect(false);
 		}
 
 		delete s;
 	};
 
 	if (Open)
 		Select->Open(Cb);
 	else
 		Select->Save(Cb);
 }
 
 void LMru::OnCommand(int Cmd, std::function<void(bool)> OnStatus)
 {
 	LViewI *Wnd = d->Parent->GetMenu() ? d->Parent->GetMenu()->WindowHandle() : 0;
 	if (!Wnd)
 		return;
 
 	if (Cmd >= M_MRU_BASE &&
 		Cmd < M_MRU_BASE + d->Items.Length())
 	{
 		int Index = Cmd - M_MRU_BASE;
 		auto c = d->Items[Index];
 		if (!c)
 		{
 			if (OnStatus)
 				OnStatus(false);
 		}
 		else
 		{
 			_OpenFile(c->Raw, false, [OnStatus](auto ok)
 			{
 				if (OnStatus)
 					OnStatus(ok);
 			});
 		}
 	}
 	else if (Cmd == IDM_OPEN || Cmd == IDM_SAVEAS)
 	{
 		LAutoPtr<LFileSelect> Select(new LFileSelect);
 		Select->Parent(Wnd);
 		Select->ClearTypes();
 		d->SelectedType = 0;
 		
 		if (_GetCurFile())
 		{
 			if (LFileExists(_GetCurFile()))
 				Select->Name(_GetCurFile());
 			
 			char Path[256];
 			strcpy_s(Path, sizeof(Path), _GetCurFile());
 			LTrimDir(Path);
 			if (LDirExists(Path))
 				Select->InitialDir(Path);
 		}
 
 		auto ForwardStatus = [OnStatus](bool ok)
 		{
 			if (OnStatus)
 				OnStatus(ok);
 		};
 
 		if (Cmd == IDM_OPEN)
 			DoFileDlg(Select, true, ForwardStatus);
 		else if (Cmd == IDM_SAVEAS)
 			DoFileDlg(Select, false, ForwardStatus);
 	}
 }
 
 LMessage::Result LMru::OnEvent(LMessage *Msg)
 {
 	/*
 	if (d->Parent &&
 		MsgCode(Msg) == M_COMMAND)
 	{
 		#ifdef BEOS
 		int32 Cmd = 0;
 		int32 Event = 0;
 		Msg->FindInt32("Cmd", &Cmd);
 		Msg->FindInt32("Event", &Event);
 		#else
 		int Cmd = MsgA(Msg) & 0xffff;
 		#endif
 
 		OnCommand(Cmd);
 	}
 	*/
 
 	return false;
 }
 
 bool LMru::Serialize(LDom *Store, const char *Prefix, bool Write)
 {
 	bool Status = false;
 	LVariant v;
 
 	if (Store && Prefix)
 	{
 		if (Write)
 		{
 			// add our keys
 			int Idx = 0;
 			char Key[64];
 			LHashTbl<StrKey<char>, bool> Saved;
 
 			for (int i=0; i<d->Items.Length(); i++)
 			{
 				LMruEntry *e = d->Items[i];
 				LAssert(e->Raw.Get() != NULL);
 				if (!Saved.Find(e->Raw))
 				{
 					Saved.Add(e->Raw, true);
 					
 					LString Stored;
 					if (SerializeEntry(NULL, &e->Raw, &Stored)) // Convert Raw -> Stored
 					{
 						sprintf_s(Key, sizeof(Key), "%s.Item%i", Prefix, Idx++);
 						Store->SetValue(Key, v = Stored.Get());
 					}
 					else LAssert(0);
 				}
 			}
 
 			sprintf_s(Key, sizeof(Key), "%s.Items", Prefix);
 			Store->SetValue(Key, v = (int)Idx);
 		}
 		else
 		{
 			// clear ourself
 			d->Items.DeleteObjects();
 
 			// read our keys in
 			char Key[64];
 			sprintf_s(Key, sizeof(Key), "%s.Items", Prefix);
 			LVariant i;
 			if (Store->GetValue(Key, i))
 			{
 				for (int n=0; n<i.CastInt32(); n++)
 				{
 					sprintf_s(Key, sizeof(Key), "%s.Item%i", Prefix, n);
 
 					LVariant File;
 					if (Store->GetValue(Key, File))
 					{
 						LString Stored = File.Str();
 						LAssert(Stored.Get() != NULL);
 						
 						LAutoPtr<LMruEntry> e(new LMruEntry);
 						if (SerializeEntry(&e->Display, &e->Raw, &Stored)) // Convert Stored -> Raw
 						{
 							d->Items.Add(e.Release());
 						}
 					}
 				}
 			}
 
 			_Update();
 		}
 	}
 
 	return Status;
 }
 
 
diff --git a/utils/SlogViewer/src/SlogViewerMain.cpp b/utils/SlogViewer/src/SlogViewerMain.cpp
--- a/utils/SlogViewer/src/SlogViewerMain.cpp
+++ b/utils/SlogViewer/src/SlogViewerMain.cpp
@@ -1,430 +1,432 @@
 #define _CRT_SECURE_NO_WARNINGS
 #include "lgi/common/Lgi.h"
 #include "lgi/common/OptionsFile.h"
 #include "lgi/common/DocApp.h"
 #include "lgi/common/Box.h"
 #include "lgi/common/List.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/StructuredLog.h"
 #include "lgi/common/StatusBar.h"
 
 #include "resdefs.h"
 
 //////////////////////////////////////////////////////////////////
 const char *AppName = "SlogViewer";
 
 enum DisplayMode
 {
 	DisplayHex,
 	DisplayEscaped
 };
 
 enum Ctrls 
 {
 	IDC_BOX = 100,
 	IDC_LOG,
 	IDC_HEX,
 	IDC_ESCAPED,
 	IDC_TABS,
 	IDC_STATUS,
 };
 
 struct Context
 {
 	LList *log = NULL;
 	LTabView *tabs = NULL;
 	LTextView3 *hex = NULL;
 	LTextView3 *escaped = NULL;
 };
 
 class Entry : public LListItem
 {
 	Context *c;
 
 	struct Value
 	{
 		LVariantType type;
 		LArray<uint8_t> data;
 		LString name;
 	};
 	LArray<Value> values;
 
 	LString cache;
 
 public:
 	Entry(Context *ctx) : c(ctx)
 	{
 	}
 
 	void add(LVariantType type, size_t sz, void *ptr, const char *name)
 	{
 		auto &v = values.New();
 		v.type = type;
 		v.data.Add((uint8_t*)ptr, sz);
 		v.name = name;
 	}
 
 	const char *GetText(int i)
 	{
 		if (!cache)
 		{
 			LStringPipe p;
 			for (auto &v: values)
 			{
 				switch (v.type)
 				{
 					case GV_INT32:
 					case GV_INT64:
 					{
 						if (v.data.Length() == 4)
 							p.Print("%i", *(int*)v.data.AddressOf());
 						else if (v.data.Length() == 8)
 							p.Print(LPrintfInt64, *(int64_t*)v.data.AddressOf());
 						else
 							LAssert(!"Unknown int size.");
 						break;
 					}
 					case GV_STRING:
 					{
 						if (v.data.Length() >= 32)
 							p.Print(" (...)");
 						else
 							p.Print("%.*s", (int)v.data.Length(), v.data.AddressOf());
 						break;
 					}
 					case GV_CUSTOM:
 					{
 						p.Print("Object: %s", v.name.Get());
 						break;
 					}
 					case GV_VOID_PTR:
 					{
 						p.Print("/Object");
 						break;
 					}
 					default:
 					{
 						LAssert(!"Unknown type.");
 						break;
 					}
 				}
 
 				if (p.GetSize() > 64)
 					break;
 			}
 
 			cache = p.NewLStr();
 		}
 
 		return cache;
 	}
 
 	void Select(bool b) override
 	{
 		LListItem::Select(b);
 
 		auto mode = (DisplayMode)c->tabs->Value();
 		auto ctrl = mode ? c->escaped : c->hex;
 
 		if (b)
 		{
 			LStringPipe p;
 			LString Obj;
 			int Idx = 0;
 
 			auto PrintEscaped = [&](char *s, char *e)
 			{
 				for (auto c = s; c < e; c++)
 				{
 					switch (*c)
 					{
 						case '\\': p.Print("\\\\");  break;
 						case '\t': p.Print("\\t");   break;
 						case '\r': p.Print("\\r");   break;
 						case '\n': p.Print("\\n\n"); break;
 						case 0x07: p.Print("\\b");   break;
 						case 0x1b: p.Print("\\e");   break;
 						default:
 							if (*c < ' ' || *c >= 128)
 							{
 								LString hex;
 								hex.Printf("\\x%x", (uint8_t)*c);
 								p.Write(hex);
 							}
 							else p.Write(c, 1);
 							break;
 
 					}
 				}
 			};
 
 			for (auto &v: values)
 			{
 				auto sType = LVariant::TypeToString(v.type);
 				
 				switch (v.type)
 				{
 					case GV_CUSTOM:
 					{
 						p.Print("object %s {\n\n", v.name.Get());
 						Obj = v.name;
 						Idx = 0;
 						continue;
 					}
 					case GV_VOID_PTR:
 					{
 						p.Print("}\n");
 						Obj.Empty();
 						continue;
 					}
 					case GV_STRING:
 					{
 						if (Obj == "LConsole")
 						{
 							auto s = (char*)v.data.AddressOf();
 							auto e = s + v.data.Length();
 							p.Print("[%i]=", Idx++);
 							PrintEscaped(s, e);
 							p.Print("\n");
 							continue;
 						}
 						break;
 					}
 				}				
 				
 				p.Print("%s, %i bytes%s%s:\n",
 					sType,
 					(int)v.data.Length(),
 					v.name ? ", " : "",
 					v.name ? v.name.Get() : "");
 
 				switch (v.type)
 				{
 					case GV_INT32:
 					case GV_INT64:
 					{
 						if (v.data.Length() == 4)
 						{
 							auto i = (int*) v.data.AddressOf();
 							p.Print("%i 0x%x\n", *i, *i);
 						}
 						else if (v.data.Length() == 8)
 						{
 							auto i = (int64_t*) v.data.AddressOf();
 							p.Print(LPrintfInt64 " 0x" LPrintfHex64 "\n", *i, *i);
 						}
 						else
 							LAssert(!"Impl me.");
 						break;
 					}
 					case GV_STRING:
 					{
 						if (mode == DisplayHex)
 						{
 							char line[300];
 							int ch = 0;
 						
 							const int rowSize = 16;
 							const int colHex = 10;
 							const int colAscii = colHex + (rowSize * 3) + 2;
 							const int colEnd = colAscii + rowSize;
 
 							for (size_t addr = 0; addr < v.data.Length() ; addr += rowSize)
 							{
 								ZeroObj(line);
 								sprintf(line, "%8.8x", (int)addr);
 								auto rowBytes = MIN(v.data.Length() - addr, rowSize);
 								LAssert(rowBytes <= rowSize);
 								auto rowPtr = v.data.AddressOf(addr);
 								for (int i=0; i<rowBytes; i++)
 								{
 									sprintf(line + colHex + (i * 3), "%2.2x", rowPtr[i]);
 									line[colAscii + i] = rowPtr[i] >= ' ' && rowPtr[i] < 128 ? rowPtr[i] : '.';
 								}
 								for (int i=0; i<colEnd; i++)
 								{
 									if (line[i] == 0)
 										line[i] = ' ';
 								}
 								p.Print("%.*s\n", colEnd, line);
 							}
 						}
 						else if (mode == DisplayEscaped)
 						{
 							auto s = (char*)v.data.AddressOf();
 							auto e = s + v.data.Length();
 							PrintEscaped(s, e);
 							if (e > s && e[-1] != '\n')
 								p.Write("\n");
 						}
 						break;
 					}
 					default:
 					{
 						LAssert(!"Impl me.");
 						break;
 					}
 				}
 
 				p.Print("\n");
 			}
 
 			ctrl->Name(p.NewLStr());
 		}
 	}
 };
 
 class ReaderThread : public LThread
 {
 	Context *Ctx;
 	LString FileName;
 	LList *Lst = NULL;
 	Progress *Prog = NULL;
 
 public:
 	ReaderThread(Context *ctx,
 				const char *filename,
 				LList *lst,
 				Progress *prog)
 		: LThread("ReaderThread")
 	{
 		Ctx = ctx;
 		FileName = filename;
 		Lst = lst;
 		Prog = prog;
 
 		Run();
 	}
 
 	~ReaderThread()
 	{
 		Prog->Cancel();
 		WaitForExit(10000);
 	}
 
 	int Main()
 	{
 		LStructuredLog file(FileName, false);
 
 		LAutoPtr<Entry> cur;
 		List<LListItem> items;
 
 		while (file.Read([this, &cur, &items](auto type, auto size, auto ptr, auto name)
 			{
 				if (type == LStructuredIo::EndRow)
 				{
 					items.Insert(cur.Release());
 					if (items.Length() > 100)
 					{
 						Lst->Insert(items);
 						items.Empty();
 					}
 					return;
 				}
 
 				if (!cur && !cur.Reset(new Entry(Ctx)))
 					return;
 
 				cur->add(type, size, ptr, name);
 			},	Prog))
 			;
 
 		Lst->Insert(items);
 
 		return 0;
 	}
 };
 
 class App : public LDocApp<LOptionsFile>, public Context
 {
 	LBox *box = NULL;
 	LAutoPtr<ReaderThread> Reader;
 	LStatusBar *Status = NULL;
 	LProgressStatus *Prog = NULL;
 
 public:
     App() : LDocApp<LOptionsFile>(AppName)
     {
         Name(AppName);
         LRect r(0, 0, 1000, 800);
         SetPos(r);
         MoveToCenter();
         SetQuitOnClose(true);
 
         if (_Create())
         {
 			_LoadMenu();
 
 			AddView(Status = new LStatusBar(IDC_STATUS));
 			Status->AppendPane("Some text");
 			Status->AppendPane(Prog = new LProgressStatus());
 			Prog->GetCss(true)->Width("200px");
 			Prog->GetCss()->TextAlign(LCss::AlignRight);
 
 			AddView(box = new LBox(IDC_BOX));
 			box->AddView(log = new LList(IDC_LOG, 0, 0, 200, 200));
 			log->GetCss(true)->Width("40%");
 			log->ShowColumnHeader(false);
 			log->AddColumn("Items", 1000);
 
 			box->AddView(tabs = new LTabView(IDC_TABS));
 
 			auto tab = tabs->Append("Hex");
 			tab->Append(hex = new LTextView3(IDC_HEX));
 			hex->Sunken(true);
 			hex->SetPourLargest(true);
 
 			tab = tabs->Append("Escaped");
 			tab->Append(escaped = new LTextView3(IDC_ESCAPED));
 			escaped->Sunken(true);
 			escaped->SetPourLargest(true);
 
 			AttachChildren();
             Visible(true);
         }
     }
 
 	void OnReceiveFiles(LArray<const char*> &Files)
 	{
 		if (Files.Length())
-			OpenFile(Files[0]);
+			OpenFile(Files[0], false, NULL);
 	}	
 
-	bool OpenFile(const char *FileName, bool ReadOnly = false)
+	void OpenFile(const char *FileName, bool ReadOnly, std::function<void(bool status)> Callback)
 	{
-		return Reader.Reset(new ReaderThread(this, FileName, log, Prog));
+		auto ok = Reader.Reset(new ReaderThread(this, FileName, log, Prog));
+		if (Callback)
+			Callback(ok);
 	}
 
 	void SaveFile(const char *FileName, std::function<void(LString fileName, bool status)> Callback)
 	{
 		if (Callback)
 			Callback(FileName, false);
 	}
 
 	int OnNotify(LViewI *Ctrl, LNotification n)
 	{
 		if (Ctrl->GetId() == IDC_TABS)
 		{
 			auto item = log->GetSelected();
 			if (item)
 				item->Select(true);
 		}
 
 		return 0;
 	}
 };
 
 //////////////////////////////////////////////////////////////////
 int LgiMain(OsAppArguments &AppArgs)
 {
 	LApp a(AppArgs, AppName);
 	if (a.IsOk())
 	{
 		a.AppWnd = new App;
 		a.Run();
 	}
 
 	return 0;
 }