diff --git a/Ide/Code/FindInFiles.cpp b/Ide/Code/FindInFiles.cpp
--- a/Ide/Code/FindInFiles.cpp
+++ b/Ide/Code/FindInFiles.cpp
@@ -1,467 +1,467 @@
 #include <stdio.h>
 #include <ctype.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/DocView.h"
 #include "lgi/common/Token.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/FileSelect.h"
 
 #include "LgiIde.h"
 
 #define DEBUG_HIST		0
 #define DEBUG_SEARCH	0
 
 /////////////////////////////////////////////////////////////////////////////////////
 FindInFiles::FindInFiles(AppWnd *app, FindParams *params)
 {
 	TypeHistory = 0;
 	FolderHistory = 0;
 
 	SetParent(App = app);
 	
 	if (params)
 	{
 		Params = params;
 		OwnParams = false;
 	}
 	else
 	{
 		Params = new FindParams;
 		OwnParams = true;
 	}
 
 	if (LoadFromResource(IDD_FIND_IN_FILES))
 	{
 		auto r = GetPos();
 		auto Scale = (float)LScreenDpi().x / 96.0;
-		r.x2 *= Scale;
-		r.y2 *= Scale;
+		r.x2 = (int)(r.x2 * Scale);
+		r.y2 = (int)(r.y2 * Scale);
 		SetPos(r);
 
 		MoveToCenter();
 
 		if (GetViewById(IDC_TYPE_HISTORY, TypeHistory))
 			TypeHistory->SetTargetId(IDC_FILE_TYPES);
 
 		if (GetViewById(IDC_FOLDER_HISTORY, FolderHistory))
 			FolderHistory->SetTargetId(IDC_DIR);
 	}
 }
 
 FindInFiles::~FindInFiles()
 {
 	if (OwnParams)
 		DeleteObj(Params);
 }
 
 void SerializeHistory(LHistory *h, const char *opt, LOptionsFile *p, bool Write)
 {
 	if (h && p)
 	{
 		LString last;
 		last.Printf("%sSelect", opt);
 		LViewI *Edit = NULL;
 		h->GetWindow()->GetViewById(h->GetTargetId(), Edit);
 		
 		#if DEBUG_HIST
 		LgiTrace("%s:%i - SerializeHistory '%s', Write=%i\n", _FL, last.Get(), Write);
 		#endif
 
 		LVariant v;
 		if (Write)
 		{
 			LString::Array a;
 			a.SetFixedLength(false);
 			int64 i = 0;
 			int64 Selected = h->Value();
 			LString EdTxt;
 			if (Edit)
 				EdTxt = Edit->Name();
 
 			for (auto s: *h)
 			{
 				if (EdTxt && EdTxt.Equals(s))
 				{
 					Selected = i;
 				}
 
 				a.Add(s);
 				#if DEBUG_HIST
 				LgiTrace("\t[%i]='%s'\n", i, s);
 				#endif
 				i++;
 			}
 
 			LString strs = LString(OptFileSeparator).Join(a);
 			p->SetValue(opt, v = strs.Get());
 			#if DEBUG_HIST
 			LgiTrace("\tstrs='%s'\n", strs.Get());
 			#endif
 			
 			p->SetValue(last, v = Selected);
 			#if DEBUG_HIST
 			LgiTrace("\tv=%i\n", v.CastInt32());
 			#endif
 		}
 		else
 		{
 			if (p->GetValue(opt, v))
 			{
 				LString raw(v.Str());
 				LString::Array t = raw.Split("|");
 				h->DeleteArrays();
 				for (unsigned i=0; i<t.Length(); i++)
 				{
 					h->Insert(NewStr(t[i]));
 					#if DEBUG_HIST
 					LgiTrace("\t[%i]='%s'\n", i, t[i].Get());
 					#endif
 				}
 				h->Update();
 				
 				if (p->GetValue(last, v))
 				{
 					h->Value(v.CastInt64());
 					#if DEBUG_HIST
 					LgiTrace("\tValue=%i\n", v.CastInt32());
 					#endif
 				}
 				else LgiTrace("%s:%i - No option '%s'\n", _FL, last.Get());
 			}
 		}
 	}
 }
 
 void FindInFiles::OnCreate()
 {
 	if (Params)
 	{
 		SetCtrlValue(IDC_ENTIRE_SOLUTION, Params->Type == FifSearchSolution);
 		SetCtrlValue(IDC_SEARCH_DIR, Params->Type == FifSearchDirectory);
 
 		SetCtrlName(IDC_LOOK_FOR, Params->Text);
 		SetCtrlName(IDC_FILE_TYPES, Params->Ext);
 		SetCtrlName(IDC_DIR, Params->Dir);
 		
 		SetCtrlValue(IDC_WHOLE_WORD, Params->MatchWord);
 		SetCtrlValue(IDC_CASE, Params->MatchCase);
 		SetCtrlValue(IDC_SUB_DIRS, Params->SubDirs);
 		
 		SerializeHistory(TypeHistory,   "TypeHist",   App->GetOptions(), false);
 		SerializeHistory(FolderHistory, "FolderHist", App->GetOptions(), false);
 
 		LEdit *v;
 		if (GetViewById(IDC_LOOK_FOR, v))
 		{
 			v->Focus(true);
 			v->SelectAll();
 		}
 	}
 }
 
 int FindInFiles::OnNotify(LViewI *v, LNotification n)
 {
 	switch (v->GetId())
 	{
 		case IDC_SET_DIR:
 		{
 			LFileSelect s;
 			s.Parent(this);
 			s.InitialDir(GetCtrlName(IDC_DIR));
 			if (s.OpenFolder())
 			{
 				int Idx = FolderHistory->Add(s.Name());
 				if (Idx >= 0)
 					FolderHistory->Value(Idx);
 				else
 					SetCtrlName(IDC_DIR, s.Name());
 			}
 			break;
 		}
 		case IDC_ENTIRE_SOLUTION:
 		case IDC_SEARCH_DIR:
 		{
 			bool SearchSol = GetCtrlValue(IDC_ENTIRE_SOLUTION) != 0;
 			SetCtrlEnabled(IDC_DIR, !SearchSol);
 			SetCtrlEnabled(IDC_SET_DIR, !SearchSol);
 			SetCtrlEnabled(IDC_FOLDER_HISTORY, !SearchSol);
 			SetCtrlEnabled(IDC_SUB_DIRS, !SearchSol);
 			break;
 		}
 		case IDOK:
 		case IDCANCEL:
 		{
 			Params->Type = GetCtrlValue(IDC_ENTIRE_SOLUTION) != 0 ? FifSearchSolution :  FifSearchDirectory;
 			Params->Text = GetCtrlName(IDC_LOOK_FOR);
 			Params->Ext = GetCtrlName(IDC_FILE_TYPES);
 			Params->Dir = GetCtrlName(IDC_DIR);
 			
 			Params->MatchWord = GetCtrlValue(IDC_WHOLE_WORD);
 			Params->MatchCase = GetCtrlValue(IDC_CASE);
 			Params->SubDirs = GetCtrlValue(IDC_SUB_DIRS);
 		
 			if (TypeHistory) TypeHistory->Add(Params->Ext);
 			SerializeHistory(TypeHistory,   "TypeHist",   App->GetOptions(), true);
 			if (FolderHistory) FolderHistory->Add(Params->Dir);
 			SerializeHistory(FolderHistory, "FolderHist", App->GetOptions(), true);
 			
 			EndModal(v->GetId() == IDOK);
 			break;
 		}
 	}
 	
 	return 0;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////
 class FindInFilesThreadPrivate
 {
 public:
 	int AppHnd;
 	LAutoPtr<FindParams> Params;
 	bool Loop, Busy;
 	LStringPipe Pipe;
 	int64 Last;
 };
 
 FindInFilesThread::FindInFilesThread(int AppHnd) : LEventTargetThread("FindInFiles")
 {
 	d = new FindInFilesThreadPrivate;
 	d->AppHnd = AppHnd;
 	d->Loop = true;
 	d->Busy = false;
 	d->Last = 0;
 }
 
 FindInFilesThread::~FindInFilesThread()
 {
 	d->Loop = false;
 	EndThread();
 	DeleteObj(d);
 }
 
 void FindInFilesThread::Log(const char *Str)
 {
 	PostThreadEvent(d->AppHnd, M_APPEND_TEXT, (LMessage::Param)Str, AppWnd::FindTab);
 }
 
 void FindInFilesThread::SearchFile(char *File)
 {
 	if (!File || !ValidStr(d->Params->Text))
 		return;
 
 	LFile f;
 	if (!f.Open(File, O_READ))
 	{
 		LString s;
 		s.Printf("Couldn't Read file '%s'\n", File);
 		Log(NewStr(s));
 		return;
 	}
 
 	auto Doc = f.Read();
 	if (!Doc)
 		return;
 
 	auto Len = d->Params->Text.Length();
 	const char *Text = d->Params->Text;
 	
 	char *LineStart = 0;
 	int Line = 0;
 	for (char *s = Doc; *s && d->Loop; s++)
 	{
 		if (*s == '\n')
 		{
 			Line++;
 			LineStart = 0;
 		}
 		else
 		{
 			if (!LineStart)
 				LineStart = s;
 				
 			bool Match = false;
 			if (d->Params->MatchCase)
 			{
 				if (Text[0] == *s)
 				{
 					Match = strncmp(s, Text, Len) == 0;
 				}
 			}
 			else
 			{
 				if (toupper(Text[0]) == toupper(*s))
 				{
 					Match = strnicmp(s, Text, Len) == 0;
 				}
 			}
 			
 			if (Match)
 			{
 				char *Eol = s + Len;
 				while (*Eol && *Eol != '\n') Eol++;
 				auto LineLen = Eol - LineStart;						
 				
 				bool StartOk = true;
 				bool EndOk = true;
 				if (d->Params->MatchWord)
 				{
 					if (s > Doc)
 					{
 						StartOk = IsWordBoundry(s[-1]);
 					}
 					
 					EndOk = IsWordBoundry(s[Len]);
 				}
 				
 				if (StartOk && EndOk)
 				{
 					static char Buf[1024];
 					int Chars = snprintf(Buf, sizeof(Buf), "%s:%i:%.*s\n", File, Line + 1, (int)LineLen, LineStart);
 					d->Pipe.Push(Buf, Chars);
 					
 					int64 Now = LCurrentTime();
 					if (Now > d->Last  + 500)
 						Log(d->Pipe.NewStr());
 				}
 				s = Eol - 1;
 			}
 		}
 	}
 }
 
 void FindInFilesThread::Stop()
 {
 	d->Loop = false;
 	while (d->Busy)
 		LSleep(1);
 }
 
 LMessage::Result FindInFilesThread::OnEvent(LMessage *Msg)
 {
 	switch (Msg->Msg())
 	{
 		case M_START_SEARCH:
 		{
 			d->Params.Reset((FindParams*)Msg->A());
 			if (!d->AppHnd ||
 				!d->Params ||
 				!ValidStr(d->Params->Text))
 			{
 				LAssert(!"Invalid params.");
 				break;
 			}
 
 			char Msg[256];
 
 			PostThreadEvent(d->AppHnd, M_SELECT_TAB, AppWnd::FindTab);
 			
 			d->Loop = true;
 			d->Busy = true;
 			snprintf(Msg, sizeof(Msg), "Searching for '%s'...\n", d->Params->Text.Get());
 			Log(NULL);
 			Log(NewStr(Msg));
 
 			LArray<const char*> Ext;
 			LToken e(d->Params->Ext, ";, ");
 			for (int i=0; i<e.Length(); i++)
 			{
 				Ext.Add(e[i]);
 			}
 	
 			LArray<char*> Files;
 			if (d->Params->Type == FifSearchSolution)
 			{
 				// Do the extension filtering...
 				for (auto p: d->Params->ProjectFiles)
 				{
 					if (p)
 					{
 						const char *Leaf = LGetLeaf(p);
 						for (auto e: Ext)
 						{
 							if (MatchStr(e, Leaf))
 							{
 								Files.Add(NewStr(p));
 								break;
 							}
 						}
 					}
 					else LgiTrace("%s:%i - Null string in project files array.\n", _FL);
 				}
 			}
 			else
 			{
 				// Find the files recursively...
 				LRecursiveFileSearch(d->Params->Dir, &Ext, &Files, NULL, NULL, [](auto Path, auto Dir)
 				{
 					if (Dir->IsDir())
 					{
 						char *p = Dir->GetName();
 						if
 						(
 							p
 							&&
 							(
 								stricmp(p, ".svn") == 0
 								||
 								stricmp(p, ".git") == 0
 							)
 						)
 							return false;
 					}
 	
 					return true;
 				});
 			}
 
 			if (Files.Length() > 0)
 			{			
 				sprintf(Msg, "in %i files...\n", (int)Files.Length());
 				Log(NewStr(Msg));
 
 				for (auto f: Files)
 				{
 					if (!d->Loop)
 						break;
 					
 					if (f)
 					{
 						auto Dir = strrchr(f, DIR_CHAR);
 						if (!Dir || Dir[1] != '.')
 						{
 							#if DEBUG_SEARCH
 							LgiTrace("Searching '%s'\n", f);
 							#endif
 							SearchFile(f);
 						}
 						#if DEBUG_SEARCH
 						else LgiTrace("Skipping '%s'\n", f);
 						#endif
 					}
 					else LgiTrace("%s:%i - NULL Ptr in list????", _FL);
 				}
 		
 				auto Str = d->Pipe.NewStr();
 				if (Str)
 					Log(Str);
 		
 				Files.DeleteArrays();
 
 				Log(NewStr("Done.\n"));
 			}
 			else
 			{
 				Log(NewStr("No files matched.\n"));
 			}
 			
 			d->Busy = false;
 			break;
 		}
 	}
 
 	return 0;
 }
diff --git a/Ide/Code/IdeProject.cpp b/Ide/Code/IdeProject.cpp
--- a/Ide/Code/IdeProject.cpp
+++ b/Ide/Code/IdeProject.cpp
@@ -1,4052 +1,4056 @@
 #if defined(WIN32)
 #include <direct.h>
 #else
 #include <unistd.h>
 #endif
 #include <stdio.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/DragAndDrop.h"
 #include "lgi/common/Token.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Net.h"
 #include "lgi/common/ListItemCheckBox.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DropFiles.h"
 #include "lgi/common/SubProcess.h"
 #include "lgi/common/Css.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/RegKey.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 
 #include "LgiIde.h"
 #include "resdefs.h"
 #include "FtpThread.h"
 #include "ProjectNode.h"
 #include "WebFldDlg.h"
 
 extern const char *Untitled;
 const char SourcePatterns[] = "*.c;*.h;*.cpp;*.cc;*.java;*.d;*.php;*.html;*.css;*.js";
 const char *AddFilesProgress::DefaultExt = "c,cpp,cc,cxx,h,hpp,hxx,html,css,json,js,jsx,txt,png,jpg,jpeg,rc,xml,mk,paths,makefile,py,java,php";
 const char *VsBinaries[] = {"devenv.com", "WDExpress.exe"};
 
 #define USE_OPEN_PROGRESS			1
 
 #define STOP_BUILD_TIMEOUT			2000
 #ifdef WINDOWS
 #define LGI_STATIC_LIBRARY_EXT		"lib"
 #else
 #define LGI_STATIC_LIBRARY_EXT		"a"
 #endif
 
 const char *PlatformNames[] =
 {
 	"Windows",
 	"Linux",
 	"Mac",
 	"Haiku",
 	0
 };
 
 int PlatformCtrlId[] =
 {
 	IDC_WIN32,
 	IDC_LINUX,
 	IDC_MAC,
 	IDC_HAIKU,
 	0
 };
 
 const char *PlatformDynamicLibraryExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return "dll";
 	if (Platform == PlatformMac)
 		return "dylib";
 	
 	return "so";
 }
 
 const char *PlatformSharedLibraryExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return "lib";
 
 	return "a";
 }
 
 const char *PlatformExecutableExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return ".exe";
 	return "";
 }
 
 char *ToUnixPath(char *s)
 {
 	if (s)
 	{
 		char *c;
 		while ((c = strchr(s, '\\')))
 			*c = '/';
 	}
 	return s;
 }
 
 const char *CastEmpty(char *s)
 {
 	return s ? s : "";
 }
 
 bool FindInPath(LString &Exe)
 {
 	LString::Array Path = LString(getenv("PATH")).Split(LGI_PATH_SEPARATOR);
 	for (unsigned i=0; i<Path.Length(); i++)
 	{
 		char p[MAX_PATH_LEN];
 		LMakePath(p, sizeof(p), Path[i], Exe);
 		if (LFileExists(p))
 		{
 			Exe = p;
 			return true;
 		}
 	}
 	
 	return false;
 }
 
 LAutoString ToNativePath(const char *s)
 {
 	LAutoString a(NewStr(s));
 	if (a)
 	{
 		if (strnicmp(a, "ftp://", 6))
 		{
 			for (char *c = a; *c; c++)
 			{
 				#ifdef WIN32
 				if (*c == '/')
 					*c = '\\';
 				#else
 				if (*c == '\\')
 					*c = '/';
 				#endif
 			}
 		}
 	}
 	return a;
 }
 
 int StrCmp(char *a, char *b, NativeInt d)
 {
 	return stricmp(a, b);
 }
 
 int StrSort(char **a, char **b)
 {
 	return stricmp(*a, *b);
 }
 
 //////////////////////////////////////////////////////////////////////////////////
 class ProjectNode;
 
 class BuildThread : public LThread, public LStream
 {
 	IdeProject *Proj;
 	LString Makefile, CygwinPath;
 	bool Clean, All;
 	BuildConfig Config;
 	int WordSize;
 	LAutoPtr<LSubProcess> SubProc;
 	LString::Array BuildConfigs;
 	LString::Array PostBuild;
 	int AppHnd;
 
 	enum CompilerType
 	{
 		DefaultCompiler,
 		VisualStudio,
 		MingW,
 		Gcc,
 		CrossCompiler,
 		PythonScript,
 		IAR,
 		Nmake,
 		Cygwin,
 		Xcode,
 	}
 		Compiler;
 
 	enum ArchType
 	{
 		DefaultArch,
 		ArchX32,
 		ArchX64,
 		ArchArm6,
 		ArchArm7,
 	}
 		Arch;
 
 public:
 	BuildThread(IdeProject *proj, char *makefile, bool clean, BuildConfig config, bool all, int wordsize);
 	~BuildThread();
 	
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0) override;
 	LString FindExe();
 	LAutoString WinToMingWPath(const char *path);
 	int Main() override;
 };
 
 class IdeProjectPrivate
 {
 public:
 	AppWnd *App;
 	IdeProject *Project;
 	bool Dirty, UserFileDirty;
 	LString FileName;
 	IdeProject *ParentProject;
 	IdeProjectSettings Settings;
 	LAutoPtr<BuildThread> Thread;
 	LHashTbl<ConstStrKey<char,false>, ProjectNode*> Nodes;
 	int NextNodeId;
 
 	// Threads
 	LAutoPtr<class MakefileThread> CreateMakefile;
 
 	// User info file
 	LString UserFile;
 	LHashTbl<IntKey<int>,int> UserNodeFlags;
 
 	IdeProjectPrivate(AppWnd *a, IdeProject *project) :
 		Project(project),
 		Settings(project)
 	{
 		App = a;
 		Dirty = false;
 		UserFileDirty = false;
 		ParentProject = 0;
 		NextNodeId = 1;
 	}
 
 	void CollectAllFiles(LTreeNode *Base, LArray<ProjectNode*> &Files, bool SubProjects, int Platform);
 };
 
 LString ToPlatformPath(const char *s, IdePlatform platform)
 {
 	LString p = s;
 	if (platform == PlatformWin)
 		return p.Replace("/", "\\");
 	else
 		return p.Replace("\\", "/");
 }
 
 class MakefileThread : public LThread, public LCancel
 {
 	IdeProjectPrivate *d;
 	IdeProject *Proj;
 	IdePlatform Platform;
 	LStream *Log;
 	bool BuildAfterwards;
 	bool HasError;
 	
 public:
 	static int Instances;
 
 	MakefileThread(IdeProjectPrivate *priv, IdePlatform platform, bool Build) : LThread("MakefileThread")
 	{
 		Instances++;
 
 		d = priv;
 		Proj = d->Project;
 		Platform = platform;
 		BuildAfterwards = Build;
 		HasError = false;
 		Log = d->App->GetBuildLog();
 		
 		Run();
 	}
 
 	~MakefileThread()
 	{
 		Cancel();
 		while (!IsExited())
 			LSleep(1);
 		Instances--;
 	}
 	
 	void OnError(const char *Fmt, ...)
 	{
 		va_list Arg;
 		va_start(Arg, Fmt);
 		LStreamPrintf(Log, 0, Fmt, Arg);
 		va_end(Arg);
 		HasError = true;
 	}
 	
 	int Main()
 	{
 		const char *PlatformName = PlatformNames[Platform];
 		const char *PlatformLibraryExt = NULL;
 		const char *PlatformStaticLibExt = NULL;
 		const char *PlatformExeExt = "";
 		LString LinkerFlags;
 		const char *TargetType = d->Settings.GetStr(ProjTargetType, NULL, Platform);
 		const char *CompilerName = d->Settings.GetStr(ProjCompiler);
 		LString CCompilerBinary = "gcc";
 		LString CppCompilerBinary = "g++";
 		LStream *Log = d->App->GetBuildLog();
 		bool IsExecutableTarget = TargetType && !stricmp(TargetType, "Executable");
 		bool IsDynamicLibrary	= TargetType && !stricmp(TargetType, "DynamicLibrary");
 		
 		LAssert(Log);
 		if (!Log)
 			return false;
 		
 		Log->Print("CreateMakefile for '%s'...\n", PlatformName);
 		
 		if (Platform == PlatformWin)
 		{
 			LinkerFlags = ",--enable-auto-import";
 		}
 		else
 		{
 			if (IsDynamicLibrary)
 			{
 				LinkerFlags = ",-soname,$(TargetFile)";
 			}
 			LinkerFlags += ",-export-dynamic,-R.";
 		}
 
 		char Buf[256];
 		auto MakeFile = Proj->GetMakefile(Platform);
 		Proj->CheckExists(MakeFile);
 		if (!MakeFile)
 			MakeFile = "../Makefile";
 		
 		// LGI_LIBRARY_EXT
 		switch (Platform)
 		{
 			case PlatformWin:
 				PlatformLibraryExt = "dll";
 				PlatformStaticLibExt = "lib";
 				PlatformExeExt = ".exe";
 				break;
 			case PlatformLinux:
 			case PlatformHaiku:
 				PlatformLibraryExt = "so";
 				PlatformStaticLibExt = "a";
 				break;
 			case PlatformMac:
 				PlatformLibraryExt = "dylib";
 				PlatformStaticLibExt = "a";
 				break;
 			default:
 				LAssert(0);
 				break;
 		}
 
 		if (CompilerName)
 		{
 			if (!stricmp(CompilerName, "cross"))
 			{
 				LString CBin = d->Settings.GetStr(ProjCCrossCompiler, NULL, Platform);
 				if (CBin && !LFileExists(CBin))
 					FindInPath(CBin);
 				if (CBin && LFileExists(CBin))
 					CCompilerBinary = CBin;
 				else
 					Log->Print("%s:%i - Error: C cross compiler '%s' not found.\n", _FL, CBin.Get());
 				
 				LString CppBin = d->Settings.GetStr(ProjCppCrossCompiler, NULL, Platform);
 				if (CppBin && !LFileExists(CppBin))
 					FindInPath(CppBin);
 				if (CppBin && LFileExists(CppBin))
 					CppCompilerBinary = CppBin;
 				else
 					Log->Print("%s:%i - Error: C++ cross compiler '%s' not found.\n", _FL, CppBin.Get());
 			}
 		}
 		
 		LFile m;
 		if (!m.Open(MakeFile, O_WRITE))
 		{
 			Log->Print("Error: Failed to open '%s' for writing.\n", MakeFile.Get());
 			return false;
 		}
 		
 		m.SetSize(0);
 		
 		m.Print("#!/usr/bin/make\n"
 				"#\n"
 				"# This makefile generated by LgiIde\n"
 				"# http://www.memecode.com/lgi.php\n"
 				"#\n"
 				"\n"
 				".SILENT :\n"
 				"\n"
 				"CC = %s\n"
 				"CPP = %s\n",
 				CCompilerBinary.Get(),
 				CppCompilerBinary.Get());
 
 		// Collect all files that require building
 		LArray<ProjectNode*> Files;
 		d->CollectAllFiles
 		(
 			Proj,
 			Files,
 			false,
 			1 << Platform
 		);
 		
 		auto Base = Proj->GetBasePath();
 		if (IsExecutableTarget)
 		{
 			LString Exe = Proj->GetExecutable(Platform);
 			if (Exe)
 			{
 				if (LIsRelativePath(Exe))
 					m.Print("Target = %s\n", ToPlatformPath(Exe, Platform).Get());
 				else
 				{
 					auto RelExe = LMakeRelativePath(Base, Exe);
 					if (Base && RelExe)
 					{
 						m.Print("Target = %s\n", ToPlatformPath(RelExe, Platform).Get());
 					}
 					else
 					{
 						Log->Print("%s:%i - Error: Missing path (%s, %s).\n", _FL, Base.Get(), RelExe.Get());
 						return false;
 					}
 				}
 			}
 			else
 			{
 				Log->Print("%s:%i - Error: No executable name specified (%s, %s).\n", _FL, TargetType, d->FileName.Get());
 				return false;
 			}
 		}
 		else
 		{
 			LString Target = Proj->GetTargetName(Platform);
 			if (Target)
 				m.Print("Target = %s\n", ToPlatformPath(Target, Platform).Get());
 			else
 			{
 				Log->Print("%s:%i - Error: No target name specified.\n", _FL);
 				return false;
 			}
 		}
 
 		// Output the build mode, flags and some paths
 		auto BuildMode = d->App->GetBuildMode();
 		auto BuildModeName = toString(BuildMode);
 		m.Print("ifndef Build\n"
 				"	Build = %s\n"
 				"endif\n",
 				BuildModeName);
 		
 		LString sDefines[BuildMax];
 		LString sLibs[BuildMax];
 		LString sIncludes[BuildMax];
 		const char *ExtraLinkFlags = NULL;
 		const char *ExeFlags = NULL;
 		if (Platform == PlatformWin)
 		{
 			ExtraLinkFlags = "";
 			ExeFlags = " -mwindows";
 			m.Print("BuildDir = $(Build)\n"
 					"\n"
 					"Flags = -fPIC -w -fno-inline -fpermissive\n");
 			
 			const char *DefDefs = "-DWIN32 -D_REENTRANT";
 			sDefines[BuildDebug] = DefDefs;
 			sDefines[BuildRelease] = DefDefs;
 		}
 		else
 		{
 			LString PlatformCap = PlatformName;
 		
 			ExtraLinkFlags = "";
 			ExeFlags = "";
 			m.Print("BuildDir = $(Build)\n"
 					"\n"
 					"Flags = -fPIC -w -fno-inline -fpermissive\n" // -fexceptions
 					);
 			sDefines[0].Printf("-D%s -D_REENTRANT", PlatformCap.Upper().Get());
 			#ifdef LINUX
 			sDefines[BuildDebug] += " -D_FILE_OFFSET_BITS=64"; // >:-(
 			sDefines[BuildDebug] += " -DPOSIX";
 			#endif
 			sDefines[BuildRelease] = sDefines[BuildDebug];
 		}
 
 		List<IdeProject> Deps;
 		Proj->GetChildProjects(Deps);
 
 		for (int Cfg = BuildDebug; Cfg < BuildMax; Cfg++)
 		{
 			// Set the config
 			auto cfgName = toString((BuildConfig)Cfg);
 			d->Settings.SetCurrentConfig(cfgName);
 		
 			// Get the defines setup
 			auto PDefs = d->Settings.GetStr(ProjDefines, NULL, Platform);
 			if (ValidStr(PDefs))
 			{
 				LToken Defs(PDefs, " ;,\r\n");
 				for (int i=0; i<Defs.Length(); i++)
 				{
 					LString s;
 					s.Printf(" -D%s", Defs[i]);
 					sDefines[Cfg] += s;
 				}
 			}
 		
 			// Collect all dependencies, output their lib names and paths
 			LString PLibPaths = d->Settings.GetStr(ProjLibraryPaths, NULL, Platform);
 			if (ValidStr(PLibPaths))
 			{
 				LString::Array LibPaths = PLibPaths.Split("\n");
 				for (auto i: LibPaths)
 				{
 					LString s, in = i.Strip();
 					if (!in.Length())
 						continue;
 					
 					if (strchr("`-", in(0)))
 					{
 						s.Printf(" \\\n\t\t%s", in.Get());
 					}
 					else
 					{
 						LString Rel;
 						if (!LIsRelativePath(in))
 							Rel = LMakeRelativePath(Base, in);
 
 						LString Final = Rel ? Rel.Get() : in.Get();
 						if (!Proj->CheckExists(Final))
 							OnError("%s:%i - Library path '%s' doesn't exist (from %s).\n",
 								_FL, Final.Get(),
 								Proj->GetFileName());
 
 						s.Printf(" \\\n\t\t-L%s", ToUnixPath(Final));
 					}
 					
 					sLibs[Cfg] += s;
 				}
 			}
 
 			const char *PLibs = d->Settings.GetStr(ProjLibraries, NULL, Platform);
 			if (ValidStr(PLibs))
 			{
 				LToken Libs(PLibs, "\r\n");
 				for (int i=0; i<Libs.Length(); i++)
 				{
 					LString l = Libs[i];
 
 					LString s;
 					if (l(0) == '`' || l(0) == '-')
 						s.Printf(" \\\n\t\t%s", l.Get());
 					else
 					{
 						Proj->CheckExists(l);
 						s.Printf(" \\\n\t\t-l%s", ToUnixPath(l));
 					}
 					sLibs[Cfg] += s;
 				}
 			}
 
 			for (auto dep: Deps)
 			{
 				LString Target = dep->GetTargetName(Platform);
 				if (Target)
 				{
 					char t[MAX_PATH_LEN];
 					strcpy_s(t, sizeof(t), Target);
 					if (!strnicmp(t, "lib", 3))
 						memmove(t, t + 3, strlen(t + 3) + 1);
 					char *dot = strrchr(t, '.');
 					if (dot)
 						*dot = 0;
 													
 					LString s, sTarget = t;
 					Proj->CheckExists(sTarget);
 					s.Printf(" \\\n\t\t-l%s$(Tag)", ToUnixPath(sTarget));
 					sLibs[Cfg] += s;
 
 					auto DepBase = dep->GetBasePath();
 					if (DepBase)
 					{
 						LString DepPath = DepBase.Get();
 						
 						auto Rel = LMakeRelativePath(Base, DepPath);
 
 						LString Final = Rel ? Rel.Get() : DepPath.Get();
 						Proj->CheckExists(Final);
 						s.Printf(" \\\n\t\t-L%s/$(BuildDir)", ToUnixPath(Final.RStrip("/\\")));
 						sLibs[Cfg] += s;
 					}
 				}
 			}
 			
 			// Includes
 
 			// Do include paths
 			LHashTbl<StrKey<char>,bool> Inc;
 			auto ProjIncludes = d->Settings.GetStr(ProjIncludePaths, NULL, Platform);
 			if (ValidStr(ProjIncludes))
 			{
 				// Add settings include paths.
 				LToken Paths(ProjIncludes, "\r\n");
 				for (int i=0; i<Paths.Length(); i++)
 				{
 					char *p = Paths[i];
 					LAutoString pn = ToNativePath(p);					
 					if (pn.Get()[0] != '`' && !Proj->CheckExists(pn))
 						OnError("%s:%i - Include path '%s' doesn't exist.\n", _FL, pn.Get());
 					else if (!Inc.Find(pn))
 						Inc.Add(pn, true);
 				}
 			}
 			const char *SysIncludes = d->Settings.GetStr(ProjSystemIncludes, NULL, Platform);
 			if (ValidStr(SysIncludes))
 			{
 				// Add settings include paths.
 				LToken Paths(SysIncludes, "\r\n");
 				for (int i=0; i<Paths.Length(); i++)
 				{
 					char *p = Paths[i];
 					LAutoString pn = ToNativePath(p);
 					if (pn.Get()[0] != '`' && !Proj->CheckExists(pn))
 						OnError("%s:%i - System include path '%s' doesn't exist (from %s).\n",
 							_FL, pn.Get(),
 							Proj->GetFileName());
 					else if (!Inc.Find(pn))
 						Inc.Add(pn, true);
 				}
 			}
 
 			#if 0
 			/*
 			Currently this code is adding extra paths that are covered by the official 'IncludePaths'
 			in addition to relative paths in the actual #include parameter. e.g.
 				#include "lgi/common/SomeHeader.h"
 			Hence disabling it for the time being.
 			*/
 			// Add paths of headers
 			for (int i=0; i<Files.Length(); i++)
 			{
 				ProjectNode *n = Files[i];
 				
 				if (n->GetFileName())
 				{
 					char *e = LGetExtension(n->GetFileName());
 					if (e && stricmp(e, "h") == 0)
 					{
 						LString Fn = n->GetFileName();
 						for (char *Dir = Fn; *Dir; Dir++)
 						{
 							if (*Dir == '/' || *Dir == '\\')
 							{
 								*Dir = DIR_CHAR;
 							}
 						}						
 
 						char Path[MAX_PATH_LEN];
 						strcpy_s(Path, sizeof(Path), Fn);
 
 						LTrimDir(Path);
 					
 						LString Rel;
 						if (!Proj->RelativePath(Rel, Path))
 							Rel = Path;
 						
 						if (stricmp(Rel, ".") != 0)
 						{
 							LAutoString RelN = ToNativePath(Rel);
 							if (!Proj->CheckExists(RelN))
 								OnError("Header include path '%s' doesn't exist.\n", RelN.Get());
 							else if (!Inc.Find(RelN))
 								Inc.Add(RelN, true);
 						}
 					}
 				}
 			}
 			#endif
 
 			LString::Array Incs;
 			for (auto i: Inc)
 				Incs.New() = i.key;
 			Incs.Sort();
 			
 			for (auto i: Incs)
 			{
 				LString s;
 				if (*i == '`')
 					s.Printf(" \\\n\t\t%s", i.Get());
 				else
 					s.Printf(" \\\n\t\t-I%s", ToUnixPath(i));
 				sIncludes[Cfg] += s;
 			}
 		}
 
 		// Output the defs section for Debug and Release		
 
 		// Debug specific
 		m.Print("\n"
 				"ifeq ($(Build),Debug)\n"
 				"	Flags += -g -std=c++14\n"
 				"	Tag = d\n"
 				"	Defs = -D_DEBUG %s\n"
 				"	Libs = %s\n"
 				"	Inc = %s\n",
 					CastEmpty(sDefines[0].Get()),
 					CastEmpty(sLibs[0].Get()),
 					CastEmpty(sIncludes[0].Get()));
 		
 		// Release specific
 		m.Print("else\n"
 				"	Flags += -s -Os -std=c++14\n"
 				"	Defs = %s\n"
 				"	Libs = %s\n"
 				"	Inc = %s\n"
 				"endif\n"
 				"\n",
 					CastEmpty(sDefines[1].Get()),
 					CastEmpty(sLibs[1].Get()),
 					CastEmpty(sIncludes[1].Get()));
 		
 		if (Files.Length())
 		{
 			LArray<LString> IncPaths;
 			if (Proj->BuildIncludePaths(IncPaths, false, false, Platform))
 			{
 				// Do source code list...
 				m.Print("# Dependencies\n"
 						"Source =\t");
 					
 				LString::Array SourceFiles;
 				for (auto &n: Files)
 				{
 					if (n->GetType() == NodeSrc)
 					{
 						auto f = n->GetFileName();
 						auto path = ToPlatformPath(f, Platform);
 						if (path.Find("./") == 0)
 							path = path(2,-1);
 						SourceFiles.Add(path);
 					}
 				}
 				SourceFiles.Sort();
 				int c = 0;
 				for (auto &src: SourceFiles)
 				{
 					if (c++) m.Print(" \\\n\t\t\t");
 					m.Print("%s", src.Get());
 				}
 				m.Print("\n"
 						"\n"
 						"SourceLst := $(patsubst %%.c,%%.o,$(patsubst %%.cpp,%%.o,$(Source)))\n"
 						"\n"
 						"Objects := $(addprefix $(BuildDir)/,$(SourceLst))\n"
 						"\n");
 
 				// Write out the target stuff
 				m.Print("# Target\n");
 
 				LHashTbl<StrKey<char,false>,bool> DepFiles;
 
 				if (TargetType)
 				{
 					if (IsExecutableTarget)
 					{
 						m.Print("# Executable target\n"
 								"$(Target) :");
 								
 						LStringPipe Rules;
 						IdeProject *Dep;
 						
 						uint64 Last = LCurrentTime();
 						int Count = 0;
 						auto It = Deps.begin();
 						for (Dep=*It; Dep && !IsCancelled(); Dep=*(++It), Count++)
 						{
 							// Get dependency to create it's own makefile...
 							Dep->CreateMakefile(Platform, false);
 						
 							// Build a rule to make the dependency if any of the source changes...
 							auto DepBase = Dep->GetBasePath();
 							auto Base = Proj->GetBasePath();
 							auto TargetFile = Dep->GetTargetFile(Platform);
 							
 							if (DepBase && Base && TargetFile)
 							{
 								LString Rel;
 								if (!Proj->RelativePath(Rel, DepBase))
 									Rel = DepBase;
 								ToUnixPath(Rel);
 								
 								// Add tag to target name
 								auto Parts = TargetFile.SplitDelimit(".");
 								if (Parts.Length() == 2)
 									TargetFile.Printf("lib%s$(Tag).%s", Parts[0].Get(), Parts[1].Get());
 
 								sprintf(Buf, "%s/$(BuildDir)/%s", Rel.Get(), TargetFile.Get());
 								m.Print(" %s", Buf);
 								
 								LArray<char*> AllDeps;
 								Dep->GetAllDependencies(AllDeps, Platform);
 								LAssert(AllDeps.Length() > 0);
 								AllDeps.Sort(StrSort);
 
 								Rules.Print("%s : ", Buf);
 								for (int i=0; i<AllDeps.Length(); i++)
 								{
 									if (i)
 										Rules.Print(" \\\n\t");
 									
 									LString DepRel;
 									char *f = Proj->RelativePath(DepRel, AllDeps[i]) ? DepRel.Get() : AllDeps[i];
 									ToUnixPath(f);
 									Rules.Print("%s", f);
 									
 									// Add these dependencies to this makefiles dep list
 									if (!DepFiles.Find(f))
 										DepFiles.Add(f, true);
 								}
 
 								AllDeps.DeleteArrays();
 
 								Rules.Print("\n\texport Build=$(Build); \\\n"
 											"\t$(MAKE) -C %s",
 											Rel.Get());
 
 								auto Mk = Dep->GetMakefile(Platform);
 								// RenameMakefileForPlatform(Mk, Platform);
 								if (Mk)
 								{
 									char *DepMakefile = strrchr(Mk, DIR_CHAR);
 									if (DepMakefile)
 										Rules.Print(" -f %s", DepMakefile + 1);
 								}
 								else
 								{
 									Mk = Dep->GetMakefile(Platform);
 									OnError("%s:%i - No makefile for '%s'\n", _FL, Dep->GetFullPath().Get());
 								}
 
 								Rules.Print("\n\n");
 							}
 							
 							uint64 Now = LCurrentTime();
 							if (Now - Last > 1000)
 							{
 								Last = Now;
 								Log->Print("Building deps %i%%...\n", (int) (((int64)Count+1)*100/Deps.Length()));
 							}
 						}
 
 						m.Print(" $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(Target) [$(Build)]...\n"
 								"	$(CPP)%s%s %s%s -o \\\n"
 								"		$(Target) $(Objects) $(Libs)\n",
 								ExtraLinkFlags,
 								ExeFlags,
 								ValidStr(LinkerFlags) ? "-Wl" : "", LinkerFlags.Get());
 
 						if (Platform == PlatformHaiku)
 						{
 							// Is there an application icon configured?
 							const char *AppIcon = d->Settings.GetStr(ProjApplicationIcon, NULL, Platform);
 							if (AppIcon)
 							{
 								m.Print("	addattr -f %s -t \"'VICN'\" \"BEOS:ICON\" $(Target)\n", AppIcon);
 							}							
 						}
 						
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						LAutoString r(Rules.NewStr());
 						if (r)
 							m.Write(r, strlen(r));
 
 						// Various fairly global rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"						
 								"# Clean just this target\n"
 								"clean :\n"
 								"	rm -rf $(BuildDir)/* $(Target)%s\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformExecutableExt(Platform));
 						
 						m.Print("# Clean all targets\n"
 								"cleanall :\n"
 								"	rm -rf $(BuildDir)/* $(Target)%s\n"
 								"	@echo Cleaned $(BuildDir)\n",
 								PlatformExecutableExt(Platform));
 						
 						for (auto d: Deps)
 						{
 							auto mk = d->GetMakefile(Platform);
 							if (mk)
 							{
 								LAutoString my_base = Proj->GetBasePath();
 								LAutoString dep_base = d->GetBasePath();
 								d->CheckExists(dep_base);
 
 								auto rel_dir = LMakeRelativePath(my_base, dep_base);
 								d->CheckExists(rel_dir);
 								
 								char *mk_leaf = strrchr(mk, DIR_CHAR);
 								m.Print("	+make -C \"%s\" -f \"%s\" clean\n",
 									ToUnixPath(rel_dir ? rel_dir.Get() : dep_base.Get()),
 									ToUnixPath(mk_leaf ? mk_leaf + 1 : mk.Get()));
 							}
 						}
 						m.Print("\n");
 					}
 					// Shared library
 					else if (!stricmp(TargetType, "DynamicLibrary"))
 					{
 						m.Print("TargetFile = lib$(Target)$(Tag).%s\n"
 								"$(TargetFile) : $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(TargetFile) [$(Build)]...\n"
 								"	$(CPP)$s -shared \\\n"
 								"		%s%s \\\n"
 								"		-o $(BuildDir)/$(TargetFile) \\\n"
 								"		$(Objects) \\\n"
 								"		$(Libs)\n",
 								PlatformLibraryExt,
 								ValidStr(ExtraLinkFlags) ? "-Wl" : "", ExtraLinkFlags,
 								LinkerFlags.Get());
 
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						// Other rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"
 								"# Clean out targets\n"
 								"clean :\n"
 								"	rm -rf $(BuildDir)/* $(BuildDir)/$(TargetFile)\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformLibraryExt);
 					}
 					// Static library
 					else if (!stricmp(TargetType, "StaticLibrary"))
 					{
 						m.Print("TargetFile = lib$(Target)$(Tag).%s\n"
 								"$(TargetFile) : $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(TargetFile) [$(Build)]...\n"
 								"	ar rcs $(BuildDir)/$(TargetFile) $(Objects)\n",
 								PlatformStaticLibExt);
 
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						// Other rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"
 								"# Clean out targets\n"
 								"clean :\n"
 								"	rm -rf $(BuildDir)/* $(BuildDir)/$(TargetFile)\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformStaticLibExt);
 					}
 				}
 
 				// Output VPATH
 				m.Print("VPATH=%%.cpp \\\n");
 				IncPaths.Sort();
 				for (int i=0; i<IncPaths.Length() && !IsCancelled(); i++)
 				{
 					LString p = IncPaths[i];
 					Proj->CheckExists(p);
 					if (p && !strchr(p, '`'))
 					{
 						if (!LIsRelativePath(p))
 						{
 							auto a = LMakeRelativePath(Base, p);
 							m.Print("\t%s \\\n", ToPlatformPath(a ? a.Get() : p.Get(), Platform).Get());
 						}
 						else
 						{
 							m.Print("\t%s \\\n", ToPlatformPath(p, Platform).Get());
 						}
 					}
 				}
 				m.Print("\t$(BuildDir)\n\n");
 
 				const char *OtherMakefileRules = d->Settings.GetStr(ProjMakefileRules, NULL, Platform);
 				if (ValidStr(OtherMakefileRules))
 				{
 					m.Print("\n%s\n", OtherMakefileRules);
 				}
 			}
 		}
 		else
 		{
 			m.Print("# No files require building.\n");
 		}
 
 		Log->Print("...Done: '%s'\n", MakeFile.Get());
 
 		if (BuildAfterwards)
 		{
 			if (!Proj->GetApp()->PostEvent(M_START_BUILD))
 				printf("%s:%i - PostEvent(M_START_BUILD) failed.\n", _FL);
 		}
 		
 		return HasError;
 	}
 
 	void OnAfterMain()
 	{
 		Proj->GetApp()->PostEvent(M_MAKEFILES_CREATED, (LMessage::Param)Proj);
 	}
 };
 
 
 /////////////////////////////////////////////////////////////////////////////////////
 NodeSource::~NodeSource()
 {
 	if (nView)
 	{
 		nView->nSrc = 0;
 	}
 }
 
 NodeView::~NodeView()
 {
 	if (nSrc)
 	{
 		nSrc->nView = 0;
 	}
 }
 
 
 //////////////////////////////////////////////////////////////////////////////////
 int NodeSort(LTreeItem *a, LTreeItem *b, NativeInt d)
 {
 	ProjectNode *A = dynamic_cast<ProjectNode*>(a);
 	ProjectNode *B = dynamic_cast<ProjectNode*>(b);
 	if (A && B)
 	{
 		if
 		(
 			(A->GetType() == NodeDir)
 			^
 			(B->GetType() == NodeDir)
 		)
 		{
 			return A->GetType() == NodeDir ? -1 : 1;
 		}
 		else
 		{
 			return Stricmp(a->GetText(0), b->GetText(0));
 		}
 	}
 
 	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 bool ReadVsProjFile(LString File, LString &Ver, LString::Array &Configs)
 {
 	const char *Ext = LGetExtension(File);
 	if (!Ext || _stricmp(Ext, "vcxproj"))
 		return false;
 
 	LFile f;
 	if (!f.Open(File, O_READ))
 		return false;
 
 	LXmlTree Io;
 	LXmlTag r;
 	if (Io.Read(&r, &f) &&
 		r.IsTag("Project"))
 	{
 		Ver = r.GetAttr("ToolsVersion");
 
 		LXmlTag *ItemGroup = r.GetChildTag("ItemGroup");
 		if (ItemGroup)
 			for (auto c: ItemGroup->Children)
 			{
 				if (c->IsTag("ProjectConfiguration"))
 				{
 					char *s = c->GetAttr("Include");
 					if (s)
 						Configs.New() = s;
 				}
 			}
 	}
 	else return false;
 
 	return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 BuildThread::BuildThread(IdeProject *proj, char *makefile, bool clean, BuildConfig config, bool all, int wordsize) : LThread("BuildThread")
 {
 	Proj = proj;
 	Makefile = makefile;
 	Clean = clean;
 	Config = config;
 	All = all;
 	WordSize = wordsize;
 	Arch = DefaultArch;
 	Compiler = DefaultCompiler;
 	AppHnd = Proj->GetApp()->AddDispatch();
 	
 	LString Cmds = proj->d->Settings.GetStr(ProjPostBuildCommands, NULL);
 	if (ValidStr(Cmds))
 		PostBuild = Cmds.SplitDelimit("\r\n");
 
 	auto Ext = LGetExtension(Makefile);
 	if (Ext && !_stricmp(Ext, "py"))
 		Compiler = PythonScript;
 	else if (Ext && !_stricmp(Ext, "sln"))
 		Compiler = VisualStudio;
 	else if (Ext && !Stricmp(Ext, "xcodeproj"))
 		Compiler = Xcode;
 	else
 	{
 		auto Comp = Proj->GetSettings()->GetStr(ProjCompiler);
 		if (Comp)
 		{
 			// Use the specified compiler...
 			if (!stricmp(Comp, "VisualStudio"))
 				Compiler = VisualStudio;
 			else if (!stricmp(Comp, "MingW"))
 				Compiler = MingW;
 			else if (!stricmp(Comp, "gcc"))
 				Compiler = Gcc;
 			else if (!stricmp(Comp, "cross"))
 				Compiler = CrossCompiler;
 			else if (!stricmp(Comp, "IAR"))
 				Compiler = IAR;
 			else if (!stricmp(Comp, "Cygwin"))
 				Compiler = Cygwin;
 			else
 				LAssert(!"Unknown compiler.");
 		}
 	}
 
 	if (Compiler == DefaultCompiler)
 	{
 		// Use default compiler for platform...
 		#ifdef WIN32
 		Compiler = VisualStudio;
 		#else
 		Compiler = Gcc;
 		#endif
 	}
 
 	Run();
 }
 
 BuildThread::~BuildThread()
 {
 	if (SubProc)
 	{
 		bool b = SubProc->Interrupt();
 		LgiTrace("%s:%i - Sub process interrupt = %i.\n", _FL, b);
 	}
 	else LgiTrace("%s:%i - No sub process to interrupt.\n", _FL);
 
 	uint64 Start = LCurrentTime();
 	bool Killed = false;
 	while (!IsExited())
 	{
 		LSleep(10);
 
 		if (LCurrentTime() - Start > STOP_BUILD_TIMEOUT &&
 			SubProc)
 		{
 			if (Killed)
 			{
 				// Thread is stuck as well... ok kill that too!!! Argh - kill all the things!!!!
 				Terminate();
 				LgiTrace("%s:%i - Thread killed.\n", _FL);
 				Proj->GetApp()->PostEvent(M_BUILD_DONE);
 				break;
 			}
 			else
 			{
 				// Kill the sub-process...
 				bool b = SubProc->Kill();
 				Killed = true;
 				LgiTrace("%s:%i - Sub process killed.\n", _FL, b);
 				Start = LCurrentTime();
 			}
 		}
 	}
 }
 
 ssize_t BuildThread::Write(const void *Buffer, ssize_t Size, int Flags)
 {
 	if (Proj->GetApp())
 	{
 		Proj->GetApp()->PostEvent(M_APPEND_TEXT, (LMessage::Param)NewStr((char*)Buffer, Size), AppWnd::BuildTab);
 	}
 	return Size;
 }
 
 #pragma comment(lib, "version.lib")
 
 struct ProjInfo
 {
 	LString Guid, Name, File;
 	LHashTbl<StrKey<char>,ssize_t> Configs;
 };
 
 LString BuildThread::FindExe()
 {
 	LString::Array p = LGetPath();
 
 	if (Compiler == PythonScript)
 	{
 		#if defined(WINDOWS)
 		uint32_t BestVer = 0;
 		#else
 		LString BestVer;
 		#endif
 		static LString Best;
 
 		if (!Best)
 		{
 			const char *binName[] = {"python3", "python"};
 			for (int i=0; i<p.Length(); i++)
 			{
 				char Path[MAX_PATH_LEN];
 				for (unsigned n=0; n<CountOf(binName); n++)
 				{
 					LMakePath(Path, sizeof(Path), p[i], LString(binName[n]) + LGI_EXECUTABLE_EXT);
 					if (LFileExists(Path))
 					{			
 						// Check version
 						#if defined(WINDOWS)
 							DWORD Sz = GetFileVersionInfoSizeA(Path, NULL);
 							void *Buf = malloc(Sz);
 							if (GetFileVersionInfoA(Path, NULL, Sz, Buf))
 							{
 								LPVOID Ptr = NULL;
 								UINT Bytes;
 								if (VerQueryValueA(Buf, "\\", &Ptr, &Bytes))
 								{
 									VS_FIXEDFILEINFO *v = (VS_FIXEDFILEINFO *)Ptr;
 									if (v->dwProductVersionMS > BestVer)
 									{
 										BestVer = v->dwProductVersionMS;
 										Best = Path;
 									}
 								}
 							}
 							else if (!Best)
 							{
 								Best = Path;
 							}
 							free(Buf);
 						#else
 							LSubProcess p(Path, "--version");
 							LStringPipe o;
 							if (p.Start())
 								p.Communicate(&o);
 							auto Out = o.NewGStr();
 							auto Ver = Out.SplitDelimit().Last();
 							printf("Ver=%s\n", Ver.Get());
 
 							if (!BestVer || Stricmp(Ver.Get(), BestVer.Get()) > 0)
 							{
 								Best = Path;
 								BestVer = Ver;
 							}
 							break;
 						#endif
 					}
 				}
 			}
 		}
 
 		return Best;
 	}
 	else if (Compiler == VisualStudio)
 	{
 		// Find the version we need:
 		double fVer = 0.0;
 
 		ProjInfo *First = NULL;
 		LHashTbl<StrKey<char>, ProjInfo*> Projects;
 		const char *Ext = LGetExtension(Makefile);
 		if (Ext && !_stricmp(Ext, "sln"))
 		{
 			LFile f;
 			if (f.Open(Makefile, O_READ))
 			{
 				LString ProjKey = "Project(";
 				LString StartSection = "GlobalSection(";
 				LString EndSection = "EndGlobalSection";
 				LString Section;
 				ssize_t Pos;
 
 				LString::Array Ln = f.Read().SplitDelimit("\r\n");
 				for (size_t i = 0; i < Ln.Length(); i++)
 				{
 					LString s = Ln[i].Strip();
 					if ((Pos = s.Find(ProjKey)) >= 0)
 					{
 						LString::Array p = s.SplitDelimit("(),=");
 						if (p.Length() > 5)
 						{
 							ProjInfo *i = new ProjInfo;
 							i->Name = p[3].Strip(" \t\"");
 							i->File = p[4].Strip(" \t\'\"");
 							i->Guid = p[5].Strip(" \t\"");
 							if (LIsRelativePath(i->File))
 							{
 								char f[MAX_PATH_LEN];
 								LMakePath(f, sizeof(f), Makefile, "..");
 								LMakePath(f, sizeof(f), f, i->File);
 								if (LFileExists(f))
 									i->File = f;
 								/*
 								else
 									LAssert(0);
 								*/
 							}
 
 							if (!First)
 								First = i;
 
 							Projects.Add(i->Guid, i);
 						}
 					}
 					else if (s.Find(StartSection) >= 0)
 					{
 						auto p = s.SplitDelimit("() \t");
 						Section = p[1];
 					}
 					else if (s.Find(EndSection) >= 0)
 					{
 						Section.Empty();
 					}
 					else if (Section == "ProjectConfigurationPlatforms")
 					{
 						auto p = s.SplitDelimit(". \t");
 						auto i = Projects.Find(p[0]);
 						if (i)
 						{
 							if (!i->Configs.Find(p[1]))
 							{
 								auto Idx = i->Configs.Length() + 1;
 								i->Configs.Add(p[1], Idx);
 							}
 						}
 					}
 					else if (Section == "SolutionConfigurationPlatforms")
 					{
 						auto p = s.SplitDelimit();
 						auto config = p[0];
 						for (auto &it: Projects)
 						{							
 							auto proj = it.value;
 							if (!proj->Configs.Find(config))
 								proj->Configs.Add(config, proj->Configs.Length()+1);
 						}
 					}
 				}
 			}
 		}
 		else if (Ext && !_stricmp(Ext, "vcxproj"))
 		{
 			// ProjFile = Makefile;
 		}
 		else
 		{
 			if (Arch == DefaultArch)
 			{
 				if (sizeof(size_t) == 4)
 					Arch = ArchX32;
 				else
 					Arch = ArchX64;
 			}
 
 			#ifdef _MSC_VER
 			// Nmake file..
 			LString NmakePath;
 			switch (_MSC_VER)
 			{
 				#ifdef _MSC_VER_VS2013
 				case _MSC_VER_VS2013:
 				{
 					if (Arch == ArchX32)
 						NmakePath = "c:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\bin\\nmake.exe";
 					else
 						NmakePath = "c:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\bin\\amd64\\nmake.exe";
 					break;
 				}
 				#endif
 				#ifdef _MSC_VER_VS2015
 				case _MSC_VER_VS2015:
 				{
 					if (Arch == ArchX32)
 						NmakePath = "c:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\nmake.exe";
 					else
 						NmakePath = "c:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\amd64\\nmake.exe";
 					break;
 				}
 				#endif
 				default:
 				{
 					LAssert(!"Impl me.");
 					break;
 				}
 			}
 
 			if (LFileExists(NmakePath))
 			{
 				Compiler = Nmake;
 				return NmakePath;
 			}
 			#endif
 		}
 
 		/*
 		if (ProjFile && LFileExists(ProjFile))
 		{
 			LString sVer;
 			if (ReadVsProjFile(ProjFile, sVer, BuildConfigs))
 			{
 				fVer = sVer.Float();
 			}
 		}
 		*/
 		if (First)
 		{
 			for (auto i: First->Configs)
 			{
 				BuildConfigs[i.value - 1] = i.key;
 
 				LFile f(First->File, O_READ);
 				LXmlTree t;
 				LXmlTag r;
 				if (t.Read(&r, &f))
 				{
 					if (r.IsTag("Project"))
 					{
 						auto ToolsVersion = r.GetAttr("ToolsVersion");
 						if (ToolsVersion)
 						{
 							fVer = atof(ToolsVersion);
 						}
 					}
 				}
 			}
 		}
 
 		if (fVer > 0.0)
 		{
 			for (int i=0; i<CountOf(VsBinaries); i++)
 			{
 				LString p;
 				p.Printf("C:\\Program Files (x86)\\Microsoft Visual Studio %.1f\\Common7\\IDE\\%s", fVer, VsBinaries[i]);
 				if (LFileExists(p))
 				{
 					return p;
 				}
 			}
 		}
 	}
 	else if (Compiler == IAR)
 	{
 		// const char *Def = "c:\\Program Files (x86)\\IAR Systems\\Embedded Workbench 7.0\\common\\bin\\IarBuild.exe";
 		
 		LString ProgFiles = LGetSystemPath(LSP_USER_APPS, 32);
 		char p[MAX_PATH_LEN];
 		if (!LMakePath(p, sizeof(p), ProgFiles, "IAR Systems"))
 			return LString();
 		LDirectory d;
 		double LatestVer = 0.0;
 		LString Latest;
 		for (int b = d.First(p); b; b = d.Next())
 		{
 			if (d.IsDir())
 			{
 				LString n(d.GetName());
 				LString::Array p = n.Split(" ");
 				if (p.Length() == 3 &&
 					p[2].Float() > LatestVer)
 				{
 					LatestVer = p[2].Float();
 					Latest = n;
 				}
 			}
 		}
 		if (Latest &&
 			LMakePath(p, sizeof(p), p, Latest) &&
 			LMakePath(p, sizeof(p), p, "common\\bin\\IarBuild.exe"))
 		{
 			if (LFileExists(p))
 				return p;
 		}
 	}
 	else if (Compiler == Xcode)
 	{
 		return "/usr/bin/xcodebuild";
 	}
 	else if (Compiler == Cygwin)
 	{
 		#ifdef WINDOWS
 		LRegKey k(false, "HKEY_CURRENT_USER\\Software\\Cygwin\\Installations");
 		List<char> n;
 		k.GetValueNames(n);
 		LString s;
 		for (auto i:n)
 		{
 			s = k.GetStr(i);
 			if (s.Find("\\??\\") == 0)
 				s = s(4,-1);
 			if (LDirExists(s))
 			{
 				CygwinPath = s;
 				break;
 			}
 		}
 		n.DeleteArrays();
 
 		LFile::Path p(s, "bin\\make.exe");
 		if (p.Exists())
 			return p.GetFull();
 		#endif
 	}
 	else
 	{
 		if (Compiler == MingW)
 		{
 			// Have a look in the default spot first...
 			const char *Def = "C:\\MinGW\\msys\\1.0\\bin\\make.exe";
 			if (LFileExists(Def))
 			{
 				return Def;
 			}				
 		}
 		
 		for (int i=0; i<p.Length(); i++)
 		{
 			char Exe[MAX_PATH_LEN];
 			LMakePath
 			(
 				Exe,
 				sizeof(Exe),
 				p[i],
 				"make"
 				#ifdef WIN32
 				".exe"
 				#endif
 			);
 			if (LFileExists(Exe))
 			{
 				return Exe;
 			}
 		}
 	}
 	
 	return LString();
 }
 
 LAutoString BuildThread::WinToMingWPath(const char *path)
 {
 	LToken t(path, "\\");
 	LStringPipe a(256);
 	for (int i=0; i<t.Length(); i++)
 	{
 		char *p = t[i];
 		char *colon = strchr(p, ':');
 		if (colon)
 		{
 			*colon = 0;
 			StrLwr(p);
 		}
 		a.Print("/%s", p);				
 	}
 	return LAutoString(a.NewStr());
 }
 
 int BuildThread::Main()
 {
 	const char *Err = 0;
 	char ErrBuf[256];
 
 	auto Exe = FindExe();
 	if (Exe)
 	{
 		bool Status = false;
 		LString MakePath = Makefile.Get();
 		LString InitDir = Makefile.Get();
 		LVariant Jobs;
 		if (!Proj->GetApp()->GetOptions()->GetValue(OPT_Jobs, Jobs) || Jobs.CastInt32() < 1)
 			Jobs = 2;
 
 		auto Pos = InitDir.RFind(DIR_STR);
 		if (Pos)
 			InitDir.Length(Pos);
 
 		LString TmpArgs, Include, Lib, LibPath, Path;
 		
 		if (Compiler == VisualStudio)
 		{
 			// TmpArgs.Printf("\"%s\" /make \"All - Win32 Debug\"", Makefile.Get());
 			LString BuildConf = "All - Win32 Debug";
 			if (BuildConfigs.Length())
 			{
 				auto Key = toString(Config);
 				for (size_t i=0; i<BuildConfigs.Length(); i++)
 				{
 					LString c = BuildConfigs[i];
 					if (c.Find(Key) >= 0)
 					{
 						if (!BuildConf || (c.Find("x64") >= 0 && BuildConf.Find("x64") < 0))
 							BuildConf = c;
 					}
 				}
 			}
 			TmpArgs.Printf("\"%s\" %s \"%s\"", Makefile.Get(), Clean ? "/Clean" : "/Build", BuildConf.Get());
 		}
 		else if (Compiler == Nmake)
 		{
 			const char *DefInc[] = {
 				"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\INCLUDE",
 				"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\INCLUDE",
 				"C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\shared",
 				"C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\um",
 				"C:\\Program Files (x86)\\Windows Kits\\8.1\\include\\winrt"
 			};
 			LString f;
 
 			#define ADD_PATHS(out, in) \
 				for (unsigned i=0; i<CountOf(in); i++) \
 				{ \
 					f.Printf("%s%s", i ? LGI_PATH_SEPARATOR : "", in[i]); \
 					out += f; \
 				}
 			if (Arch == ArchX32)
 			{
 				const char *DefLib[] = {
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB",
 					"C:\\Program Files (x86)\\Windows Kits\\8.1\\lib\\winv6.3\\um\\x32"
 				};
 				const char *DefLibPath[] = {
 					"C:\\WINDOWS\\Microsoft.NET\\Framework64\\v4.0.30319",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB",
 					"C:\\Program Files (x86)\\Windows Kits\\8.1\\References\\CommonConfiguration\\Neutral",
 					"C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v8.1\\ExtensionSDKs\\Microsoft.VCLibs\\12.0\\References\\CommonConfiguration\\neutral"
 				};
 				const char *DefPath[] = {
 					"c:\\Program Files (x86)\\Windows Kits\\8.1\\bin\\x86"
 				};
 			
 				ADD_PATHS(Include, DefInc);
 				ADD_PATHS(Lib, DefLib);
 				ADD_PATHS(LibPath, DefLibPath);
 				ADD_PATHS(Path, DefPath);
 			}
 			else if (Arch == ArchX64)
 			{
 				const char *DefLib[] = {
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB\\amd64",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB\\amd64",
 					"C:\\Program Files (x86)\\Windows Kits\\8.1\\lib\\winv6.3\\um\\x64"
 				};
 				const char *DefLibPath[] = {
 					"C:\\WINDOWS\\Microsoft.NET\\Framework64\\v4.0.30319",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\LIB\\amd64",
 					"C:\\Program Files (x86)\\Microsoft Visual Studio 12.0\\VC\\ATLMFC\\LIB\\amd64",
 					"C:\\Program Files (x86)\\Windows Kits\\8.1\\References\\CommonConfiguration\\Neutral",
 					"C:\\Program Files (x86)\\Microsoft SDKs\\Windows\\v8.1\\ExtensionSDKs\\Microsoft.VCLibs\\12.0\\References\\CommonConfiguration\\neutral"
 				};
 				const char *DefPath[] = {
 					"c:\\Program Files (x86)\\Windows Kits\\8.1\\bin\\x64"
 				};
 							
 				ADD_PATHS(Include, DefInc);
 				ADD_PATHS(Lib, DefLib);
 				ADD_PATHS(LibPath, DefLibPath);
 				ADD_PATHS(Path, DefPath);
 			}
 			else LAssert(!"Invalid Arch");
 
 			TmpArgs.Printf(" -f \"%s\"", Makefile.Get());
 
 			if (Clean)
 				TmpArgs += " clean";
 		}
 		else if (Compiler == PythonScript)
 		{
 			TmpArgs = MakePath;
 		}
 		else if (Compiler == IAR)
 		{
 			LString Conf;
 
 			LFile f;
 			if (f.Open(Makefile, O_READ))
 			{
 				LXmlTree t;
 				LXmlTag r;
 				if (t.Read(&r, &f))
 				{
 					LXmlTag *c = r.GetChildTag("configuration");
 					c = c ? c->GetChildTag("name") : NULL;
 					if (c)
 						Conf = c->GetContent();
 				}				
 			}
 
 			TmpArgs.Printf("\"%s\" %s %s -log warnings", Makefile.Get(), Clean ? "-clean" : "-make", Conf.Get());
 		}
 		else if (Compiler == Xcode)
 		{
 			LString::Array Configs;
 			Configs.SetFixedLength(false);
 			LString a;
 			a.Printf("-list -project \"%s\"", Makefile.Get());
 			LSubProcess Ls(Exe, a);
 			if (Ls.Start())
 			{
 				LStringPipe o;
 				Ls.Communicate(&o);
 				auto key = "Build Configurations:";
 				auto lines = o.NewGStr().SplitDelimit("\n");
 				int inKey = -1;
 				for (auto l: lines)
 				{
 					int ws = 0;
 					for (int i=0; i<l.Length(); i++)
 						if (IsWhiteSpace(l(i))) ws++;
 						else break;
 					if (l.Find(key)>=0)
 						inKey = ws;
 					else if (inKey>=0)
 					{
 						if (ws>inKey) { Configs.New() = l.Strip(); }
 						else { inKey = -1; }
 					}
 					// printf("%s\n", l.Get());
 				}
 			}
 			
 			auto Config = Configs.Length() > 0 ? Configs[0] : LString("Debug");
 			TmpArgs.Printf("-project \"%s\" -configuration %s", Makefile.Get(), Config.Get());
 		}
 		else
 		{
 			if (Compiler == Cygwin)
 			{
 				LFile::Path p(CygwinPath, "bin");
 				Path = p.GetFull();
 			}
 
 			if (Compiler == MingW)
 			{
 				LString a;
 				char *Dir = strrchr(MakePath, DIR_CHAR);
 				#if 1
 				TmpArgs.Printf("/C \"%s\"", Exe.Get());
 
 				
 				/*	As of MSYS v1.0.18 the support for multiple jobs causes make to hang:
 					http://sourceforge.net/p/mingw/bugs/1950/
 					http://mingw-users.1079350.n2.nabble.com/MSYS-make-freezes-td7579038.html
 					
 					Apparently it'll be "fixed" in v1.0.19. We'll see. >:-(
 				
 				if (Jobs.CastInt32() > 1)
 					a.Print(" -j %i", Jobs.CastInt32());
 				
 				*/
 				
 				a.Printf(" -f \"%s\"", Dir ? Dir + 1 : MakePath.Get());
 				TmpArgs += a;
 				#else
 				TmpArgs.Printf("/C set");
 				#endif
 				Exe = "C:\\Windows\\System32\\cmd.exe";
 			}
 			else
 			{
 				if (Jobs.CastInt32())
 					TmpArgs.Printf("-j %i -f \"%s\"", Jobs.CastInt32(), MakePath.Get());
 				else
 					TmpArgs.Printf("-f \"%s\"", MakePath.Get());
 			}
 
 			if (Clean)
             {
 				if (All)
 					TmpArgs += " cleanall";
 				else
 					TmpArgs += " clean";
             }
 			if (Config == BuildRelease)
 				TmpArgs += " Build=Release";
 		}
 
 		PostThreadEvent(AppHnd, M_SELECT_TAB, AppWnd::BuildTab);
 
 		LString Msg;
 		Msg.Printf("Making: %s\n", MakePath.Get());
 		Proj->GetApp()->PostEvent(M_APPEND_TEXT, (LMessage::Param)NewStr(Msg), AppWnd::BuildTab);
 
 		LgiTrace("%s %s\n", Exe.Get(), TmpArgs.Get());
 		if (SubProc.Reset(new LSubProcess(Exe, TmpArgs)))
 		{
 			SubProc->SetNewGroup(false);
 			SubProc->SetInitFolder(InitDir);
 			if (Include)
 				SubProc->SetEnvironment("INCLUDE", Include);
 			if (Lib)
 				SubProc->SetEnvironment("LIB", Lib);
 			if (LibPath)
 				SubProc->SetEnvironment("LIBPATHS", LibPath);
 			if (Path)
 			{
 				LString Cur = getenv("PATH");
 				LString New = Cur + LGI_PATH_SEPARATOR + Path;
 				SubProc->SetEnvironment("PATH", New);
 			}
 			// SubProc->SetEnvironment("DLL", "1");
 
 			if (Compiler == MingW)
 				SubProc->SetEnvironment("PATH", "c:\\MingW\\bin;C:\\MinGW\\msys\\1.0\\bin;%PATH%");
 				
 			if ((Status = SubProc->Start(true, false)))
 			{
 				// Read all the output					
 				char Buf[256];
 				ssize_t rd;
 
 				while ( (rd = SubProc->Read(Buf, sizeof(Buf))) > 0 )
 				{
 					Write(Buf, rd);
 				}
 					
 				uint32_t ex = SubProc->Wait();
 				Print("Make exited with %i (0x%x)\n", ex, ex);
 
 				if (Compiler == IAR &&
 					ex == 0 &&
 					PostBuild.Length())
 				{
 					for (auto Cmd : PostBuild)
 					{
 						auto p = Cmd.Split(" ", 1);
 						if (p[0].Equals("cd"))
 						{
 							if (p.Length() > 1)
 								FileDev->SetCurrentFolder(p[1]);
 							else
 								LAssert(!"No folder for cd?");
 						}
 						else
 						{
 							LSubProcess PostCmd(p[0], p.Length() > 1 ? p[1] : NULL);
 							if (PostCmd.Start(true, false))
 							{
 								char Buf[256];
 								ssize_t rd;
 								while ( (rd = PostCmd.Read(Buf, sizeof(Buf))) > 0 )
 								{
 									Write(Buf, rd);
 								}
 							}
 						}
 					}
 				}
 			}
 			else
 			{
 				// Create a nice error message.
 				LString ErrStr = LErrorCodeToString(SubProc->GetErrorCode());
 				if (ErrStr)
 				{
 					char *e = ErrStr.Get() + ErrStr.Length();
 					while (e > ErrStr && strchr(" \t\r\n.", e[-1]))
 						*(--e) = 0;
 				}
 					
 				sprintf_s(ErrBuf, sizeof(ErrBuf), "Running make failed with %i (%s)\n",
 					SubProc->GetErrorCode(),
 					ErrStr.Get());
 				Err = ErrBuf;
 			}
 		}
 	}
 	else
 	{
 		Err = "Couldn't find program to build makefile.";
 		LgiTrace("%s,%i - %s.\n", _FL, Err);
 	}
 
 	AppWnd *w = Proj->GetApp();
 	if (w)
 	{
 		w->PostEvent(M_BUILD_DONE);
 		if (Err)
 			Proj->GetApp()->PostEvent(M_BUILD_ERR, 0, (LMessage::Param)NewStr(Err));
 	}
 	else LAssert(0);
 	
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////////
 IdeProject::IdeProject(AppWnd *App) : IdeCommon(NULL)
 {
 	Project = this;
 	d = new IdeProjectPrivate(App, this);
 	Tag = NewStr("Project");
 }
 
 IdeProject::~IdeProject()
 {
 	d->App->OnProjectDestroy(this);
 	LXmlTag::Empty(true);
 	DeleteObj(d);
 }
 
 bool IdeProject::OnNode(const char *Path, ProjectNode *Node, bool Add)
 {
 	if (!Path || !Node)
 	{
 		LAssert(0);
 		return false;
 	}
 
 	char Full[MAX_PATH_LEN];
 	if (LIsRelativePath(Path))
 	{
 		LAutoString Base = GetBasePath();
 		if (LMakePath(Full, sizeof(Full), Base, Path))
 		{
 			Path = Full;
 		}
 	}
 
 	bool Status = false;
 	if (Add)
 		Status = d->Nodes.Add(Path, Node);
 	else
 		Status = d->Nodes.Delete(Path);
 	
 	LString p = Path;
 	if (Status && CheckExists(p))
 		d->App->OnNode(p, Node, Add ? FindSymbolSystem::FileAdd : FindSymbolSystem::FileRemove);
 
 	return Status;
 }
 
 void IdeProject::ShowFileProperties(const char *File)
 {
 	ProjectNode *Node = NULL;
 	// char *fp = FindFullPath(File, &Node);
 	if (Node)
 	{
 		Node->OnProperties();
 	}
 }
 
 const char *IdeProject::GetFileComment()
 {
 	return d->Settings.GetStr(ProjCommentFile);
 }
 
 const char *IdeProject::GetFunctionComment()
 {
 	return d->Settings.GetStr(ProjCommentFunction);
 }
 
 IdeProject *IdeProject::GetParentProject()
 {
 	return d->ParentProject;
 }
 
 void IdeProject::SetParentProject(IdeProject *p)
 {
 	d->ParentProject = p;
 }
 
 bool IdeProject::GetChildProjects(List<IdeProject> &c)
 {
 	CollectAllSubProjects(c);
 	return c.Length() > 0;
 }
 
 bool IdeProject::RelativePath(LString &Out, const char *In, bool Debug)
 {
 	if (!In)
 		return false;
 
 	auto Base = GetBasePath();
 	if (!Base)
 		return false;
 
 	CheckExists(Base);
 if (Debug) LgiTrace("XmlBase='%s'\n		In='%s'\n", Base.Get(), In);
 		
 	LToken b(Base, DIR_STR);
 	LToken i(In, DIR_STR);
 	char out[MAX_PATH_LEN] = "";
 	
 if (Debug) LgiTrace("Len %i-%i\n", b.Length(), i.Length());
 	
 	auto ILen = i.Length() + (LDirExists(In) ? 0 : 1);
 	auto Max = MIN(b.Length(), ILen);
 	int Common = 0;
 	for (; Common < Max; Common++)
 	{
 		#ifdef WIN32
 		#define StrCompare stricmp
 		#else
 		#define StrCompare strcmp
 		#endif
 		
 if (Debug) LgiTrace("Cmd '%s'-'%s'\n", b[Common], i[Common]);
 		if (StrCompare(b[Common], i[Common]) != 0)
 		{
 			break;
 		}
 	}
 	
 if (Debug) LgiTrace("Common=%i\n", Common);
 	if (Common > 0)
 	{
 		if (Common < b.Length())
 		{
 			out[0] = 0;
 			auto Back = b.Length() - Common;
 if (Debug) LgiTrace("Back=%i\n", (int)Back);
 			for (int n=0; n<Back; n++)
 			{
 				strcat(out, "..");
 				if (n < Back - 1) strcat(out, DIR_STR);
 			}
 		}
 		else
 		{
 			strcpy(out, ".");
 		}
 		for (int n=Common; n<i.Length(); n++)
 		{
 			sprintf(out+strlen(out), "%s%s", DIR_STR, i[n]);
 		}
 		
 		Out = out;
 	}	
 	else
 	{
 		Out = In;
 	}		
 
 	CheckExists(Out);
 	return true;
 }
 
 bool IdeProject::GetExePath(char *Path, int Len)
 {
 	auto PExe = d->Settings.GetStr(ProjExe);
 	LString Exe;
 	if (!PExe)
 	{
 		// Use the default exe name?
 		Exe = GetExecutable(GetCurrentPlatform());
 		if (Exe)
 		{
 			printf("Exe='%s'\n", Exe.Get());
 			PExe = Exe;
 		}
 	}
 	
 	if (!PExe)
 		return false;	
 	
 	if (LIsRelativePath(PExe))
 	{
 		auto Base = GetBasePath();
 		if (Base)
 			LMakePath(Path, Len, Base, PExe);
 		else
 			return false;
 	}
 	else
 	{
 		strcpy_s(Path, Len, PExe);
 	}
 	
 	return true;
 }
 
 LString IdeProject::GetMakefile(IdePlatform Platform)
 {
 	LString Path;
 	const char *PMakefile = d->Settings.GetStr(ProjMakefile, NULL, Platform);
 	if (PMakefile)
 	{
 		if (LIsRelativePath(PMakefile))
 		{
 			LAutoString Base = GetBasePath();
 			if (Base)
 			{
 				char p[MAX_PATH_LEN];
 				LMakePath(p, sizeof(p), Base, PMakefile);
 				Path = p;
 			}
 		}
 		else
 		{
 			Path = PMakefile;
 		}
 	}
 	
 	return Path;
 }
 
 void IdeProject::Clean(bool All, BuildConfig Config)
 {
 	if (!d->Thread &&
 		d->Settings.GetStr(ProjMakefile))
 	{
 		auto m = GetMakefile(PlatformCurrent);
 		if (m)		
 		{
 			CheckExists(m);
 			d->Thread.Reset(new BuildThread(this, m, true, Config, All, sizeof(ssize_t)*8));
 		}
 	}
 }
 
 char *QuoteStr(char *s)
 {
 	LStringPipe p(256);
 	while (s && *s)
 	{
 		if (*s == ' ')
 		{
 			p.Push("\\ ", 2);
 		}
 		else p.Push(s, 1);
 		s++;
 	}
 	return p.NewStr();
 }
 
 class ExecuteThread : public LThread, public LStream, public LCancel
 {
 	IdeProject *Proj;
 	LString Exe, Args, Path;
 	int Len;
 	ExeAction Act;
 	int AppHnd;
 
 public:
 	ExecuteThread(IdeProject *proj, const char *exe, const char *args, char *path, ExeAction act) : LThread("ExecuteThread")
 	{
 		Len = 32 << 10;
 		Proj = proj;
 		Act = act;
 		Exe = exe;
 		Args = args;
 		Path = path;
 		DeleteOnExit = true;
 		AppHnd = proj->GetApp()->AddDispatch();
 		
 		Run();
 	}
 	
 	~ExecuteThread()
 	{
 		Cancel();
 		while (!IsExited())
 			LSleep(1);
 	}
 	
 	int Main() override
 	{
 		PostThreadEvent(AppHnd, M_SELECT_TAB, AppWnd::OutputTab);
 		PostThreadEvent(AppHnd, M_APPEND_TEXT, 0, AppWnd::OutputTab);
 		
 		if (Exe)
 		{
 			if (Act == ExeDebug)
 			{
 				LSubProcess sub("kdbg", Exe);
 				if (Path)
 					sub.SetInitFolder(Path);
 				if (sub.Start())
 					sub.Communicate(this, NULL, this);
 			}
 			else if (Act == ExeValgrind)
 			{
 				#ifdef LINUX
 				LString ExePath = Proj->GetExecutable(GetCurrentPlatform());
 				if (ExePath)
 				{
 					char Path[MAX_PATH_LEN];
 					char *ExeLeaf = LGetLeaf(Exe);
 					strcpy_s(Path, sizeof(Path), ExeLeaf ? ExeLeaf : Exe.Get());
 					LTrimDir(Path);
 									
 					char *Term = 0;
 					char *WorkDir = 0;
 					char *Execute = 0;
 					switch (LGetWindowManager())
 					{
 						case WM_Kde:
 							Term = "konsole";
 							WorkDir = "--workdir ";
 							Execute = "-e";
 							break;
 						case WM_Gnome:
 							Term = "gnome-terminal";
 							WorkDir = "--working-directory=";
 							Execute = "-x";
 							break;
 					}
 					
 					if (Term && WorkDir && Execute)
 					{					
 						char *e = QuoteStr(ExePath);
 						char *p = QuoteStr(Path);
 						char *a = Proj->GetExeArgs() ? Proj->GetExeArgs() : (char*)"";
 						char Args[512];
 						sprintf(Args,
 								"%s%s "
 								"--noclose "
 								"%s valgrind --tool=memcheck --num-callers=20 %s %s",
 								WorkDir,
 								p,
 								Execute,
 								e, a);
 								
 						LExecute(Term, Args);
 					}
 				}
 				#endif
 			}
 			else
 			{
 				LSubProcess sub(Exe, Args);
 				if (Path)
 					sub.SetInitFolder(Path);
 				if (sub.Start())
 					sub.Communicate(this, NULL, this);
 			}
 		}
 		
 		return 0;
 	}
 
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0) override
 	{
 		if (Len <= 0)
 			return 0;
 
 		PostThreadEvent(AppHnd, M_APPEND_TEXT, (LMessage::Param)NewStr((char*)Buffer, Size), AppWnd::OutputTab);
 		Len -= Size;
 		return Size;
 	}
 };
 
 LDebugContext *IdeProject::Execute(ExeAction Act, LString *ErrMsg)
 {
 	auto Base = GetBasePath();
 	
 	if (!Base)
 	{
 		if (ErrMsg) *ErrMsg = "No base path for project.";
 		return NULL;		
 	}
 	
 	char e[MAX_PATH_LEN];
 	if (!GetExePath(e, sizeof(e)))
 	{
 		if (ErrMsg) *ErrMsg = "GetExePath failed.";
 		return NULL;		
 	}
 	
 	if (!LFileExists(e))
 	{
 		if (ErrMsg) ErrMsg->Printf("Executable '%s' doesn't exist.\n", e);
 		return NULL;
 	}
 
 	const char *Args = d->Settings.GetStr(ProjArgs);
 	const char *Env = d->Settings.GetStr(ProjEnv);
 	LString InitDir = d->Settings.GetStr(ProjInitDir);
 	int RunAsAdmin = d->Settings.GetInt(ProjDebugAdmin);
 	if (Act == ExeDebug)
 	{
 		if (InitDir && LIsRelativePath(InitDir))
 		{
 			LFile::Path p(Base);
 			p += InitDir;
 			InitDir = p.GetFull();
 		}
 			
 		return new LDebugContext(d->App, this, e, Args, RunAsAdmin != 0, Env, InitDir);
 	}
 
 	// Run without debugging...
 	new ExecuteThread(this, e, Args, Base, Act);
 	return NULL;
 }
 
 bool IdeProject::IsMakefileAScript()
 {
 	auto m = GetMakefile(PlatformCurrent);
 	if (m)
 	{
 		auto Ext = LGetExtension(m);
 		if (!Stricmp(Ext, "py"))
 		{
 			// Not a makefile but a build script... can't update.
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool IdeProject::IsMakefileUpToDate()
 {
 	if (IsMakefileAScript())
 		return true; // We can't know if it's up to date...
 
 	List<IdeProject> Proj;
 	GetChildProjects(Proj);
 
 	Proj.Insert(this);
 	for (auto p: Proj)
 	{
 		// Is the project file modified after the makefile?
 		auto Proj = p->GetFullPath();
 		uint64 ProjModTime = 0, MakeModTime = 0;
 		LDirectory dir;
 		if (dir.First(Proj))
 		{
 			ProjModTime = dir.GetLastWriteTime();
 			dir.Close();
 		}
 
 		auto m = p->GetMakefile(PlatformCurrent);
 		if (!m)
 		{		
 			d->App->GetBuildLog()->Print("Error: no makefile? (%s:%i)\n", _FL);
 			break;
 		}
 		
 		auto Ext = LGetExtension(m);
 		if (!Stricmp(Ext, "py"))
 		{
 			// Not a makefile but a build script... can't update.
 			return true;
 		}
 
 		if (dir.First(m))
 		{
 			MakeModTime = dir.GetLastWriteTime();
 			dir.Close();
 		}
 
 		// printf("Proj=%s - Timestamps " LGI_PrintfInt64 " - " LGI_PrintfInt64 "\n", Proj.Get(), ProjModTime, MakeModTime);
 		if (ProjModTime != 0 &&
 			MakeModTime != 0 &&
 			ProjModTime > MakeModTime)
 		{
 			// Need to rebuild the makefile...
 			return false;
 		}
 	}
 	
 	return true;
 }
 
 bool IdeProject::FindDuplicateSymbols()
 {
 	LStream *Log = d->App->GetBuildLog();	
 	Log->Print("FindDuplicateSymbols starting...\n");
 
 	List<IdeProject> Proj;
 	CollectAllSubProjects(Proj);
 	Proj.Insert(this);
 
 	int Lines = 0;
 	
 	LHashTbl<StrKey<char,false>,int64> Map(200000);
 	int Found = 0;
 	for (auto p: Proj)
 	{
 		LString s = p->GetExecutable(GetCurrentPlatform());
 		if (s)
 		{
 			LString Args;
 			Args.Printf("--print-size --defined-only -C %s", s.Get());
 			LSubProcess Nm("nm", Args);
 			if (Nm.Start(true, false))
 			{
 				char Buf[256];
 				LStringPipe q;
 				for (ssize_t Rd = 0; (Rd = Nm.Read(Buf, sizeof(Buf))); )
 					q.Write(Buf, Rd);
 				LString::Array a = q.NewGStr().SplitDelimit("\r\n");
 				LHashTbl<StrKey<char,false>,bool> Local(200000);
 				for (auto &Ln: a)
 				{
 					LString::Array p = Ln.SplitDelimit(" \t", 3);
 					if (!Local.Find(p.Last()))
 					{
 						Local.Add(p.Last(), true);
 					
 						// const char *Sz = p[1];
 						int64 Ours = p[1].Int(16);
 						int64 Theirs = Map.Find(p.Last());
 						if (Theirs >= 0)
 						{
 							if (Ours != Theirs)
 							{
 								if (Found++ < 100)
 									Log->Print("    %s (" LPrintfInt64 " -> " LPrintfInt64 ")\n",
 										p.Last().Get(),
 										Ours, Theirs);
 							}
 						}
 						else if (Ours >= 0)
 						{						
 							Map.Add(p.Last(), Ours);
 						}
 						else
 						{
 							printf("Bad line: %s\n", Ln.Get());
 						}
 					}
 					Lines++;
 				}
 			}
 		}
 		else printf("%s:%i - GetExecutable failed.\n", _FL);
 	}
 
 	/*
 	char *Sym;
 	for (int Count = Map.First(&Sym); Count; Count = Map.Next(&Sym))
 	{
 		if (Count > 1)
 			Log->Print("    %i: %s\n", Count, Sym);
 	}
 	*/
 
 	Log->Print("FindDuplicateSymbols finished (%i lines)\n", Lines);
 	return false;
 }
 
 bool IdeProject::FixMissingFiles()
 {
 	FixMissingFilesDlg(this);
 	return true;
 }
 
 void IdeProject::Build(bool All, BuildConfig Config)
 {
 	if (d->Thread)
 	{
 		d->App->GetBuildLog()->Print("Error: Already building (%s:%i)\n", _FL);
 		return;
 	}
 
 	auto m = GetMakefile(PlatformCurrent);
 	CheckExists(m);
 	if (!m)
 	{		
 		d->App->GetBuildLog()->Print("Error: no makefile? (%s:%i)\n", _FL);
 		return;
 	}
 
 	if (GetApp())
 		GetApp()->PostEvent(M_APPEND_TEXT, 0, 0);
 
 	SetClean();
 
 	if (!IsMakefileUpToDate())
 		CreateMakefile(GetCurrentPlatform(), true);
 	else
 		// Start the build thread...
 		d->Thread.Reset
 		(
 			new BuildThread
 			(
 				this,
 				m,
 				false,
 				Config,
 				All,
 				sizeof(size_t)*8
 			)
 		);
 }
 
 void IdeProject::StopBuild()
 {
 	d->Thread.Reset();
 }
 
 bool IdeProject::Serialize(bool Write)
 {
 	return true;
 }
 
 AppWnd *IdeProject::GetApp()
 {
 	return d->App;
 }
 
 const char *IdeProject::GetIncludePaths()
 {
 	return d->Settings.GetStr(ProjIncludePaths);
 }
 
 const char *IdeProject::GetPreDefinedValues()
 {
 	return d->Settings.GetStr(ProjDefines);
 }
 
 const char *IdeProject::GetExeArgs()
 {
 	return d->Settings.GetStr(ProjArgs);
 }
 
 LString IdeProject::GetExecutable(IdePlatform Platform)
 {
 	LString Bin = d->Settings.GetStr(ProjExe, NULL, Platform);
 	auto TargetType = d->Settings.GetStr(ProjTargetType, NULL, Platform);
 	auto Base = GetBasePath();
 
 	if (Bin)
 	{
 		if (LIsRelativePath(Bin) && Base)
 		{
 			char p[MAX_PATH_LEN];
 			if (LMakePath(p, sizeof(p), Base, Bin))
 				Bin = p;
 		}
 		
 		return Bin;
 	}
 
 	// Create binary name from target:	
 	auto Target = GetTargetName(Platform);
 	if (Target)
 	{
 		bool IsLibrary = Stristr(TargetType, "library");
 		int BuildMode = d->App->GetBuildMode();
 		const char *Name = BuildMode ? "Release" : "Debug";
 		const char *Postfix = BuildMode ? "" : "d";
 		
 		switch (Platform)
 		{			
 			case PlatformWin:
 			{
 				if (IsLibrary)
 					Bin.Printf("%s%s.dll", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			case PlatformMac:
 			{
 				if (IsLibrary)
 					Bin.Printf("lib%s%s.dylib", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			case PlatformLinux:
 			case PlatformHaiku:
 			{
 				if (IsLibrary)
 					Bin.Printf("lib%s%s.so", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			default:
 			{
 				LAssert(0);
 				printf("%s:%i - Unknown platform.\n", _FL);
 				return LString();
 			}
 		}
 		
 		// Find the actual file...
 		if (!Base)
 		{
 			printf("%s:%i - GetBasePath failed.\n", _FL);
 			return LString();
 		}
 			
 		char Path[MAX_PATH_LEN];
 		LMakePath(Path, sizeof(Path), Base, Name);
 		LMakePath(Path, sizeof(Path), Path, Bin);
 		if (LFileExists(Path))
 			Bin = Path;
 		else
 			printf("%s:%i - '%s' doesn't exist.\n", _FL, Path);
 		
 		
 		return Bin;
 	}
 	
 	return LString();
 }
 
 const char *IdeProject::GetFileName()
 {
 	return d->FileName;
 }
 
 int IdeProject::GetPlatforms()
 {
 	return PLATFORM_ALL;
 }
 	
 LAutoString IdeProject::GetFullPath()
 {
 	LAutoString Status;
 	if (!d->FileName)
 	{
 		// LAssert(!"No path.");
 		return Status;
 	}
 
 	LArray<const char*> sections;
 	IdeProject *proj = this;
 	while (	proj &&
 			proj->GetFileName() &&
 			LIsRelativePath(proj->GetFileName()))
 	{
 		sections.AddAt(0, proj->GetFileName());
 		proj = proj->GetParentProject();
 	}
 
 	if (!proj)
 	{
 		// LAssert(!"All projects have a relative path?");
 		return Status; // No absolute path in the parent projects?
 	}
 
 	char p[MAX_PATH_LEN];
 	strcpy_s(p, sizeof(p), proj->GetFileName()); // Copy the base path
 	if (sections.Length() > 0)
 		LTrimDir(p); // Trim off the filename
 	for (int i=0; i<sections.Length(); i++) // For each relative section
 	{
 		LMakePath(p, sizeof(p), p, sections[i]); // Append relative path
 		if (i < sections.Length() - 1)
 			LTrimDir(p); // Trim filename off
 	}
 	
 	Status.Reset(NewStr(p));
 	return Status;
 }
 
 LAutoString IdeProject::GetBasePath()
 {
 	auto a = GetFullPath();
 	LTrimDir(a);
 	return a;
 }
 
 void IdeProject::CreateProject()
 {
 	Empty();
 	
 	d->FileName.Empty();
 	d->UserFile.Empty();
 	d->App->GetTree()->Insert(this);
 	
 	ProjectNode *f = new ProjectNode(this);
 	if (f)
 	{
 		f->SetName("Source");
 		f->SetType(NodeDir);
 		InsertTag(f);
 	}
 	
 	f = new ProjectNode(this);
 	if (f)
 	{
 		f->SetName("Headers");
 		f->SetType(NodeDir);
 		InsertTag(f);
 	}
 	
 	d->Settings.Set(ProjEditorTabSize, 4);
 	d->Settings.Set(ProjEditorIndentSize, 4);
 	d->Settings.Set(ProjEditorUseHardTabs, true);
 	
 	d->Dirty = true;
 	Expanded(true);	
 }
 
 ProjectStatus IdeProject::OpenFile(const char *FileName)
 {
+	auto Log = d->App->GetBuildLog();
+
 	LProfile Prof("IdeProject::OpenFile");
 	Prof.HideResultsIfBelow(1000);
 
 	Empty();
 
 	Prof.Add("Init");
 
 	d->UserNodeFlags.Empty();
 	if (LIsRelativePath(FileName))
 	{
 		char p[MAX_PATH_LEN];
 		getcwd(p, sizeof(p));
 		LMakePath(p, sizeof(p), p, FileName);
 		d->FileName = p;
 	}
 	else
 	{
 		d->FileName = FileName;
 	}
 	d->UserFile = d->FileName + "." + LCurrentUserName();
 
 	if (!d->FileName)
 	{
-		LgiTrace("%s:%i - No filename.\n", _FL);
+		Log->Print("%s:%i - No filename.\n", _FL);
 		return OpenError;
 	}
 	
 	Prof.Add("FileOpen");
 
 	LFile f;
 	LString FullPath = d->FileName.Get();
-	if (CheckExists(FullPath) &&
+	if (!CheckExists(FullPath) ||
 		!f.Open(FullPath, O_READWRITE))
 	{
-		LgiTrace("%s:%i - Error: Can't open '%s'.\n", _FL, FullPath.Get());
+		Log->Print("%s:%i - Error: Can't open '%s'.\n", _FL, FullPath.Get());
 		return OpenError;
 	}
 
 	Prof.Add("Xml");
 
 	LXmlTree x;
 	LXmlTag r;
 	if (!x.Read(&r, &f))
 	{
-		LgiTrace("%s:%i - Error: Can't read XML: %s\n", _FL, x.GetErrorMsg());
-		LgiMsg(Tree, x.GetErrorMsg(), AppName);
+		Log->Print("%s:%i - Error: Can't read XML: %s\n", _FL, x.GetErrorMsg());
 		return OpenError;
 	}
 
 	Prof.Add("Progress Setup");
 
 	#if DEBUG_OPEN_PROGRESS
 	int64 Nodes = r.CountTags();
 	LProgressDlg Prog(d->App, 1000);
 	Prog.SetDescription("Loading project...");
 	Prog.SetLimits(0, Nodes);
 	Prog.SetYieldTime(1000);
 	Prog.SetAlwaysOnTop(true);
 	#endif
 
 	Prof.Add("UserFile");
 
 	if (LFileExists(d->UserFile))
 	{
 		LFile Uf;
 		if (Uf.Open(d->UserFile, O_READ))
 		{
 			LString::Array Ln = Uf.Read().SplitDelimit("\n");
 			for (unsigned i=0; i<Ln.Length(); i++)
 			{
 				LString::Array p = Ln[i].SplitDelimit(",");
 				if (p.Length() == 2)
 					d->UserNodeFlags.Add((int)p[0].Int(), (int)p[1].Int(16));
 			}
 		}
 	}
 	
 	if (!r.IsTag("Project"))
+	{
+		Log->Print("%s:%i - No 'Project' tag.\n", _FL);
 		return OpenError;
+	}
 
 	Prof.Add("OnOpen");
 
 	bool Ok = OnOpen(
 		#if DEBUG_OPEN_PROGRESS
 		&Prog,
 		#else
 		NULL,
 		#endif
 		&r);
 	#if DEBUG_OPEN_PROGRESS
 	if (Prog.IsCancelled())
 		return OpenCancel;
 	else 
 	#endif
 	if (!Ok)
 		return OpenError;
 
 	Prof.Add("Insert");
 
 	d->App->GetTree()->Insert(this);
 	Expanded(true);
 
 	Prof.Add("Serialize");
 	
 	d->Settings.Serialize(&r, false /* read */);
 	return OpenOk;
 }
 
 bool IdeProject::SaveFile()
 {
 	auto Full = GetFullPath();
 
 	if (ValidStr(Full) && d->Dirty)
 	{
 		LFile f;
 		if (f.Open(Full, O_WRITE))
 		{
 			f.SetSize(0);
 
 			LXmlTree x;
 			d->Settings.Serialize(this, true /* write */);
 
 			if (x.Write(this, &f))
 				d->Dirty = false;
 			else
 				LgiTrace("%s:%i - Failed to write XML.\n", _FL);
 		}
 		else LgiTrace("%s:%i - Couldn't open '%s' for writing.\n", _FL, Full.Get());
 	}
 
 	if (d->UserFileDirty)
 	{
 		LFile f;
 		LAssert(d->UserFile.Get());
 		if (f.Open(d->UserFile, O_WRITE))
 		{
 			f.SetSize(0);
 
 			// Save user file details..
 			// int Id;
 			// for (int Flags = d->UserNodeFlags.First(&Id); Flags >= 0; Flags = d->UserNodeFlags.Next(&Id))
 			for (auto i : d->UserNodeFlags)
 			{
 				f.Print("%i,%x\n", i.key, i.value);
 			}
 
 			d->UserFileDirty = false;
 		}
 	}
 
 	printf("\tIdeProject::SaveFile %i %i\n", d->Dirty, d->UserFileDirty);
 
 	return	!d->Dirty &&
 			!d->UserFileDirty;
 }
 
 void IdeProject::SetDirty()
 {
 	d->Dirty = true;
 	d->App->OnProjectChange();
 }
 
 void IdeProject::SetUserFileDirty()
 {
 	d->UserFileDirty = true;
 }
 
 bool IdeProject::GetExpanded(int Id)
 {
 	int f = d->UserNodeFlags.Find(Id);
 	return f >= 0 ? f : false;
 }
 
 void IdeProject::SetExpanded(int Id, bool Exp)
 {
 	if (d->UserNodeFlags.Find(Id) != (int)Exp)
 	{
 		d->UserNodeFlags.Add(Id, Exp);
 		SetUserFileDirty();
 	}
 }
 
 int IdeProject::AllocateId()
 {
 	return d->NextNodeId++;
 }
 
 template<typename T, typename Fn>
 bool CheckExists(LAutoString Base, T &p, Fn Setter, bool Debug)
 {
 	LFile::Path Full;
 	bool WasRel = LIsRelativePath(p);
 	if (WasRel)
 	{
 		Full = Base.Get();
 		Full += p.Get();
 	}
 	else Full = p.Get();
 	
 	bool Ret = Full.Exists();
 	if (!Ret)
 	{
 		// Is the case wrong?
 		for (int i=1; i<Full.Length(); i++)
 		{
 			LFile::Path t;
 			t = Full.Slice(0, i);
 			if (!t.Exists())
 			{
 				LDirectory dir;
 				bool Matched = false;
 				auto &Leaf = Full[i-1];
 				auto Parent = t.GetParent();
 				
 				if (Debug)
 					printf("Searching '%s' for missing '%s'\n", Parent.GetFull().Get(), Leaf.Get());
 				
 				for (auto b=dir.First(Parent); b; b = dir.Next())
 				{
 					if (!Stricmp(dir.GetName(), t.Last().Get()))
 					{
 						if (Debug)
 							printf("t[%i]: %s->%s\n", i, Leaf.Get(), dir.GetName());
 						Leaf = dir.GetName();
 						Matched = true;
 						break;
 					}
 				}
 				if (!Matched)					
 					break;
 			}
 		}
 		
 		if ((Ret = Full.Exists()))
 		{
 			LString Old = p.Get();
 			if (WasRel)
 			{
 				auto r = LMakeRelativePath(Base, Full);
 				Setter(p, r);
 			}
 			else
 			{
 				Setter(p, Full.GetFull());
 			}
 			
 			if (Debug)
 				printf("%s -> %s\n", Old.Get(), p.Get());
 		}
 	}
 
 	if (Debug)
 		printf("CheckExists '%s' = %i\n", Full.GetFull().Get(), Ret);		
 
 	return Ret;
 }
 
 bool IdeProject::CheckExists(LString &p, bool Debug)
 {
 	return ::CheckExists(GetBasePath(), p, [](LString &o, const char *i) {
 			o = i;
 		}, Debug);
 }
 
 bool IdeProject::CheckExists(LAutoString &p, bool Debug)
 {
 	return ::CheckExists(GetBasePath(), p, [](LAutoString &o, const char *i) {
 			o.Reset(NewStr(i));
 		}, Debug);
 }
 
 bool IdeProject::SetClean()
 {
 	// printf("IdeProject::SetClean %i %i\n", d->Dirty, d->UserFileDirty);
 	if (d->Dirty || d->UserFileDirty)
 	{
 		if (!ValidStr(d->FileName))
 		{
 			LFileSelect s;
 			s.Parent(Tree);
 			s.Name("Project.xml");
 			if (s.Save())
 			{
 				d->FileName = s.Name();
 				d->UserFile = d->FileName + "." + LCurrentUserName();
 				d->App->OnFile(d->FileName, true);
 				Update();
 			}
 			else return false;
 		}
 
 		SaveFile();
 	}
 
 	for (auto i:*this)
 	{
 		ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 		if (!p) break;
 
 		p->SetClean();
 	}
 
 	return true;
 }
 
 const char *IdeProject::GetText(int Col)
 {
 	if (d->FileName)
 	{
 		char *s = strrchr(d->FileName, DIR_CHAR);
 		return s ? s + 1 : d->FileName.Get();
 	}
 
 	return Untitled;
 }
 
 int IdeProject::GetImage(int Flags)
 {
 	return 0;
 }
 
 void IdeProject::Empty()
 {
 	LXmlTag *t;
 	while (Children.Length() > 0 &&
 		(t = Children[0]))
 	{
 		ProjectNode *n = dynamic_cast<ProjectNode*>(t);
 		if (n)
 		{
 			n->Remove();
 		}
 		DeleteObj(t);
 	}
 }
 
 LXmlTag *IdeProject::Create(char *Tag)
 {
 	if (!stricmp(Tag, TagSettings))
 		return NULL;
 
 	return new ProjectNode(this);
 }
 
 void IdeProject::OnMouseClick(LMouse &m)
 {
 	if (m.IsContextMenu())
 	{
 		LSubMenu Sub;
 		Sub.AppendItem("New Folder", IDM_NEW_FOLDER);
 		Sub.AppendItem("New Web Folder", IDM_WEB_FOLDER);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Build", IDM_BUILD);
 		Sub.AppendItem("Clean Project", IDM_CLEAN_PROJECT);
 		Sub.AppendItem("Clean All", IDM_CLEAN_ALL);
 		Sub.AppendItem("Rebuild Project", IDM_REBUILD_PROJECT);
 		Sub.AppendItem("Rebuild All", IDM_REBUILD_ALL);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Sort Children", IDM_SORT_CHILDREN);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Settings", IDM_SETTINGS, true);
 		Sub.AppendItem("Insert Dependency", IDM_INSERT_DEP);
 
 		m.ToScreen();
 		auto c = _ScrollPos();
 		m.x -= c.x;
 		m.y -= c.y;
 		switch (Sub.Float(Tree, m.x, m.y))
 		{
 			case IDM_NEW_FOLDER:
 			{
 				LInput Name(Tree, "", "Name:", AppName);
 				if (Name.DoModal())
 				{
 					GetSubFolder(this, Name.GetStr(), true);
 				}
 				break;
 			}
 			case IDM_WEB_FOLDER:
 			{
 				WebFldDlg Dlg(Tree, 0, 0, 0);
 				if (Dlg.DoModal())
 				{
 					if (Dlg.Ftp && Dlg.Www)
 					{
 						IdeCommon *f = GetSubFolder(this, Dlg.Name, true);
 						if (f)
 						{
 							f->SetAttr(OPT_Ftp, Dlg.Ftp);
 							f->SetAttr(OPT_Www, Dlg.Www);
 						}
 					}
 				}
 				break;
 			}
 			case IDM_BUILD:
 			{
 				StopBuild();
 				Build(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_CLEAN_PROJECT:
 			{
 				Clean(false, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_CLEAN_ALL:
 			{
 				Clean(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_REBUILD_PROJECT:
 			{
 				StopBuild();
 				Clean(false, d->App->GetBuildMode());
 				Build(false, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_REBUILD_ALL:
 			{
 				StopBuild();
 				Clean(true, d->App->GetBuildMode());
 				Build(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_SORT_CHILDREN:
 			{
 				SortChildren();
 				Project->SetDirty();
 				break;
 			}
 			case IDM_SETTINGS:
 			{
 				if (d->Settings.Edit(Tree))
 				{
 					SetDirty();
 				}
 				break;
 			}
 			case IDM_INSERT_DEP:
 			{
 				LFileSelect s;
 				s.Parent(Tree);
 				s.Type("Project", "*.xml");
 				if (s.Open())
 				{
 					ProjectNode *New = new ProjectNode(this);
 					if (New)
 					{
 						New->SetFileName(s.Name());
 						New->SetType(NodeDependancy);
 						InsertTag(New);
 						SetDirty();
 					}
 				}
 				break;
 			}
 		}
 	}
 }
 
 char *IdeProject::FindFullPath(const char *File, ProjectNode **Node)
 {
 	char *Full = 0;
 	
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		ProjectNode *n = c->FindFile(File, &Full);
 		if (n)
 		{
 			if (Node)
 				*Node = n;
 			break;
 		}
 	}
 	
 	return Full;
 }
 
 bool IdeProject::HasNode(ProjectNode *Node)
 {
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		if (c->HasNode(Node))
 			return true;
 	}
 	return false;
 }
 
 bool IdeProject::GetAllNodes(LArray<ProjectNode*> &Nodes)
 {
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		c->AddNodes(Nodes);
 	}
 	return true;
 }
 
 bool IdeProject::InProject(bool FuzzyMatch, const char *Path, bool Open, IdeDoc **Doc)
 {
 	if (!Path)
 		return false;
 		
 	// Search complete path first...
 	ProjectNode *n = d->Nodes.Find(Path);	
 	if (!n && FuzzyMatch)
 	{
 		// No match, do partial matching.
 		const char *Leaf = LGetLeaf(Path);
 		auto PathLen = strlen(Path);
 		auto LeafLen = strlen(Leaf);
 		uint32_t MatchingScore = 0;
 
 		// Traverse all nodes and try and find the best fit.
 		// const char *p;
 		// for (ProjectNode *Cur = d->Nodes.First(&p); Cur; Cur = d->Nodes.Next(&p))
 		for (auto Cur : d->Nodes)
 		{
 			int CurPlatform = Cur.value->GetPlatforms();
 			uint32_t Score = 0;
 
 			if (stristr(Cur.key, Path))
 			{
 				Score += PathLen;
 			}
 			else if (stristr(Cur.key, Leaf))
 			{
 				Score += LeafLen;
 			}
 
 			const char *pLeaf = LGetLeaf(Cur.key);
 			if (pLeaf && !stricmp(pLeaf, Leaf))
 			{
 				Score |= 0x40000000;
 			}
 			if (Score && (CurPlatform & PLATFORM_CURRENT) != 0)
 			{
 				Score |= 0x80000000;
 			}
 
 			if (Score > MatchingScore)
 			{
 				MatchingScore = Score;
 				n = Cur.value;
 			}
 		}
 	}
 	
 	if (n && Doc)
 	{
 		*Doc = n->Open();
 	}
 	
 	return n != 0;
 }
 
 char *GetQuotedStr(char *Str)
 {
 	char *s = strchr(Str, '\"');
 	if (s)
 	{
 		s++;
 		char *e = strchr(s, '\"');
 		if (e)
 		{
 			return NewStr(s, e - s);
 		}
 	}
 
 	return 0;
 }
 
 void IdeProject::ImportDsp(const char *File)
 {
 	if (File && LFileExists(File))
 	{
 		char Base[256];
 		strcpy(Base, File);
 		LTrimDir(Base);
 		
 		char *Dsp = LReadTextFile(File);
 		if (Dsp)
 		{
 			LToken Lines(Dsp, "\r\n");
 			IdeCommon *Current = this;
 			bool IsSource = false;
 			for (int i=0; i<Lines.Length(); i++)
 			{
 				char *L = Lines[i];
 				if (strnicmp(L, "# Begin Group", 13) == 0)
 				{
 					char *Folder = GetQuotedStr(L);
 					if (Folder)
 					{
 						IdeCommon *Sub = Current->GetSubFolder(this, Folder, true);
 						if (Sub)
 						{
 							Current = Sub;
 						}
 						DeleteArray(Folder);
 					}
 				}
 				else if (strnicmp(L, "# End Group", 11) == 0)
 				{
 					IdeCommon *Parent = dynamic_cast<IdeCommon*>(Current->GetParent());
 					if (Parent)
 					{
 						Current = Parent;
 					}
 				}
 				else if (strnicmp(L, "# Begin Source", 14) == 0)
 				{
 					IsSource = true;
 				}
 				else if (strnicmp(L, "# End Source", 12) == 0)
 				{
 					IsSource = false;
 				}
 				else if (Current && IsSource && strncmp(L, "SOURCE=", 7) == 0)
 				{
 					ProjectNode *New = new ProjectNode(this);
 					if (New)
 					{
 						char *Src = 0;
 						if (strchr(L, '\"'))
 						{
 							Src = GetQuotedStr(L);
 						}
 						else
 						{
 							Src = NewStr(L + 7);
 						}						
 						if (Src)
 						{
 							// Make absolute path
 							char Abs[256];
 							LMakePath(Abs, sizeof(Abs), Base, ToUnixPath(Src));
 							
 							// Make relitive path
 							New->SetFileName(Src);
 							DeleteArray(Src);
 						}
 
 						Current->InsertTag(New);
 						SetDirty();
 					}
 				}
 			}
 			
 			DeleteArray(Dsp);
 		}
 	}
 }
 
 IdeProjectSettings *IdeProject::GetSettings()
 {
 	return &d->Settings;
 }
 
 bool IdeProject::BuildIncludePaths(LArray<LString> &Paths, bool Recurse, bool IncludeSystem, IdePlatform Platform)
 {
 	List<IdeProject> Projects;
 	if (Recurse)
 		GetChildProjects(Projects);
 	Projects.Insert(this, 0);
 
 	LHashTbl<StrKey<char>, bool> Map;
 	
 	for (auto p: Projects)
 	{
 		LString ProjInclude = d->Settings.GetStr(ProjIncludePaths, NULL, Platform);
 		LAutoString Base = p->GetBasePath();
 		
 		const char *Delim = ",;\r\n";
 		LString::Array In, Out;
 		LString::Array a = ProjInclude.SplitDelimit(Delim);
 		In = a;
 		
 		if (IncludeSystem)
 		{
 			LString SysInclude = d->Settings.GetStr(ProjSystemIncludes, NULL, Platform);
 			a = SysInclude.SplitDelimit(Delim);
 			In.SetFixedLength(false);
 			In.Add(a);
 		}
 		
 		for (unsigned i=0; i<In.Length(); i++)
 		{
 			auto p = ToPlatformPath(In[i], Platform);
 
 			char *Path = p;
 			if (*Path == '`')
 			{
 				// Run config app to get the full path list...
 				p = p.Strip("`");
 				LString::Array a = p.Split(" ", 1);
 				LSubProcess Proc(a[0], a.Length() > 1 ? a[1].Get() : NULL);
 				LStringPipe Buf;
 				if (Proc.Start())
 				{
 					Proc.Communicate(&Buf);
 
 					LString result = Buf.NewGStr();
 					a = result.Split(" \t\r\n");
 					for (int i=0; i<a.Length(); i++)
 					{
 						char *inc = a[i];
 						if (inc[0] == '-' &&
 							inc[1] == 'I')
 						{
 							Out.New() = a[i](2,-1);
 						}
 					}
 				}
 				else LgiTrace("%s:%i - Error: failed to run process for '%s'\n", _FL, p.Get());
 			}
 			else
 			{
 				// Add path literal
 				Out.New() = Path;
 			}
 		}
 			
 		for (int i=0; i<Out.Length(); i++)
 		{
 			char *Path = Out[i];
 			char *Full = 0, Buf[MAX_PATH_LEN];
 			if
 			(
 				*Path != '/'
 				&&
 				!(
 					IsAlpha(*Path)
 					&&
 					Path[1] == ':'
 				)
 			)
 			{
 				LMakePath(Buf, sizeof(Buf), Base, Path);
 				Full = Buf;
 			}
 			else
 			{
 				Full = Out[i];
 			}
 			
 			if (!Map.Find(Full))
 				Map.Add(Full, true);
 		}
 
 		// Add paths for the headers in the project... bit of a hack but it'll
 		// help it find them if the user doesn't specify the paths in the project.
 		LArray<ProjectNode*> Nodes;
 		if (p->GetAllNodes(Nodes))
 		{
 			auto Base = p->GetFullPath();
 			if (Base)
 			{
 				LTrimDir(Base);
 
 				for (auto &n: Nodes)
 				{
 					if (n->GetType() == NodeHeader &&				// Only look at headers.
 						(n->GetPlatforms() & (1 << Platform)) != 0)	// Exclude files not on this platform.
 					{
 						auto f = n->GetFileName();
 						char p[MAX_PATH_LEN];
 						if (f &&
 							LMakePath(p, sizeof(p), Base, f))
 						{
 							char *l = strrchr(p, DIR_CHAR);
 							if (l)
 								*l = 0;
 							if (!Map.Find(p))
 							{
 								Map.Add(p, true);
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 	// char *p;
 	// for (bool b = Map.First(&p); b; b = Map.Next(&p))
 	for (auto p : Map)
 		Paths.Add(p.key);
 
 	return true;
 }
 
 void IdeProjectPrivate::CollectAllFiles(LTreeNode *Base, LArray<ProjectNode*> &Files, bool SubProjects, int Platform)
 {
 	for (auto i:*Base)
 	{
 		IdeProject *Proj = dynamic_cast<IdeProject*>(i);
 		if (Proj)
 		{
 			if (Proj->GetParentProject() && !SubProjects)
 			{
 				continue;
 			}
 		}
 		else
 		{
 			ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 			if (p)
 			{
 				if (p->GetType() == NodeSrc ||
 					p->GetType() == NodeHeader)
 				{
 					if (p->GetPlatforms() & Platform)
 					{
 						Files.Add(p);
 					}
 				}
 			}
 		}
 
 		CollectAllFiles(i, Files, SubProjects, Platform);
 	}
 }
 
 LString IdeProject::GetTargetName(IdePlatform Platform)
 {
 	LString Status;
 	const char *t = d->Settings.GetStr(ProjTargetName, NULL, Platform);
 	if (ValidStr(t))
 	{
 		// Take target name from the settings
 		Status = t;
 	}
 	else
 	{
 		char *s = strrchr(d->FileName, DIR_CHAR);
 		if (s)
 		{
 			// Generate the target executable name
 			char Target[MAX_PATH_LEN];
 			strcpy_s(Target, sizeof(Target), s + 1);
 			s = strrchr(Target, '.');
 			if (s) *s = 0;
 			strlwr(Target);
 			s = Target;
 			for (char *i = Target; *i; i++)
 			{
 				if (*i != '.' && *i != ' ')
 				{
 					*s++ = *i;
 				}
 			}
 			*s = 0;
 			Status = Target;
 		}
 	}
 	
 	return Status;
 }
 
 LString IdeProject::GetTargetFile(IdePlatform Platform)
 {
 	LString Target = GetTargetName(PlatformCurrent);
 	if (!Target)
 	{
 		LAssert(!"No target?");
 		return NULL;
 	}
 
 	const char *TargetType = d->Settings.GetStr(ProjTargetType);
 	if (!TargetType)
 	{
 		LAssert(!"Needs a target type.");
 		return NULL;
 	}
 
 	if (!stricmp(TargetType, "Executable"))
 	{
 		return Target;
 	}
 	else if (!stricmp(TargetType, "DynamicLibrary"))
 	{
 		char t[MAX_PATH_LEN];
 		auto DefExt = PlatformDynamicLibraryExt(Platform);
 		strcpy_s(t, sizeof(t), Target);
 		char *ext = LGetExtension(t);
 		if (!ext)
 			sprintf(t + strlen(t), ".%s", DefExt);
 		else if (stricmp(ext, DefExt))
 			strcpy(ext, DefExt);
 		return t;
 	}
 	else if (!stricmp(TargetType, "StaticLibrary"))
 	{
 		LString Ret;
 		Ret.Printf("%s.%s", Target.Get(), PlatformSharedLibraryExt(Platform));
 		return Ret;
 	}
 	
 	return NULL;
 }
 
 struct ProjDependency
 {
 	bool Scanned;
 	LAutoString File;
 	
 	ProjDependency(const char *f)
 	{
 		Scanned = false;
 		File.Reset(NewStr(f));
 	}
 };
 
 bool IdeProject::GetAllDependencies(LArray<char*> &Files, IdePlatform Platform)
 {
 	if (!GetTree()->Lock(_FL))
 		return false;
 		
 	LHashTbl<StrKey<char>, ProjDependency*> Deps;
 	LAutoString Base = GetBasePath();
 	
 	// Build list of all the source files...
 	LArray<LString> Src;
 	CollectAllSource(Src, Platform);
 	
 	// Get all include paths
 	LArray<LString> IncPaths;
 	BuildIncludePaths(IncPaths, false, false, Platform);
 	
 	// Add all source to dependencies
 	for (int i=0; i<Src.Length(); i++)
 	{
 		char *f = Src[i];
 		ProjDependency *dep = Deps.Find(f);
 		if (!dep)
 			Deps.Add(f, new ProjDependency(f));
 	}
 	
 	// Scan all dependencies for includes
 	LArray<ProjDependency*> Unscanned;
 	do
 	{
 		// Find all the unscanned dependencies
 		Unscanned.Length(0);
 		// for (ProjDependency *d = Deps.First(); d; d = Deps.Next())
 		for (auto d : Deps)
 		{
 			if (!d.value->Scanned)
 				Unscanned.Add(d.value);
 		}		
 
 		for (int i=0; i<Unscanned.Length(); i++)
 		{
 			// Then scan source for includes...
 			ProjDependency *d = Unscanned[i];
 			d->Scanned = true;
 			
 			char *Src = d->File;
 			char Full[MAX_PATH_LEN];
 			if (LIsRelativePath(d->File))
 			{
 				LMakePath(Full, sizeof(Full), Base, d->File);
 				Src = Full;
 			}
 
 			LArray<char*> SrcDeps;
 			if (GetDependencies(Src, IncPaths, SrcDeps, Platform))
 			{
 				for (int n=0; n<SrcDeps.Length(); n++)
 				{
 					// Add include to dependencies...
 					char *File = SrcDeps[n];
 
 					if (LIsRelativePath(File))
 					{
 						LMakePath(Full, sizeof(Full), Base, File);
 						File = Full;
 					}
 
 					if (!Deps.Find(File))
 					{						
 						Deps.Add(File, new ProjDependency(File));
 					}
 				}
 				SrcDeps.DeleteArrays();
 			}
 		}
 	}
 	while (Unscanned.Length() > 0);
 	
 	// for (ProjDependency *d = Deps.First(); d; d = Deps.Next())
 	for (auto d : Deps)
 	{
 		Files.Add(d.value->File.Release());
 	}
 	
 	Deps.DeleteObjects();
 	GetTree()->Unlock();
 	
 	return true;
 }
 
 bool IdeProject::GetDependencies(const char *InSourceFile, LArray<LString> &IncPaths, LArray<char*> &Files, IdePlatform Platform)
 {
 	LString SourceFile = InSourceFile;
 	if (!CheckExists(SourceFile))
 	{
 		LgiTrace("%s:%i - can't read '%s'\n", _FL, SourceFile.Get());
 		return false;
 	}
 
 	LAutoString c8(LReadTextFile(SourceFile));
 	if (!c8)
 		return false;
 
 	LArray<char*> Headers;
 	if (!BuildHeaderList(c8, Headers, IncPaths, false))
 		return false;
 	
 	for (int n=0; n<Headers.Length(); n++)
 	{
 		char *i = Headers[n];
 		LString p;
 		if (!RelativePath(p, i))
 			p = i;
 		ToUnixPath(p);
 		Files.Add(NewStr(p));
 	}
 	Headers.DeleteArrays();
 	
 	return true;
 }
 
 int MakefileThread::Instances = 0;
 
 bool IdeProject::CreateMakefile(IdePlatform Platform, bool BuildAfterwards)
 {
 	if (d->CreateMakefile)
 	{
 		if (d->CreateMakefile->IsExited())
 			d->CreateMakefile.Reset();
 		else
 		{
 			d->App->GetBuildLog()->Print("%s:%i - Makefile thread still running.\n", _FL);
 			return false;
 		}
 	}
 	
 	if (Platform == PlatformCurrent)
 		Platform = GetCurrentPlatform();
 
 	return d->CreateMakefile.Reset(new MakefileThread(d, Platform, BuildAfterwards));
 }
 
 void IdeProject::OnMakefileCreated()
 {
 	if (d->CreateMakefile)
 	{
 		d->CreateMakefile.Reset();
 		if (MakefileThread::Instances == 0)
 			GetApp()->PostEvent(M_LAST_MAKEFILE_CREATED);
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 IdeTree::IdeTree() : LTree(IDC_PROJECT_TREE, 0, 0, 100, 100)
 {
 	Hit = 0;
 	MultiSelect(true);
 }
 
 void IdeTree::OnCreate()
 {
 	SetWindow(this);
 }
 
 void IdeTree::OnDragExit()
 {
 	SelectDropTarget(0);
 }
 
 int IdeTree::WillAccept(LDragFormats &Formats, LPoint p, int KeyState)
 {
 	static bool First = true;
 	
 	Formats.SupportsFileDrops();
 	Formats.Supports(NODE_DROP_FORMAT);
 	First = false;
 		
 	if (Formats.Length() == 0)
 	{
 		LgiTrace("%s:%i - No valid drop formats.\n", _FL);
 		return DROPEFFECT_NONE;
 	}
 
 	Hit = ItemAtPoint(p.x, p.y);
 	if (!Hit)
 	{
 		SelectDropTarget(NULL);
 		return DROPEFFECT_NONE;
 	}
 
 	if (Formats.HasFormat(LGI_FileDropFormat))
 	{
 		SelectDropTarget(Hit);
 		return DROPEFFECT_LINK;
 	}
 
 	IdeCommon *Src = dynamic_cast<IdeCommon*>(Selection());
 	IdeCommon *Dst = dynamic_cast<IdeCommon*>(Hit);
 	if (Src && Dst)
 	{
 		// Check this folder is not a child of the src
 		for (IdeCommon *n=Dst; n; n=dynamic_cast<IdeCommon*>(n->GetParent()))
 		{
 			if (n == Src)
 				return DROPEFFECT_NONE;
 		}
 	}
 
 	// Valid target
 	SelectDropTarget(Hit);
 	return DROPEFFECT_MOVE;
 }
 
 int IdeTree::OnDrop(LArray<LDragData> &Data, LPoint p, int KeyState)
 {
 	int Ret = DROPEFFECT_NONE;
 	SelectDropTarget(NULL);
 	if (!(Hit = ItemAtPoint(p.x, p.y)))
 		return Ret;
 	
 	for (unsigned n=0; n<Data.Length(); n++)
 	{
 		LDragData &dd = Data[n];
 		LVariant *Data = &dd.Data[0];
 		if (dd.IsFormat(NODE_DROP_FORMAT))
 		{
 			if (Data->Type == GV_BINARY && Data->Value.Binary.Length == sizeof(ProjectNode*))
 			{
 				ProjectNode *Src = ((ProjectNode**)Data->Value.Binary.Data)[0];
 				if (Src)
 				{
 					ProjectNode *Folder = dynamic_cast<ProjectNode*>(Hit);
 					while (Folder && Folder->GetType() != NodeDir)
 						Folder = dynamic_cast<ProjectNode*>(Folder->GetParent());
 
 					IdeCommon *Dst = dynamic_cast<IdeCommon*>(Folder?Folder:Hit);
 					if (Dst)
 					{
 						// Check this folder is not a child of the src
 						for (IdeCommon *n=Dst; n; n=dynamic_cast<IdeCommon*>(n->GetParent()))
 						{
 							if (n == Src)
 								return DROPEFFECT_NONE;
 						}
 
 						// Detach
 						LTreeItem *i = dynamic_cast<LTreeItem*>(Src);
 						i->Detach();
 						if (Src->LXmlTag::Parent)
 						{
 							LAssert(Src->LXmlTag::Parent->Children.HasItem(Src));
 							Src->LXmlTag::Parent->Children.Delete(Src);
 						}
 						
 						// Attach
 						Src->LXmlTag::Parent = Dst;
 						Dst->Children.SetFixedLength(false);
 						Dst->Children.Add(Src);
 						Dst->Children.SetFixedLength(true);
 						Dst->Insert(Src);
 						
 						// Dirty
 						Src->GetProject()->SetDirty();
 					}
 				
 					Ret = DROPEFFECT_MOVE;
 				}
 			}
 		}
 		else if (dd.IsFileDrop())
 		{
 			ProjectNode *Folder = dynamic_cast<ProjectNode*>(Hit);
 			while (Folder && Folder->GetType() > NodeDir)
 				Folder = dynamic_cast<ProjectNode*>(Folder->GetParent());
 			
 			IdeCommon *Dst = dynamic_cast<IdeCommon*>(Folder?Folder:Hit);
 			if (Dst)
 			{
 				AddFilesProgress Prog(this);
 				LDropFiles Df(dd);
 				for (int i=0; i<Df.Length() && !Prog.Cancel; i++)
 				{
 					if (Dst->AddFiles(&Prog, Df[i]))
 						Ret = DROPEFFECT_LINK;
 				}
 			}
 		}
 		else LgiTrace("%s:%i - Unknown drop format: %s.\n", _FL, dd.Format.Get());
 	}
 
 	return Ret;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 AddFilesProgress::AddFilesProgress(LViewI *par)
 {
 	v = 0;
 	Cancel = false;
 	Msg = NULL;
 	SetParent(par);
 	Ts = LCurrentTime();
 	LRect r(0, 0, 140, 100);
 	SetPos(r);
 	MoveSameScreen(par);
 	Name("Importing files...");
 
 	LString::Array a = LString(DefaultExt).SplitDelimit(",");
 	for (unsigned i=0; i<a.Length(); i++)
 	{
 		Exts.Add(a[i], true);
 	}
 
 	LTableLayout *t = new LTableLayout(100);
 	AddView(t);
 		
 	auto *c = t->GetCell(0, 0);
 	c->Add(new LTextLabel(-1, 0, 0, -1, -1, "Loaded:"));
 		
 	c = t->GetCell(1, 0);
 	c->Add(Msg = new LTextLabel(-1, 0, 0, -1, -1, "..."));
 		
 	c = t->GetCell(0, 1, true, 2);
 	c->TextAlign(LCss::Len(LCss::AlignRight));
 	c->Add(new LButton(IDCANCEL, 0, 0, -1, -1, "Cancel"));
 }
 
 int64 AddFilesProgress::Value()
 {
 	return v;
 }
 
 void AddFilesProgress::Value(int64 val)
 {
 	v = val;
 
 	uint64 Now = LCurrentTime();
 	if (Visible())
 	{
 		if (Now - Ts > 200)
 		{
 			if (Msg)
 			{
 				Msg->Value(v);
 				Msg->SendNotify(LNotifyTableLayoutRefresh);
 			}
 			LYield();
 			Ts = Now;
 		}
 	}
 	else if (Now - Ts > 1000)
 	{
 		DoModeless();
 		SetAlwaysOnTop(true);
 	}
 }
 
 int AddFilesProgress::OnNotify(LViewI *c, LNotification n)
 {
 	if (c->GetId() == IDCANCEL)
 		Cancel = true;
 	return 0;
 }
diff --git a/Ide/Code/LgiIde.cpp b/Ide/Code/LgiIde.cpp
--- a/Ide/Code/LgiIde.cpp
+++ b/Ide/Code/LgiIde.cpp
@@ -1,4489 +1,4491 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <ctype.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Mdi.h"
 #include "lgi/common/Token.h"
 #include "lgi/common/XmlTree.h"
 #include "lgi/common/Panel.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/TabView.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/Box.h"
 #include "lgi/common/TextLog.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/LgiRes.h"
 #include "lgi/common/Box.h"
 #include "lgi/common/SubProcess.h"
 #include "lgi/common/About.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/ToolBar.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/SubProcess.h"
 
 #include "LgiIde.h"
 #include "FtpThread.h"
 #include "FindSymbol.h"
 #include "Debugger.h"
 #include "ProjectNode.h"
 
 #define IDM_RECENT_FILE			1000
 #define IDM_RECENT_PROJECT		1100
 #define IDM_WINDOWS				1200
 #define IDM_MAKEFILE_BASE		1300
 
 #define USE_HAIKU_PULSE_HACK	0
 
 #define OPT_ENTIRE_SOLUTION		"SearchSolution"
 #define OPT_SPLIT_PX			"SplitPos"
 #define OPT_OUTPUT_PX			"OutputPx"
 #define OPT_FIX_RENAMED			"FixRenamed"
 #define OPT_RENAMED_SYM			"RenamedSym"
 
 #define IsSymbolChar(c)			( IsDigit(c) || IsAlpha(c) || strchr("-_", c) )
 
 //////////////////////////////////////////////////////////////////////////////////////////
 class FindInProject : public LDialog
 {
 	AppWnd *App;
 	LList *Lst;
 
 public:
 	FindInProject(AppWnd *app)
 	{
 		Lst = NULL;
 		App = app;
 		if (LoadFromResource(IDC_FIND_PROJECT_FILE))
 		{
 			MoveSameScreen(App);
 
 			LViewI *v;
 			if (GetViewById(IDC_TEXT, v))
 				v->Focus(true);
 			if (!GetViewById(IDC_FILES, Lst))
 				return;
 
 			RegisterHook(this, LKeyEvents, 0);
 		}
 	}
 
 	bool OnViewKey(LView *v, LKey &k)
 	{
 		switch (k.vkey)
 		{
 			case LK_UP:
 			case LK_DOWN:
 			case LK_PAGEDOWN:
 			case LK_PAGEUP:
 			{
 				return Lst->OnKey(k);
 				break;
 			}
 			case LK_RETURN:
 			{
 				if (k.Down())
 				{
 					LListItem *i = Lst->GetSelected();
 					if (i)
 					{
 						const char *Ref = i->GetText(0);
 						App->GotoReference(Ref, 1, false);
 					}
 					EndModal(1);
 					return true;
 				}
 				break;
 			}
 			case LK_ESCAPE:
 			{
 				if (k.Down())
 				{
 					EndModal(0);
 					return true;
 				}
 				break;
 			}
 		}
 	
 		return false;
 	}
 
 	void Search(const char *s)
 	{
 		IdeProject *p = App->RootProject();
 		if (!p || !s)
 			return;
 		
 		LArray<ProjectNode*> Matches, Nodes;
 
 		List<IdeProject> All;
 		p->GetChildProjects(All);
 		All.Insert(p);							
 		for (auto p: All)
 		{
 			p->GetAllNodes(Nodes);
 		}
 
 		FilterFiles(Matches, Nodes, s);
 
 		Lst->Empty();
 		for (auto m: Matches)
 		{
 			LListItem *li = new LListItem;
 			LString Fn = m->GetFileName();
 			#ifdef WINDOWS
 			Fn = Fn.Replace("/","\\");
 			#else
 			Fn = Fn.Replace("\\","/");
 			#endif
 			m->GetProject()->CheckExists(Fn);
 			li->SetText(Fn);
 			Lst->Insert(li);
 		}
 
 		Lst->ResizeColumnsToContent();
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_FILES:
 				if (n.Type == LNotifyItemDoubleClick)
 				{
 					LListItem *i = Lst->GetSelected();
 					if (i)
 					{
 						App->GotoReference(i->GetText(0), 1, false);
 						EndModal(1);
 					}
 				}
 				break;
 			case IDC_TEXT:
 				if (n.Type != LNotifyReturnKey)
 					Search(c->Name());
 				break;
 			case IDCANCEL:
 				EndModal(0);
 				break;
 		}
 
 		return 0;
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////
 char AppName[] = "LgiIde";
 
 char *dirchar(char *s, bool rev = false)
 {
 	if (rev)
 	{
 		char *last = 0;
 		while (s && *s)
 		{
 			if (*s == '/' || *s == '\\')
 				last = s;
 			s++;
 		}
 		return last;
 	}
 	else
 	{
 		while (s && *s)
 		{
 			if (*s == '/' || *s == '\\')
 				return s;
 			s++;
 		}
 	}
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////////////////
 class AppDependency : public LTreeItem
 {
 	char *File;
 	bool Loaded;
 	LTreeItem *Fake;
 
 public:
 	AppDependency(const char *file)
 	{
 		File = NewStr(file);
 		char *d = strrchr(File, DIR_CHAR);
 		Loaded = false;
 		Insert(Fake = new LTreeItem);
 
 		if (LFileExists(File))
 		{
 			SetText(d?d+1:File);
 		}
 		else
 		{
 			char s[256];
 			sprintf(s, "%s (missing)", d?d+1:File);
 			SetText(s);
 		}
 	}
 	
 	~AppDependency()
 	{
 		DeleteArray(File);
 	}
 	
 	char *GetFile()
 	{
 		return File;
 	}
 	
 	void Copy(LStringPipe &p, int Depth = 0)
 	{
 		{
 			char s[1024];
 			ZeroObj(s);
 			memset(s, ' ', Depth * 4);
 			sprintf(s+(Depth*4), "[%c] %s\n", Expanded() ? '-' : '+', GetText(0));
 			p.Push(s);
 		}
 		
 		if (Loaded)
 		{
 			for (LTreeItem *i=GetChild(); i; i=i->GetNext())
 			{
 				((AppDependency*)i)->Copy(p, Depth+1);
 			}
 		}
 	}
 	
 	char *Find(const char *Paths, char *e)
 	{
 		LToken Path(Paths, LGI_PATH_SEPARATOR);
 		for (int p=0; p<Path.Length(); p++)
 		{
 			char Full[256];
 			LMakePath(Full, sizeof(Full), Path[p], e);
 			if (LFileExists(Full))
 			{
 				return NewStr(Full);
 			}
 		}
 		
 		return 0;
 	}
 	
 	char *Find(char *e)
 	{
 		char *s = Find("/lib:/usr/X11R6/lib:/usr/lib", e);
 		if (s) return s;
 
 		char *Env = getenv("LD_LIBRARY_PATH");
 		if (Env)
 		{
 			s = Find(Env, e);
 			if (s) return s;
 		}
 		
 		return 0;
 	}
 
 	void OnExpand(bool b)
 	{
 		if (b && !Loaded)
 		{
 			Loaded = true;
 			DeleteObj(Fake);
 			
 			LStringPipe Out;
 			char Args[256];
 			sprintf(Args, "-d %s", File);
 			
 			LSubProcess p("readelf", Args);
 			if (p.Start())
 			{
 				p.Communicate(&Out);
 
 				char *o = Out.NewStr();
 				// LgiTrace("o=%s\n", o);
 				if (o)
 				{
 					LToken t(o, "\r\n");
 					for (int i=0; i<t.Length(); i++)
 					{
 						char *SharedLib = stristr(t[i], "Shared library:");
 						if (SharedLib &&
 							(SharedLib = strchr(SharedLib, '[')) != 0)
 						{
 							char *e = strchr(++SharedLib, ']');
 							if (e)
 							{
 								*e++ = 0;
 
 								char *Dep = Find(SharedLib);
 								Insert(new AppDependency(Dep?Dep:SharedLib));
 								DeleteArray(Dep);
 							}
 						}
 					}
 					
 					DeleteArray(o);
 				}
 			}
 			else
 			{
 				LgiMsg(Tree, "Couldn't read executable.\n", AppName);
 			}
 		}
 	}
 };
 
 #define IDC_COPY 100
 class Depends : public LDialog
 {
 	AppDependency *Root;
 
 public:
 	Depends(LView *Parent, const char *File)
 	{
 		Root = 0;
 		SetParent(Parent);
 		LRect r(0, 0, 600, 700);
 		SetPos(r);
 		MoveToCenter();
 		Name("Dependencies");
 		
 		LTree *t = new LTree(100, 10, 10, r.X() - 20, r.Y() - 50);
 		if (t)
 		{
 			t->Sunken(true);
 			
 			Root = new AppDependency(File);
 			if (Root)
 			{
 				t->Insert(Root);
 				Root->Expanded(true);
 			}
 			
 			Children.Insert(t);
 			Children.Insert(new LButton(IDC_COPY, 10, t->LView::GetPos().y2 + 10, 60, 20, "Copy"));
 			Children.Insert(new LButton(IDOK, 80, t->LView::GetPos().y2 + 10, 60, 20, "Ok"));
 		}
 		
 		
 		DoModal();
 	}
 	
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_COPY:
 			{
 				if (Root)
 				{
 					LStringPipe p;
 					Root->Copy(p);
 					char *s = p.NewStr();
 					if (s)
 					{
 						LClipBoard c(this);
 						c.Text(s);
 						DeleteArray(s);
 					}
 					break;
 				}
 				break;
 			}			
 			case IDOK:
 			{
 				EndModal(0);
 				break;
 			}
 		}
 		
 		return 0;
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////
 class DebugTextLog : public LTextLog
 {
 public:
 	DebugTextLog(int id) : LTextLog(id)
 	{
 	}
 	
 	void PourText(size_t Start, ssize_t Len) override
 	{
 		auto Ts = LCurrentTime();
 		LTextView3::PourText(Start, Len);
 		auto Dur = LCurrentTime() - Ts;
 		if (Dur > 1500)
 		{
 			// Yo homes, too much text bro...
 			Name(NULL);
 		}
 		else
 		{
 			for (auto l: Line)
 			{
 				char16 *t = Text + l->Start;
 				
 				if (l->Len > 5 && !StrnicmpW(t, L"(gdb)", 5))
 				{
 					l->c.Rgb(0, 160, 0);
 				}
 				else if (l->Len > 1 && t[0] == '[')
 				{
 					l->c.Rgb(192, 192, 192);
 				}
 			}
 		}
 	}
 };
 
 WatchItem::WatchItem(IdeOutput *out, const char *Init)
 {
 	Out = out;
 	Expanded(false);
 	if (Init)
 		SetText(Init);
 	Insert(PlaceHolder = new LTreeItem);
 }
 
 WatchItem::~WatchItem()
 {
 }
 
 bool WatchItem::SetValue(LVariant &v)
 {
 	char *Str = v.CastString();
 	if (ValidStr(Str))
 		SetText(Str, 2);
 	else
 		LTreeItem::SetText(NULL, 2);
 	return true;
 }
 
 bool WatchItem::SetText(const char *s, int i)
 {
 	if (ValidStr(s))
 	{
 		LTreeItem::SetText(s, i);
 
 		if (i == 0 && Tree && Tree->GetWindow())
 		{
 			LViewI *Tabs = Tree->GetWindow()->FindControl(IDC_DEBUG_TAB);
 			if (Tabs)
 				Tabs->SendNotify(LNotifyValueChanged);
 		}
 		return true;
 	}
 
 	if (i == 0)	
 		delete this;
 		
 	return false;
 }
 
 void WatchItem::OnExpand(bool b)
 {
 	if (b && PlaceHolder)
 	{
 		// Do something 
 	}
 }
 
 class BuildLog : public LTextLog
 {
 public:
 	BuildLog(int id) : LTextLog(id)
 	{
 	}
 
 	void PourStyle(size_t Start, ssize_t Length)
 	{
 		List<LTextLine>::I it = LTextView3::Line.begin();
 		for (LTextLine *ln = *it; ln; ln = *++it)
 		{
 			if (!ln->c.IsValid())
 			{
 				char16 *t = Text + ln->Start;
 				char16 *Err = Strnistr(t, L"error", ln->Len);
 				char16 *Undef = Strnistr(t, L"undefined reference", ln->Len);
 				char16 *Warn = Strnistr(t, L"warning", ln->Len);
 				
 				if
 				(
 					(Err && strchr(":[", Err[5]))
 					||
 					(Undef != NULL)
 				)
 					ln->c.Rgb(222, 0, 0);
 				else if (Warn && strchr(":[", Warn[7]))
 					ln->c.Rgb(255, 128, 0);
 				else
 					ln->c = LColour(L_TEXT);
 			}
 		}
 	}
 };
 
 class IdeOutput : public LTabView
 {
 public:
 	AppWnd *App;
 	LTabPage *Build;
 	LTabPage *Output;
 	LTabPage *Debug;
 	LTabPage *Find;
 	LTabPage *Ftp;
 	LList *FtpLog;
 	LTextLog *Txt[AppWnd::Channels::ChannelMax];
 	LArray<char> Buf[AppWnd::Channels::ChannelMax];
 	LFont Small;
 	LFont Fixed;
 
 	LTabView *DebugTab;
 	LBox *DebugBox;
 	LBox *DebugLog;
 	LList *Locals, *CallStack, *Threads;
 	LTree *Watch;
 	LTextLog *ObjectDump, *MemoryDump, *Registers;
 	LTableLayout *MemTable;
 	LEdit *DebugEdit;
 	LTextLog *DebuggerLog;
 
 	IdeOutput(AppWnd *app)
 	{
 		ZeroObj(Txt);
 		App = app;
 		Build = Output = Debug = Find = Ftp = 0;
 		FtpLog = 0;
 		DebugBox = NULL;
 		Locals = NULL;
 		Watch = NULL;
 		DebugLog = NULL;
 		DebugEdit = NULL;
 		DebuggerLog = NULL;
 		CallStack = NULL;
 		ObjectDump = NULL;
 		MemoryDump = NULL;
 		MemTable = NULL;
 		Threads = NULL;
 		Registers = NULL;
 
 		Small = *LSysFont;
 		Small.PointSize(Small.PointSize()-1);
 		Small.Create();
 		LAssert(Small.Handle());
 		
 		LFontType Type;
 		if (Type.GetSystemFont("Fixed"))
 		{
 			Type.SetPointSize(LSysFont->PointSize()-1);
 			Fixed.Create(&Type);
 		}
 		else
 		{
 			Fixed.PointSize(LSysFont->PointSize()-1);
 			Fixed.Face("Courier");
 			Fixed.Create();			
 		}		
 
 		GetCss(true)->MinHeight("60px");
 
 		Build = Append("Build");
 		Output = Append("Output");
 		Find = Append("Find");
 		Ftp = Append("Ftp");
 		Debug = Append("Debug");
 
 		SetFont(&Small);
 		Build->SetFont(&Small);
 		Output->SetFont(&Small);
 		Find->SetFont(&Small);
 		Ftp->SetFont(&Small);
 		Debug->SetFont(&Small);
 			
 		if (Build)
 			Build->Append(Txt[AppWnd::BuildTab] = new BuildLog(IDC_BUILD_LOG));
 		if (Output)
 			Output->Append(Txt[AppWnd::OutputTab] = new LTextLog(IDC_OUTPUT_LOG));
 		if (Find)
 			Find->Append(Txt[AppWnd::FindTab] = new LTextLog(IDC_FIND_LOG));
 		if (Ftp)
 			Ftp->Append(FtpLog = new LList(104, 0, 0, 100, 100));
 		if (Debug)
 		{
 			Debug->Append(DebugBox = new LBox);
 			if (DebugBox)
 			{
 				DebugBox->SetVertical(false);
 					
 				if ((DebugTab = new LTabView(IDC_DEBUG_TAB)))
 				{
 					DebugTab->GetCss(true)->Padding("0px");
 					DebugTab->SetFont(&Small);
 					DebugBox->AddView(DebugTab);
 
 					LTabPage *Page;
 					if ((Page = DebugTab->Append("Locals")))
 					{
 						Page->SetFont(&Small);
 						if ((Locals = new LList(IDC_LOCALS_LIST, 0, 0, 100, 100, "Locals List")))
 						{
 							Locals->SetFont(&Small);
 							Locals->AddColumn("", 30);
 							Locals->AddColumn("Type", 50);
 							Locals->AddColumn("Name", 50);
 							Locals->AddColumn("Value", 1000);
 							Locals->SetPourLargest(true);
 
 							Page->Append(Locals);
 						}
 					}
 					if ((Page = DebugTab->Append("Object")))
 					{
 						Page->SetFont(&Small);
 						if ((ObjectDump = new LTextLog(IDC_OBJECT_DUMP)))
 						{
 							ObjectDump->SetFont(&Fixed);
 							ObjectDump->SetPourLargest(true);
 							Page->Append(ObjectDump);
 						}
 					}
 					if ((Page = DebugTab->Append("Watch")))
 					{
 						Page->SetFont(&Small);
 						if ((Watch = new LTree(IDC_WATCH_LIST, 0, 0, 100, 100, "Watch List")))
 						{
 							Watch->SetFont(&Small);
 							Watch->ShowColumnHeader(true);
 							Watch->AddColumn("Watch", 80);
 							Watch->AddColumn("Type", 100);
 							Watch->AddColumn("Value", 600);
 							Watch->SetPourLargest(true);
 
 							Page->Append(Watch);
 								
 							LXmlTag *w = App->GetOptions()->LockTag("watches", _FL);
 							if (!w)
 							{
 								App->GetOptions()->CreateTag("watches");
 								w = App->GetOptions()->LockTag("watches", _FL);
 							}
 							if (w)
 							{
 								for (auto c: w->Children)
 								{
 									if (c->IsTag("watch"))
 									{
 										Watch->Insert(new WatchItem(this, c->GetContent()));
 									}
 								}
 									
 								App->GetOptions()->Unlock();
 							}
 						}
 					}
 					if ((Page = DebugTab->Append("Memory")))
 					{
 						Page->SetFont(&Small);
 							
 						if ((MemTable = new LTableLayout(IDC_MEMORY_TABLE)))
 						{
 							LCombo *cbo;
 							LCheckBox *chk;
 							LTextLabel *txt;
 							LEdit *ed;
 							MemTable->SetFont(&Small);
 							
 							int x = 0, y = 0;
 							auto *c = MemTable->GetCell(x++, y);
 							if (c)
 							{
 								c->VerticalAlign(LCss::VerticalMiddle);
 								c->Add(txt = new LTextLabel(IDC_STATIC, 0, 0, -1, -1, "Address:"));
 								txt->SetFont(&Small);
 							}
 							c = MemTable->GetCell(x++, y);
 							if (c)
 							{
 								c->PaddingRight(LCss::Len("1em"));
 								c->Add(ed = new LEdit(IDC_MEM_ADDR, 0, 0, 60, 20));
 								ed->SetFont(&Small);
 							}								
 							c = MemTable->GetCell(x++, y);
 							if (c)
 							{
 								c->PaddingRight(LCss::Len("1em"));
 								c->Add(cbo = new LCombo(IDC_MEM_SIZE, 0, 0, 60, 20));
 								cbo->SetFont(&Small);
 								cbo->Insert("1 byte");
 								cbo->Insert("2 bytes");
 								cbo->Insert("4 bytes");
 								cbo->Insert("8 bytes");
 							}
 							c = MemTable->GetCell(x++, y);
 							if (c)
 							{
 								c->VerticalAlign(LCss::VerticalMiddle);
 								c->Add(txt = new LTextLabel(IDC_STATIC, 0, 0, -1, -1, "Page width:"));
 								txt->SetFont(&Small);
 							}
 							c = MemTable->GetCell(x++, y);
 							if (c)
 							{
 								c->PaddingRight(LCss::Len("1em"));
 								c->Add(ed = new LEdit(IDC_MEM_ROW_LEN, 0, 0, 60, 20));
 								ed->SetFont(&Small);
 							}
 							c = MemTable->GetCell(x++, y);								
 							if (c)
 							{
 								c->VerticalAlign(LCss::VerticalMiddle);
 								c->Add(chk = new LCheckBox(IDC_MEM_HEX, 0, 0, -1, -1, "Show Hex"));
 								chk->SetFont(&Small);
 								chk->Value(true);
 							}
 
 							int cols = x;
 							x = 0;
 							c = MemTable->GetCell(x++, ++y, true, cols);
 							if ((MemoryDump = new LTextLog(IDC_MEMORY_DUMP)))
 							{
 								MemoryDump->SetFont(&Fixed);
 								MemoryDump->SetPourLargest(true);
 								c->Add(MemoryDump);
 							}
 
 							Page->Append(MemTable);
 						}
 					}
 					if ((Page = DebugTab->Append("Threads")))
 					{
 						Page->SetFont(&Small);
 						if ((Threads = new LList(IDC_THREADS, 0, 0, 100, 100, "Threads")))
 						{
 							Threads->SetFont(&Small);
 							Threads->AddColumn("", 20);
 							Threads->AddColumn("Thread", 1000);
 							Threads->SetPourLargest(true);
 							Threads->MultiSelect(false);
 
 							Page->Append(Threads);
 						}
 					}
 					if ((Page = DebugTab->Append("Call Stack")))
 					{
 						Page->SetFont(&Small);
 						if ((CallStack = new LList(IDC_CALL_STACK, 0, 0, 100, 100, "Call Stack")))
 						{
 							CallStack->SetFont(&Small);
 							CallStack->AddColumn("", 20);
 							CallStack->AddColumn("Call Stack", 1000);
 							CallStack->SetPourLargest(true);
 							CallStack->MultiSelect(false);
 
 							Page->Append(CallStack);
 						}
 					}
 
 					if ((Page = DebugTab->Append("Registers")))
 					{
 						Page->SetFont(&Small);
 						if ((Registers = new LTextLog(IDC_REGISTERS)))
 						{
 							Registers->SetFont(&Small);
 							Registers->SetPourLargest(true);
 							Page->Append(Registers);
 						}
 					}
 				}
 					
 				if ((DebugLog = new LBox))
 				{
 					DebugLog->SetVertical(true);
 					DebugBox->AddView(DebugLog);
 					DebugLog->AddView(DebuggerLog = new DebugTextLog(IDC_DEBUGGER_LOG));
 					DebuggerLog->SetFont(&Small);
 					DebugLog->AddView(DebugEdit = new LEdit(IDC_DEBUG_EDIT, 0, 0, 60, 20));
 					DebugEdit->GetCss(true)->Height(LCss::Len(LCss::LenPx, (float)(LSysFont->GetHeight() + 8)));
 				}
 			}
 		}
 
 		if (FtpLog)
 		{
 			FtpLog->SetPourLargest(true);
 			FtpLog->Sunken(true);
 			FtpLog->AddColumn("Entry", 1000);
 			FtpLog->ShowColumnHeader(false);
 		}
 
 		for (int n=0; n<CountOf(Txt); n++)
 		{
 			if (!Txt[n])
 				continue;
 			Txt[n]->SetTabSize(8);
 			Txt[n]->Sunken(true);
 		}
 	}
 
 	~IdeOutput()
 	{
 	}
 
 	const char *GetClass()
 	{
 		return "IdeOutput";
 	}
 
 	void Save()
 	{
 		if (Watch)
 		{
 			LXmlTag *w = App->GetOptions()->LockTag("watches", _FL);
 			if (!w)
 			{
 				App->GetOptions()->CreateTag("watches");
 				w = App->GetOptions()->LockTag("watches", _FL);
 			}
 			if (w)
 			{
 				w->EmptyChildren();
 				for (LTreeItem *ti = Watch->GetChild(); ti; ti = ti->GetNext())
 				{
 					LXmlTag *t = new LXmlTag("watch");
 					if (t)
 					{
 						t->SetContent(ti->GetText(0));
 						w->InsertTag(t);
 					}
 				}
 				
 				App->GetOptions()->Unlock();
 			}
 		}
 	}
 	
 	void OnCreate()
 	{
 		SetPulse(1000);
 		AttachChildren();
 	}
 
 	void RemoveAnsi(LArray<char> &a)
 	{
 		char *s = a.AddressOf();
 		char *e = s + a.Length();
 		while (s < e)
 		{
 			if (*s == 0x7)
 			{
 				a.DeleteAt(s - a.AddressOf(), true);
 				s--;
 			}
 			else if
 			(
 				*s == 0x1b
 				&&
 				s[1] >= 0x40
 				&&
 				s[1] <= 0x5f
 			)
 			{
 				// ANSI seq
 				char *end;
 				if (s[1] == '[' &&
 					s[2] == '0' &&
 					s[3] == ';')
 					end = s + 4;
 				else
 				{
 					end = s + 2;
 					while (end < e && !IsAlpha(*end))
 					{
 						end++;
 					}
 					if (*end) end++;
 				}
 
 				auto len = end - s;
 				memmove(s, end, e - end);
 				a.Length(a.Length() - len);
 				s--;
 			}
 			s++;
 		}
 	}
 	
 	void OnPulse()
 	{
 		int Changed = -1;
 
 		for (int Channel = 0; Channel<CountOf(Buf); Channel++)
 		{
 			int64 Size = Buf[Channel].Length();
 			if (Size)
 			{
 				char *Utf = &Buf[Channel][0];
 				LAutoPtr<char16, true> w;
 
 				if (!LIsUtf8(Utf, (ssize_t)Size))
 				{
 					LgiTrace("Ch %i not utf len=" LPrintfInt64 "\n", Channel, Size);
 					
 					// Clear out the invalid UTF?
 					uint8_t *u = (uint8_t*) Utf, *e = u + Size;
 					ssize_t len = Size;
 					LArray<wchar_t> out;
 					while (u < e)
 					{
 						int32 u32 = LgiUtf8To32(u, len);
 						if (u32)
 						{
 							out.Add(u32);
 						}
 						else
 						{
 							out.Add(0xFFFD);
 							u++;
 						}
 					}
 					out.Add(0);
 					w.Reset(out.Release());
 				}
 				else
 				{
 					RemoveAnsi(Buf[Channel]);
 					w.Reset(Utf8ToWide(Utf, (ssize_t)Size));
 				}
 				
 				// auto OldText = Txt[Channel]->NameW();
 				ssize_t OldLen = Txt[Channel]->Length();
 
 				auto Cur = Txt[Channel]->GetCaret();
 				Txt[Channel]->Insert(OldLen, w, StrlenW(w));
 				if (Cur > OldLen - 1)
 					Txt[Channel]->SetCaret(OldLen + StrlenW(w), false);
 				else
 					printf("Caret move: %i, %i = %i\n", (int)Cur, (int)OldLen, Cur > OldLen - 1);
 				Changed = Channel;
 				Buf[Channel].Length(0);
 				Txt[Channel]->Invalidate();
 			}
 		}
 		
 		/*
 		if (Changed >= 0)
 			Value(Changed);
 		*/
 	}
 };
 
 int DocSorter(IdeDoc *a, IdeDoc *b, NativeInt d)
 {
 	auto A = a->GetFileName();
 	auto B = b->GetFileName();
 	if (A && B)
 	{
 		auto Af = strrchr(A, DIR_CHAR);
 		auto Bf = strrchr(B, DIR_CHAR);
 		return stricmp(Af?Af+1:A, Bf?Bf+1:B);
 	}
 	
 	return 0;
 }
 
 struct FileLoc
 {
 	LAutoString File;
 	int Line;
 	
 	void Set(const char *f, int l)
 	{
 		File.Reset(NewStr(f));
 		Line = l;
 	}
 };
 
 class AppWndPrivate
 {
 public:
 	AppWnd *App;
 	LMdiParent *Mdi;
 	LOptionsFile Options;
 	LBox *HBox, *VBox;
 	List<IdeDoc> Docs;
 	List<IdeProject> Projects;
 	LImageList *Icons;
 	LTree *Tree;
 	IdeOutput *Output;
 	bool Debugging;
 	bool Running;
 	bool Building;
 	bool FixBuildWait = false;
 	int RebuildWait = 0;
 	LSubMenu *WindowsMenu;
 	LSubMenu *CreateMakefileMenu;
 	LAutoPtr<FindSymbolSystem> FindSym;
 	LArray<LAutoString> SystemIncludePaths;
 	LArray<LDebugger::BreakPoint> BreakPoints;
 	
 	// Debugging
 	LDebugContext *DbgContext;
 	
 	// Cursor history tracking
 	int HistoryLoc;
 	LArray<FileLoc> CursorHistory;
 	bool InHistorySeek;
 	
 	void SeekHistory(int Direction)
 	{
 		if (CursorHistory.Length())
 		{
 			int Loc = HistoryLoc + Direction;
 			if (Loc >= 0 && Loc < CursorHistory.Length())
 			{
 				HistoryLoc = Loc;
 				FileLoc &Loc = CursorHistory[HistoryLoc];
 				App->GotoReference(Loc.File, Loc.Line, false, false);
 
 				App->DumpHistory();
 			}
 		}
 	}
 	
 	// Find in files
 	LAutoPtr<FindParams> FindParameters;
 	LAutoPtr<FindInFilesThread> Finder;
 	int AppHnd;
 	
 	// Mru
 	LString::Array RecentFiles;
 	LSubMenu *RecentFilesMenu;
 	LString::Array RecentProjects;
 	LSubMenu *RecentProjectsMenu;
 
 	// Object
 	AppWndPrivate(AppWnd *a) :
 		Options(LOptionsFile::DesktopMode, AppName),
 		AppHnd(LEventSinkMap::Dispatch.AddSink(a))
 	{
 		FindSym.Reset(new FindSymbolSystem(AppHnd));
 		HistoryLoc = 0;
 		InHistorySeek = false;
 		WindowsMenu = 0;
 		App = a;
 		HBox = VBox = NULL;
 		Tree = 0;
 		Mdi = NULL;
 		DbgContext = NULL;
 		Output = 0;
 		Debugging = false;
 		Running = false;
 		Building = false;
 		RecentFilesMenu = 0;
 		RecentProjectsMenu = 0;
 
 		Icons = LLoadImageList("icons.png", 16, 16);
 
 		Options.SerializeFile(false);
 		App->SerializeState(&Options, "WndPos", true);
 
 		SerializeStringList("RecentFiles", &RecentFiles, false);
 		SerializeStringList("RecentProjects", &RecentProjects, false);
 	}
 	
 	~AppWndPrivate()
 	{
 		if (RecentFilesMenu)
 			RecentFilesMenu->Empty();
 		if (RecentProjectsMenu)
 			RecentProjectsMenu->Empty();
 
 		FindSym.Reset();
 		Finder.Reset();
 		if (Output)
 			Output->Save();
 		App->SerializeState(&Options, "WndPos", false);
 		SerializeStringList("RecentFiles", &RecentFiles, true);
 		SerializeStringList("RecentProjects", &RecentProjects, true);
 		Options.SerializeFile(true);
 		
 		Docs.DeleteObjects();
 		Projects.DeleteObjects();
 		DeleteObj(Icons);
 	}
 
 	bool FindSource(LAutoString &Full, char *File, char *Context)
 	{
 		if (!LIsRelativePath(File))
 		{
 			Full.Reset(NewStr(File));
 		}
 
 		char *ContextPath = 0;
 		if (Context && !Full)
 		{
 			char *Dir = strrchr(Context, DIR_CHAR);
 			for (auto p: Projects)
 			{
 				ContextPath = p->FindFullPath(Dir?Dir+1:Context);
 				if (ContextPath)
 					break;
 			}
 			
 			if (ContextPath)
 			{
 				LTrimDir(ContextPath);
 				
 				char p[300];
 				LMakePath(p, sizeof(p), ContextPath, File);
 				if (LFileExists(p))
 				{
 					Full.Reset(NewStr(p));
 				}
 			}
 			else
 			{
 				LgiTrace("%s:%i - Context '%s' not found in project.\n", _FL, Context);
 			}
 		}
 
 		if (!Full)
 		{
 			List<IdeProject>::I Projs = Projects.begin();
 			for (IdeProject *p=*Projs; p; p=*++Projs)
 			{
 				LAutoString Base = p->GetBasePath();
 				if (Base)
 				{
 					char Path[MAX_PATH_LEN];
 					LMakePath(Path, sizeof(Path), Base, File);
 					if (LFileExists(Path))
 					{
 						Full.Reset(NewStr(Path));
 						break;
 					}
 				}
 			}
 		}
 		
 		if (!Full)
 		{
 			char *Dir = dirchar(File, true);
 			for (auto p: Projects)
 			{
 				if (Full.Reset(p->FindFullPath(Dir?Dir+1:File)))
 					break;
 			}
 			
 			if (!Full)
 			{
 				if (LFileExists(File))
 				{
 					Full.Reset(NewStr(File));
 				}
 			}
 		}
 		
 		return ValidStr(Full);
 	}
 
 	void ViewMsg(char *File, int Line, char *Context)
 	{
 		LAutoString Full;
 		if (FindSource(Full, File, Context))
 		{
 			App->GotoReference(Full, Line, false);
 		}
 	}
 	
 	#if 1
 		#define LOG_SEEK_MSG(...) printf(__VA_ARGS__)
 	#else
 		#define LOG_SEEK_MSG(...)
 	#endif
 		
 	void GetContext(const char16 *Txt, ssize_t &i, char16 *&Context)
 	{
 		static char16 NMsg[] = L"In file included ";
 		static char16 FromMsg[] = L"from ";
 		auto NMsgLen = StrlenW(NMsg);
 
 		if (Txt[i] != '\n')
 			return;
 
 		if (StrncmpW(Txt + i + 1, NMsg, NMsgLen))
 			return;
 
 		i += NMsgLen + 1;								
 				
 		while (Txt[i])
 		{
 			// Skip whitespace
 			while (Txt[i] && strchr(" \t\r\n", Txt[i]))
 				i++;
 					
 			// Check for 'from'
 			if (StrncmpW(FromMsg, Txt + i, 5))
 				break;
 
 			i += 5;
 			auto Start = Txt + i;
 
 			// Skip to end of doc or line
 			const char16 *Colon = 0;
 			while (Txt[i] && Txt[i] != '\n')
 			{
 				if (Txt[i] == ':' && Txt[i+1] != '\n')
 				{
 					Colon = Txt + i;
 				}
 				i++;
 			}
 			if (Colon)
 			{
 				DeleteArray(Context);
 				Context = NewStrW(Start, Colon-Start);
 			}
 		}
 	}
 
 	template<typename T>
 	bool IsTimeStamp(T *s, ssize_t i)
 	{
 		while (i > 0 && s[i-1] != '\n')
 			i--;
 		auto start = i;
 		while (s[i] && (IsDigit(s[i]) || strchr(" :-", s[i])))
 			i++;
 		LString txt(s + start, i - start);
 		auto parts = txt.SplitDelimit(" :-");
 		return	parts.Length() == 6 &&
 				parts[0].Length() == 4;
 	}
 	
 	template<typename T>
 	bool IsContext(T *s, ssize_t i)
 	{
 		auto key = L"In file included";
 		auto end = i;
 		while (i > 0 && s[i-1] != '\n')
 			i--;
 		if (Strnistr(s + i, key, end - i))
 			return true;
 		
 		return false;
 	}
 
 	#define PossibleLineSep(ch) \
 		( (ch) == ':' || (ch) == '(' )
 		
 	void SeekMsg(int Direction)
 	{
 		LString Comp;
 		IdeProject *p = App->RootProject();
 		if (p)
 			p ->GetSettings()->GetStr(ProjCompiler);
 		// bool IsIAR = Comp.Equals("IAR");
 		
 		if (!Output)
 			return;
 
 		int64 Current = Output->Value();
 		LTextView3 *o = Current < CountOf(Output->Txt) ? Output->Txt[Current] : 0;
 		if (!o)
 			return;
 
 		auto Txt = o->NameW();
 		if (!Txt)
 			return;
 
 		ssize_t Cur = o->GetCaret();
 		char16 *Context = NULL;
 		
 		// Scan forward to the end of file for the next filename/line number separator.
 		ssize_t i;
 		for (i=Cur; Txt[i]; i++)
 		{
 			GetContext(Txt, i, Context);
 						
 			if
 			(
 				PossibleLineSep(Txt[i])
 				&&
 				isdigit(Txt[i+1])
 				&&
 				!IsTimeStamp(Txt, i)
 				&&
 				!IsContext(Txt, i)
 			)
 			{
 				break;
 			}
 		}
 					
 		// If not found then scan from the start of the file for the next filename/line number separator.
 		if (!PossibleLineSep(Txt[i]))
 		{
 			for (i=0; i<Cur; i++)
 			{
 				GetContext(Txt, i, Context);
 							
 				if
 				(
 					PossibleLineSep(Txt[i])
 					&&
 					isdigit(Txt[i+1])
 					&&
 					!IsTimeStamp(Txt, i)
 					&&
 					!IsContext(Txt, i)
 				)
 				{
 					break;
 				}
 			}
 		}
 					
 		// If match found?
 		if (!PossibleLineSep(Txt[i]))
 			return;
 
 		// Scan back to the start of the filename
 		auto Line = i;
 		while (Line > 0 && !strchr("\n>", Txt[Line-1]))
 		{
 			Line--;
 		}
 						
 		// Store the filename
 		LString File(Txt+Line, i-Line);
 		if (!File)
 			return;
 		#if DIR_CHAR == '\\'
 		File = File.Replace("/", "\\");
 		#else
 		File = File.Replace("\\", "/");
 		#endif
 
 		// Scan over the line number..
 		auto NumIndex = ++i;
 		while (isdigit(Txt[NumIndex]))
 			NumIndex++;
 							
 		// Store the line number
 		LString NumStr(Txt + i, NumIndex - i);
 		if (!NumStr)
 			return;
 
 		// Convert it to an integer
 		auto LineNumber = (int)NumStr.Int();
 		o->SetCaret(Line, false);
 		o->SetCaret(NumIndex + 1, true);
 								
 		LString Context8 = Context;
 		ViewMsg(File, LineNumber, Context8);
 	}
 
 	void UpdateMenus()
 	{
 		static const char *None = "(none)";
 
 		if (!App->GetMenu())
 			return; // This happens in GTK during window destruction
 
 		if (RecentFilesMenu)
 		{
 			RecentFilesMenu->Empty();
 
 			if (RecentFiles.Length() == 0)
 				RecentFilesMenu->AppendItem(None, 0, false);
 			else
 			{
 				int n=0;
 				char *f;
 				for (auto It = RecentFiles.begin(); (f = *It); f=*(++It))
 				{
 					for (; f; f=*(++It))
 					{
 						if (LIsUtf8(f))
 							RecentFilesMenu->AppendItem(f, IDM_RECENT_FILE+n++, true);
 						else
 							RecentFiles.Delete(It);
 					}
 				}
 			}
 		}
 
 		if (RecentProjectsMenu)
 		{
 			RecentProjectsMenu->Empty();
 
 			if (RecentProjects.Length() == 0)
 				RecentProjectsMenu->AppendItem(None, 0, false);
 			else
 			{
 				int n=0;
 				char *f;
 				for (auto It = RecentProjects.begin(); (f = *It); f=*(++It))
 				{
 					if (LIsUtf8(f))
 						RecentProjectsMenu->AppendItem(f, IDM_RECENT_PROJECT+n++, true);
 					else
 						RecentProjects.Delete(It);
 				}
 			}
 		}
 		
 		if (WindowsMenu)
 		{
 			WindowsMenu->Empty();
 			Docs.Sort(DocSorter);
 			int n=0;
 			for (auto d: Docs)
 			{
 				const char *File = d->GetFileName();
 				if (!File) File = "(untitled)";
 				char *Dir = strrchr((char*)File, DIR_CHAR);
 				WindowsMenu->AppendItem(Dir?Dir+1:File, IDM_WINDOWS+n++, true);
 			}
 			
 			if (!Docs.Length())
 			{
 				WindowsMenu->AppendItem(None, 0, false);
 			}
 		}
 	}
 
 	void Dump(LString::Array &a)
 	{
 		for (auto i: a)
 			printf("  %s\n", i.Get());
 	}
 	
 	void OnFile(const char *File, bool IsProject = false)
 	{
 		if (!File)
 			return;
 
 		auto *Recent = IsProject ? &RecentProjects : &RecentFiles;
 		for (auto &f: *Recent)
 		{
 			if (f && LFileCompare(f, File) == 0)
 			{
 				f = File;
 				UpdateMenus();
 				return;
 			}
 		}
 
 		Recent->AddAt(0, File);
 		if (Recent->Length() > 10)
 			Recent->Length(10);
 
 		UpdateMenus();
 	}
 	
 	void RemoveRecent(const char *File)
 	{
 		if (File)
 		{
 			LString::Array *Recent[3] = { &RecentProjects, &RecentFiles, 0 };
 			for (int i=0; Recent[i]; i++)
 			{
 				auto &a = *Recent[i];
 				for (size_t n=0; n<a.Length(); n++)
 				{
-					if (stricmp(a[n], File) == 0)
-					{
+					if (!a[n] || stricmp(a[n], File) == 0)
 						a.DeleteAt(n--);
-						break;
-					}
 				}
 			}
 
 			UpdateMenus();
 		}
 	}
 
 	IdeDoc *IsFileOpen(const char *File)
 	{
 		if (!File)
 		{
 			LgiTrace("%s:%i - No input File?\n", _FL);
 			return NULL;
 		}
 		
 		for (auto Doc: Docs)
 		{
 			if (Doc->IsFile(File))
 			{
 				return Doc;
 			}
 		}
 
 		// LgiTrace("%s:%i - '%s' not found in %i docs.\n", _FL, File, Docs.Length());
 		return 0;
 	}
 
 	IdeProject *IsProjectOpen(const char *File)
 	{
 		if (File)
 		{
 			for (auto p: Projects)
 			{
 				if (p->GetFileName() && stricmp(p->GetFileName(), File) == 0)
 				{
 					return p;
 				}
 			}
 		}
 
 		return 0;
 	}
 
 	void SerializeStringList(const char *Opt, LString::Array *Lst, bool Write)
 	{
 		LVariant v;
 		LString Sep = OptFileSeparator;
 		if (Write)
 		{
 			if (Lst->Length() > 0)
 			{
 				auto s = Sep.Join(*Lst);
 				Options.SetValue(Opt, v = s.Get());
 				// printf("Saving '%s' to %s\n", s.Get(), Opt);
 			}
 			else
 				Options.DeleteValue(Opt);
 		}
 		else if (Options.GetValue(Opt, v))
 		{
 			auto files = LString(v.Str()).Split(Sep);
 			Lst->Length(0);
 			for (auto f: files)
 				if (f.Length() > 0)
 					Lst->Add(f);
 			// printf("Reading '%s' to %s, file.len=%i %s\n", v.Str(), Opt, (int)files.Length(), v.Str());
 		}
 		// else printf("%s:%i - No option '%s' to read.\n", _FL, Opt);
 	}
 };
 
 AppWnd::AppWnd()
 {
 	#ifdef __GTK_H__
 	LgiGetResObj(true, AppName);
 	#endif
 	
 	LRect r(0, 0, 1300, 900);
 	SetPos(r);
 	MoveToCenter();
 
 	d = new AppWndPrivate(this);
 
 	Name(AppName);
 	SetQuitOnClose(true);
 
 	#if WINNATIVE
 		SetIcon((char*)MAKEINTRESOURCE(IDI_APP));
 	#else
 		SetIcon("icon64.png");
 	#endif
 
 	if (!Attach(0))
 	{
 		LgiTrace("%s:%i - Attach failed.\n", _FL);
 		return;
 	}
 
     if ((Menu = new LMenu))
 	{
 		Menu->Attach(this);
 		bool Loaded = Menu->Load(this, "IDM_MENU");
 		LAssert(Loaded);
 		if (Loaded)
 		{
 			Menu->SetPrefAndAboutItems(IDM_OPTIONS, IDM_ABOUT);
 			d->RecentFilesMenu = Menu->FindSubMenu(IDM_RECENT_FILES);
 			d->RecentProjectsMenu = Menu->FindSubMenu(IDM_RECENT_PROJECTS);
 			d->WindowsMenu = Menu->FindSubMenu(IDM_WINDOW_LST);
 			d->CreateMakefileMenu = Menu->FindSubMenu(IDM_CREATE_MAKEFILE);
 			if (d->CreateMakefileMenu)
 			{
 				d->CreateMakefileMenu->Empty();
 				for (int i=0; PlatformNames[i]; i++)
 				{
 					d->CreateMakefileMenu->AppendItem(PlatformNames[i], IDM_MAKEFILE_BASE + i);
 				}
 			}
 			else LgiTrace("%s:%i - FindSubMenu failed.\n", _FL);
 
 			LMenuItem *Debug = GetMenu()->FindItem(IDM_DEBUG_MODE);
 			if (Debug)
 			{
 				Debug->Checked(true);
 			}
 			else LgiTrace("%s:%i - FindSubMenu failed.\n", _FL);
 			
 			d->UpdateMenus();
 		}
 	}
 
 	LToolBar *Tools = NULL;
 	if (GdcD->Y() > 1200)
 		Tools = LgiLoadToolbar(this, "cmds-32px.png", 32, 32);
 	else
 		Tools = LgiLoadToolbar(this, "cmds-16px.png", 16, 16);
 	
 	if (Tools)
 	{
 		Tools->AppendButton("New", IDM_NEW, TBT_PUSH, true, CMD_NEW);
 		Tools->AppendButton("Open", IDM_OPEN, TBT_PUSH, true, CMD_OPEN);
 		Tools->AppendButton("Save", IDM_SAVE_ALL, TBT_PUSH, true, CMD_SAVE_ALL);
 		Tools->AppendSeparator();
 		Tools->AppendButton("Cut", IDM_CUT, TBT_PUSH, true, CMD_CUT);
 		Tools->AppendButton("Copy", IDM_COPY, TBT_PUSH, true, CMD_COPY);
 		Tools->AppendButton("Paste", IDM_PASTE, TBT_PUSH, true, CMD_PASTE);
 		Tools->AppendSeparator();
 
 		Tools->AppendButton("Compile", IDM_COMPILE, TBT_PUSH, true, CMD_COMPILE);
 		Tools->AppendButton("Build", IDM_BUILD, TBT_PUSH, true, CMD_BUILD);
 		Tools->AppendButton("Stop", IDM_STOP_BUILD, TBT_PUSH, true, CMD_STOP_BUILD);
 		// Tools->AppendButton("Execute", IDM_EXECUTE, TBT_PUSH, true, CMD_EXECUTE);
 		
 		Tools->AppendSeparator();
 		Tools->AppendButton("Debug", IDM_START_DEBUG, TBT_PUSH, true, CMD_DEBUG);
 		Tools->AppendButton("Pause", IDM_PAUSE_DEBUG, TBT_PUSH, true, CMD_PAUSE);
 		Tools->AppendButton("Restart", IDM_RESTART_DEBUGGING, TBT_PUSH, true, CMD_RESTART);
 		Tools->AppendButton("Kill", IDM_STOP_DEBUG, TBT_PUSH, true, CMD_KILL);
 		Tools->AppendButton("Step Into", IDM_STEP_INTO, TBT_PUSH, true, CMD_STEP_INTO);
 		Tools->AppendButton("Step Over", IDM_STEP_OVER, TBT_PUSH, true, CMD_STEP_OVER);
 		Tools->AppendButton("Step Out", IDM_STEP_OUT, TBT_PUSH, true, CMD_STEP_OUT);
 		Tools->AppendButton("Run To", IDM_RUN_TO, TBT_PUSH, true, CMD_RUN_TO);
 
 		Tools->AppendSeparator();
 		Tools->AppendButton("Find In Files", IDM_FIND_IN_FILES, TBT_PUSH, true, CMD_FIND_IN_FILES);
 		
 		Tools->GetCss(true)->Padding("4px");
 		Tools->Attach(this);
 	}
 	else LgiTrace("%s:%i - No tools obj?", _FL);
 
 	LVariant v = 270, OutPx = 250;
 	d->Options.GetValue(OPT_SPLIT_PX, v);
 	d->Options.GetValue(OPT_OUTPUT_PX, OutPx);
 
 	AddView(d->VBox = new LBox);
 	d->VBox->SetVertical(true);
 
 	d->HBox = new LBox;
 	d->VBox->AddView(d->HBox);
 	d->VBox->AddView(d->Output = new IdeOutput(this));
 
 	d->HBox->AddView(d->Tree = new IdeTree);
 	if (d->Tree)
 	{
 		d->Tree->SetImageList(d->Icons, false);
 		d->Tree->Sunken(false);
 	}
 	d->HBox->AddView(d->Mdi = new LMdiParent);
 	if (d->Mdi)
 	{
 		d->Mdi->HasButton(true);
 	}
 
 	d->HBox->Value(MAX(v.CastInt32(), 20));
 
 	LRect c = GetClient();
 	if (c.Y() > OutPx.CastInt32())
 	{
 		auto Px = OutPx.CastInt32();
 		LCss::Len y(LCss::LenPx, (float)MAX(Px, 120));
 		d->Output->GetCss(true)->Height(y);
 	}
 
 	AttachChildren();
 	OnPosChange();
 
 	UpdateState();
 	
 	Visible(true);
 	DropTarget(true);
 
 	SetPulse(1000);
 	
 	#ifdef LINUX
 	LFinishXWindowsStartup(this);
 	#endif
 	
 	#if USE_HAIKU_PULSE_HACK
 	if (d->Output)
 		d->Output->SetPulse(1000);
 	#endif
 }
 
 AppWnd::~AppWnd()
 {
 	if (d->HBox)
 	{
 		LVariant v = d->HBox->Value();
 		d->Options.SetValue(OPT_SPLIT_PX, v);
 	}
 	if (d->Output)
 	{
 		LVariant v = d->Output->Y();
 		d->Options.SetValue(OPT_OUTPUT_PX, v);
 	}
 
 	ShutdownFtpThread();
 
 	CloseAll();
 	
 	LAppInst->AppWnd = 0;
 	DeleteObj(d);
 }
 
 void AppWnd::OnPulse()
 {
 	IdeDoc *Top = TopDoc();
 	if (Top)
 		Top->OnPulse();
 
 	if (d->FixBuildWait)
 	{
 		d->FixBuildWait = false;
 		if (OnFixBuildErrors() > 0)
 			d->RebuildWait = 3;
 	}
 	else if (d->RebuildWait > 0)
 	{
 		if (--d->RebuildWait == 0)
 			Build();
 	}
 }
 
 LDebugContext *AppWnd::GetDebugContext()
 {
 	return d->DbgContext;
 }
 
 struct DumpBinThread : public LThread
 {
 	LStream *Out;
 	LString InFile;
 	bool IsLib;
 
 public:
 	DumpBinThread(LStream *out, LString file) : LThread("DumpBin.Thread")
 	{
 		Out = out;
 		InFile = file;
 		DeleteOnExit = true;
 
 		auto Ext = LGetExtension(InFile);
 		IsLib = Ext && !stricmp(Ext, "lib");
 
 		Run();
 	}
 
 	bool DumpBin(LString Args, LStream *Str)
 	{
 		char Buf[256];
 		ssize_t Rd;
 
 		const char *Prog = "c:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\VC\\bin\\dumpbin.exe";
 		LSubProcess s(Prog, Args);
 		if (!s.Start(true, false))
 		{
 			Out->Print("%s:%i - '%s' doesn't exist.\n", _FL, Prog);
 			return false;
 		}
 
 		while ((Rd = s.Read(Buf, sizeof(Buf))) > 0)
 			Str->Write(Buf, Rd);
 
 		return true;
 	}
 
 	LString::Array Dependencies(const char *Executable, int Depth = 0)
 	{
 		LString Args;
 		LStringPipe p;
 		Args.Printf("/dependents \"%s\"", Executable);
 		DumpBin(Args, &p);
 
 		char Spaces[256];
 		int Len = Depth * 2;
 		memset(Spaces, ' ', Len);
 		Spaces[Len] = 0;
 
 		LString::Array Files;
 		auto Parts = p.NewGStr().Replace("\r", "").Split("\n\n");
 		if (Parts.Length() > 0)
 		{
 			Files = Parts[4].Strip().Split("\n");
 			auto Path = LGetPath();
 			for (size_t i=0; i<Files.Length(); i++)
 			{
 				auto &f = Files[i];
 				f = f.Strip();
 
 				bool Found = false;
 				for (auto s : Path)
 				{
 					LFile::Path c(s);
 					c += f.Get();
 					if (c.IsFile())
 					{
 						f = c.GetFull();
 						Found = true;
 						break;
 					}
 				}
 
 				if (!Found)
 					f += " (not found in path)";
 				else
 				{
 					if (!stristr(f, "\\system32\\") &&
 						!stristr(f, "\\Windows Kits\\") &&
 						!stristr(f, "vcruntime"))
 					{
 						auto Deps = Dependencies(f, Depth + 1);
 						Files.SetFixedLength(false);
 						for (auto s: Deps)
 						{
 							LString p;
 							p.Printf("%s%s", Spaces, s.Get());
 							Files.AddAt(++i, p);
 						}
 					}
 				}
 			}
 		}
 
 		return Files;
 	}
 
 	LString GetArch()
 	{
 		LString Args;
 		LStringPipe p;
 		Args.Printf("/headers \"%s\"", InFile.Get());
 		DumpBin(Args, &p);
 	
 		const char *Key = " machine ";
 		LString Arch;
 		auto Lines = p.NewGStr().SplitDelimit("\r\n");
 		int64 Machine = 0;
 		for (auto &Ln : Lines)
 		{
 			if (Ln.Find(Key) >= 0)
 			{
 				auto p = Ln.Strip().Split(Key);
 				if (p.Length() == 2)
 				{
 					Arch = p[1].Strip("()");
 					Machine = p[0].Int(16);
 				}
 			}
 		}
 
 		if (Machine == 0x14c)
 			Arch += " 32bit";
 		else if (Machine == 0x200)
 			Arch += " 64bit Itanium";
 		else if (Machine == 0x8664)
 			Arch += " 64bit";
 
 		return Arch;
 	}
 
 	LString GetExports()
 	{
 		LString Args;
 		LStringPipe p;
 
 		/*
 		if (IsLib)
 			Args.Printf("/symbols \"%s\"", InFile.Get());
 		else
 		*/
 		Args.Printf("/exports \"%s\"", InFile.Get());
 		DumpBin(Args, &p);
 	
 		LString Exp;
 
 		auto Raw = p.NewGStr().Replace("\r", "");
 		auto Sect = Raw.Split("\n\n");
 
 		#if 0
 
 		// Debug output
 		Exp = Raw;
 
 		#else
 
 		if (IsLib)
 		{
 			for (auto &s : Sect)
 			{
 				if (s.Find("COFF/PE Dumper") >= 0)
 					continue;
 				auto ln = s.Split("\n");
 				if (ln.Length() == 1)
 					continue;
 				
 				for (auto &l: ln)
 					l = l.LStrip();
 
 				Exp = LString("\n").Join(ln);
 				break;
 			}
 		}
 		else
 		{
 			bool Ord = false;
 			for (auto &s : Sect)
 			{
 				if (s.Strip().Find("ordinal") == 0)
 					Ord = true;
 				else if (Ord)
 				{
 					Exp = s;
 					break;
 				}
 				else Ord = false;
 			}
 		}
 
 		#endif
 
 		return Exp;
 	}
 
 	int Main()
 	{
 		if (!IsLib)
 		{
 			auto Deps = Dependencies(InFile);
 			if (Deps.Length())
 				Out->Print("Dependencies:\n\t%s\n\n", LString("\n\t").Join(Deps).Get());
 		}
 
 		auto Arch = GetArch();
 		if (Arch)
 			Out->Print("Arch: %s\n\n", Arch.Get());
 
 		auto Exp = GetExports();
 		if (Arch)
 			Out->Print("Exports:\n%s\n\n", Exp.Get());
 		return 0;
 	}
 };
 
 void AppWnd::OnReceiveFiles(LArray<const char*> &Files)
 {
 	for (int i=0; i<Files.Length(); i++)
 	{
 		auto f = Files[i];
 		
 		auto ext = LGetExtension(f);
 		if (ext && !stricmp(ext, "mem"))
 		{
 			NewMemDumpViewer(this, f);
 			return;
 		}
 		else if (ext && !stricmp(ext, "xml"))
 		{
 			if (!OpenProject(f, NULL))
 				OpenFile(f);
 		}
 		else if (LDirExists(f))
 			;
 		else if
 		(
 			LIsFileNameExecutable(f)
 			||
 			(ext != NULL && !stricmp(ext, "lib"))
 		)
 		{
 			// dumpbin /exports csp.dll
 			LFile::Path Docs(LSP_USER_DOCUMENTS);
 			LString Name;
 			Name.Printf("%s.txt", Files[i]);
 			Docs += Name;
 			IdeDoc *Doc = NewDocWnd(NULL, NULL);
 			if (Doc)
 			{
 				Doc->SetFileName(Docs, false);
 				new DumpBinThread(Doc, Files[i]);
 			}
 		}
 		else
 		{
 			OpenFile(f);
 		}
 	}
 	
 	Raise();
 	
 	if (LAppInst->GetOption("createMakeFiles"))
 	{
 		IdeProject *p = RootProject();
 		if (p)
 		{
 			p->CreateMakefile(PlatformCurrent, false);
 		}
 	}
 }
 
 void AppWnd::OnDebugState(bool Debugging, bool Running)
 {
 	// Make sure this event is processed in the GUI thread.
 	#if DEBUG_SESSION_LOGGING
 	LgiTrace("AppWnd::OnDebugState(%i,%i) InThread=%i\n", Debugging, Running, InThread());
 	#endif
 	
 	PostEvent(M_DEBUG_ON_STATE, Debugging, Running);
 }
 
 bool IsVarChar(LString &s, ssize_t pos)
 {
 	if (pos < 0)
 		return false;
 	if (pos >= s.Length())
 		return false;
 	char i = s[pos];
 	return IsAlpha(i) || IsDigit(i) || i == '_';
 }
 
 bool ReplaceWholeWord(LString &Ln, LString Word, LString NewWord)
 {
 	ssize_t Pos = 0;
 	bool Status = false;
 
 	while (Pos >= 0)
 	{
 		Pos = Ln.Find(Word, Pos);
 		if (Pos < 0)
 			return Status;
 
 		ssize_t End = Pos + Word.Length();
 		if (!IsVarChar(Ln, Pos-1) && !IsVarChar(Ln, End))
 		{
 			LString NewLn = Ln(0,Pos) + NewWord + Ln(End,-1);
 			Ln = NewLn;
 			Status = true;
 		}
 
 		Pos++;
 	}
 
 	return Status;
 }
 
 struct LFileInfo
 {
 	LString Path;
 	LString::Array Lines;
 	bool Dirty;
 
 	LFileInfo()
 	{
 		Dirty = false;
 	}
 
 	bool Save()
 	{
 		LFile f;
 		if (!f.Open(Path, O_WRITE))
 			return false;
 
 		LString NewFile = LString("\n").Join(Lines);
 
 		f.SetSize(0);
 		f.Write(NewFile);
 
 		f.Close();
 		return true;
 	}
 };
 
 
 int AppWnd::OnFixBuildErrors()
 {
 	LHashTbl<StrKey<char>, LString> Map;
 	LVariant v;
 	if (GetOptions()->GetValue(OPT_RENAMED_SYM, v))
 	{
 		auto Lines = LString(v.Str()).Split("\n");
 		for (auto Ln: Lines)
 		{
 			auto p = Ln.SplitDelimit();
 			if (p.Length() == 2)
 				Map.Add(p[0], p[1]);
 		}
 	}
 
 	LString Raw = d->Output->Txt[AppWnd::BuildTab]->Name();
 	LString::Array Lines = Raw.Split("\n");
 	auto *Log = d->Output->Txt[AppWnd::OutputTab];
 
 	Log->Name(NULL);
 	Log->Print("Parsing errors...\n");
 	int Replacements = 0;
 	LArray<LFileInfo> Files;
 	LHashTbl<StrKey<char>,bool> FixHistory;
 
 	for (int Idx=0; Idx<Lines.Length(); Idx++)
 	{
 		auto Ln = Lines[Idx];
 		auto ErrPos = Ln.Find("error");
 		if (ErrPos >= 0)
 		{
 			#ifdef WINDOWS
 			LString::Array p = Ln.SplitDelimit(">()");
 			#else
 			LString::Array p = Ln(0, ErrPos).Strip().SplitDelimit(":");
 			#endif
 			if (p.Length() <= 2)
 			{
 				Log->Print("Error: Only %i parts? '%s'\n", (int)p.Length(), Ln.Get());
 			}
 			else
 			{
 				#ifdef WINDOWS
 				int Base = p[0].IsNumeric() ? 1 : 0;
 				LString Fn = p[Base];
 				if (Fn.Find("Program Files") >= 0)
 				{
 					Log->Print("Is prog file\n");
 					continue;
 				}
 				auto LineNo = p[Base+1].Int();
 				bool FileNotFound = Ln.Find("Cannot open include file:") > 0;
 				#else
 				LString Fn = p[0];
 				auto LineNo = p[1].Int();
 				bool FileNotFound = false; // fixme
 				#endif
 
 				LAutoString Full;
 				if (!d->FindSource(Full, Fn, NULL))
 				{
 					Log->Print("Error: Can't find Fn='%s' Line=%i\n", Fn.Get(), (int)LineNo);
 					continue;
 				}
 
 				LFileInfo *Fi = NULL;
 				for (auto &i: Files)
 				{
 					if (i.Path.Equals(Full))
 					{
 						Fi = &i;
 						break;
 					}
 				}
 				if (!Fi)
 				{
 					LFile f(Full, O_READ);
 					if (f.IsOpen())
 					{
 						Fi = &Files.New();
 						Fi->Path = Full.Get();
 						auto OldFile = f.Read();
 						Fi->Lines = OldFile.SplitDelimit("\n", -1, false);
 					}
 					else
 					{
 						Log->Print("Error: Can't open '%s'\n", Full.Get());
 					}
 				}
 
 				if (Fi)
 				{
 					LString Loc;
 					Loc.Printf("%s:%i", Full.Get(), (int)LineNo);
 					if (FixHistory.Find(Loc))
 					{
 						// Log->Print("Already fixed %s\n", Loc.Get());
 					}
 					else if (LineNo <= Fi->Lines.Length())
 					{
 						FixHistory.Add(Loc, true);
 
 						if (FileNotFound)
 						{
 							auto n = p.Last().SplitDelimit("\'");
 							auto wrongName = n[1];
 							LFile f(Full, O_READ);
 							auto Lines = f.Read().SplitDelimit("\n", -1, false);
 							f.Close();
 							if (LineNo <= Lines.Length())
 							{
 								auto &errLine = Lines[LineNo-1];
 								auto Pos = errLine.Find(wrongName);
 								
 								/*
 								if (Pos < 0)
 								{
 									for (int i=0; i<Lines.Length(); i++)
 										Log->Print("[%i]=%s\n", i, Lines[i].Get());
 								}
 								*/
 
 								if (Pos > 0)
 								{
 									// Find where it went...
 									LString newPath;
 									for (auto p: d->Projects)
 									{
 										const char *SubStr[] = { ".", "lgi/common" };
 
 										LArray<LString> IncPaths;
 										if (p->BuildIncludePaths(IncPaths, true, false, PlatformCurrent))
 										{
 											for (auto &inc: IncPaths)
 											{
 												for (int sub=0; !newPath && sub<CountOf(SubStr); sub++)
 												{
 													char path[MAX_PATH_LEN];
 													LMakePath(path, sizeof(path), inc, SubStr[sub]);
 													LMakePath(path, sizeof(path), path, wrongName);
 													if (LFileExists(path))
 													{
 														newPath = path + inc.Length() + 1;
 													}
 													else
 													{
 														LString minusFirst = wrongName(1,-1);
 														LMakePath(path, sizeof(path), inc, SubStr[sub]);
 														LMakePath(path, sizeof(path), path, minusFirst);
 														if (LFileExists(path))
 														{
 															newPath = path + inc.Length() + 1;
 														}
 													}
 												}
 											}
 										}
 									}
 
 									if (newPath)
 									{
 										newPath = newPath.Replace("\\", "/"); // Use unix dir chars
 										LString newLine = errLine(0, Pos) + newPath + errLine(Pos + wrongName.Length(), -1);
 										if (newLine == errLine)
 										{
 											Log->Print("Already changed '%s'.\n", wrongName.Get()); 
 										}
 										else
 										{
 											LString backup = LString(Full.Get()) + ".orig";
 											if (LFileExists(backup))
 												FileDev->Delete(backup);
 											LError Err;
 											if (FileDev->Move(Full, backup, &Err))
 											{
 												errLine = newLine;
 												LString newLines = LString("\n").Join(Lines);
 												LFile out(Full, O_WRITE);
 												out.Write(newLines);
 												Log->Print("Fixed '%s'->'%s' on ln %i in %s\n",
 													wrongName.Get(), newPath.Get(),
 													(int)LineNo, Full.Get());
 												Replacements++;
 											}
 											else Log->Print("Error: moving '%s' to backup (%s).\n", Full.Get(), Err.GetMsg().Get());
 										}
 									}
 									else Log->Print("Error: Missing header '%s'.\n", wrongName.Get()); 
 								}
 								else
 								{
 									Log->Print("Error: '%s' not found in line %i of '%s' -> '%s'\n",
 										wrongName.Get(), (int)LineNo,
 										Fn.Get(), Full.Get());
 									// return;
 								}
 							}
 							else Log->Print("Error: Line %i is beyond file lines: %i\n", (int)LineNo, (int)Lines.Length());
 						}
 						else
 						{
 							auto OldReplacements = Replacements;
 							for (auto i: Map)
 							{
 								for (int Offset = 0; (LineNo + Offset >= 1) && Offset >= -1; Offset--)
 								{
 									LString &s = Fi->Lines[LineNo+Offset-1];
 									if (ReplaceWholeWord(s, i.key, i.value))
 									{
 										Log->Print("Renamed '%s' -> '%s' at %s:%i\n", i.key, i.value.Get(), Full.Get(), LineNo+Offset);
 										Fi->Dirty = true;
 										Replacements++;
 										Offset = -2;
 									}
 								}
 							}
 
 							if (OldReplacements == Replacements &&
 								Ln.Find("syntax error: id") > 0)
 							{
 								Log->Print("Unhandled: %s\n", Ln.Get());
 							}
 						}
 					}
 					else
 					{
 						Log->Print("Error: Invalid line %i\n", (int)LineNo);
 					}
 				}
 				else
 				{
 					Log->Print("Error: Fi is NULL\n");
 				}
 			}
 		}
 	}
 
 	for (auto &Fi : Files)
 	{
 		if (Fi.Dirty)
 			Fi.Save();
 	}
 
 	Log->Print("%i replacements made.\n", Replacements);
 	if (Replacements > 0)
 		d->Output->Value(AppWnd::OutputTab);
 
 	return Replacements;
 }
 
 void AppWnd::OnBuildStateChanged(bool NewState)
 {
 	LVariant v;
 	if (!NewState &&
 		GetOptions()->GetValue(OPT_FIX_RENAMED, v) &&
 		v.CastInt32())
 	{
 		d->FixBuildWait = true;
 	}
 }
 
 void AppWnd::UpdateState(int Debugging, int Building)
 {
 	// printf("UpdateState %i %i\n", Debugging, Building);
 	
 	if (Debugging >= 0) d->Debugging = Debugging;
 	if (Building >= 0)
 	{
 		if (d->Building != (Building != 0))
 			OnBuildStateChanged(Building);
 		d->Building = Building;
 	}
 
 	SetCtrlEnabled(IDM_COMPILE, !d->Building);
 	SetCtrlEnabled(IDM_BUILD, !d->Building);
 	SetCtrlEnabled(IDM_STOP_BUILD, d->Building);
 	// SetCtrlEnabled(IDM_RUN, !d->Building);
 	// SetCtrlEnabled(IDM_TOGGLE_BREAKPOINT, !d->Building);
 	
 	SetCtrlEnabled(IDM_START_DEBUG, !d->Debugging && !d->Building);
 	SetCtrlEnabled(IDM_PAUSE_DEBUG, d->Debugging);
 	SetCtrlEnabled(IDM_RESTART_DEBUGGING, d->Debugging);
 	SetCtrlEnabled(IDM_STOP_DEBUG, d->Debugging);
 	SetCtrlEnabled(IDM_STEP_INTO, d->Debugging);
 	SetCtrlEnabled(IDM_STEP_OVER, d->Debugging);
 	SetCtrlEnabled(IDM_STEP_OUT, d->Debugging);
 	SetCtrlEnabled(IDM_RUN_TO, d->Debugging);
 }
 
 void AppWnd::AppendOutput(char *Txt, AppWnd::Channels Channel)
 {
 	if (!d->Output)
 	{
 		LgiTrace("%s:%i - No output panel.\n", _FL);
 		return;
 	}
 	
 	if (Channel < 0 ||
 		Channel >= CountOf(d->Output->Txt))
 	{
 		LgiTrace("%s:%i - Channel range: %i, %i.\n", _FL, Channel, CountOf(d->Output->Txt));
 		return;
 	}
 
 	if (!d->Output->Txt[Channel])
 	{
 		LgiTrace("%s:%i - No log for channel %i.\n", _FL, Channel);
 		return;
 	}
 	
 	if (Txt)
 	{
 		d->Output->Buf[Channel].Add(Txt, strlen(Txt));
 	}
 	else
 	{
 		auto Ctrl = d->Output->Txt[Channel];
 		Ctrl->UnSelectAll();
 		Ctrl->Name("");
 	}
 }
 
 void AppWnd::SaveAll()
 {
 	List<IdeDoc>::I Docs = d->Docs.begin();
 	for (IdeDoc *Doc = *Docs; Doc; Doc = *++Docs)
 	{
 		Doc->SetClean();
 		d->OnFile(Doc->GetFileName());
 	}
 	
 	List<IdeProject>::I Projs = d->Projects.begin();
 	for (IdeProject *Proj = *Projs; Proj; Proj = *++Projs)
 	{
 		Proj->SetClean();
 		d->OnFile(Proj->GetFileName(), true);
 	}
 }
 
 void AppWnd::CloseAll()
 {
 	SaveAll();
 	while (d->Docs[0])
 		delete d->Docs[0];
 	
 	IdeProject *p = RootProject();
 	if (p)
 		DeleteObj(p);
 	
 	while (d->Projects[0])
 		delete d->Projects[0];	
 
 	DeleteObj(d->DbgContext);
 }
 
 bool AppWnd::OnRequestClose(bool IsClose)
 {
 	SaveAll();
 	return LWindow::OnRequestClose(IsClose);
 }
 
 bool AppWnd::OnBreakPoint(LDebugger::BreakPoint &b, bool Add)
 {
 	List<IdeDoc>::I it = d->Docs.begin();
 
 	for (IdeDoc *doc = *it; doc; doc = *++it)
 	{
 		auto fn = doc->GetFileName();
 		bool Match = !Stricmp(fn, b.File.Get());
 		if (Match)
 			doc->AddBreakPoint(b.Line, Add);
 	}
 
 	if (d->DbgContext)
 		d->DbgContext->OnBreakPoint(b, Add);
 	
 	return true;
 }
 
 bool AppWnd::LoadBreakPoints(IdeDoc *doc)
 {
 	if (!doc)
 		return false;
 
 	auto fn = doc->GetFileName();
 	for (int i=0; i<d->BreakPoints.Length(); i++)
 	{
 		LDebugger::BreakPoint &b = d->BreakPoints[i];
 		if (!_stricmp(fn, b.File))
 		{
 			doc->AddBreakPoint(b.Line, true);
 		}
 	}
 
 	return true;
 }
 
 bool AppWnd::LoadBreakPoints(LDebugger *db)
 {
 	if (!db)
 		return false;
 
 	for (int i=0; i<d->BreakPoints.Length(); i++)
 	{
 		LDebugger::BreakPoint &bp = d->BreakPoints[i];
 		db->SetBreakPoint(&bp);
 	}
 
 	return true;
 }
 
 bool AppWnd::ToggleBreakpoint(const char *File, ssize_t Line)
 {
 	bool DeleteBp = false;
 
 	for (int i=0; i<d->BreakPoints.Length(); i++)
 	{
 		LDebugger::BreakPoint &b = d->BreakPoints[i];
 		if (!_stricmp(File, b.File) &&
 			b.Line == Line)
 		{
 			OnBreakPoint(b, false);
 			d->BreakPoints.DeleteAt(i);
 			DeleteBp = true;
 			break;
 		}
 	}
 	
 	if (!DeleteBp)
 	{
 		LDebugger::BreakPoint &b = d->BreakPoints.New();
 		b.File = File;
 		b.Line = Line;
 		OnBreakPoint(b, true);
 	}
 	
 	return true;
 }
 
 void AppWnd::DumpHistory()
 {
 	#if 0
 	LgiTrace("History %i of %i\n", d->HistoryLoc, d->CursorHistory.Length());
 	for (int i=0; i<d->CursorHistory.Length(); i++)
 	{
 		FileLoc &p = d->CursorHistory[i];		
 		LgiTrace("    [%i] = %s, %i %s\n", i, p.File.Get(), p.Line, d->HistoryLoc == i ? "<-----":"");
 	}
 	#endif
 }
 
 /*
 void CheckHistory(LArray<FileLoc> &CursorHistory)
 {
 	if (CursorHistory.Length() > 0)
 	{
 		FileLoc *loc = &CursorHistory[0];
 		for (unsigned i=CursorHistory.Length(); i<CursorHistory.GetAlloc(); i++)
 		{
 			if ((NativeInt)loc[i].File.Get() == 0xcdcdcdcdcdcdcdcd)
 			{
 				int asd=0;
 			}
 		}
 	}
 }
 */
 
 void AppWnd::OnLocationChange(const char *File, int Line)
 {
 	if (!File)
 		return;
 
 	if (!d->InHistorySeek)
 	{
 		if (d->CursorHistory.Length() > 0)
 		{
 			FileLoc &Last = d->CursorHistory.Last();
 			if (_stricmp(File, Last.File) == 0 && abs(Last.Line - Line) <= 1)
 			{
 				// Previous or next line... just update line number
 				Last.Line = Line;
 				DumpHistory();
 				return;
 			}
 
 			// Add new entry
 			d->HistoryLoc++;
 
 			FileLoc &loc = d->CursorHistory[d->HistoryLoc];
 			#ifdef WIN64
 			if ((NativeInt)loc.File.Get() == 0xcdcdcdcdcdcdcdcd)
 				LAssert(0); // wtf?
 			else
 			#endif
 				loc.Set(File, Line);
 		}
 		else
 		{
 			// Add new entry
 			d->CursorHistory[0].Set(File, Line);
 		}
 
 		// Destroy any history after the current...
 		d->CursorHistory.Length(d->HistoryLoc+1);
 
 		DumpHistory();
 	}
 }
 
 void AppWnd::OnFile(char *File, bool IsProject)
 {
 	d->OnFile(File, IsProject);
 }
 
 IdeDoc *AppWnd::NewDocWnd(const char *FileName, NodeSource *Src)
 {
 	IdeDoc *Doc = new IdeDoc(this, Src, 0);
 	if (Doc)
 	{
 		d->Docs.Insert(Doc);
 
 		LRect p = d->Mdi->NewPos();
 		Doc->LView::SetPos(p);
 		Doc->Attach(d->Mdi);
 		Doc->Focus(true);
 		Doc->Raise();
 
 		if (FileName)
 			d->OnFile(FileName);
 	}
 
 	return Doc;
 }
 
 IdeDoc *AppWnd::GetCurrentDoc()
 {
 	if (d->Mdi)
 		return dynamic_cast<IdeDoc*>(d->Mdi->GetTop());
 	return NULL;
 }
 
 IdeDoc *AppWnd::GotoReference(const char *File, int Line, bool CurIp, bool WithHistory)
 {
 	if (!WithHistory)
 		d->InHistorySeek = true;
 
 	IdeDoc *Doc = File ? OpenFile(File) : GetCurrentDoc();
 	if (Doc)
 	{
 		Doc->SetLine(Line, CurIp);
 		Doc->Focus(true);
 	}
 
 	if (!WithHistory)
 		d->InHistorySeek = false;
 
 	return Doc;			
 }
 
 IdeDoc *AppWnd::FindOpenFile(char *FileName)
 {
 	List<IdeDoc>::I it = d->Docs.begin();
 	for (IdeDoc *i=*it; i; i=*++it)
 	{
 		auto f = i->GetFileName();
 		if (f)
 		{
 			IdeProject *p = i->GetProject();
 			if (p)
 			{
 				LAutoString Base = p->GetBasePath();
 				if (Base)
 				{
 					char Path[MAX_PATH_LEN];
 					if (*f == '.')
 						LMakePath(Path, sizeof(Path), Base, f);
 					else
 						strcpy_s(Path, sizeof(Path), f);
 
 					if (stricmp(Path, FileName) == 0)
 						return i;
 				}
 			}
 			else
 			{
 				if (stricmp(f, FileName) == 0)
 					return i;
 			}
 		}
 	}
 
 	return 0;
 }
 
 IdeDoc *AppWnd::OpenFile(const char *FileName, NodeSource *Src)
 {
 	static bool DoingProjectFind = false;
 	IdeDoc *Doc = 0;
 	
 	const char *File = Src ? Src->GetFileName() : FileName;
 	if (!Src && !ValidStr(File))
 	{
 		LgiTrace("%s:%i - No source or file?\n", _FL);
 		return NULL;
 	}
 	
 	LString FullPath;
 	if (LIsRelativePath(File))
 	{
 		IdeProject *Proj = Src && Src->GetProject() ? Src->GetProject() : RootProject();
 		if (Proj)
 		{
 			List<IdeProject> Projs;
 			Projs.Insert(Proj);
 			Proj->CollectAllSubProjects(Projs);
 
 			for (auto p: Projs)
 			{
 				auto ProjPath = p->GetBasePath();
 				char s[MAX_PATH_LEN];
 				LMakePath(s, sizeof(s), ProjPath, File);
 				
 				LString Path = s;
 				if (p->CheckExists(Path))
 				{
 					FullPath = Path;
 					File = FullPath;
 					break;
 				}
 			}
 		}
 	}
 
 	// Sniff type...
 	bool probablyLgiProj = false;
 	if (!Stricmp(LGetExtension(File), "xml"))
 	{	
 		LFile f(File, O_READ);
 		if (f)
 		{
 			char buf[256];
 			auto rd = f.Read(buf, sizeof(buf));
 			if (rd > 0)
 				probablyLgiProj = Strnistr(buf, "<Project", rd) != NULL;
 		}
 	}
 	
 	if (probablyLgiProj)
 	{
 		CloseAll();
 		if (OpenProject(File, NULL))
 		{
 			return NULL;
 		}
 		// else lets just open it as text...
 	}
 		
 	Doc = d->IsFileOpen(File);
 	if (!Doc)
 	{
 		if (Src)
 		{
 			Doc = NewDocWnd(File, Src);
 		}
 		else if (!DoingProjectFind)
 		{
 			DoingProjectFind = true;
 			List<IdeProject>::I Proj = d->Projects.begin();
 			for (IdeProject *p=*Proj; p && !Doc; p=*++Proj)
 			{
 				p->InProject(LIsRelativePath(File), File, true, &Doc);				
 			}
 			DoingProjectFind = false;
 
 			d->OnFile(File);
 		}
 	}
 
 	if (!Doc && LFileExists(File))
 	{
 		Doc = new IdeDoc(this, 0, File);
 		if (Doc)
 		{
 			Doc->OpenFile(File);
 
 			LRect p = d->Mdi->NewPos();
 			Doc->LView::SetPos(p);
 			d->Docs.Insert(Doc);
 			d->OnFile(File);
 		}
 	}
 
 	if (Doc)
 	{
 		Doc->SetEditorParams(4, 4, true, false);
 		if (!Doc->IsAttached())
 		{
 			Doc->Attach(d->Mdi);
 		}
 
 		Doc->Focus(true);
 		Doc->Raise();
 	}
 	
 	return Doc;
 }
 
 IdeProject *AppWnd::RootProject()
 {
 	IdeProject *Root = 0;
 	
 	for (auto p: d->Projects)
 	{
 		if (!p->GetParentProject())
 		{
 			LAssert(Root == 0);
 			Root = p;
 		}
 	}
 	
 	return Root;
 }
 
 IdeProject *AppWnd::OpenProject(const char *FileName, IdeProject *ParentProj, bool Create, bool Dep)
 {	
 	if (!FileName)
 	{
 		LgiTrace("%s:%i - Error: No filename.\n", _FL);
 		return NULL;
 	}
 	
 	if (d->IsProjectOpen(FileName))
 	{
 		LgiTrace("%s:%i - Warning: Project already open.\n", _FL);
 		return NULL;
 	}
 	
 
 	IdeProject *p = new IdeProject(this);
 	if (!p)
 	{
 		LgiTrace("%s:%i - Error: mem alloc.\n", _FL);
 		return NULL;
 	}
 	
 	LString::Array Inc;
 	p->BuildIncludePaths(Inc, false, false, PlatformCurrent);
 	d->FindSym->SetIncludePaths(Inc);
 
 	p->SetParentProject(ParentProj);
 	
 	ProjectStatus Status = p->OpenFile(FileName);
 	if (Status == OpenOk)
 	{
 		d->Projects.Insert(p);
 		d->OnFile(FileName, true);
 		
 		if (!Dep)
 		{
 			auto d = strrchr(FileName, DIR_CHAR);
 			if (d++)
 			{
 				char n[256];
 				sprintf(n, "%s [%s]", AppName, d);
 				Name(n);						
 			}
 		}
 	}
 	else
 	{
 		LgiTrace("%s:%i - Failed to open '%s'\n", _FL, FileName);
 
 		DeleteObj(p);
 		if (Status == OpenError)
 			d->RemoveRecent(FileName);
 	}
 
 	if (!GetTree()->Selection())
 	{
 		GetTree()->Select(GetTree()->GetChild());
 	}
 
 	GetTree()->Focus(true);
 
 	return p;
 }
 
 LMessage::Result AppWnd::OnEvent(LMessage *m)
 {
 	switch (m->Msg())
 	{
 		case M_MAKEFILES_CREATED:
 		{
 			IdeProject *p = (IdeProject*)m->A();
 			if (p)
 				p->OnMakefileCreated();
 			break;
 		}
 		case M_LAST_MAKEFILE_CREATED:
 		{
 			if (LAppInst->GetOption("exit"))
 				LCloseApp();
 			break;
 		}
 		case M_START_BUILD:
 		{
 			IdeProject *p = RootProject();
 			if (p)
 				p->Build(true, GetBuildMode());
 			else
 				printf("%s:%i - No root project.\n", _FL);
 			break;
 		}
 		case M_BUILD_DONE:
 		{
 			UpdateState(-1, false);
 			
 			IdeProject *p = RootProject();
 			if (p)
 				p->StopBuild();
 			break;
 		}
 		case M_BUILD_ERR:
 		{
 			char *Msg = (char*)m->B();
 			if (Msg)
 			{
 				d->Output->Txt[AppWnd::BuildTab]->Print("Build Error: %s\n", Msg);
 				DeleteArray(Msg);
 			}
 			break;
 		}
 		case M_APPEND_TEXT:
 		{
 			LAutoString Text((char*) m->A());
 			Channels Ch = (Channels) m->B();
 			AppendOutput(Text, Ch);
 			break;
 		}
 		case M_SELECT_TAB:
 		{
 			if (!d->Output)
 				break;
 			d->Output->Value(m->A());
 			break;
 		}
 		case M_DEBUG_ON_STATE:
 		{
 			bool Debugging = m->A();
 			bool Running = m->B();
 
 			if (d->Running != Running)
 			{
 				bool RunToNotRun = d->Running && !Running;
 				
 				d->Running = Running;
 				
 				if (RunToNotRun &&
 					d->Output &&
 					d->Output->DebugTab)
 				{
 					d->Output->DebugTab->SendNotify(LNotifyValueChanged);
 				}
 			}
 			if (d->Debugging != Debugging)
 			{
 				d->Debugging = Debugging;
 				if (!Debugging)
 				{
 					IdeDoc::ClearCurrentIp();
 					IdeDoc *c = GetCurrentDoc();
 					if (c)
 						c->UpdateControl();
 						
 					// Shutdown the debug context and free the memory
 					DeleteObj(d->DbgContext);
 				}
 			}
 			
 			SetCtrlEnabled(IDM_START_DEBUG, !Debugging || !Running);
 			SetCtrlEnabled(IDM_PAUSE_DEBUG, Debugging && Running);
 			SetCtrlEnabled(IDM_RESTART_DEBUGGING, Debugging);
 			SetCtrlEnabled(IDM_STOP_DEBUG, Debugging);
 
 			SetCtrlEnabled(IDM_STEP_INTO, Debugging && !Running);
 			SetCtrlEnabled(IDM_STEP_OVER, Debugging && !Running);
 			SetCtrlEnabled(IDM_STEP_OUT, Debugging && !Running);
 			SetCtrlEnabled(IDM_RUN_TO, Debugging && !Running);
 			break;
 		}
 		default:
 		{
 			if (d->DbgContext)
 				d->DbgContext->OnEvent(m);
 			break;
 		}
 	}
 
 	return LWindow::OnEvent(m);
 }
 
 bool AppWnd::OnNode(const char *Path, ProjectNode *Node, FindSymbolSystem::SymAction Action)
 {
 	// This takes care of adding/removing files from the symbol search engine.
 	if (!Path || !Node)
 		return false;
 
 	d->FindSym->OnFile(Path, Action, Node->GetPlatforms());
 	return true;
 }
 
 LOptionsFile *AppWnd::GetOptions()
 {
 	return &d->Options;
 }
 
 class Options : public LDialog
 {
 	AppWnd *App;
 	LFontType Font;
 
 public:
 	Options(AppWnd *a)
 	{
 		SetParent(App = a);
 		if (LoadFromResource(IDD_OPTIONS))
 		{
 			SetCtrlEnabled(IDC_FONT, false);
 			MoveToCenter();
 			
 			if (!Font.Serialize(App->GetOptions(), OPT_EditorFont, false))
 			{
 				Font.GetSystemFont("Fixed");
 			}			
 			char s[256];
 			if (Font.GetDescription(s, sizeof(s)))
 			{
 				SetCtrlName(IDC_FONT, s);
 			}
 
 			LVariant v;
 			if (App->GetOptions()->GetValue(OPT_Jobs, v))
 				SetCtrlValue(IDC_JOBS, v.CastInt32());
 			else
 				SetCtrlValue(IDC_JOBS, 2);
 			
 			DoModal();
 		}
 	}
 	
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDOK:
 			{
 				LVariant v;
 				Font.Serialize(App->GetOptions(), OPT_EditorFont, true);
 				App->GetOptions()->SetValue(OPT_Jobs, v = GetCtrlValue(IDC_JOBS));
 			}
 			case IDCANCEL:
 			{
 				EndModal(c->GetId());
 				break;
 			}
 			case IDC_SET_FONT:
 			{
 				if (Font.DoUI(this))
 				{
 					char s[256];
 					if (Font.GetDescription(s, sizeof(s)))
 					{
 						SetCtrlName(IDC_FONT, s);
 					}
 				}
 				break;
 			}
 		}
 		return 0;
 	}
 };
 
 void AppWnd::UpdateMemoryDump()
 {
 	if (d->DbgContext)
 	{
 		const char *sWord = GetCtrlName(IDC_MEM_SIZE);
 		int iWord = sWord ? atoi(sWord) : 1;
 		int64 RowLen = GetCtrlValue(IDC_MEM_ROW_LEN);
 		bool InHex = GetCtrlValue(IDC_MEM_HEX) != 0;
 
 		d->DbgContext->FormatMemoryDump(iWord, (int)RowLen, InHex);
 	}
 }
 
 int AppWnd::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_PROJECT_TREE:
 		{
 			if (n.Type == LNotifyDeleteKey)
 			{
 				ProjectNode *n = dynamic_cast<ProjectNode*>(d->Tree->Selection());
 				if (n)
 					n->Delete();
 			}
 			break;
 		}
 		case IDC_DEBUG_EDIT:
 		{
 			if (n.Type == LNotifyReturnKey && d->DbgContext)
 			{
 				const char *Cmd = Ctrl->Name();
 				if (Cmd)
 				{
 					d->DbgContext->OnUserCommand(Cmd);
 					Ctrl->Name(NULL);
 				}
 			}
 			break;
 		}
 		case IDC_MEM_ADDR:
 		{
 			if (n.Type == LNotifyReturnKey)
 			{
 				if (d->DbgContext)
 				{
 					const char *s = Ctrl->Name();
 					if (s)
 					{
 						auto sWord = GetCtrlName(IDC_MEM_SIZE);
 						int iWord = sWord ? atoi(sWord) : 1;
 						d->DbgContext->OnMemoryDump(s, iWord, (int)GetCtrlValue(IDC_MEM_ROW_LEN), GetCtrlValue(IDC_MEM_HEX) != 0);
 					}
 					else if (d->DbgContext->MemoryDump)
 					{
 						d->DbgContext->MemoryDump->Print("No address specified.");
 					}
 					else
 					{
 						LAssert(!"No MemoryDump.");
 					}
 				}
 				else LAssert(!"No debug context.");
 			}
 			break;
 		}
 		case IDC_MEM_ROW_LEN:
 		{
 			if (n.Type == LNotifyReturnKey)
 				UpdateMemoryDump();
 			break;
 		}
 		case IDC_MEM_HEX:
 		case IDC_MEM_SIZE:
 		{
 			UpdateMemoryDump();
 			break;
 		}
 		case IDC_DEBUG_TAB:
 		{
 			if (d->DbgContext && n.Type == LNotifyValueChanged)
 			{
 				switch (Ctrl->Value())
 				{
 					case AppWnd::LocalsTab:
 					{
 						d->DbgContext->UpdateLocals();
 						break;
 					}
 					case AppWnd::WatchTab:
 					{
 						d->DbgContext->UpdateWatches();
 						break;
 					}
 					case AppWnd::RegistersTab:
 					{
 						d->DbgContext->UpdateRegisters();
 						break;
 					}
 					case AppWnd::CallStackTab:
 					{
 						d->DbgContext->UpdateCallStack();
 						break;
 					}
 					case AppWnd::ThreadsTab:
 					{
 						d->DbgContext->UpdateThreads();
 						break;
 					}
 					default:
 						break;
 				}
 			}
 			break;
 		}
 		case IDC_LOCALS_LIST:
 		{
 			if (d->Output->Locals &&
 				n.Type == LNotifyItemDoubleClick &&
 				d->DbgContext)
 			{
 				LListItem *it = d->Output->Locals->GetSelected();
 				if (it)
 				{
 					const char *Var = it->GetText(2);
 					const char *Val = it->GetText(3);
 					if (Var)
 					{
 						if (d->Output->DebugTab)
 							d->Output->DebugTab->Value(AppWnd::ObjectTab);
 							
 						d->DbgContext->DumpObject(Var, Val);
 					}
 				}
 			}
 			break;
 		}
 		case IDC_CALL_STACK:
 		{
 			if (n.Type == LNotifyValueChanged)
 			{
 				if (d->Output->DebugTab)
 					d->Output->DebugTab->Value(AppWnd::CallStackTab);
 			}
 			else if (n.Type == LNotifyItemSelect)
 			{
 				// This takes the user to a given call stack reference
 				if (d->Output->CallStack && d->DbgContext)
 				{
 					LListItem *item = d->Output->CallStack->GetSelected();
 					if (item)
 					{
 						LAutoString File;
 						int Line;
 						if (d->DbgContext->ParseFrameReference(item->GetText(1), File, Line))
 						{
 							LAutoString Full;
 							if (d->FindSource(Full, File, NULL))
 							{
 								GotoReference(Full, Line, false);
 								
 								const char *sFrame = item->GetText(0);
 								if (sFrame && IsDigit(*sFrame))
 									d->DbgContext->SetFrame(atoi(sFrame));
 							}
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDC_WATCH_LIST:
 		{
 			WatchItem *Edit = NULL;
 			switch (n.Type)
 			{
 				case LNotifyDeleteKey:
 				{
 					LArray<LTreeItem *> Sel;
 					for (LTreeItem *c = d->Output->Watch->GetChild(); c; c = c->GetNext())
 					{
 						if (c->Select())
 							Sel.Add(c);
 					}
 					Sel.DeleteObjects();
 					break;
 				}
 				case LNotifyItemClick:
 				{
 					Edit = dynamic_cast<WatchItem*>(d->Output->Watch->Selection());
 					break;
 				}
 				case LNotifyContainerClick:
 				{
 					// Create new watch.
 					Edit = new WatchItem(d->Output);
 					if (Edit)
 						d->Output->Watch->Insert(Edit);
 					break;
 				}
 				default:
 					break;
 			}
 			
 			if (Edit)
 				Edit->EditLabel(0);
 			break;
 		}
 		case IDC_THREADS:
 		{
 			if (n.Type == LNotifyItemSelect)
 			{
 				// This takes the user to a given thread
 				if (d->Output->Threads && d->DbgContext)
 				{
 					LListItem *item = d->Output->Threads->GetSelected();
 					if (item)
 					{
 						LString sId = item->GetText(0);
 						int ThreadId = (int)sId.Int();
 						if (ThreadId > 0)
 						{
 							d->DbgContext->SelectThread(ThreadId);
 						}
 					}
 				}
 			}
 			break;
 		}
 	}
 	
 	return 0;
 }
 
 bool AppWnd::Build()
 {
 	SaveAll();
 	
 	IdeDoc *Top;
 	IdeProject *p = RootProject();
 	if (p)
 	{		
 		UpdateState(-1, true);
 
 		p->Build(false, GetBuildMode());
 
 		return true;
 	}
 	else if ((Top = TopDoc()))
 	{
 		return Top->Build();
 	}
 
 	return false;
 }
 
 class RenameDlg : public LDialog
 {
 	AppWnd *App;
 
 public:
 	static RenameDlg *Inst;
 
 	RenameDlg(AppWnd *a)
 	{
 		Inst = this;
 		SetParent(App = a);
 		MoveSameScreen(a);
 
 		if (LoadFromResource(IDC_RENAME))
 		{
 			LVariant v;
 			if (App->GetOptions()->GetValue(OPT_FIX_RENAMED, v))
 				SetCtrlValue(IDC_FIX_RENAMED, v.CastInt32());
 			if (App->GetOptions()->GetValue(OPT_RENAMED_SYM, v))
 				SetCtrlName(IDC_SYM, v.Str());
 
 			SetAlwaysOnTop(true);
 			DoModeless();
 		}
 	}
 
 	~RenameDlg()
 	{
 		Inst = NULL;
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		switch (c->GetId())
 		{
 			case IDC_APPLY:
 			{
 				LVariant v;
 				App->GetOptions()->SetValue(OPT_RENAMED_SYM, v = GetCtrlName(IDC_SYM));
 				App->GetOptions()->SetValue(OPT_FIX_RENAMED, v = GetCtrlValue(IDC_FIX_RENAMED));
 				App->GetOptions()->SerializeFile(true);
 				break;
 			}
 			case IDC_CLOSE:
 			{
 				EndModeless();
 				break;
 			}
 		}
 		return 0;
 	}
 };
 
 void AppWnd::SeekHistory(int Offset)
 {
 	d->SeekHistory(Offset);
 }
 
 RenameDlg *RenameDlg::Inst = NULL;
 
 bool AppWnd::ShowInProject(const char *Fn)
 {
 	if (!Fn)
 		return false;
 	
 	for (auto p: d->Projects)
 	{
 		ProjectNode *Node = NULL;
 		if (p->FindFullPath(Fn, &Node))
 		{
 			for (LTreeItem *i = Node->GetParent(); i; i = i->GetParent())
 			{
 				i->Expanded(true);
 			}
 			Node->Select(true);
 			Node->ScrollTo();		
 			return true;
 		}	
 	}
 	
 	return false;
 }
 
 int AppWnd::OnCommand(int Cmd, int Event, OsView Wnd)
 {
 	switch (Cmd)
 	{
 		case IDM_EXIT:
 		{
 			LCloseApp();
 			break;
 		}
 		case IDM_OPTIONS:
 		{
 			Options Dlg(this);
 			break;
 		}
 		case IDM_HELP:
 		{
 			LExecute(APP_URL);
 			break;
 		}
 		case IDM_ABOUT:
 		{
 			LAbout a(this,
 					AppName, APP_VER,
 					"\nLGI Integrated Development Environment",
 					"icon128.png",
 					APP_URL,
 					"fret@memecode.com");
 			break;
 		}
 		case IDM_NEW:
 		{
 			IdeDoc *Doc;
 			d->Docs.Insert(Doc = new IdeDoc(this, 0, 0));
 			if (Doc && d->Mdi)
 			{
 				LRect p = d->Mdi->NewPos();
 				Doc->LView::SetPos(p);
 				Doc->Attach(d->Mdi);
 				Doc->Focus(true);
 			}
 			break;
 		}
 		case IDM_OPEN:
 		{
 			LFileSelect s;
 			s.Parent(this);
 			if (s.Open())
 			{
 				OpenFile(s.Name());
 			}
 			break;
 		}
 		case IDM_SAVE_ALL:
 		{
 			SaveAll();
 			break;
 		}
 		case IDM_SAVE:
 		{
 			IdeDoc *Top = TopDoc();
 			if (Top)
 				Top->SetClean();
 			break;
 		}
 		case IDM_SAVEAS:
 		{
 			IdeDoc *Top = TopDoc();
 			if (Top)
 			{
 				LFileSelect s;
 				s.Parent(this);
 				if (s.Save())
 				{
 					Top->SetFileName(s.Name(), true);
 					d->OnFile(s.Name());
 				}
 			}
 			break;
 		}
 		case IDM_CLOSE:
 		{
 			IdeDoc *Top = TopDoc();
 			if (Top)
 			{
 				if (Top->OnRequestClose(false))
 				{
 					Top->Quit();
 				}
 			}
 			DeleteObj(d->DbgContext);
 			break;
 		}
 		case IDM_CLOSE_ALL:
 		{
 			CloseAll();
 			Name(AppName);
 			break;
 		}
 		
 		
 		//
 		// Editor
 		//
 		case IDM_UNDO:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 			{
 				Doc->Undo();
 			}
 			else LgiTrace("%s:%i - No focus doc.\n", _FL);
 			break;
 		}
 		case IDM_REDO:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 			{
 				Doc->Redo();
 			}
 			else LgiTrace("%s:%i - No focus doc.\n", _FL);
 			break;
 		}
 		case IDM_FIND:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 			{
 				Doc->DoFind();
 			}
 			else LgiTrace("%s:%i - No focus doc.\n", _FL);
 			break;
 		}
 		case IDM_FIND_NEXT:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 			{
 				Doc->DoFindNext();
 			}
 			else LgiTrace("%s:%i - No focus doc.\n", _FL);
 			break;
 		}
 		case IDM_REPLACE:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 			{
 				Doc->DoReplace();
 			}
 			else LgiTrace("%s:%i - No focus doc.\n", _FL);
 			break;
 		}
 		case IDM_GOTO:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 				Doc->DoGoto();
 			else
 			{
 				LInput Inp(this, NULL, LLoadString(L_TEXTCTRL_GOTO_LINE, "Goto [file:]line:"), "Goto");
 				if (Inp.DoModal())
 				{
 					LString s = Inp.GetStr();
 					LString::Array p = s.SplitDelimit(":,");
 					if (p.Length() == 2)
 					{
 						LString file = p[0];
 						int line = (int)p[1].Int();
 						GotoReference(file, line, false, true);
 					}
 					else LgiMsg(this, "Error: Needs a file name as well.", AppName);
 				}
 			}
 			break;
 		}
 		case IDM_CUT:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 				Doc->PostEvent(M_CUT);
 			break;
 		}
 		case IDM_COPY:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 				Doc->PostEvent(M_COPY);
 			break;
 		}
 		case IDM_PASTE:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 				Doc->PostEvent(M_PASTE);
 			break;
 		}
 		case IDM_FIND_IN_FILES:
 		{
 			if (!d->Finder)
 			{
 				d->Finder.Reset(new FindInFilesThread(d->AppHnd));
 			}
 			if (d->Finder)
 			{
 				if (!d->FindParameters &&
 					d->FindParameters.Reset(new FindParams))
 				{
 					LVariant var;
 					if (GetOptions()->GetValue(OPT_ENTIRE_SOLUTION, var))
 						d->FindParameters->Type = var.CastInt32() ? FifSearchSolution : FifSearchDirectory;
 				}		
 
 				FindInFiles Dlg(this, d->FindParameters);
 
 				LViewI *Focus = GetFocus();
 				if (Focus)
 				{
 					LTextView3 *Edit = dynamic_cast<LTextView3*>(Focus);
 					if (Edit && Edit->HasSelection())
 					{
 						LAutoString a(Edit->GetSelection());
 						Dlg.Params->Text = a;
 					}
 				}
 				
 				IdeProject *p = RootProject();
 				if (p)
 				{
 					LAutoString Base = p->GetBasePath();
 					if (Base)
 						Dlg.Params->Dir = Base;
 				}
 
 				if (Dlg.DoModal())
 				{
 					if (p && Dlg.Params->Type == FifSearchSolution)
 					{
 						Dlg.Params->ProjectFiles.Length(0);
 
 						
 						List<IdeProject> Projects;
 						Projects.Insert(p);
 						p->GetChildProjects(Projects);
 
 						LArray<ProjectNode*> Nodes;
 						for (auto p: Projects)
 							p->GetAllNodes(Nodes);
 
 						for (unsigned i=0; i<Nodes.Length(); i++)
 						{
 							LString s = Nodes[i]->GetFullPath();
 							if (s)
 								Dlg.Params->ProjectFiles.Add(s);
 						}
 					}
 
 					LVariant var = d->FindParameters->Type == FifSearchSolution;
 					GetOptions()->SetValue(OPT_ENTIRE_SOLUTION, var);
 
 					d->Finder->Stop();
 					d->Finder->PostEvent(FindInFilesThread::M_START_SEARCH, (LMessage::Param) new FindParams(d->FindParameters));
 				}
 			}
 			break;
 		}
 		case IDM_FIND_SYMBOL:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (Doc)
 			{
 				Doc->GotoSearch(IDC_SYMBOL_SEARCH);
 			}
 			else
 			{
 				FindSymResult r = d->FindSym->OpenSearchDlg(this);
 				if (r.File)
 				{
 					GotoReference(r.File, r.Line, false);
 				}
 			}
 			break;
 		}
 		case IDM_GOTO_SYMBOL:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (Doc)
 			{
 				Doc->SearchSymbol();
 			}
 			break;
 		}
 		case IDM_FIND_PROJECT_FILE:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (Doc)
 			{
 				Doc->SearchFile();
 			}
 			else
 			{
 				FindInProject Dlg(this);
 				Dlg.DoModal();
 			}
 			break;
 		}
 		case IDM_FIND_REFERENCES:
 		{
 			LViewI *f = LAppInst->GetFocus();
 			LDocView *doc = dynamic_cast<LDocView*>(f);
 			if (!doc)
 				break;
 
 			ssize_t c = doc->GetCaret();
 			if (c < 0)
 				break;
 
 			LString Txt = doc->Name();
 			char *s = Txt.Get() + c;
 			char *e = s;
 			while (	s > Txt.Get() &&
 					IsSymbolChar(s[-1]))
 				s--;
 			while (*e &&
 					IsSymbolChar(*e))
 				e++;
 			if (e <= s)
 				break;
 
 			LString Word(s, e - s);
 
 			if (!d->Finder)
 				d->Finder.Reset(new FindInFilesThread(d->AppHnd));
 			if (!d->Finder)
 				break;
 
 			IdeProject *p = RootProject();
 			if (!p)
 				break;
 			List<IdeProject> Projects;
 			Projects.Insert(p);
 			p->GetChildProjects(Projects);
 
 			LArray<ProjectNode*> Nodes;
 			for (auto p: Projects)
 				p->GetAllNodes(Nodes);
 
 			LAutoPtr<FindParams> Params(new FindParams);
 			Params->Type = FifSearchSolution;
 			Params->MatchWord = true;
 			Params->Text = Word;
 			for (unsigned i = 0; i < Nodes.Length(); i++)
 			{
 				Params->ProjectFiles.New() = Nodes[i]->GetFullPath();
 			}
 
 			d->Finder->Stop();
 			d->Finder->PostEvent(FindInFilesThread::M_START_SEARCH, (LMessage::Param) Params.Release());
 			break;
 		}
 		case IDM_PREV_LOCATION:
 		{
 			d->SeekHistory(-1);
 			break;
 		}
 		case IDM_NEXT_LOCATION:
 		{
 			d->SeekHistory(1);
 			break;
 		}
 		
 		//
 		// Project
 		//
 		case IDM_NEW_PROJECT:
 		{
 			CloseAll();
 			
 			IdeProject *p;
 			d->Projects.Insert(p = new IdeProject(this));
 			if (p)
 			{
 				p->CreateProject();
 			}
 			break;
 		}
 		case IDM_NEW_PROJECT_TEMPLATE:
 		{
 			NewProjectFromTemplate(this);
 			break;
 		}
 		case IDM_OPEN_PROJECT:
 		{
 			LFileSelect s;
 			s.Parent(this);
 			s.Type("Projects", "*.xml");
 			if (s.Open())
 			{
 				CloseAll();
 				OpenProject(s.Name(), NULL, Cmd == IDM_NEW_PROJECT);
 				if (d->Tree)
 				{
 					d->Tree->Focus(true);
 				}
 			}
 			break;
 		}
 		case IDM_IMPORT_DSP:
 		{
 			IdeProject *p = RootProject();
 			if (p)
 			{
 				LFileSelect s;
 				s.Parent(this);
 				s.Type("Developer Studio Project", "*.dsp");
 				if (s.Open())
 				{
 					p->ImportDsp(s.Name());
 				}
 			}
 			break;
 		}
 		case IDM_RUN:
 		{
 			SaveAll();
 			IdeProject *p = RootProject();
 			if (p)
 			{
 				p->Execute();
 			}
 			break;
 		}
 		case IDM_VALGRIND:
 		{
 			SaveAll();
 			IdeProject *p = RootProject();
 			if (p)
 			{
 				p->Execute(ExeValgrind);
 			}
 			break;
 		}
 		case IDM_FIX_MISSING_FILES:
 		{
 			IdeProject *p = RootProject();
 			if (p)
 				p->FixMissingFiles();
 			else
 				LgiMsg(this, "No project loaded.", AppName);
 			break;
 		}
 		case IDM_FIND_DUPE_SYM:
 		{
 			IdeProject *p = RootProject();
 			if (p)
 				p->FindDuplicateSymbols();
 			else
 				LgiMsg(this, "No project loaded.", AppName);
 			break;
 		}
 		case IDM_RENAME_SYM:
 		{
 			if (!RenameDlg::Inst)
 				new RenameDlg(this);
 			break;
 		}
 		case IDM_START_DEBUG:
 		{
 			SaveAll();
 			IdeProject *p = RootProject();
 			if (!p)
 			{
 				LgiMsg(this, "No project loaded.", "Error");
 				break;
 			}
 
 			LString ErrMsg;
 			if (d->DbgContext)
 			{
 				d->DbgContext->OnCommand(IDM_CONTINUE);
 			}
 			else if ((d->DbgContext = p->Execute(ExeDebug, &ErrMsg)))
 			{
 				d->DbgContext->DebuggerLog = d->Output->DebuggerLog;
 				d->DbgContext->Watch = d->Output->Watch;
 				d->DbgContext->Locals = d->Output->Locals;
 				d->DbgContext->CallStack = d->Output->CallStack;
 				d->DbgContext->Threads = d->Output->Threads;
 				d->DbgContext->ObjectDump = d->Output->ObjectDump;
 				d->DbgContext->Registers = d->Output->Registers;
 				d->DbgContext->MemoryDump = d->Output->MemoryDump;
 				
 				d->DbgContext->OnCommand(IDM_START_DEBUG);
 				
 				d->Output->Value(AppWnd::DebugTab);
 				d->Output->DebugEdit->Focus(true);
 			}
 			else if (ErrMsg)
 			{
 				LgiMsg(this, "Error: %s", AppName, MB_OK, ErrMsg.Get());
 			}
 			break;
 		}
 		case IDM_TOGGLE_BREAKPOINT:
 		{
 			IdeDoc *Cur = GetCurrentDoc();
 			if (Cur)
 				ToggleBreakpoint(Cur->GetFileName(), Cur->GetLine());
 			break;
 		}
 		case IDM_ATTACH_TO_PROCESS:
 		case IDM_PAUSE_DEBUG:
 		case IDM_RESTART_DEBUGGING:
 		case IDM_RUN_TO:
 		case IDM_STEP_INTO:
 		case IDM_STEP_OVER:
 		case IDM_STEP_OUT:
 		{
 			if (d->DbgContext)
 				d->DbgContext->OnCommand(Cmd);
 			break;
 		}
 		case IDM_STOP_DEBUG:
 		{
 			if (d->DbgContext && d->DbgContext->OnCommand(Cmd))
 			{
 				DeleteObj(d->DbgContext);
 			}
 			break;
 		}
 		case IDM_BUILD:
 		{
 			Build();
 			break;			
 		}
 		case IDM_STOP_BUILD:
 		{
 			IdeProject *p = RootProject();
 			if (p)
 				p->StopBuild();
 			break;
 		}
 		case IDM_CLEAN:
 		{
 			SaveAll();
 			IdeProject *p = RootProject();
 			if (p)
 				p->Clean(true, GetBuildMode());
 			break;
 		}
 		case IDM_NEXT_MSG:
 		{
 			d->SeekMsg(1);
 			break;
 		}
 		case IDM_PREV_MSG:
 		{
 			d->SeekMsg(-1);
 			break;
 		}
 		case IDM_DEBUG_MODE:
 		{
 			LMenuItem *Debug = GetMenu()->FindItem(IDM_DEBUG_MODE);
 			LMenuItem *Release = GetMenu()->FindItem(IDM_RELEASE_MODE);
 			if (Debug && Release)
 			{
 				Debug->Checked(true);
 				Release->Checked(false);
 			}
 			break;
 		}
 		case IDM_RELEASE_MODE:
 		{
 			LMenuItem *Debug = GetMenu()->FindItem(IDM_DEBUG_MODE);
 			LMenuItem *Release = GetMenu()->FindItem(IDM_RELEASE_MODE);
 			if (Debug && Release)
 			{
 				Debug->Checked(false);
 				Release->Checked(true);
 			}
 			break;
 		}
 		
 		//
 		// Other
 		//
 		case IDM_LOOKUP_SYMBOLS:
 		{
 			IdeDoc *Cur = GetCurrentDoc();
 			if (Cur)
 			{
 				// LookupSymbols(Cur->Read());
 			}
 			break;
 		}
 		case IDM_DEPENDS:
 		{
 			IdeProject *p = RootProject();
 			if (p)
 			{
 				LString Exe = p->GetExecutable(GetCurrentPlatform());
 				if (LFileExists(Exe))
 				{
 					Depends Dlg(this, Exe);
 				}
 				else
 				{
 					LgiMsg(this, "Couldn't find '%s'\n", AppName, MB_OK, Exe ? Exe.Get() : "<project_executable_undefined>");
 				}
 			}			
 			break;
 		}
 		case IDM_SP_TO_TAB:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (Doc)
 				Doc->ConvertWhiteSpace(true);
 			break;
 		}
 		case IDM_TAB_TO_SP:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (Doc)
 				Doc->ConvertWhiteSpace(false);
 			break;
 		}
 		case IDM_ESCAPE:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (Doc)
 				Doc->EscapeSelection(true);
 			break;
 		}
 		case IDM_DESCAPE:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (Doc)
 				Doc->EscapeSelection(false);
 			break;
 		}
 		case IDM_SPLIT:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (!Doc)
 				break;
 
 			LInput i(this, "", "Separator:", AppName);
 			if (!i.DoModal())
 				break;
 				
 			Doc->SplitSelection(i.GetStr());
 			break;
 		}
 		case IDM_JOIN:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (!Doc)
 				break;
 
 			LInput i(this, "", "Separator:", AppName);
 			if (!i.DoModal())
 				break;
 				
 			Doc->JoinSelection(i.GetStr());
 			break;
 		}
 		case IDM_EOL_LF:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (!Doc)
 				break;
 			Doc->SetCrLf(false);
 			break;
 		}
 		case IDM_EOL_CRLF:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (!Doc)
 				break;
 			Doc->SetCrLf(true);
 			break;
 		}
 		case IDM_LOAD_MEMDUMP:
 		{
 			NewMemDumpViewer(this);
 			break;
 		}
 		case IDM_SYS_CHAR_SUPPORT:
 		{
 			new SysCharSupport(this);
 			break;
 		}
 		default:
 		{
 			LString r = d->RecentFiles[Cmd - IDM_RECENT_FILE];
 			if (r)
 			{
 				auto idx = Cmd - IDM_RECENT_FILE;
 				if (idx > 0)
 				{
 					d->RecentFiles.DeleteAt(idx, true);
 					d->RecentFiles.AddAt(0, r);
 				}
 
 				IdeDoc *f = d->IsFileOpen(r);
 				if (f)
 					f->Raise();
 				else
 					OpenFile(r);
 			}
 
 			LString p = d->RecentProjects[Cmd - IDM_RECENT_PROJECT];
 			if (p)
 			{
 				auto idx = Cmd - IDM_RECENT_PROJECT;
 				if (idx > 0)
 				{
 					d->RecentProjects.DeleteAt(idx, true);
 					d->RecentProjects.AddAt(0, p);
 				}
 			
 				CloseAll();
 				OpenProject(p, NULL, false);
 				if (d->Tree)
 				{
 					d->Tree->Focus(true);
 				}
 			}
 			
 			IdeDoc *Doc = d->Docs[Cmd - IDM_WINDOWS];
 			if (Doc)
 			{
 				Doc->Raise();
 			}
 			
 			IdePlatform PlatIdx = (IdePlatform) (Cmd - IDM_MAKEFILE_BASE);
 			const char *Platform =	PlatIdx >= 0 && PlatIdx < PlatformMax
 									?
 									PlatformNames[Cmd - IDM_MAKEFILE_BASE]
 									:
 									NULL;
 			if (Platform)
 			{
 				IdeProject *p = RootProject();
 				if (p)
 				{
 					p->CreateMakefile(PlatIdx, false);
 				}
 			}
 			break;
 		}
 	}
 	
 	return 0;
 }
 
 LTree *AppWnd::GetTree()
 {
 	return d->Tree;
 }
 
 IdeDoc *AppWnd::TopDoc()
 {
 	return d->Mdi ? dynamic_cast<IdeDoc*>(d->Mdi->GetTop()) : NULL;
 }
 
 LTextView3 *AppWnd::FocusEdit()
 {
 	return dynamic_cast<LTextView3*>(GetWindow()->GetFocus());	
 }
 	
 IdeDoc *AppWnd::FocusDoc()
 {
 	IdeDoc *Doc = TopDoc();
 	if (Doc)
 	{
 		if (Doc->HasFocus())
 		{
 			return Doc;
 		}
 		else
 		{
 			LViewI *f = GetFocus();
 			LgiTrace("%s:%i - Edit doesn't have focus, f=%p %s doc.edit=%s\n",
 				_FL, f, f ? f->GetClass() : 0,
 				Doc->Name());
 		}
 	}
 	
 	return 0;
 }
 
 void AppWnd::OnProjectDestroy(IdeProject *Proj)
 {
 	d->Projects.Delete(Proj);
 }
 
 void AppWnd::OnProjectChange()
 {
 	LArray<LMdiChild*> Views;
 	if (d->Mdi->GetChildren(Views))
 	{
 		for (unsigned i=0; i<Views.Length(); i++)
 		{
 			IdeDoc *Doc = dynamic_cast<IdeDoc*>(Views[i]);
 			if (Doc)
 				Doc->OnProjectChange();
 		}
 	}
 }
 
 void AppWnd::OnDocDestroy(IdeDoc *Doc)
 {
 	if (d)
 	{
 		d->Docs.Delete(Doc);
 		d->UpdateMenus();
 	}
 }
 
 BuildConfig AppWnd::GetBuildMode()
 {
 	LMenuItem *Release = GetMenu()->FindItem(IDM_RELEASE_MODE);
 	if (Release && Release->Checked())
 	{
 		return BuildRelease;
 	}
 
 	return BuildDebug;
 }
 
 LList *AppWnd::GetFtpLog()
 {
 	return d->Output->FtpLog;
 }
 
+LStream *AppWnd::GetOutputLog()
+{
+	return d->Output->Txt[AppWnd::OutputTab];
+}
+
 LStream *AppWnd::GetBuildLog()
 {
 	return d->Output->Txt[AppWnd::BuildTab];
 }
 
 LStream *AppWnd::GetDebugLog()
 {
 	return d->Output->Txt[AppWnd::DebugTab];
 }
 
 void AppWnd::FindSymbol(int ResultsSinkHnd, const char *Sym, bool AllPlatforms)
 {
 	d->FindSym->Search(ResultsSinkHnd, Sym, AllPlatforms);
 }
 
 bool AppWnd::GetSystemIncludePaths(::LArray<LString> &Paths)
 {
 	if (d->SystemIncludePaths.Length() == 0)
 	{
 		#if !defined(WINNATIVE)
 		// echo | gcc -v -x c++ -E -
 		LSubProcess sp1("echo");
 		LSubProcess sp2("gcc", "-v -x c++ -E -");
 		sp1.Connect(&sp2);
 		sp1.Start(true, false);
 		
 		char Buf[256];
 		ssize_t r;
 
 		LStringPipe p;
 		while ((r = sp1.Read(Buf, sizeof(Buf))) > 0)
 		{
 			p.Write(Buf, r);
 		}
 
 		bool InIncludeList = false;
 		while (p.Pop(Buf, sizeof(Buf)))
 		{
 			if (stristr(Buf, "#include"))
 			{
 				InIncludeList = true;
 			}
 			else if (stristr(Buf, "End of search"))
 			{
 				InIncludeList = false;
 			}
 			else if (InIncludeList)
 			{
 				LAutoString a(TrimStr(Buf));
 				d->SystemIncludePaths.New() = a;
 			}
 		}
 		#else
 		char p[MAX_PATH_LEN];
 		LGetSystemPath(LSP_USER_DOCUMENTS, p, sizeof(p));
 		LMakePath(p, sizeof(p), p, "Visual Studio 2008\\Settings\\CurrentSettings.xml");
 		if (LFileExists(p))
 		{
 			LFile f;
 			if (f.Open(p, O_READ))
 			{
 				LXmlTree t;
 				LXmlTag r;
 				if (t.Read(&r, &f))
 				{
 					LXmlTag *Opts = r.GetChildTag("ToolsOptions");
 					if (Opts)
 					{
 						LXmlTag *Projects = NULL;
 						char *Name;
 						for (auto c: Opts->Children)
 						{
 							if (c->IsTag("ToolsOptionsCategory") &&
 								(Name = c->GetAttr("Name")) &&
 								!stricmp(Name, "Projects"))
 							{
 								Projects = c;
 								break;
 							}
 						}
 
 						LXmlTag *VCDirectories = NULL;
 						if (Projects)
 							for (auto c: Projects->Children)
 							{
 								if (c->IsTag("ToolsOptionsSubCategory") &&
 									(Name = c->GetAttr("Name")) &&
 									!stricmp(Name, "VCDirectories"))
 								{
 									VCDirectories = c;
 									break;
 								}
 							}
 
 						if (VCDirectories)
 							for (auto prop: VCDirectories->Children)
 							{
 								if (prop->IsTag("PropertyValue") &&
 									(Name = prop->GetAttr("Name")) &&
 									!stricmp(Name, "IncludeDirectories"))
 								{
 									char *Bar = strchr(prop->GetContent(), '|');
 									LToken t(Bar ? Bar + 1 : prop->GetContent(), ";");
 									for (int i=0; i<t.Length(); i++)
 									{
 										char *s = t[i];
 										d->SystemIncludePaths.New().Reset(NewStr(s));
 									}
 								}
 							}
 					}
 				}
 			}
 		}		
 		#endif
 	}
 	
 	for (int i=0; i<d->SystemIncludePaths.Length(); i++)
 	{
 		Paths.Add(NewStr(d->SystemIncludePaths[i]));
 	}
 	
 	return true;
 }
 
 /*
 class SocketTest : public LWindow, public LThread
 {
 	LTextLog *Log;
 
 public:
 	SocketTest() : LThread("SocketTest")
 	{
 		Log = new LTextLog(100);
 
 		SetPos(LRect(200, 200, 900, 800));
 		Attach(0);
 		Visible(true);
 		Log->Attach(this);
 
 		Run();
 	}
 
 	int Main()
 	{
 		LSocket s;
 		s.SetTimeout(15000);
 		Log->Print("Starting...\n");
 		auto r = s.Open("192.168.1.30", 7000);
 		Log->Print("Open =%i\n", r);
 		return 0;
 	}
 };
 */
 
 class TestView : public LView
 {
 public:
 	TestView()
 	{
 		LRect r(10, 10, 110, 110);
 		SetPos(r);
 	}
 
 	void OnPaint(LSurface *pdc)
 	{
 		pdc->Colour(LColour::Red);
 
 		// pdc->Rectangle();
 		pdc->Line(0, 0, X()-1, Y()-1);
 		pdc->Circle(50, 50, 50);
 	}
 };
 
 class Test : public LWindow
 {
 public:
 	Test()
 	{
 		LRect r(100, 100, 800, 700);
 		SetPos(r);
 		Name("Test");
 		SetQuitOnClose(true);
 
 		if (Attach(0))
 		{
 			AddView(new TestView);
 			AttachChildren();
 			Visible(true);
 		}
 	}
 };
 
 int LgiMain(OsAppArguments &AppArgs)
 {
 	printf("LgiIde v%s\n", APP_VER);
 	LApp a(AppArgs, "LgiIde");
 	if (a.IsOk())
 	{
 		a.AppWnd = new AppWnd;
 		a.Run();
 	}
 
 	return 0;
 }
 
diff --git a/Ide/Code/LgiIde.h b/Ide/Code/LgiIde.h
--- a/Ide/Code/LgiIde.h
+++ b/Ide/Code/LgiIde.h
@@ -1,340 +1,341 @@
 #ifndef _LGI_IDE_H_
 #define _LGI_IDE_H_
 
 //
 // Compiler specific macros:
 //
 //		Microsoft Visual C++: _MSC_VER
 //
 //		GCC: __GNUC__
 //
 #include "lgi/common/DocView.h"
 #include "lgi/common/OptionsFile.h"
 #include "lgi/common/StringClass.h"
 #include "lgi/common/TextView3.h"
 #include "lgi/common/List.h"
 #include "lgi/common/Tree.h"
 
 #include "resdefs.h"
 #include "FindSymbol.h"
 #include "Debugger.h"
 #ifdef WIN32
 #include "resource.h"
 #endif
 
 #define APP_VER					"1.0"
 #define APP_URL					"http://www.memecode.com/lgi/ide"
 
 #define DEBUG_FIND_DEFN			0
 
 #define OptFileSeparator		"\n"
 
 enum IdeMessages
 {
 	M_APPEND_TEXT = M_USER+200, // A=(char*)heapStr, B=(int)tabIndex
 	M_APPEND_STR,
 	M_START_BUILD,
 	M_BUILD_ERR,
 	M_BUILD_DONE,
 	M_DEBUG_ON_STATE,
 	M_MAKEFILES_CREATED,
 	M_LAST_MAKEFILE_CREATED,
 	M_SELECT_TAB, // A=(int)tabIndex
 	
 	/// Find symbol results message:
 	/// LAutoPtr<FindSymRequest> Req((FindSymRequest*)Msg->A());
 	M_FIND_SYM_REQUEST,
 	
 	/// Send a file to the worker thread...
 	/// FindSymbolSystem::SymFileParams *Params = (FindSymbolSystem::SymFileParams*)Msg->A();
 	M_FIND_SYM_FILE,
 
 	/// Send a file to the worker thread...
 	/// LAutoPtr<LString::Array> Paths((LString::Array*)Msg->A());
 	M_FIND_SYM_INC_PATHS,
 
 	/// Styling is finished
 	M_STYLING_DONE,
 };
 
 #define ICON_PROJECT			0
 #define ICON_DEPENDANCY			1
 #define ICON_FOLDER				2
 #define ICON_SOURCE				3
 #define ICON_HEADER				4
 #define ICON_RESOURCE			5
 #define ICON_GRAPHIC			6
 #define ICON_WEB				7
 
 enum IdeIcon
 {
 	CMD_NEW,
 	CMD_OPEN,
 	CMD_SAVE,
 	CMD_CUT,
 	CMD_COPY,
 	CMD_PASTE,
 	CMD_COMPILE,
 	CMD_BUILD,
 	CMD_STOP_BUILD,
 	CMD_EXECUTE,
 	CMD_DEBUG,
 	CMD_PAUSE,
 	CMD_KILL,
 	CMD_RESTART,
 	CMD_RUN_TO,
 	CMD_STEP_INTO,
 	CMD_STEP_OVER,
 	CMD_STEP_OUT,
 	CMD_FIND_IN_FILES,
 	CMD_SEARCH,
 	CMD_SAVE_ALL,
 };
 
 enum IdeControls
 {
 	IDC_STATIC = -1,
 	IDC_WATCH_LIST = 700,
 	IDC_LOCALS_LIST,
 	IDC_DEBUG_EDIT,
 	IDC_DEBUGGER_LOG,
 	IDC_BUILD_LOG,
 	IDC_OUTPUT_LOG,
 	IDC_FIND_LOG,
 	IDC_CALL_STACK,
 	IDC_DEBUG_TAB,
 	IDC_OBJECT_DUMP,
 	IDC_MEMORY_DUMP,
 	IDC_MEMORY_TABLE,
 	IDC_MEM_ADDR,
 	IDC_MEM_SIZE,
 	IDC_MEM_ROW_LEN,
 	IDC_MEM_HEX,
 	IDC_REGISTERS,
 	IDC_THREADS,
 	IDC_EDIT,
 	IDC_FILE_SEARCH,
 	IDC_METHOD_SEARCH,
 	IDC_SYMBOL_SEARCH,
 	IDC_PROJECT_TREE,
 	IDC_ALL_PLATFORMS,
 };
 
 enum IdeMenuCmds
 {
 	IDM_CONTINUE = 900
 };
 
 enum BuildConfig
 {
 	BuildDebug,
 	BuildRelease,
 	BuildMax
 };
 inline const char *toString(BuildConfig c)
 {
 	switch (c)
 	{
 		default:
 		case BuildDebug: return "Debug";
 		case BuildRelease: return "Release";
 	}
 	return "#err";
 }
 
 #define OPT_EditorFont			"EdFont"
 #define OPT_Jobs				"Jobs"
 
 //////////////////////////////////////////////////////////////////////
 // Platform stuff
 enum IdePlatform
 {
 	PlatformCurrent = -1,
 	PlatformWin = 0,		// 0x1
 	PlatformLinux,			// 0x2
 	PlatformMac,			// 0x4
 	PlatformHaiku,			// 0x8
 	PlatformMax,
 };
 #define PLATFORM_WIN32			(1 << PlatformWin)
 #define PLATFORM_LINUX			(1 << PlatformLinux)
 #define PLATFORM_MAC			(1 << PlatformMac)
 #define PLATFORM_HAIKU			(1 << PlatformHaiku)
 #define PLATFORM_ALL			(PLATFORM_WIN32|PLATFORM_LINUX|PLATFORM_MAC|PLATFORM_HAIKU)
 
 #if defined(_WIN32)
 #define PLATFORM_CURRENT		PLATFORM_WIN32
 #elif defined(MAC)
 #define PLATFORM_CURRENT		PLATFORM_MAC
 #elif defined(LINUX)
 #define PLATFORM_CURRENT		PLATFORM_LINUX
 #elif defined(HAIKU)
 #define PLATFORM_CURRENT		PLATFORM_HAIKU
 #endif
 
 extern const char *PlatformNames[];
 extern const char sCurrentPlatform[];
 extern const char *Untitled;
 extern const char SourcePatterns[];
 
 //////////////////////////////////////////////////////////////////////
 class IdeDoc;
 class IdeProject;
 
 extern char AppName[];
 extern char *FindHeader(char *Short, LArray<LString> &Paths);
 extern bool BuildHeaderList(char *Cpp, LArray<char*> &Headers, LArray<LString> &IncPaths, bool Recurse);
 
 class NodeView;
 class NodeSource
 {
 	friend class NodeView;
 
 protected:
 	NodeView *nView;
 
 public:
 	NodeSource()
 	{
 		nView = 0;
 	}
 	virtual ~NodeSource();
 
 	virtual LString GetFullPath() = 0;
 	virtual bool IsWeb() = 0;
 	virtual const char *GetFileName() = 0;
 	virtual const char *GetLocalCache() = 0;
 	virtual const char *GetCharset() = 0;
 	virtual bool Load(LDocView *Edit, NodeView *Callback) = 0;
 	virtual bool Save(LDocView *Edit, NodeView *Callback) = 0;
 	virtual IdeProject *GetProject() = 0;
 };
 
 class NodeView
 {
 	friend class NodeSource;
 
 protected:
 	NodeSource *nSrc;
 
 public:
 	NodeView(NodeSource *s)
 	{
 		if ((nSrc = s))
 		{
 			nSrc->nView = this;
 		}
 	}
 
 	virtual ~NodeView();
 	virtual void OnDelete() = 0;
 	virtual void OnSaveComplete(bool Status) = 0;
 
 	NodeSource *GetSrc() { return nSrc; }
 };
 
 class AppWnd : public LWindow
 {
 	class AppWndPrivate *d;
 	friend class AppWndPrivate;
 
 	void UpdateMemoryDump();
 	void DumpHistory();
 
 public:
 	enum Channels
 	{
 		BuildTab,
 		OutputTab,
 		FindTab,
 		FtpTab,
 		DebugTab,
 		
 		ChannelMax,
 	};
 
 	enum DebugTabs
 	{
 		LocalsTab,
 		ObjectTab,
 		WatchTab,
 		MemoryTab,
 		ThreadsTab,
 		CallStackTab,
 		RegistersTab
 	};
 
 	AppWnd();
 	~AppWnd();
 
 	void SaveAll();
 	void CloseAll();
 	IdeDoc *OpenFile(const char *FileName, NodeSource *Src = 0);
 	IdeDoc *NewDocWnd(const char *FileName, NodeSource *Src);
 	IdeDoc *GetCurrentDoc();
 	IdeProject *OpenProject(const char *FileName, IdeProject *ParentProj, bool Create = false, bool Dep = false);
 	IdeProject *RootProject();
 	IdeDoc *TopDoc();
 	IdeDoc *FocusDoc();
 	LTextView3 *FocusEdit();
 	void AppendOutput(char *Txt, Channels Channel);
 	int OnFixBuildErrors();
 	void OnBuildStateChanged(bool NewState);
 	void UpdateState(int Debugging = -1, int Building = -1);
 	void OnReceiveFiles(LArray<const char*> &Files) override;
 	BuildConfig GetBuildMode();
 	LTree *GetTree();
 	LOptionsFile *GetOptions();
 	LList *GetFtpLog();
+	LStream *GetOutputLog();
 	LStream *GetBuildLog();
 	LStream *GetDebugLog();
 	IdeDoc *FindOpenFile(char *FileName);
 	IdeDoc *GotoReference(const char *File, int Line, bool CurIp, bool WithHistory = true);
 	void FindSymbol(int ResultsSinkHnd, const char *Sym, bool AllPlatforms);
 	bool GetSystemIncludePaths(LArray<LString> &Paths);
 	bool ShowInProject(const char *Fn);
 	bool Build();
 	void SeekHistory(int Offset);
 	
 	// Events
 	void OnLocationChange(const char *File, int Line);
 	int OnCommand(int Cmd, int Event, OsView Wnd) override;
 	void OnDocDestroy(IdeDoc *Doc);
 	void OnProjectDestroy(IdeProject *Proj);
 	void OnProjectChange();
 	void OnFile(char *File, bool IsProject = false);
 	bool OnRequestClose(bool IsClose) override;
 	int OnNotify(LViewI *Ctrl, LNotification n) override;
 	LMessage::Result OnEvent(LMessage *m) override;
 	bool OnNode(const char *Path, class ProjectNode *Node, FindSymbolSystem::SymAction Action);
 	void OnPulse() override;
 
 	// Debugging support
 	class LDebugContext *GetDebugContext();
 	bool ToggleBreakpoint(const char *File, ssize_t Line);
 	bool OnBreakPoint(LDebugger::BreakPoint &b, bool Add);
 	bool LoadBreakPoints(IdeDoc *doc);
 	bool LoadBreakPoints(LDebugger *db);
 	void OnDebugState(bool Debugging, bool Running);
 };
 
 #include "IdeDoc.h"
 #include "IdeProject.h"
 #include "FindInFiles.h"
 
 extern void NewMemDumpViewer(AppWnd *App, const char *file = 0);
 extern void NewProjectFromTemplate(LViewI *parent);
 
 class SysCharSupport : public LWindow
 {
 	class SysCharSupportPriv *d;
 
 public:
 	SysCharSupport(AppWnd *app);
 	~SysCharSupport();
 
 	int OnNotify(LViewI *v, LNotification n);
 	void OnPosChange();
 };
 
 #endif
diff --git a/Lgi_vs2019.vcxproj b/Lgi_vs2019.vcxproj
--- a/Lgi_vs2019.vcxproj
+++ b/Lgi_vs2019.vcxproj
@@ -1,689 +1,470 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
     <ProjectConfiguration Include="Debug|x64">
       <Configuration>Debug</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
-    <ProjectConfiguration Include="ReleaseNoOptimize|Win32">
-      <Configuration>ReleaseNoOptimize</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
     <ProjectConfiguration Include="ReleaseNoOptimize|x64">
       <Configuration>ReleaseNoOptimize</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
     <ProjectConfiguration Include="Release|x64">
       <Configuration>Release</Configuration>
       <Platform>x64</Platform>
     </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">
     <ProjectName>Lgi</ProjectName>
     <ProjectGuid>{95DF9CA4-6D37-4A85-A648-80C2712E0DA1}</ProjectGuid>
     <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
   <Import Project="$(SolutionDir)\Lgi.props" Condition="Exists('$(SolutionDir)\Lgi.props')" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v142</PlatformToolset>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v142</PlatformToolset>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>DynamicLibrary</ConfigurationType>
-    <PlatformToolset>v142</PlatformToolset>
-    <UseOfMfc>false</UseOfMfc>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <UseOfMfc>false</UseOfMfc>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <UseOfMfc>false</UseOfMfc>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
     <ConfigurationType>DynamicLibrary</ConfigurationType>
     <PlatformToolset>v142</PlatformToolset>
     <UseOfMfc>false</UseOfMfc>
     <CharacterSet>Unicode</CharacterSet>
   </PropertyGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
   <ImportGroup Label="ExtensionSettings">
   </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
-  </ImportGroup>
-  <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="PropertySheets">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-    <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
-  </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
     <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
     <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
   </ImportGroup>
   <ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
     <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
     <Import Project="$(VCTargetsPath)Microsoft.CPP.UpgradeFromVC71.props" />
   </ImportGroup>
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup>
     <_ProjectFileVersion>12.0.30501.0</_ProjectFileVersion>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <OutDir>.\Lib\</OutDir>
-    <IntDir>$(Platform)$(Configuration)19\</IntDir>
-    <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..\..\..\CodeLib\libiconv-1.14\include</IncludePath>
-    <TargetName>Lgi19x32</TargetName>
-  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <OutDir>.\Lib\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..\..\..\CodeLib\libiconv-1.14\include</IncludePath>
     <TargetName>Lgi19x64</TargetName>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <OutDir>.\Lib\</OutDir>
-    <IntDir>$(Platform)$(Configuration)19\</IntDir>
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..\..\..\CodeLib\libiconv-1.14\include</IncludePath>
-    <TargetName>Lgi19x32d</TargetName>
-  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <OutDir>.\Lib\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>true</LinkIncremental>
     <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..\..\..\CodeLib\libiconv-1.14\include</IncludePath>
     <TargetName>Lgi19x64d</TargetName>
   </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">
-    <OutDir>.\Lib\</OutDir>
-    <IntDir>$(Platform)$(Configuration)19\</IntDir>
-    <LinkIncremental>false</LinkIncremental>
-    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..\..\..\CodeLib\libiconv-1.14\include</IncludePath>
-    <TargetName>Lgi19x32nop</TargetName>
-  </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">
     <OutDir>.\Lib\</OutDir>
     <IntDir>$(Platform)$(Configuration)19\</IntDir>
     <LinkIncremental>false</LinkIncremental>
     <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);..\..\..\CodeLib\libiconv-1.14\include</IncludePath>
     <TargetName>Lgi19x64nop</TargetName>
   </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Midl>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TargetEnvironment>Win32</TargetEnvironment>
-      <TypeLibraryName>.\Release/Lgi.tlb</TypeLibraryName>
-    </Midl>
-    <ClCompile>
-      <Optimization>MinSpace</Optimization>
-      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
-      <AdditionalIncludeDirectories>include;include\lgi\win;private\common;private\win;..\..\..\CodeLib\libiconv\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>NDEBUG;WIN32;WINDOWS;LGI_RES;LGI_LIBRARY;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <StringPooling>true</StringPooling>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <RuntimeTypeInfo>true</RuntimeTypeInfo>
-      <PrecompiledHeader />
-      <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName).pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
-      <ObjectFileName>$(IntDir)</ObjectFileName>
-      <ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
-      <BrowseInformation />
-      <WarningLevel>Level2</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <CompileAs>Default</CompileAs>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x0c09</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalOptions>/MACHINE:I386 %(AdditionalOptions)</AdditionalOptions>
-      <AdditionalDependencies>ComCtl32.lib;Ws2_32.lib;UxTheme.lib;imm32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ProgramDatabaseFile>$(OutDir)$(TargetName).pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <OptimizeReferences>true</OptimizeReferences>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention />
-      <ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
-    </Link>
-  </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <Midl>
       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MkTypLibCompatible>true</MkTypLibCompatible>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <TargetEnvironment>X64</TargetEnvironment>
       <TypeLibraryName>.\Release/Lgi.tlb</TypeLibraryName>
     </Midl>
     <ClCompile>
       <Optimization>MinSpace</Optimization>
       <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
       <AdditionalIncludeDirectories>include;include\lgi\win;private\common;private\win;..\..\..\CodeLib\libiconv\include;..\..\scribe\libs\build-x64\libiconv-1.17\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN64;NDEBUG;WINDOWS;LGI_RES;LGI_LIBRARY;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <StringPooling>true</StringPooling>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <PrecompiledHeader />
       <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName).pch</PrecompiledHeaderOutputFile>
       <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
       <ObjectFileName>$(IntDir)</ObjectFileName>
       <ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
       <BrowseInformation />
       <WarningLevel>Level2</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <CompileAs>Default</CompileAs>
     </ClCompile>
     <ResourceCompile>
       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <Culture>0x0c09</Culture>
     </ResourceCompile>
     <Link>
       <AdditionalDependencies>ComCtl32.lib;Ws2_32.lib;UxTheme.lib;imm32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <ProgramDatabaseFile>$(OutDir)$(TargetName).pdb</ProgramDatabaseFile>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
       <TargetMachine>MachineX64</TargetMachine>
     </Link>
   </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Midl>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TargetEnvironment>Win32</TargetEnvironment>
-      <TypeLibraryName>.\Debug/Lgi.tlb</TypeLibraryName>
-    </Midl>
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <AdditionalIncludeDirectories>include;include\lgi\win;private\common;private\win;..\..\..\CodeLib\libiconv\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>LGI_LIBRARY;_DEBUG;WIN32;WINDOWS;LGI_RES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
-      <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
-      <RuntimeTypeInfo>true</RuntimeTypeInfo>
-      <PrecompiledHeader />
-      <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName).pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
-      <ObjectFileName>$(IntDir)</ObjectFileName>
-      <ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
-      <BrowseInformation />
-      <WarningLevel>Level2</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <CompileAs>Default</CompileAs>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x0c09</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalOptions>/MACHINE:I386 %(AdditionalOptions)</AdditionalOptions>
-      <AdditionalDependencies>ComCtl32.lib;Ws2_32.lib;UxTheme.lib;imm32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ProgramDatabaseFile>$(OutDir)$(TargetName).pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention />
-      <ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
-    </Link>
-  </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <Midl>
       <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MkTypLibCompatible>true</MkTypLibCompatible>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <TargetEnvironment>X64</TargetEnvironment>
       <TypeLibraryName>.\Debug/Lgi.tlb</TypeLibraryName>
     </Midl>
     <ClCompile>
       <Optimization>Disabled</Optimization>
       <AdditionalIncludeDirectories>include;include\lgi\win;private\common;private\win;..\..\..\CodeLib\libiconv\include;..\..\scribe\libs\build-x64\libiconv-1.17\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN64;LGI_LIBRARY;_DEBUG;WINDOWS;LGI_RES;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <BasicRuntimeChecks>EnableFastChecks</BasicRuntimeChecks>
       <RuntimeLibrary>MultiThreadedDebugDLL</RuntimeLibrary>
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <PrecompiledHeader />
       <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName).pch</PrecompiledHeaderOutputFile>
       <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
       <ObjectFileName>$(IntDir)</ObjectFileName>
       <ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
       <BrowseInformation />
       <WarningLevel>Level3</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <CompileAs>Default</CompileAs>
     </ClCompile>
     <ResourceCompile>
       <PreprocessorDefinitions>_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <Culture>0x0c09</Culture>
     </ResourceCompile>
     <Link>
       <AdditionalDependencies>ComCtl32.lib;Ws2_32.lib;UxTheme.lib;imm32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <ShowProgress>NotSet</ShowProgress>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <ProgramDatabaseFile>$(OutDir)$(TargetName).pdb</ProgramDatabaseFile>
       <SubSystem>Windows</SubSystem>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
       <TargetMachine>MachineX64</TargetMachine>
     </Link>
   </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">
-    <Midl>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <MkTypLibCompatible>true</MkTypLibCompatible>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <TargetEnvironment>Win32</TargetEnvironment>
-      <TypeLibraryName>.\Release/Lgi.tlb</TypeLibraryName>
-    </Midl>
-    <ClCompile>
-      <Optimization>Disabled</Optimization>
-      <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
-      <AdditionalIncludeDirectories>include;include\lgi\win;private\common;private\win;..\..\..\CodeLib\libiconv\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
-      <PreprocessorDefinitions>NDEBUG;WIN32;WINDOWS;LGI_RES;LGI_LIBRARY;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <StringPooling>true</StringPooling>
-      <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <RuntimeTypeInfo>true</RuntimeTypeInfo>
-      <PrecompiledHeader />
-      <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName).pch</PrecompiledHeaderOutputFile>
-      <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
-      <ObjectFileName>$(IntDir)</ObjectFileName>
-      <ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
-      <BrowseInformation />
-      <WarningLevel>Level2</WarningLevel>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
-      <CompileAs>Default</CompileAs>
-    </ClCompile>
-    <ResourceCompile>
-      <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <Culture>0x0c09</Culture>
-    </ResourceCompile>
-    <Link>
-      <AdditionalOptions>/MACHINE:I386 %(AdditionalOptions)</AdditionalOptions>
-      <AdditionalDependencies>ComCtl32.lib;Ws2_32.lib;UxTheme.lib;imm32.lib;%(AdditionalDependencies)</AdditionalDependencies>
-      <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
-      <SuppressStartupBanner>true</SuppressStartupBanner>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-      <ProgramDatabaseFile>$(OutDir)$(TargetName).pdb</ProgramDatabaseFile>
-      <SubSystem>Windows</SubSystem>
-      <OptimizeReferences>true</OptimizeReferences>
-      <RandomizedBaseAddress>false</RandomizedBaseAddress>
-      <DataExecutionPrevention />
-      <ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
-    </Link>
-  </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">
     <Midl>
       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MkTypLibCompatible>true</MkTypLibCompatible>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <TargetEnvironment>X64</TargetEnvironment>
       <TypeLibraryName>.\Release/Lgi.tlb</TypeLibraryName>
     </Midl>
     <ClCompile>
       <Optimization>MinSpace</Optimization>
       <InlineFunctionExpansion>OnlyExplicitInline</InlineFunctionExpansion>
       <AdditionalIncludeDirectories>include;include\lgi\win;private\common;private\win;..\..\..\CodeLib\libiconv\include;..\..\scribe\libs\build-x64\libiconv-1.17\include;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
       <PreprocessorDefinitions>WIN64;NDEBUG;WINDOWS;LGI_RES;LGI_LIBRARY;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <StringPooling>true</StringPooling>
       <RuntimeLibrary>MultiThreadedDLL</RuntimeLibrary>
       <FunctionLevelLinking>true</FunctionLevelLinking>
       <RuntimeTypeInfo>true</RuntimeTypeInfo>
       <PrecompiledHeader />
       <PrecompiledHeaderOutputFile>$(IntDir)$(TargetName).pch</PrecompiledHeaderOutputFile>
       <AssemblerListingLocation>$(IntDir)</AssemblerListingLocation>
       <ObjectFileName>$(IntDir)</ObjectFileName>
       <ProgramDataBaseFileName>$(IntDir)</ProgramDataBaseFileName>
       <BrowseInformation />
       <WarningLevel>Level2</WarningLevel>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <CompileAs>Default</CompileAs>
     </ClCompile>
     <ResourceCompile>
       <PreprocessorDefinitions>NDEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <Culture>0x0c09</Culture>
     </ResourceCompile>
     <Link>
       <AdditionalDependencies>ComCtl32.lib;Ws2_32.lib;UxTheme.lib;imm32.lib;%(AdditionalDependencies)</AdditionalDependencies>
       <OutputFile>$(OutDir)$(TargetFileName)</OutputFile>
       <SuppressStartupBanner>true</SuppressStartupBanner>
       <GenerateDebugInformation>true</GenerateDebugInformation>
       <ProgramDatabaseFile>$(OutDir)$(TargetName).pdb</ProgramDatabaseFile>
       <SubSystem>Windows</SubSystem>
       <OptimizeReferences>true</OptimizeReferences>
       <RandomizedBaseAddress>false</RandomizedBaseAddress>
       <DataExecutionPrevention />
       <ImportLibrary>$(OutDir)$(TargetName).lib</ImportLibrary>
       <TargetMachine>MachineX64</TargetMachine>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="src\common\Gdc2\15Bit.cpp" />
     <ClCompile Include="src\common\Gdc2\16Bit.cpp" />
     <ClCompile Include="src\common\Gdc2\24Bit.cpp" />
     <ClCompile Include="src\common\Gdc2\32Bit.cpp" />
     <ClCompile Include="src\common\Gdc2\48Bit.cpp" />
     <ClCompile Include="src\common\Gdc2\64Bit.cpp" />
     <ClCompile Include="src\common\Gdc2\8Bit.cpp" />
     <ClCompile Include="src\common\Gdc2\Alpha.cpp" />
     <ClCompile Include="src\common\Gdc2\Filters\Filter.cpp" />
     <ClCompile Include="src\common\Gdc2\Font\DisplayString.cpp" />
     <ClCompile Include="src\common\Gdc2\Font\Font.cpp" />
     <ClCompile Include="src\common\Gdc2\Font\Charset.cpp" />
     <ClCompile Include="src\common\Gdc2\Font\FontSystem.cpp" />
     <ClCompile Include="src\common\Gdc2\Font\FontType.cpp" />
     <ClCompile Include="src\common\Gdc2\Font\StringLayout.cpp" />
     <ClCompile Include="src\common\Gdc2\Font\TypeFace.cpp" />
     <ClCompile Include="src\common\Gdc2\Colour.cpp" />
     <ClCompile Include="src\common\Gdc2\GdcCommon.cpp" />
     <ClCompile Include="src\common\Gdc2\Rect.cpp" />
     <ClCompile Include="src\common\Gdc2\Surface.cpp" />
     <ClCompile Include="src\common\Gdc2\Path\Path.cpp" />
     <ClCompile Include="src\common\Gdc2\Tools\ColourReduce.cpp" />
     <ClCompile Include="src\common\General\Containers.cpp" />
     <ClCompile Include="src\common\General\ExeCheck.cpp" />
     <ClCompile Include="src\common\General\FileCommon.cpp" />
     <ClCompile Include="src\common\General\Growl.cpp" />
     <ClCompile Include="src\common\General\Password.cpp" />
     <ClCompile Include="src\common\General\DateTime.cpp" />
     <ClCompile Include="src\common\Hash\md5\md5.c" />
     <ClCompile Include="src\common\Hash\sha1\sha1.c" />
     <ClCompile Include="src\common\Net\Base64.cpp" />
     <ClCompile Include="src\common\Net\Uri.cpp" />
     <ClCompile Include="src\common\Net\Net.cpp" />
     <ClCompile Include="src\common\Net\NetTools.cpp" />
     <ClCompile Include="src\common\Net\MDStringToDigest.cpp" />
     <ClCompile Include="src\common\Lgi\Alert.cpp" />
     <ClCompile Include="src\common\Lgi\AppCommon.cpp" />
     <ClCompile Include="src\common\Lgi\Css.cpp" />
     <ClCompile Include="src\common\Lgi\CssTools.cpp" />
     <ClCompile Include="src\common\Lgi\DragAndDropCommon.cpp" />
     <ClCompile Include="src\common\Lgi\DropFiles.cpp" />
     <ClCompile Include="src\common\Lgi\FindReplace.cpp" />
     <ClCompile Include="src\common\Lgi\FontSelect.cpp" />
     <ClCompile Include="src\common\Lgi\GuiUtils.cpp" />
     <ClCompile Include="src\common\Lgi\Input.cpp" />
     <ClCompile Include="src\common\Lgi\Library.cpp" />
     <ClCompile Include="src\common\Lgi\MemStream.cpp" />
     <ClCompile Include="src\common\Lgi\MenuCommon.cpp" />
     <ClCompile Include="src\common\Lgi\Mru.cpp" />
     <ClCompile Include="src\common\Lgi\Object.cpp" />
     <ClCompile Include="src\common\Lgi\OptionsFile.cpp" />
     <ClCompile Include="src\common\Lgi\Stream.cpp" />
     <ClCompile Include="src\common\Lgi\SubProcess.cpp" />
     <ClCompile Include="src\common\Lgi\ToolTip.cpp" />
     <ClCompile Include="src\common\Lgi\TrayIcon.cpp" />
     <ClCompile Include="src\common\Lgi\Variant.cpp" />
     <ClCompile Include="src\common\Lgi\ViewCommon.cpp" />
     <ClCompile Include="src\common\Lgi\WindowCommon.cpp" />
     <ClCompile Include="src\common\Lgi\LgiCommon.cpp" />
     <ClCompile Include="src\common\Lgi\LMsg.cpp" />
     <ClCompile Include="src\common\Lgi\Rand.cpp" />
     <ClCompile Include="src\common\Lgi\Mutex.cpp" />
     <ClCompile Include="src\common\Lgi\ThreadCommon.cpp" />
     <ClCompile Include="src\common\Lgi\ThreadEvent.cpp" />
     <ClCompile Include="src\common\Resource\LgiRes.cpp" />
     <ClCompile Include="src\common\Resource\Res.cpp" />
     <ClCompile Include="src\common\Skins\Gel\Gel.cpp" />
     <ClCompile Include="src\common\Text\DocView.cpp" />
     <ClCompile Include="src\common\Text\String.cpp" />
     <ClCompile Include="src\common\Text\TextView3.cpp" />
     <ClCompile Include="src\common\Text\TextView4.cpp" />
     <ClCompile Include="src\common\Text\Token.cpp" />
     <ClCompile Include="src\common\Text\Unicode.cpp" />
     <ClCompile Include="src\common\Text\Utf8.cpp" />
     <ClCompile Include="src\common\Text\XmlTree.cpp" />
     <ClCompile Include="src\common\Text\UnicodeString.cpp" />
     <ClCompile Include="src\common\Widgets\Bitmap.cpp" />
     <ClCompile Include="src\common\Widgets\Box.cpp" />
     <ClCompile Include="src\common\Widgets\Button.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="src\common\Widgets\CheckBox.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="src\common\Widgets\Combo.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="src\common\Widgets\Edit.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="src\common\Widgets\ItemContainer.cpp" />
     <ClCompile Include="src\common\Widgets\Panel.cpp" />
     <ClCompile Include="src\common\Widgets\Popup.cpp" />
     <ClCompile Include="src\common\Widgets\ProgressDlg.cpp" />
     <ClCompile Include="src\common\Widgets\RadioGroup.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">false</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">false</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">false</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="src\common\Widgets\Slider.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="src\common\Widgets\Splitter.cpp" />
     <ClCompile Include="src\common\Widgets\StatusBar.cpp" />
     <ClCompile Include="src\common\Widgets\TableLayout.cpp" />
     <ClCompile Include="src\common\Widgets\TabView.cpp" />
     <ClCompile Include="src\common\Widgets\TextLabel.cpp" />
     <ClCompile Include="src\common\Widgets\ToolBar.cpp" />
     <ClCompile Include="src\common\Widgets\Tree.cpp" />
     <ClCompile Include="src\common\Widgets\List.cpp" />
     <ClCompile Include="src\win\Gdc2\Gdc2.cpp" />
     <ClCompile Include="src\win\Gdc2\GdiLeak.cpp" />
     <ClCompile Include="src\win\Gdc2\MemDC.cpp" />
     <ClCompile Include="src\win\Gdc2\PrintDC.cpp" />
     <ClCompile Include="src\win\Gdc2\ScreenDC.cpp" />
     <ClCompile Include="src\win\General\File.cpp" />
     <ClCompile Include="src\win\General\Mem.cpp" />
     <ClCompile Include="src\win\General\ShowFileProp_Win.cpp" />
     <ClCompile Include="src\win\INet\MibAccess.cpp" />
     <ClCompile Include="src\win\Lgi\App.cpp" />
     <ClCompile Include="src\win\Lgi\ClipBoard.cpp" />
     <ClCompile Include="src\win\Lgi\DragAndDrop.cpp" />
     <ClCompile Include="src\win\Lgi\FileSelect.cpp" />
     <ClCompile Include="src\win\Lgi\General.cpp" />
     <ClCompile Include="src\win\Lgi\Layout.cpp" />
     <ClCompile Include="src\win\Lgi\Menu.cpp" />
     <ClCompile Include="src\win\Lgi\Printer.cpp" />
     <ClCompile Include="src\win\Lgi\ScrollBar.cpp" />
     <ClCompile Include="src\win\Lgi\View.cpp" />
     <ClCompile Include="src\win\Lgi\Window.cpp" />
     <ClCompile Include="src\win\Lgi\LgiException.cpp" />
     <ClCompile Include="src\win\Lgi\Thread.cpp" />
     <ClCompile Include="src\win\Widgets\Button_Win.cpp" />
     <ClCompile Include="src\win\Widgets\CheckBox_Win.cpp">
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|Win32'">true</ExcludedFromBuild>
-      <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='ReleaseNoOptimize|x64'">true</ExcludedFromBuild>
       <ExcludedFromBuild Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</ExcludedFromBuild>
     </ClCompile>
     <ClCompile Include="src\win\Widgets\Combo_Win.cpp" />
     <ClCompile Include="src\win\Widgets\Dialog_Win.cpp" />
     <ClCompile Include="src\win\Widgets\Edit_Win.cpp" />
     <ClCompile Include="src\win\Widgets\Progress_Win.cpp" />
     <ClCompile Include="src\win\Widgets\RadioGroup_Win.cpp" />
     <ClCompile Include="src\win\Widgets\Slider_Win.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="include\common\Array.h" />
     <ClInclude Include="include\common\AutoPtr.h" />
     <ClInclude Include="include\common\Box.h" />
     <ClInclude Include="include\common\Button.h" />
     <ClInclude Include="include\common\Capabilities.h" />
     <ClInclude Include="include\common\CheckBox.h" />
     <ClInclude Include="include\common\Colour.h" />
     <ClInclude Include="include\common\ColourSpace.h" />
     <ClInclude Include="include\common\Com.h" />
     <ClInclude Include="include\common\Combo.h" />
     <ClInclude Include="include\common\Containers.h" />
     <ClInclude Include="include\common\Css.h" />
     <ClInclude Include="include\common\CssTools.h" />
     <ClInclude Include="include\common\Gdc2.h" />
     <ClInclude Include="include\common\GdiLeak.h" />
     <ClInclude Include="include\common\DisplayStringLayout.h" />
     <ClInclude Include="include\common\Dom.h" />
     <ClInclude Include="include\common\DragAndDrop.h" />
     <ClInclude Include="include\common\DropFiles.h" />
     <ClInclude Include="include\common\Edit.h" />
     <ClInclude Include="include\common\EventTargetThread.h" />
     <ClInclude Include="include\common\File.h" />
     <ClInclude Include="include\common\FileSelect.h" />
     <ClInclude Include="include\common\Filter.h" />
     <ClInclude Include="include\common\Font.h" />
     <ClInclude Include="include\common\Growl.h" />
     <ClInclude Include="include\common\HashTable.h" />
     <ClInclude Include="include\common\ImageList.h" />
     <ClInclude Include="include\common\ItemContainer.h" />
     <ClInclude Include="include\common\Library.h" />
     <ClInclude Include="include\common\Matrix.h" />
     <ClInclude Include="include\common\Mem.h" />
     <ClInclude Include="include\common\Path.h" />
     <ClInclude Include="include\common\Slider.h" />
     <ClInclude Include="include\common\View.h" />
     <ClInclude Include="include\common\Menu.h" />
     <ClInclude Include="include\common\Mru.h" />
     <ClInclude Include="include\common\Notifications.h" />
     <ClInclude Include="include\common\Palette.h" />
     <ClInclude Include="include\common\PixelRops.h" />
     <ClInclude Include="include\common\Point.h" />
     <ClInclude Include="include\common\Popup.h" />
     <ClInclude Include="include\common\Progress.h" />
     <ClInclude Include="include\common\RadioGroup.h" />
     <ClInclude Include="include\common\Rect.h" />
     <ClInclude Include="include\common\Rops.h" />
     <ClInclude Include="include\common\ScrollBar.h" />
     <ClInclude Include="include\common\Stream.h" />
     <ClInclude Include="include\common\String.h" />
     <ClInclude Include="include\common\SubProcess.h" />
     <ClInclude Include="include\common\TableLayout.h" />
     <ClInclude Include="include\common\abView.h" />
     <ClInclude Include="include\common\TextLabel.h" />
     <ClInclude Include="include\common\TextView3.h" />
     <ClInclude Include="include\common\ToolBar.h" />
     <ClInclude Include="include\common\Tree.h" />
     <ClInclude Include="include\common\Unicode.h" />
     <ClInclude Include="include\common\Variant.h" />
     <ClInclude Include="include\common\ViewPriv.h" />
     <ClInclude Include="include\common\Net.h" />
     <ClInclude Include="include\common\NetTools.h" />
     <ClInclude Include="include\common\Cancel.h" />
     <ClInclude Include="include\common\DateTime.h" />
     <ClInclude Include="include\common\DomFields.h" />
     <ClInclude Include="include\common\Error.h" />
     <ClInclude Include="include\common\Lgi.h" />
     <ClInclude Include="include\common\LgiClass.h" />
     <ClInclude Include="include\common\LgiClasses.h" />
     <ClInclude Include="include\common\LgiCommon.h" />
     <ClInclude Include="include\common\LgiDefs.h" />
     <ClInclude Include="include\common\LgiInterfaces.h" />
     <ClInclude Include="include\common\LgiRes.h" />
     <ClInclude Include="include\common\List.h" />
     <ClInclude Include="include\common\ListItemCheckBox.h" />
     <ClInclude Include="include\common\ListItemRadioBtn.h" />
     <ClInclude Include="include\common\Mutex.h" />
     <ClInclude Include="include\common\PointF.h" />
     <ClInclude Include="include\common\StringLayout.h" />
     <ClInclude Include="include\common\Thread.h" />
     <ClInclude Include="include\common\ThreadEvent.h" />
     <ClInclude Include="include\common\Res.h" />
     <ClInclude Include="include\lgi\common\LgiInc.h" />
     <ClInclude Include="include\lgi\common\Message.h" />
     <ClInclude Include="include\win\GCom.h" />
     <ClInclude Include="include\win\LgiOsClasses.h" />
     <ClInclude Include="include\win\LgiOsDefs.h" />
     <ClInclude Include="private\win\GAppPriv.h" />
     <ClInclude Include="src\common\Gdc2\Font\GFontPriv.h" />
     <ClInclude Include="src\common\Hash\md5\md5.h" />
     <ClInclude Include="src\common\Hash\sha1\sha1.h" />
     <ClInclude Include="src\win\INet\MibAccess.h" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>
 </Project>
\ No newline at end of file