diff --git a/Ide/Code/IdeProject.cpp b/Ide/Code/IdeProject.cpp
--- a/Ide/Code/IdeProject.cpp
+++ b/Ide/Code/IdeProject.cpp
@@ -1,4102 +1,4108 @@
 #if defined(WIN32)
 #include <direct.h>
 #else
 #include <unistd.h>
 #endif
 #include <stdio.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/DragAndDrop.h"
 #include "lgi/common/Token.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Net.h"
 #include "lgi/common/ListItemCheckBox.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/DropFiles.h"
 #include "lgi/common/SubProcess.h"
 #include "lgi/common/Css.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/RegKey.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 
 #include "LgiIde.h"
 #include "resdefs.h"
 #include "FtpThread.h"
 #include "ProjectNode.h"
 #include "WebFldDlg.h"
 
 extern const char *Untitled;
 const char SourcePatterns[] = "*.c;*.h;*.cpp;*.cc;*.java;*.d;*.php;*.html;*.css;*.js";
 const char *AddFilesProgress::DefaultExt = "c,cpp,cc,cxx,h,hpp,hxx,html,css,json,js,jsx,txt,png,jpg,jpeg,rc,xml,mk,paths,makefile,py,java,php";
 const char *VsBinaries[] = {"devenv.com", "WDExpress.exe"};
 
 #define USE_OPEN_PROGRESS			1
 
 #define STOP_BUILD_TIMEOUT			2000
 #ifdef WINDOWS
 #define LGI_STATIC_LIBRARY_EXT		"lib"
 #else
 #define LGI_STATIC_LIBRARY_EXT		"a"
 #endif
 
 const char *PlatformNames[] =
 {
 	"Windows",
 	"Linux",
 	"Mac",
 	"Haiku",
 	0
 };
 
 int PlatformCtrlId[] =
 {
 	IDC_WIN32,
 	IDC_LINUX,
 	IDC_MAC,
 	IDC_HAIKU,
 	0
 };
 
 const char *PlatformDynamicLibraryExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return "dll";
 	if (Platform == PlatformMac)
 		return "dylib";
 	
 	return "so";
 }
 
 const char *PlatformSharedLibraryExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return "lib";
 
 	return "a";
 }
 
 const char *PlatformExecutableExt(IdePlatform Platform)
 {
 	if (Platform == PlatformWin)
 		return ".exe";
 	return "";
 }
 
 char *ToUnixPath(char *s)
 {
 	if (s)
 	{
 		char *c;
 		while ((c = strchr(s, '\\')))
 			*c = '/';
 	}
 	return s;
 }
 
 const char *CastEmpty(char *s)
 {
 	return s ? s : "";
 }
 
 bool FindInPath(LString &Exe)
 {
 	LString::Array Path = LString(getenv("PATH")).Split(LGI_PATH_SEPARATOR);
 	for (unsigned i=0; i<Path.Length(); i++)
 	{
 		char p[MAX_PATH_LEN];
 		LMakePath(p, sizeof(p), Path[i], Exe);
 		if (LFileExists(p))
 		{
 			Exe = p;
 			return true;
 		}
 	}
 	
 	return false;
 }
 
 LAutoString ToNativePath(const char *s)
 {
 	LAutoString a(NewStr(s));
 	if (a)
 	{
 		if (strnicmp(a, "ftp://", 6))
 		{
 			for (char *c = a; *c; c++)
 			{
 				#ifdef WIN32
 				if (*c == '/')
 					*c = '\\';
 				#else
 				if (*c == '\\')
 					*c = '/';
 				#endif
 			}
 		}
 	}
 	return a;
 }
 
 int StrCmp(char *a, char *b, NativeInt d)
 {
 	return stricmp(a, b);
 }
 
 int StrSort(char **a, char **b)
 {
 	return stricmp(*a, *b);
 }
 
 //////////////////////////////////////////////////////////////////////////////////
 class ProjectNode;
 
 class BuildThread : public LThread, public LStream
 {
 	IdeProject *Proj;
 	LString Makefile, CygwinPath;
 	bool Clean, All;
 	BuildConfig Config;
 	int WordSize;
 	LAutoPtr<LSubProcess> SubProc;
 	LString::Array BuildConfigs;
 	LString::Array PostBuild;
 	int AppHnd;
 
 	enum CompilerType
 	{
 		DefaultCompiler,
 		VisualStudio,
 		MingW,
 		Gcc,
 		CrossCompiler,
 		PythonScript,
 		IAR,
 		Nmake,
 		Cygwin,
 		Xcode,
 	}
 		Compiler;
 
 	enum ArchType
 	{
 		DefaultArch,
 		ArchX32,
 		ArchX64,
 		ArchArm6,
 		ArchArm7,
 	}
 		Arch;
 
 public:
 	BuildThread(IdeProject *proj, char *makefile, bool clean, BuildConfig config, bool all, int wordsize);
 	~BuildThread();
 	
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0) override;
 	LString FindExe();
 	LAutoString WinToMingWPath(const char *path);
 	int Main() override;
 };
 
 class IdeProjectPrivate
 {
 public:
 	AppWnd *App;
 	IdeProject *Project;
 	bool Dirty, UserFileDirty;
 	LString FileName;
 	IdeProject *ParentProject;
 	IdeProjectSettings Settings;
 	LAutoPtr<BuildThread> Thread;
 	LHashTbl<ConstStrKey<char,false>, ProjectNode*> Nodes;
 	int NextNodeId;
 
 	// Threads
 	LAutoPtr<class MakefileThread> CreateMakefile;
 
 	// User info file
 	LString UserFile;
 	LHashTbl<IntKey<int>,int> UserNodeFlags;
 
 	IdeProjectPrivate(AppWnd *a, IdeProject *project) :
 		Project(project),
 		Settings(project)
 	{
 		App = a;
 		Dirty = false;
 		UserFileDirty = false;
 		ParentProject = 0;
 		NextNodeId = 1;
 	}
 
 	void CollectAllFiles(LTreeNode *Base, LArray<ProjectNode*> &Files, bool SubProjects, int Platform);
 };
 
 LString ToPlatformPath(const char *s, IdePlatform platform)
 {
 	LString p = s;
 	if (platform == PlatformWin)
 		return p.Replace("/", "\\");
 	else
 		return p.Replace("\\", "/");
 }
 
 class MakefileThread : public LThread, public LCancel
 {
 	IdeProjectPrivate *d;
 	IdeProject *Proj;
 	IdePlatform Platform;
 	LStream *Log;
 	bool BuildAfterwards;
 	bool HasError;
 	
 public:
 	static int Instances;
 
 	MakefileThread(IdeProjectPrivate *priv, IdePlatform platform, bool Build) : LThread("MakefileThread")
 	{
 		Instances++;
 
 		d = priv;
 		Proj = d->Project;
 		Platform = platform;
 		BuildAfterwards = Build;
 		HasError = false;
 		Log = d->App->GetBuildLog();
 		
 		Run();
 	}
 
 	~MakefileThread()
 	{
 		Cancel();
 		while (!IsExited())
 			LSleep(1);
 		Instances--;
 	}
 	
 	void OnError(const char *Fmt, ...)
 	{
 		va_list Arg;
 		va_start(Arg, Fmt);
 		LStreamPrintf(Log, 0, Fmt, Arg);
 		va_end(Arg);
 		HasError = true;
 	}
 	
 	int Main()
 	{
 		const char *PlatformName = PlatformNames[Platform];
 		const char *PlatformLibraryExt = NULL;
 		const char *PlatformStaticLibExt = NULL;
 		const char *PlatformExeExt = "";
 		LString LinkerFlags;
 		const char *TargetType = d->Settings.GetStr(ProjTargetType, NULL, Platform);
 		const char *CompilerName = d->Settings.GetStr(ProjCompiler);
 		LString CCompilerBinary = "gcc";
 		LString CppCompilerBinary = "g++";
 		LStream *Log = d->App->GetBuildLog();
 		bool IsExecutableTarget = TargetType && !stricmp(TargetType, "Executable");
 		bool IsDynamicLibrary	= TargetType && !stricmp(TargetType, "DynamicLibrary");
 		
 		LAssert(Log);
 		if (!Log)
 			return false;
 		
 		Log->Print("CreateMakefile for '%s'...\n", PlatformName);
 		
 		if (Platform == PlatformWin)
 		{
 			LinkerFlags = ",--enable-auto-import";
 		}
 		else
 		{
 			if (IsDynamicLibrary)
 			{
 				LinkerFlags = ",-soname,$(TargetFile)";
 			}
 			LinkerFlags += ",-export-dynamic,-R.";
 		}
 
 		char Buf[256];
 		auto MakeFile = Proj->GetMakefile(Platform);
 		Proj->CheckExists(MakeFile);
 		if (!MakeFile)
 			MakeFile = "../Makefile";
 		
 		// LGI_LIBRARY_EXT
 		switch (Platform)
 		{
 			case PlatformWin:
 				PlatformLibraryExt = "dll";
 				PlatformStaticLibExt = "lib";
 				PlatformExeExt = ".exe";
 				break;
 			case PlatformLinux:
 			case PlatformHaiku:
 				PlatformLibraryExt = "so";
 				PlatformStaticLibExt = "a";
 				break;
 			case PlatformMac:
 				PlatformLibraryExt = "dylib";
 				PlatformStaticLibExt = "a";
 				break;
 			default:
 				LAssert(0);
 				break;
 		}
 
 		if (CompilerName)
 		{
 			if (!stricmp(CompilerName, "cross"))
 			{
 				LString CBin = d->Settings.GetStr(ProjCCrossCompiler, NULL, Platform);
 				if (CBin && !LFileExists(CBin))
 					FindInPath(CBin);
 				if (CBin && LFileExists(CBin))
 					CCompilerBinary = CBin;
 				else
 					Log->Print("%s:%i - Error: C cross compiler '%s' not found.\n", _FL, CBin.Get());
 				
 				LString CppBin = d->Settings.GetStr(ProjCppCrossCompiler, NULL, Platform);
 				if (CppBin && !LFileExists(CppBin))
 					FindInPath(CppBin);
 				if (CppBin && LFileExists(CppBin))
 					CppCompilerBinary = CppBin;
 				else
 					Log->Print("%s:%i - Error: C++ cross compiler '%s' not found.\n", _FL, CppBin.Get());
 			}
 		}
 		
 		LFile m;
 		if (!m.Open(MakeFile, O_WRITE))
 		{
 			Log->Print("Error: Failed to open '%s' for writing.\n", MakeFile.Get());
 			return false;
 		}
 		
 		m.SetSize(0);
 		
 		m.Print("#!/usr/bin/make\n"
 				"#\n"
 				"# This makefile generated by LgiIde\n"
 				"# http://www.memecode.com/lgi.php\n"
 				"#\n"
 				"\n"
 				".SILENT :\n"
 				"\n"
 				"CC = %s\n"
 				"CPP = %s\n",
 				CCompilerBinary.Get(),
 				CppCompilerBinary.Get());
 
 		// Collect all files that require building
 		LArray<ProjectNode*> Files;
 		d->CollectAllFiles
 		(
 			Proj,
 			Files,
 			false,
 			1 << Platform
 		);
 		
 		auto Base = Proj->GetBasePath();
 		if (IsExecutableTarget)
 		{
 			LString Exe = Proj->GetExecutable(Platform);
 			if (Exe)
 			{
 				if (LIsRelativePath(Exe))
 					m.Print("Target = %s\n", ToPlatformPath(Exe, Platform).Get());
 				else
 				{
 					auto RelExe = LMakeRelativePath(Base, Exe);
 					if (Base && RelExe)
 					{
 						m.Print("Target = %s\n", ToPlatformPath(RelExe, Platform).Get());
 					}
 					else
 					{
 						Log->Print("%s:%i - Error: Missing path (%s, %s).\n", _FL, Base.Get(), RelExe.Get());
 						return false;
 					}
 				}
 			}
 			else
 			{
 				Log->Print("%s:%i - Error: No executable name specified (%s, %s).\n", _FL, TargetType, d->FileName.Get());
 				return false;
 			}
 		}
 		else
 		{
 			LString Target = Proj->GetTargetName(Platform);
 			if (Target)
 				m.Print("Target = %s\n", ToPlatformPath(Target, Platform).Get());
 			else
 			{
 				Log->Print("%s:%i - Error: No target name specified.\n", _FL);
 				return false;
 			}
 		}
 
 		// Output the build mode, flags and some paths
 		auto BuildMode = d->App->GetBuildMode();
 		auto BuildModeName = toString(BuildMode);
 		m.Print("ifndef Build\n"
 				"	Build = %s\n"
 				"endif\n",
 				BuildModeName);
 		
 		LString sDefines[BuildMax];
 		LString sLibs[BuildMax];
 		LString sIncludes[BuildMax];
 		const char *ExtraLinkFlags = NULL;
 		const char *ExeFlags = NULL;
 		if (Platform == PlatformWin)
 		{
 			ExtraLinkFlags = "";
 			ExeFlags = " -mwindows";
 			m.Print("BuildDir = $(Build)\n"
 					"\n"
 					"Flags = -fPIC -w -fno-inline -fpermissive\n");
 			
 			const char *DefDefs = "-DWIN32 -D_REENTRANT";
 			sDefines[BuildDebug] = DefDefs;
 			sDefines[BuildRelease] = DefDefs;
 		}
 		else
 		{
 			LString PlatformCap = PlatformName;
 		
 			ExtraLinkFlags = "";
 			ExeFlags = "";
 			m.Print("BuildDir = $(Build)\n"
 					"\n"
 					"Flags = -fPIC -w -fno-inline -fpermissive\n" // -fexceptions
 					);
 			sDefines[0].Printf("-D%s -D_REENTRANT", PlatformCap.Upper().Get());
 			#ifdef LINUX
 			sDefines[BuildDebug] += " -D_FILE_OFFSET_BITS=64"; // >:-(
 			sDefines[BuildDebug] += " -DPOSIX";
 			#endif
 			sDefines[BuildRelease] = sDefines[BuildDebug];
 		}
 
 		List<IdeProject> Deps;
 		Proj->GetChildProjects(Deps);
 
 		for (int Cfg = BuildDebug; Cfg < BuildMax; Cfg++)
 		{
 			// Set the config
 			auto cfgName = toString((BuildConfig)Cfg);
 			d->Settings.SetCurrentConfig(cfgName);
 		
 			// Get the defines setup
 			auto PDefs = d->Settings.GetStr(ProjDefines, NULL, Platform);
 			if (ValidStr(PDefs))
 			{
 				LToken Defs(PDefs, " ;,\r\n");
 				for (int i=0; i<Defs.Length(); i++)
 				{
 					LString s;
 					s.Printf(" -D%s", Defs[i]);
 					sDefines[Cfg] += s;
 				}
 			}
 		
 			// Collect all dependencies, output their lib names and paths
 			LString PLibPaths = d->Settings.GetStr(ProjLibraryPaths, NULL, Platform);
 			if (ValidStr(PLibPaths))
 			{
 				LString::Array LibPaths = PLibPaths.Split("\n");
 				for (auto i: LibPaths)
 				{
 					LString s, in = i.Strip();
 					if (!in.Length())
 						continue;
 					
 					if (strchr("`-", in(0)))
 					{
 						s.Printf(" \\\n\t\t%s", in.Get());
 					}
 					else
 					{
 						LString Rel;
 						if (!LIsRelativePath(in))
 							Rel = LMakeRelativePath(Base, in);
 
 						LString Final = Rel ? Rel.Get() : in.Get();
 						if (!Proj->CheckExists(Final))
 							OnError("%s:%i - Library path '%s' doesn't exist (from %s).\n",
 								_FL, Final.Get(),
 								Proj->GetFileName());
 
 						s.Printf(" \\\n\t\t-L%s", ToUnixPath(Final));
 					}
 					
 					sLibs[Cfg] += s;
 				}
 			}
 
 			const char *PLibs = d->Settings.GetStr(ProjLibraries, NULL, Platform);
 			if (ValidStr(PLibs))
 			{
 				LToken Libs(PLibs, "\r\n");
 				for (int i=0; i<Libs.Length(); i++)
 				{
 					LString l = Libs[i];
 
 					LString s;
 					if (l(0) == '`' || l(0) == '-')
 						s.Printf(" \\\n\t\t%s", l.Get());
 					else
 					{
 						Proj->CheckExists(l);
 						s.Printf(" \\\n\t\t-l%s", ToUnixPath(l));
 					}
 					sLibs[Cfg] += s;
 				}
 			}
 
 			for (auto dep: Deps)
 			{
 				LString Target = dep->GetTargetName(Platform);
 				if (Target)
 				{
 					char t[MAX_PATH_LEN];
 					strcpy_s(t, sizeof(t), Target);
 					if (!strnicmp(t, "lib", 3))
 						memmove(t, t + 3, strlen(t + 3) + 1);
 					char *dot = strrchr(t, '.');
 					if (dot)
 						*dot = 0;
 													
 					LString s, sTarget = t;
 					Proj->CheckExists(sTarget);
 					s.Printf(" \\\n\t\t-l%s$(Tag)", ToUnixPath(sTarget));
 					sLibs[Cfg] += s;
 
 					auto DepBase = dep->GetBasePath();
 					if (DepBase)
 					{
 						LString DepPath = DepBase.Get();
 						
 						auto Rel = LMakeRelativePath(Base, DepPath);
 
 						LString Final = Rel ? Rel.Get() : DepPath.Get();
 						Proj->CheckExists(Final);
 						s.Printf(" \\\n\t\t-L%s/$(BuildDir)", ToUnixPath(Final.RStrip("/\\")));
 						sLibs[Cfg] += s;
 					}
 				}
 			}
 			
 			// Includes
 
 			// Do include paths
 			LHashTbl<StrKey<char>,bool> Inc;
 			auto ProjIncludes = d->Settings.GetStr(ProjIncludePaths, NULL, Platform);
 			if (ValidStr(ProjIncludes))
 			{
 				// Add settings include paths.
 				LToken Paths(ProjIncludes, "\r\n");
 				for (int i=0; i<Paths.Length(); i++)
 				{
 					char *p = Paths[i];
 					LAutoString pn = ToNativePath(p);					
 					if (pn.Get()[0] != '`' && !Proj->CheckExists(pn))
 						OnError("%s:%i - Include path '%s' doesn't exist.\n", _FL, pn.Get());
 					else if (!Inc.Find(pn))
 						Inc.Add(pn, true);
 				}
 			}
 			const char *SysIncludes = d->Settings.GetStr(ProjSystemIncludes, NULL, Platform);
 			if (ValidStr(SysIncludes))
 			{
 				// Add settings include paths.
 				LToken Paths(SysIncludes, "\r\n");
 				for (int i=0; i<Paths.Length(); i++)
 				{
 					char *p = Paths[i];
 					LAutoString pn = ToNativePath(p);
 					if (pn.Get()[0] != '`' && !Proj->CheckExists(pn))
 						OnError("%s:%i - System include path '%s' doesn't exist (from %s).\n",
 							_FL, pn.Get(),
 							Proj->GetFileName());
 					else if (!Inc.Find(pn))
 						Inc.Add(pn, true);
 				}
 			}
 
 			#if 0
 			/*
 			Currently this code is adding extra paths that are covered by the official 'IncludePaths'
 			in addition to relative paths in the actual #include parameter. e.g.
 				#include "lgi/common/SomeHeader.h"
 			Hence disabling it for the time being.
 			*/
 			// Add paths of headers
 			for (int i=0; i<Files.Length(); i++)
 			{
 				ProjectNode *n = Files[i];
 				
 				if (n->GetFileName())
 				{
 					char *e = LGetExtension(n->GetFileName());
 					if (e && stricmp(e, "h") == 0)
 					{
 						LString Fn = n->GetFileName();
 						for (char *Dir = Fn; *Dir; Dir++)
 						{
 							if (*Dir == '/' || *Dir == '\\')
 							{
 								*Dir = DIR_CHAR;
 							}
 						}						
 
 						char Path[MAX_PATH_LEN];
 						strcpy_s(Path, sizeof(Path), Fn);
 
 						LTrimDir(Path);
 					
 						LString Rel;
 						if (!Proj->RelativePath(Rel, Path))
 							Rel = Path;
 						
 						if (stricmp(Rel, ".") != 0)
 						{
 							LAutoString RelN = ToNativePath(Rel);
 							if (!Proj->CheckExists(RelN))
 								OnError("Header include path '%s' doesn't exist.\n", RelN.Get());
 							else if (!Inc.Find(RelN))
 								Inc.Add(RelN, true);
 						}
 					}
 				}
 			}
 			#endif
 
 			LString::Array Incs;
 			for (auto i: Inc)
 				Incs.New() = i.key;
 			Incs.Sort();
 			
 			for (auto i: Incs)
 			{
 				LString s;
 				if (*i == '`')
 					s.Printf(" \\\n\t\t%s", i.Get());
 				else
 					s.Printf(" \\\n\t\t-I%s", ToUnixPath(i));
 				sIncludes[Cfg] += s;
 			}
 		}
 
 		// Output the defs section for Debug and Release		
 
 		// Debug specific
 		m.Print("\n"
 				"ifeq ($(Build),Debug)\n"
 				"	Flags += -g -std=c++14\n"
 				"	Tag = d\n"
 				"	Defs = -D_DEBUG %s\n"
 				"	Libs = %s\n"
 				"	Inc = %s\n",
 					CastEmpty(sDefines[0].Get()),
 					CastEmpty(sLibs[0].Get()),
 					CastEmpty(sIncludes[0].Get()));
 		
 		// Release specific
 		m.Print("else\n"
 				"	Flags += -s -Os -std=c++14\n"
 				"	Defs = %s\n"
 				"	Libs = %s\n"
 				"	Inc = %s\n"
 				"endif\n"
 				"\n",
 					CastEmpty(sDefines[1].Get()),
 					CastEmpty(sLibs[1].Get()),
 					CastEmpty(sIncludes[1].Get()));
 		
 		if (Files.Length())
 		{
 			LArray<LString> IncPaths;
 			if (Proj->BuildIncludePaths(IncPaths, false, false, Platform))
 			{
 				// Do source code list...
 				m.Print("# Dependencies\n"
 						"Source =\t");
 					
 				LString::Array SourceFiles;
 				for (auto &n: Files)
 				{
 					if (n->GetType() == NodeSrc)
 					{
 						auto f = n->GetFileName();
 						auto path = ToPlatformPath(f, Platform);
 						if (path.Find("./") == 0)
 							path = path(2,-1);
 						SourceFiles.Add(path);
 					}
 				}
 				SourceFiles.Sort();
 				int c = 0;
 				for (auto &src: SourceFiles)
 				{
 					if (c++) m.Print(" \\\n\t\t\t");
 					m.Print("%s", src.Get());
 				}
 				m.Print("\n"
 						"\n"
 						"SourceLst := $(patsubst %%.c,%%.o,$(patsubst %%.cpp,%%.o,$(Source)))\n"
 						"Objects := $(addprefix $(BuildDir)/,$(SourceLst))\n"
 						"Deps := $(patsubst %%.o,%%.d,$(Objects))\n"
 						"\n");
 
 				// Write out the target stuff
 				m.Print("# Target\n");
 
 				LHashTbl<StrKey<char,false>,bool> DepFiles;
 
 				if (TargetType)
 				{
 					if (IsExecutableTarget)
 					{
 						m.Print("# Executable target\n"
 								"$(Target) :");
 								
 						LStringPipe Rules;
 						IdeProject *Dep;
 						
 						uint64 Last = LCurrentTime();
 						int Count = 0;
 						auto It = Deps.begin();
 						for (Dep=*It; Dep && !IsCancelled(); Dep=*(++It), Count++)
 						{
 							// Get dependency to create it's own makefile...
 							Dep->CreateMakefile(Platform, false);
 						
 							// Build a rule to make the dependency if any of the source changes...
 							auto DepBase = Dep->GetBasePath();
 							auto Base = Proj->GetBasePath();
 							auto TargetFile = Dep->GetTargetFile(Platform);
 							
 							if (DepBase && Base && TargetFile)
 							{
 								LString Rel;
 								if (!Proj->RelativePath(Rel, DepBase))
 									Rel = DepBase;
 								ToUnixPath(Rel);
 								
 								// Add tag to target name
 								auto Parts = TargetFile.SplitDelimit(".");
 								if (Parts.Length() == 2)
 									TargetFile.Printf("lib%s$(Tag).%s", Parts[0].Get(), Parts[1].Get());
 
 								sprintf(Buf, "%s/$(BuildDir)/%s", Rel.Get(), TargetFile.Get());
 								m.Print(" %s", Buf);
 								
 								LArray<char*> AllDeps;
 								Dep->GetAllDependencies(AllDeps, Platform);
 								LAssert(AllDeps.Length() > 0);
 								AllDeps.Sort(StrSort);
 
 								Rules.Print("%s : ", Buf);
 								for (int i=0; i<AllDeps.Length(); i++)
 								{
 									if (i)
 										Rules.Print(" \\\n\t");
 									
 									LString DepRel;
 									char *f = Proj->RelativePath(DepRel, AllDeps[i]) ? DepRel.Get() : AllDeps[i];
 									ToUnixPath(f);
 									Rules.Print("%s", f);
 									
 									// Add these dependencies to this makefiles dep list
 									if (!DepFiles.Find(f))
 										DepFiles.Add(f, true);
 								}
 
 								AllDeps.DeleteArrays();
 
 								Rules.Print("\n\texport Build=$(Build); \\\n"
 											"\t$(MAKE) -C %s",
 											Rel.Get());
 
 								auto Mk = Dep->GetMakefile(Platform);
 								// RenameMakefileForPlatform(Mk, Platform);
 								if (Mk)
 								{
 									char *DepMakefile = strrchr(Mk, DIR_CHAR);
 									if (DepMakefile)
 										Rules.Print(" -f %s", DepMakefile + 1);
 								}
 								else
 								{
 									Mk = Dep->GetMakefile(Platform);
 									OnError("%s:%i - No makefile for '%s'\n", _FL, Dep->GetFullPath().Get());
 								}
 
 								Rules.Print("\n\n");
 							}
 							
 							uint64 Now = LCurrentTime();
 							if (Now - Last > 1000)
 							{
 								Last = Now;
 								Log->Print("Building deps %i%%...\n", (int) (((int64)Count+1)*100/Deps.Length()));
 							}
 						}
 
 						m.Print(" $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(Target) [$(Build)]...\n"
 								"	$(CPP)%s%s %s%s -o \\\n"
 								"		$(Target) $(Objects) $(Libs)\n",
 								ExtraLinkFlags,
 								ExeFlags,
 								ValidStr(LinkerFlags) ? "-Wl" : "", LinkerFlags.Get());
 
 						if (Platform == PlatformHaiku)
 						{
 							// Is there an application icon configured?
 							const char *AppIcon = d->Settings.GetStr(ProjApplicationIcon, NULL, Platform);
 							if (AppIcon)
 							{
 								m.Print("	addattr -f %s -t \"'VICN'\" \"BEOS:ICON\" $(Target)\n", AppIcon);
 							}							
 						}
 						
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						LAutoString r(Rules.NewStr());
 						if (r)
 							m.Write(r, strlen(r));
 
 						// Various fairly global rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"						
 								"# Clean just this target\n"
 								"clean :\n"
 								"	rm $(Objects) $(Deps) $(Target)%s\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformExecutableExt(Platform));
 						
 						m.Print("# Clean all targets\n"
 								"cleanall :\n"
 								"	rm $(Objects) $(Deps) $(Target)%s\n"
 								"	@echo Cleaned $(BuildDir)\n",
 								PlatformExecutableExt(Platform));
 						
 						for (auto d: Deps)
 						{
 							auto mk = d->GetMakefile(Platform);
 							if (mk)
 							{
 								LAutoString my_base = Proj->GetBasePath();
 								LAutoString dep_base = d->GetBasePath();
 								d->CheckExists(dep_base);
 
 								auto rel_dir = LMakeRelativePath(my_base, dep_base);
 								d->CheckExists(rel_dir);
 								
 								char *mk_leaf = strrchr(mk, DIR_CHAR);
 								m.Print("	+make -C \"%s\" -f \"%s\" clean\n",
 									ToUnixPath(rel_dir ? rel_dir.Get() : dep_base.Get()),
 									ToUnixPath(mk_leaf ? mk_leaf + 1 : mk.Get()));
 							}
 						}
 						m.Print("\n");
 					}
 					// Shared library
 					else if (!stricmp(TargetType, "DynamicLibrary"))
 					{
 						m.Print("TargetFile = lib$(Target)$(Tag).%s\n"
 								"$(TargetFile) : $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(TargetFile) [$(Build)]...\n"
 								"	$(CPP)$s -shared \\\n"
 								"		%s%s \\\n"
 								"		-o $(BuildDir)/$(TargetFile) \\\n"
 								"		$(Objects) \\\n"
 								"		$(Libs)\n",
 								PlatformLibraryExt,
 								ValidStr(ExtraLinkFlags) ? "-Wl" : "", ExtraLinkFlags,
 								LinkerFlags.Get());
 
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						// Other rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"
 								"# Clean out targets\n"
 								"clean :\n"
 								"	rm $(Objects) $(Deps) $(BuildDir)/$(TargetFile)\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformLibraryExt);
 					}
 					// Static library
 					else if (!stricmp(TargetType, "StaticLibrary"))
 					{
 						m.Print("TargetFile = lib$(Target)$(Tag).%s\n"
 								"$(TargetFile) : $(Objects)\n"
 								"	mkdir -p $(BuildDir)\n"
 								"	@echo Linking $(TargetFile) [$(Build)]...\n"
 								"	ar rcs $(BuildDir)/$(TargetFile) $(Objects)\n",
 								PlatformStaticLibExt);
 
 						LString PostBuildCmds = d->Settings.GetStr(ProjPostBuildCommands, NULL, Platform);
 						if (ValidStr(PostBuildCmds))
 						{
 							LString::Array a = PostBuildCmds.Split("\n");
 							for (unsigned i=0; i<a.Length(); i++)
 								m.Print("\t%s\n", a[i].Strip().Get());
 						}
 
 						m.Print("	@echo Done.\n"
 								"\n");
 
 						// Other rules
 						m.Print(".SECONDEXPANSION:\n"
 								"$(Objects): $(BuildDir)/%%.o: $$(wildcard %%.c*)\n"
 								"	mkdir -p $(@D)\n"
 								"	@echo $(<F) [$(Build)]\n"
 								"ifeq \"$(suffix $<)\" \".cpp\"\n"
 								"	$(CPP) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"else\n"
 								"	$(CC) -MMD -MP $(Inc) $(Flags) $(Defs) -c $< -o $@\n"
 								"endif\n"
 								"\n"
 								"-include $(Objects:.o=.d)\n"
 								"\n"
 								"# Clean out targets\n"
 								"clean :\n"
 								"	rm $(Objects) $(Deps) $(BuildDir)/$(TargetFile)\n"
 								"	@echo Cleaned $(BuildDir)\n"
 								"\n",
 								PlatformStaticLibExt);
 					}
 				}
 
 				// Output VPATH
 				m.Print("VPATH=%%.cpp \\\n");
 				IncPaths.Sort();
 				for (int i=0; i<IncPaths.Length() && !IsCancelled(); i++)
 				{
 					LString p = IncPaths[i];
 					Proj->CheckExists(p);
 					if (p && !strchr(p, '`'))
 					{
 						if (!LIsRelativePath(p))
 						{
 							auto a = LMakeRelativePath(Base, p);
 							m.Print("\t%s \\\n", ToPlatformPath(a ? a.Get() : p.Get(), Platform).Get());
 						}
 						else
 						{
 							m.Print("\t%s \\\n", ToPlatformPath(p, Platform).Get());
 						}
 					}
 				}
 				m.Print("\t$(BuildDir)\n\n");
 
 				const char *OtherMakefileRules = d->Settings.GetStr(ProjMakefileRules, NULL, Platform);
 				if (ValidStr(OtherMakefileRules))
 				{
 					m.Print("\n%s\n", OtherMakefileRules);
 				}
 			}
 		}
 		else
 		{
 			m.Print("# No files require building.\n");
 		}
 
 		Log->Print("...Done: '%s'\n", MakeFile.Get());
 
 		if (BuildAfterwards)
 		{
 			if (!Proj->GetApp()->PostEvent(M_START_BUILD))
 				printf("%s:%i - PostEvent(M_START_BUILD) failed.\n", _FL);
 		}
 		
 		return HasError;
 	}
 
 	void OnAfterMain()
 	{
 		Proj->GetApp()->PostEvent(M_MAKEFILES_CREATED, (LMessage::Param)Proj);
 	}
 };
 
 
 /////////////////////////////////////////////////////////////////////////////////////
 NodeSource::~NodeSource()
 {
 	if (nView)
 	{
 		nView->nSrc = 0;
 	}
 }
 
 NodeView::~NodeView()
 {
 	if (nSrc)
 	{
 		nSrc->nView = 0;
 	}
 }
 
 
 //////////////////////////////////////////////////////////////////////////////////
 int NodeSort(LTreeItem *a, LTreeItem *b, NativeInt d)
 {
 	ProjectNode *A = dynamic_cast<ProjectNode*>(a);
 	ProjectNode *B = dynamic_cast<ProjectNode*>(b);
 	if (A && B)
 	{
 		if
 		(
 			(A->GetType() == NodeDir)
 			^
 			(B->GetType() == NodeDir)
 		)
 		{
 			return A->GetType() == NodeDir ? -1 : 1;
 		}
 		else
 		{
 			return Stricmp(a->GetText(0), b->GetText(0));
 		}
 	}
 
 	return 0;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 bool ReadVsProjFile(LString File, LString &Ver, LString::Array &Configs)
 {
 	const char *Ext = LGetExtension(File);
 	if (!Ext || _stricmp(Ext, "vcxproj"))
 		return false;
 
 	LFile f;
 	if (!f.Open(File, O_READ))
 		return false;
 
 	LXmlTree Io;
 	LXmlTag r;
 	if (Io.Read(&r, &f) &&
 		r.IsTag("Project"))
 	{
 		Ver = r.GetAttr("ToolsVersion");
 
 		LXmlTag *ItemGroup = r.GetChildTag("ItemGroup");
 		if (ItemGroup)
 			for (auto c: ItemGroup->Children)
 			{
 				if (c->IsTag("ProjectConfiguration"))
 				{
 					char *s = c->GetAttr("Include");
 					if (s)
 						Configs.New() = s;
 				}
 			}
 	}
 	else return false;
 
 	return true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 BuildThread::BuildThread(IdeProject *proj, char *makefile, bool clean, BuildConfig config, bool all, int wordsize) : LThread("BuildThread")
 {
 	Proj = proj;
 	Makefile = makefile;
 	Clean = clean;
 	Config = config;
 	All = all;
 	WordSize = wordsize;
 	Arch = DefaultArch;
 	Compiler = DefaultCompiler;
 	AppHnd = Proj->GetApp()->AddDispatch();
 	
 	LString Cmds = proj->d->Settings.GetStr(ProjPostBuildCommands, NULL);
 	if (ValidStr(Cmds))
 		PostBuild = Cmds.SplitDelimit("\r\n");
 
 	auto Ext = LGetExtension(Makefile);
 	if (Ext && !_stricmp(Ext, "py"))
 		Compiler = PythonScript;
 	else if (Ext && !_stricmp(Ext, "sln"))
 		Compiler = VisualStudio;
 	else if (Ext && !Stricmp(Ext, "xcodeproj"))
 		Compiler = Xcode;
 	else
 	{
 		auto Comp = Proj->GetSettings()->GetStr(ProjCompiler);
 		if (Comp)
 		{
 			// Use the specified compiler...
 			if (!stricmp(Comp, "VisualStudio"))
 				Compiler = VisualStudio;
 			else if (!stricmp(Comp, "MingW"))
 				Compiler = MingW;
 			else if (!stricmp(Comp, "gcc"))
 				Compiler = Gcc;
 			else if (!stricmp(Comp, "cross"))
 				Compiler = CrossCompiler;
 			else if (!stricmp(Comp, "IAR"))
 				Compiler = IAR;
 			else if (!stricmp(Comp, "Cygwin"))
 				Compiler = Cygwin;
 			else
 				LAssert(!"Unknown compiler.");
 		}
 	}
 
 	if (Compiler == DefaultCompiler)
 	{
 		// Use default compiler for platform...
 		#ifdef WIN32
 		Compiler = VisualStudio;
 		#else
 		Compiler = Gcc;
 		#endif
 	}
 
 	Run();
 }
 
 BuildThread::~BuildThread()
 {
 	if (SubProc)
 	{
 		bool b = SubProc->Interrupt();
 		LgiTrace("%s:%i - Sub process interrupt = %i.\n", _FL, b);
 	}
 	else LgiTrace("%s:%i - No sub process to interrupt.\n", _FL);
 
 	uint64 Start = LCurrentTime();
 	bool Killed = false;
 	while (!IsExited())
 	{
 		LSleep(10);
 
 		if (LCurrentTime() - Start > STOP_BUILD_TIMEOUT &&
 			SubProc)
 		{
 			if (Killed)
 			{
 				// Thread is stuck as well... ok kill that too!!! Argh - kill all the things!!!!
 				Terminate();
 				LgiTrace("%s:%i - Thread killed.\n", _FL);
 				Proj->GetApp()->PostEvent(M_BUILD_DONE);
 				break;
 			}
 			else
 			{
 				// Kill the sub-process...
 				bool b = SubProc->Kill();
 				Killed = true;
 				LgiTrace("%s:%i - Sub process killed.\n", _FL, b);
 				Start = LCurrentTime();
 			}
 		}
 	}
 }
 
 ssize_t BuildThread::Write(const void *Buffer, ssize_t Size, int Flags)
 {
 	if (Proj->GetApp())
 	{
 		Proj->GetApp()->PostEvent(M_APPEND_TEXT, (LMessage::Param)NewStr((char*)Buffer, Size), AppWnd::BuildTab);
 	}
 	return Size;
 }
 
 #pragma comment(lib, "version.lib")
 
 struct ProjInfo
 {
 	LString Guid, Name, File;
 	LHashTbl<StrKey<char>,ssize_t> Configs;
 };
 
 LString BuildThread::FindExe()
 {
 	LString::Array p = LGetPath();
 
 	if (Compiler == PythonScript)
 	{
 		#if defined(WINDOWS)
 		uint32_t BestVer = 0;
 		#else
 		LString BestVer;
 		#endif
 		static LString Best;
 
 		if (!Best)
 		{
 			const char *binName[] = {"python3", "python"};
 			for (int i=0; i<p.Length(); i++)
 			{
 				char Path[MAX_PATH_LEN];
 				for (unsigned n=0; n<CountOf(binName); n++)
 				{
 					LMakePath(Path, sizeof(Path), p[i], LString(binName[n]) + LGI_EXECUTABLE_EXT);
 					if (LFileExists(Path))
 					{			
 						// Check version
 						#if defined(WINDOWS)
 							DWORD Sz = GetFileVersionInfoSizeA(Path, NULL);
 							void *Buf = malloc(Sz);
 							if (GetFileVersionInfoA(Path, NULL, Sz, Buf))
 							{
 								LPVOID Ptr = NULL;
 								UINT Bytes;
 								if (VerQueryValueA(Buf, "\\", &Ptr, &Bytes))
 								{
 									VS_FIXEDFILEINFO *v = (VS_FIXEDFILEINFO *)Ptr;
 									if (v->dwProductVersionMS > BestVer)
 									{
 										BestVer = v->dwProductVersionMS;
 										Best = Path;
 									}
 								}
 							}
 							else if (!Best)
 							{
 								Best = Path;
 							}
 							free(Buf);
 						#else
 							LSubProcess p(Path, "--version");
 							LStringPipe o;
 							if (p.Start())
 								p.Communicate(&o);
 							auto Out = o.NewLStr();
 							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.NewLStr().SplitDelimit("\n");
 				int inKey = -1;
 				for (auto l: lines)
 				{
 					int ws = 0;
 					for (int i=0; i<l.Length(); i++)
 						if (IsWhiteSpace(l(i))) ws++;
 						else break;
 					if (l.Find(key)>=0)
 						inKey = ws;
 					else if (inKey>=0)
 					{
 						if (ws>inKey) { Configs.New() = l.Strip(); }
 						else { inKey = -1; }
 					}
 					// printf("%s\n", l.Get());
 				}
 			}
 			
 			auto Config = Configs.Length() > 0 ? Configs[0] : LString("Debug");
 			TmpArgs.Printf("-project \"%s\" -configuration %s", Makefile.Get(), Config.Get());
 		}
 		else
 		{
 			if (Compiler == Cygwin)
 			{
 				LFile::Path p(CygwinPath, "bin");
 				Path = p.GetFull();
 			}
 
 			if (Compiler == MingW)
 			{
 				LString a;
 				char *Dir = strrchr(MakePath, DIR_CHAR);
 				#if 1
 				TmpArgs.Printf("/C \"%s\"", Exe.Get());
 
 				
 				/*	As of MSYS v1.0.18 the support for multiple jobs causes make to hang:
 					http://sourceforge.net/p/mingw/bugs/1950/
 					http://mingw-users.1079350.n2.nabble.com/MSYS-make-freezes-td7579038.html
 					
 					Apparently it'll be "fixed" in v1.0.19. We'll see. >:-(
 				
 				if (Jobs.CastInt32() > 1)
 					a.Print(" -j %i", Jobs.CastInt32());
 				
 				*/
 				
 				a.Printf(" -f \"%s\"", Dir ? Dir + 1 : MakePath.Get());
 				TmpArgs += a;
 				#else
 				TmpArgs.Printf("/C set");
 				#endif
 				Exe = "C:\\Windows\\System32\\cmd.exe";
 			}
 			else
 			{
 				if (Jobs.CastInt32())
 					TmpArgs.Printf("-j %i -f \"%s\"", Jobs.CastInt32(), MakePath.Get());
 				else
 					TmpArgs.Printf("-f \"%s\"", MakePath.Get());
 			}
 
 			if (Clean)
             {
 				if (All)
 					TmpArgs += " cleanall";
 				else
 					TmpArgs += " clean";
             }
 			if (Config == BuildRelease)
 				TmpArgs += " Build=Release";
 		}
 
 		PostThreadEvent(AppHnd, M_SELECT_TAB, AppWnd::BuildTab);
 
 		LString Msg;
 		Msg.Printf("Making: %s\n", MakePath.Get());
 		Proj->GetApp()->PostEvent(M_APPEND_TEXT, (LMessage::Param)NewStr(Msg), AppWnd::BuildTab);
 
 		LgiTrace("%s %s\n", Exe.Get(), TmpArgs.Get());
 		if (SubProc.Reset(new LSubProcess(Exe, TmpArgs)))
 		{
 			SubProc->SetNewGroup(false);
 			SubProc->SetInitFolder(InitDir);
 			if (Include)
 				SubProc->SetEnvironment("INCLUDE", Include);
 			if (Lib)
 				SubProc->SetEnvironment("LIB", Lib);
 			if (LibPath)
 				SubProc->SetEnvironment("LIBPATHS", LibPath);
 			if (Path)
 			{
 				LString Cur = getenv("PATH");
 				LString New = Cur + LGI_PATH_SEPARATOR + Path;
 				SubProc->SetEnvironment("PATH", New);
 			}
 			// SubProc->SetEnvironment("DLL", "1");
 
 			if (Compiler == MingW)
 				SubProc->SetEnvironment("PATH", "c:\\MingW\\bin;C:\\MinGW\\msys\\1.0\\bin;%PATH%");
 				
 			if ((Status = SubProc->Start(true, false)))
 			{
 				// Read all the output					
 				char Buf[256];
 				ssize_t rd;
 
 				while ( (rd = SubProc->Read(Buf, sizeof(Buf))) > 0 )
 				{
 					Write(Buf, rd);
 				}
 					
 				uint32_t ex = SubProc->Wait();
 				Print("Make exited with %i (0x%x)\n", ex, ex);
 
 				if (Compiler == IAR &&
 					ex == 0 &&
 					PostBuild.Length())
 				{
 					for (auto Cmd : PostBuild)
 					{
 						auto p = Cmd.Split(" ", 1);
 						if (p[0].Equals("cd"))
 						{
 							if (p.Length() > 1)
 								FileDev->SetCurrentFolder(p[1]);
 							else
 								LAssert(!"No folder for cd?");
 						}
 						else
 						{
 							LSubProcess PostCmd(p[0], p.Length() > 1 ? p[1] : LString());
 							if (PostCmd.Start(true, false))
 							{
 								char Buf[256];
 								ssize_t rd;
 								while ( (rd = PostCmd.Read(Buf, sizeof(Buf))) > 0 )
 								{
 									Write(Buf, rd);
 								}
 							}
 						}
 					}
 				}
 			}
 			else
 			{
 				// Create a nice error message.
 				LString ErrStr = LErrorCodeToString(SubProc->GetErrorCode());
 				if (ErrStr)
 				{
 					char *e = ErrStr.Get() + ErrStr.Length();
 					while (e > ErrStr && strchr(" \t\r\n.", e[-1]))
 						*(--e) = 0;
 				}
 					
 				sprintf_s(ErrBuf, sizeof(ErrBuf), "Running make failed with %i (%s)\n",
 					SubProc->GetErrorCode(),
 					ErrStr.Get());
 				Err = ErrBuf;
 			}
 		}
 	}
 	else
 	{
 		Err = "Couldn't find program to build makefile.";
 		LgiTrace("%s,%i - %s.\n", _FL, Err);
 	}
 
 	AppWnd *w = Proj->GetApp();
 	if (w)
 	{
 		w->PostEvent(M_BUILD_DONE);
 		if (Err)
 			Proj->GetApp()->PostEvent(M_BUILD_ERR, 0, (LMessage::Param)NewStr(Err));
 	}
 	else LAssert(0);
 	
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////////////
 IdeProject::IdeProject(AppWnd *App) : IdeCommon(NULL)
 {
 	Project = this;
 	d = new IdeProjectPrivate(App, this);
 	Tag = NewStr("Project");
 }
 
 IdeProject::~IdeProject()
 {
 	d->App->OnProjectDestroy(this);
 	LXmlTag::Empty(true);
 	DeleteObj(d);
 }
 
 bool IdeProject::OnNode(const char *Path, ProjectNode *Node, bool Add)
 {
 	if (!Path || !Node)
 	{
 		LAssert(0);
 		return false;
 	}
 
 	char Full[MAX_PATH_LEN];
 	if (LIsRelativePath(Path))
 	{
 		LAutoString Base = GetBasePath();
 		if (LMakePath(Full, sizeof(Full), Base, Path))
 		{
 			Path = Full;
 		}
 	}
 
 	bool Status = false;
 	if (Add)
 		Status = d->Nodes.Add(Path, Node);
 	else
 		Status = d->Nodes.Delete(Path);
 	
 	LString p = Path;
 	if (Status && CheckExists(p))
 		d->App->OnNode(p, Node, Add ? FindSymbolSystem::FileAdd : FindSymbolSystem::FileRemove);
 
 	return Status;
 }
 
 void IdeProject::ShowFileProperties(const char *File)
 {
 	ProjectNode *Node = NULL;
 	// char *fp = FindFullPath(File, &Node);
 	if (Node)
 	{
 		Node->OnProperties();
 	}
 }
 
 const char *IdeProject::GetFileComment()
 {
 	return d->Settings.GetStr(ProjCommentFile);
 }
 
 const char *IdeProject::GetFunctionComment()
 {
 	return d->Settings.GetStr(ProjCommentFunction);
 }
 
 IdeProject *IdeProject::GetParentProject()
 {
 	return d->ParentProject;
 }
 
 void IdeProject::SetParentProject(IdeProject *p)
 {
 	d->ParentProject = p;
 }
 
 bool IdeProject::GetChildProjects(List<IdeProject> &c)
 {
 	CollectAllSubProjects(c);
 	return c.Length() > 0;
 }
 
 bool IdeProject::RelativePath(LString &Out, const char *In, bool Debug)
 {
 	if (!In)
 		return false;
 
 	auto Base = GetBasePath();
 	if (!Base)
 		return false;
 
 	CheckExists(Base);
 if (Debug) LgiTrace("XmlBase='%s'\n		In='%s'\n", Base.Get(), In);
 		
 	LToken b(Base, DIR_STR);
 	LToken i(In, DIR_STR);
 	char out[MAX_PATH_LEN] = "";
 	
 if (Debug) LgiTrace("Len %i-%i\n", b.Length(), i.Length());
 	
 	auto ILen = i.Length() + (LDirExists(In) ? 0 : 1);
 	auto Max = MIN(b.Length(), ILen);
 	int Common = 0;
 	for (; Common < Max; Common++)
 	{
 		#ifdef WIN32
 		#define StrCompare stricmp
 		#else
 		#define StrCompare strcmp
 		#endif
 		
 if (Debug) LgiTrace("Cmd '%s'-'%s'\n", b[Common], i[Common]);
 		if (StrCompare(b[Common], i[Common]) != 0)
 		{
 			break;
 		}
 	}
 	
 if (Debug) LgiTrace("Common=%i\n", Common);
 	if (Common > 0)
 	{
 		if (Common < b.Length())
 		{
 			out[0] = 0;
 			auto Back = b.Length() - Common;
 if (Debug) LgiTrace("Back=%i\n", (int)Back);
 			for (int n=0; n<Back; n++)
 			{
 				strcat(out, "..");
 				if (n < Back - 1) strcat(out, DIR_STR);
 			}
 		}
 		else
 		{
 			strcpy(out, ".");
 		}
 		for (int n=Common; n<i.Length(); n++)
 		{
 			sprintf(out+strlen(out), "%s%s", DIR_STR, i[n]);
 		}
 		
 		Out = out;
 	}	
 	else
 	{
 		Out = In;
 	}		
 
 	CheckExists(Out);
 	return true;
 }
 
 bool IdeProject::GetExePath(char *Path, int Len)
 {
 	auto PExe = d->Settings.GetStr(ProjExe);
 	LString Exe;
 	if (!PExe)
 	{
 		// Use the default exe name?
 		Exe = GetExecutable(GetCurrentPlatform());
 		if (Exe)
 		{
 			printf("Exe='%s'\n", Exe.Get());
 			PExe = Exe;
 		}
 	}
 	
 	if (!PExe)
 		return false;	
 	
 	if (LIsRelativePath(PExe))
 	{
 		auto Base = GetBasePath();
 		if (Base)
 			LMakePath(Path, Len, Base, PExe);
 		else
 			return false;
 	}
 	else
 	{
 		strcpy_s(Path, Len, PExe);
 	}
 	
 	return true;
 }
 
 LString IdeProject::GetMakefile(IdePlatform Platform)
 {
 	const char *PMakefile = d->Settings.GetStr(ProjMakefile, NULL, Platform);
 	if (!PMakefile)
 		return LString();
 	
 	LString Path;
 	if (LIsRelativePath(PMakefile))
 	{
 		auto Base = GetBasePath();
 		if (Base)
 		{
 			char p[MAX_PATH_LEN];
 			LMakePath(p, sizeof(p), Base, PMakefile);
 			Path = p;
 		}
 	}
 	else
 	{
 		Path = PMakefile;
 	}
 	
 	return Path;
 }
 
 void IdeProject::Clean(bool All, BuildConfig Config)
 {
 	if (!d->Thread &&
 		d->Settings.GetStr(ProjMakefile))
 	{
 		auto m = GetMakefile(PlatformCurrent);
 		if (m)		
 		{
 			CheckExists(m);
 			d->Thread.Reset(new BuildThread(this, m, true, Config, All, sizeof(ssize_t)*8));
 		}
 	}
 }
 
 char *QuoteStr(char *s)
 {
 	LStringPipe p(256);
 	while (s && *s)
 	{
 		if (*s == ' ')
 		{
 			p.Push("\\ ", 2);
 		}
 		else p.Push(s, 1);
 		s++;
 	}
 	return p.NewStr();
 }
 
 class ExecuteThread : public LThread, public LStream, public LCancel
 {
 	IdeProject *Proj;
 	LString Exe, Args, Path;
 	int Len;
 	ExeAction Act;
 	int AppHnd;
 
 public:
 	ExecuteThread(IdeProject *proj, const char *exe, const char *args, char *path, ExeAction act) : LThread("ExecuteThread")
 	{
 		Len = 32 << 10;
 		Proj = proj;
 		Act = act;
 		Exe = exe;
 		Args = args;
 		Path = path;
 		DeleteOnExit = true;
 		AppHnd = proj->GetApp()->AddDispatch();
 		
 		Run();
 	}
 	
 	~ExecuteThread()
 	{
 		Cancel();
 		while (!IsExited())
 			LSleep(1);
 	}
 	
 	int Main() override
 	{
 		PostThreadEvent(AppHnd, M_SELECT_TAB, AppWnd::OutputTab);
 		PostThreadEvent(AppHnd, M_APPEND_TEXT, 0, AppWnd::OutputTab);
 		
 		if (Exe)
 		{
 			if (Act == ExeDebug)
 			{
 				LSubProcess sub("kdbg", Exe);
 				if (Path)
 					sub.SetInitFolder(Path);
 				if (sub.Start())
 					sub.Communicate(this, NULL, this);
 			}
 			else if (Act == ExeValgrind)
 			{
 				#ifdef LINUX
 				LString ExePath = Proj->GetExecutable(GetCurrentPlatform());
 				if (ExePath)
 				{
 					char Path[MAX_PATH_LEN];
 					char *ExeLeaf = LGetLeaf(Exe);
 					strcpy_s(Path, sizeof(Path), ExeLeaf ? ExeLeaf : Exe.Get());
 					LTrimDir(Path);
 									
 					char *Term = 0;
 					char *WorkDir = 0;
 					char *Execute = 0;
 					switch (LGetWindowManager())
 					{
 						case WM_Kde:
 							Term = "konsole";
 							WorkDir = "--workdir ";
 							Execute = "-e";
 							break;
 						case WM_Gnome:
 							Term = "gnome-terminal";
 							WorkDir = "--working-directory=";
 							Execute = "-x";
 							break;
 					}
 					
 					if (Term && WorkDir && Execute)
 					{					
 						char *e = QuoteStr(ExePath);
 						char *p = QuoteStr(Path);
 						char *a = Proj->GetExeArgs() ? Proj->GetExeArgs() : (char*)"";
 						char Args[512];
 						sprintf(Args,
 								"%s%s "
 								"--noclose "
 								"%s valgrind --tool=memcheck --num-callers=20 %s %s",
 								WorkDir,
 								p,
 								Execute,
 								e, a);
 								
 						LExecute(Term, Args);
 					}
 				}
 				#endif
 			}
 			else
 			{
 				LSubProcess sub(Exe, Args);
 				if (Path)
 					sub.SetInitFolder(Path);
 				if (sub.Start())
 					sub.Communicate(this, NULL, this);
 			}
 		}
 		
 		return 0;
 	}
 
 	ssize_t Write(const void *Buffer, ssize_t Size, int Flags = 0) override
 	{
 		if (Len <= 0)
 			return 0;
 
 		PostThreadEvent(AppHnd, M_APPEND_TEXT, (LMessage::Param)NewStr((char*)Buffer, Size), AppWnd::OutputTab);
 		Len -= Size;
 		return Size;
 	}
 };
 
 LDebugContext *IdeProject::Execute(ExeAction Act, LString *ErrMsg)
 {
 	auto Base = GetBasePath();
 	
 	if (!Base)
 	{
 		if (ErrMsg) *ErrMsg = "No base path for project.";
 		return NULL;		
 	}
 	
 	char e[MAX_PATH_LEN];
 	if (!GetExePath(e, sizeof(e)))
 	{
 		if (ErrMsg) *ErrMsg = "GetExePath failed.";
 		return NULL;		
 	}
 	
 	if (!LFileExists(e))
 	{
 		if (ErrMsg) ErrMsg->Printf("Executable '%s' doesn't exist.\n", e);
 		return NULL;
 	}
 
 	const char *Args = d->Settings.GetStr(ProjArgs);
 	const char *Env = d->Settings.GetStr(ProjEnv);
 	LString InitDir = d->Settings.GetStr(ProjInitDir);
 	int RunAsAdmin = d->Settings.GetInt(ProjDebugAdmin);
 	
 	#ifndef HAIKU
 	if (Act == ExeDebug)
 	{
 		if (InitDir && LIsRelativePath(InitDir))
 		{
 			LFile::Path p(Base);
 			p += InitDir;
 			InitDir = p.GetFull();
 		}
 			
 		return new LDebugContext(d->App, this, e, Args, RunAsAdmin != 0, Env, InitDir);
 	}
 	#endif
 
 	new ExecuteThread(	this,
 						e,
 						Args,
 						Base,
 						#if defined(HAIKU) || defined(WINDOWS)
 							ExeRun // No gdb or valgrind
 						#else
 							Act
 						#endif
 						);
 	return NULL;
 }
 
 bool IdeProject::IsMakefileAScript()
 {
 	auto m = GetMakefile(PlatformCurrent);
 	if (m)
 	{
 		auto Ext = LGetExtension(m);
 		if (!Stricmp(Ext, "py"))
 		{
 			// Not a makefile but a build script... can't update.
 			return true;
 		}
 	}
 
 	return false;
 }
 
 bool IdeProject::IsMakefileUpToDate()
 {
 	if (IsMakefileAScript())
 		return true; // We can't know if it's up to date...
 
 	List<IdeProject> Proj;
 	GetChildProjects(Proj);
 
 	Proj.Insert(this);
 	for (auto p: Proj)
 	{
 		// Is the project file modified after the makefile?
 		auto Proj = p->GetFullPath();
 		uint64 ProjModTime = 0, MakeModTime = 0;
 		LDirectory dir;
 		if (dir.First(Proj))
 		{
 			ProjModTime = dir.GetLastWriteTime();
 			dir.Close();
 		}
 
 		auto m = p->GetMakefile(PlatformCurrent);
 		if (!m)
 		{		
 			d->App->GetBuildLog()->Print("Error: no makefile? (%s:%i)\n", _FL);
 			break;
 		}
 		
 		auto Ext = LGetExtension(m);
 		if (!Stricmp(Ext, "py"))
 		{
 			// Not a makefile but a build script... can't update.
 			return true;
 		}
 
 		if (dir.First(m))
 		{
 			MakeModTime = dir.GetLastWriteTime();
 			dir.Close();
 		}
 
 		// printf("Proj=%s - Timestamps " LGI_PrintfInt64 " - " LGI_PrintfInt64 "\n", Proj.Get(), ProjModTime, MakeModTime);
 		if (ProjModTime != 0 &&
 			MakeModTime != 0 &&
 			ProjModTime > MakeModTime)
 		{
 			// Need to rebuild the makefile...
 			return false;
 		}
 	}
 	
 	return true;
 }
 
 bool IdeProject::FindDuplicateSymbols()
 {
 	LStream *Log = d->App->GetBuildLog();	
 	Log->Print("FindDuplicateSymbols starting...\n");
 
 	List<IdeProject> Proj;
 	CollectAllSubProjects(Proj);
 	Proj.Insert(this);
 
 	int Lines = 0;
 	
 	LHashTbl<StrKey<char,false>,int64> Map(200000);
 	int Found = 0;
 	for (auto p: Proj)
 	{
 		LString s = p->GetExecutable(GetCurrentPlatform());
 		if (s)
 		{
 			LString Args;
 			Args.Printf("--print-size --defined-only -C %s", s.Get());
 			LSubProcess Nm("nm", Args);
 			if (Nm.Start(true, false))
 			{
 				char Buf[256];
 				LStringPipe q;
 				for (ssize_t Rd = 0; (Rd = Nm.Read(Buf, sizeof(Buf))); )
 					q.Write(Buf, Rd);
 				LString::Array a = q.NewLStr().SplitDelimit("\r\n");
 				LHashTbl<StrKey<char,false>,bool> Local(200000);
 				for (auto &Ln: a)
 				{
 					LString::Array p = Ln.SplitDelimit(" \t", 3);
 					if (!Local.Find(p.Last()))
 					{
 						Local.Add(p.Last(), true);
 					
 						// const char *Sz = p[1];
 						int64 Ours = p[1].Int(16);
 						int64 Theirs = Map.Find(p.Last());
 						if (Theirs >= 0)
 						{
 							if (Ours != Theirs)
 							{
 								if (Found++ < 100)
 									Log->Print("    %s (" LPrintfInt64 " -> " LPrintfInt64 ")\n",
 										p.Last().Get(),
 										Ours, Theirs);
 							}
 						}
 						else if (Ours >= 0)
 						{						
 							Map.Add(p.Last(), Ours);
 						}
 						else
 						{
 							printf("Bad line: %s\n", Ln.Get());
 						}
 					}
 					Lines++;
 				}
 			}
 		}
 		else printf("%s:%i - GetExecutable failed.\n", _FL);
 	}
 
 	/*
 	char *Sym;
 	for (int Count = Map.First(&Sym); Count; Count = Map.Next(&Sym))
 	{
 		if (Count > 1)
 			Log->Print("    %i: %s\n", Count, Sym);
 	}
 	*/
 
 	Log->Print("FindDuplicateSymbols finished (%i lines)\n", Lines);
 	return false;
 }
 
 bool IdeProject::FixMissingFiles()
 {
 	FixMissingFilesDlg(this);
 	return true;
 }
 
 void IdeProject::Build(bool All, BuildConfig Config)
 {
 	if (d->Thread)
 	{
 		d->App->GetBuildLog()->Print("Error: Already building (%s:%i)\n", _FL);
 		return;
 	}
 
 	auto m = GetMakefile(PlatformCurrent);
 	CheckExists(m);
 	if (!m)
 	{		
 		d->App->GetBuildLog()->Print("Error: no makefile? (%s:%i)\n", _FL);
 		return;
 	}
 
 	if (GetApp())
 		GetApp()->PostEvent(M_APPEND_TEXT, 0, 0);
 
 	SetClean([&](bool ok)
 	{
 		if (!ok)
 			return;
 
 		if (!IsMakefileUpToDate())
 			CreateMakefile(GetCurrentPlatform(), true);
 		else
 			// Start the build thread...
 			d->Thread.Reset
 			(
 				new BuildThread
 				(
 					this,
 					m,
 					false,
 					Config,
 					All,
 					sizeof(size_t)*8
 				)
 			);
 	});
 }
 
 void IdeProject::StopBuild()
 {
 	d->Thread.Reset();
 }
 
 bool IdeProject::Serialize(bool Write)
 {
 	return true;
 }
 
 AppWnd *IdeProject::GetApp()
 {
 	return d->App;
 }
 
 const char *IdeProject::GetIncludePaths()
 {
 	return d->Settings.GetStr(ProjIncludePaths);
 }
 
 const char *IdeProject::GetPreDefinedValues()
 {
 	return d->Settings.GetStr(ProjDefines);
 }
 
 const char *IdeProject::GetExeArgs()
 {
 	return d->Settings.GetStr(ProjArgs);
 }
 
 LString IdeProject::GetExecutable(IdePlatform Platform)
 {
 	LString Bin = d->Settings.GetStr(ProjExe, NULL, Platform);
 	auto TargetType = d->Settings.GetStr(ProjTargetType, NULL, Platform);
 	auto Base = GetBasePath();
 
 	if (Bin)
 	{
 		if (LIsRelativePath(Bin) && Base)
 		{
 			char p[MAX_PATH_LEN];
 			if (LMakePath(p, sizeof(p), Base, Bin))
 				Bin = p;
 		}
 		
 		return Bin;
 	}
 
 	// Create binary name from target:	
 	auto Target = GetTargetName(Platform);
 	if (Target)
 	{
 		bool IsLibrary = Stristr(TargetType, "library");
 		int BuildMode = d->App->GetBuildMode();
 		const char *Name = BuildMode ? "Release" : "Debug";
 		const char *Postfix = BuildMode ? "" : "d";
 		
 		switch (Platform)
 		{			
 			case PlatformWin:
 			{
 				if (IsLibrary)
 					Bin.Printf("%s%s.dll", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			case PlatformMac:
 			{
 				if (IsLibrary)
 					Bin.Printf("lib%s%s.dylib", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			case PlatformLinux:
 			case PlatformHaiku:
 			{
 				if (IsLibrary)
 					Bin.Printf("lib%s%s.so", Target.Get(), Postfix);
 				else
 					Bin = Target;
 				break;
 			}
 			default:
 			{
 				LAssert(0);
 				printf("%s:%i - Unknown platform.\n", _FL);
 				return LString();
 			}
 		}
 		
 		// Find the actual file...
 		if (!Base)
 		{
 			printf("%s:%i - GetBasePath failed.\n", _FL);
 			return LString();
 		}
 			
 		char Path[MAX_PATH_LEN];
 		LMakePath(Path, sizeof(Path), Base, Name);
 		LMakePath(Path, sizeof(Path), Path, Bin);
 		if (LFileExists(Path))
 			Bin = Path;
 		else
 			printf("%s:%i - '%s' doesn't exist.\n", _FL, Path);
 		
 		
 		return Bin;
 	}
 	
 	return LString();
 }
 
 const char *IdeProject::GetFileName()
 {
 	return d->FileName;
 }
 
 int IdeProject::GetPlatforms()
 {
 	return PLATFORM_ALL;
 }
 	
 LAutoString IdeProject::GetFullPath()
 {
 	LAutoString Status;
 	if (!d->FileName)
 	{
 		// LAssert(!"No path.");
 		return Status;
 	}
 
 	LArray<const char*> sections;
 	IdeProject *proj = this;
 	while (	proj &&
 			proj->GetFileName() &&
 			LIsRelativePath(proj->GetFileName()))
 	{
 		sections.AddAt(0, proj->GetFileName());
 		proj = proj->GetParentProject();
 	}
 
 	if (!proj)
 	{
 		// LAssert(!"All projects have a relative path?");
 		return Status; // No absolute path in the parent projects?
 	}
 
 	char p[MAX_PATH_LEN];
 	strcpy_s(p, sizeof(p), proj->GetFileName()); // Copy the base path
 	if (sections.Length() > 0)
 		LTrimDir(p); // Trim off the filename
 	for (int i=0; i<sections.Length(); i++) // For each relative section
 	{
 		LMakePath(p, sizeof(p), p, sections[i]); // Append relative path
 		if (i < sections.Length() - 1)
 			LTrimDir(p); // Trim filename off
 	}
 	
 	Status.Reset(NewStr(p));
 	return Status;
 }
 
 LAutoString IdeProject::GetBasePath()
 {
 	auto a = GetFullPath();
 	LTrimDir(a);
 	return a;
 }
 
 void IdeProject::CreateProject()
 {
 	Empty();
 	
 	d->FileName.Empty();
 	d->UserFile.Empty();
 	d->App->GetTree()->Insert(this);
 	
 	ProjectNode *f = new ProjectNode(this);
 	if (f)
 	{
 		f->SetName("Source");
 		f->SetType(NodeDir);
 		InsertTag(f);
 	}
 	
 	f = new ProjectNode(this);
 	if (f)
 	{
 		f->SetName("Headers");
 		f->SetType(NodeDir);
 		InsertTag(f);
 	}
 	
 	d->Settings.Set(ProjEditorTabSize, 4);
 	d->Settings.Set(ProjEditorIndentSize, 4);
 	d->Settings.Set(ProjEditorUseHardTabs, true);
 	
 	d->Dirty = true;
 	Expanded(true);	
 }
 
 ProjectStatus IdeProject::OpenFile(const char *FileName)
 {
 	auto Log = d->App->GetBuildLog();
 
 	LProfile Prof("IdeProject::OpenFile");
 	Prof.HideResultsIfBelow(1000);
 
 	Empty();
 
 	Prof.Add("Init");
 
 	d->UserNodeFlags.Empty();
 	if (LIsRelativePath(FileName))
 	{
 		char p[MAX_PATH_LEN];
 		getcwd(p, sizeof(p));
 		LMakePath(p, sizeof(p), p, FileName);
 		d->FileName = p;
 	}
 	else
 	{
 		d->FileName = FileName;
 	}
 	d->UserFile = d->FileName + "." + LCurrentUserName();
 
 	if (!d->FileName)
 	{
 		Log->Print("%s:%i - No filename.\n", _FL);
 		return OpenError;
 	}
 	
 	Prof.Add("FileOpen");
 
 	LFile f;
 	LString FullPath = d->FileName.Get();
 	if (!CheckExists(FullPath) ||
 		!f.Open(FullPath, O_READWRITE))
 	{
 		Log->Print("%s:%i - Error: Can't open '%s'.\n", _FL, FullPath.Get());
 		return OpenError;
 	}
 
 	Prof.Add("Xml");
 
 	LXmlTree x;
 	LXmlTag r;
 	if (!x.Read(&r, &f))
 	{
 		Log->Print("%s:%i - Error: Can't read XML: %s\n", _FL, x.GetErrorMsg());
 		return OpenError;
 	}
 
 	Prof.Add("Progress Setup");
 
 	#if DEBUG_OPEN_PROGRESS
 	int64 Nodes = r.CountTags();
 	LProgressDlg Prog(d->App, 1000);
 	Prog.SetDescription("Loading project...");
 	Prog.SetLimits(0, Nodes);
 	Prog.SetYieldTime(1000);
 	Prog.SetAlwaysOnTop(true);
 	#endif
 
 	Prof.Add("UserFile");
 
 	if (LFileExists(d->UserFile))
 	{
 		LFile Uf;
 		if (Uf.Open(d->UserFile, O_READ))
 		{
 			LString::Array Ln = Uf.Read().SplitDelimit("\n");
 			for (unsigned i=0; i<Ln.Length(); i++)
 			{
 				LString::Array p = Ln[i].SplitDelimit(",");
 				if (p.Length() == 2)
 					d->UserNodeFlags.Add((int)p[0].Int(), (int)p[1].Int(16));
 			}
 		}
 	}
 	
 	if (!r.IsTag("Project"))
 	{
 		Log->Print("%s:%i - No 'Project' tag.\n", _FL);
 		return OpenError;
 	}
 
 	Prof.Add("OnOpen");
 
 	bool Ok = OnOpen(
 		#if DEBUG_OPEN_PROGRESS
 		&Prog,
 		#else
 		NULL,
 		#endif
 		&r);
 	#if DEBUG_OPEN_PROGRESS
 	if (Prog.IsCancelled())
 		return OpenCancel;
 	else 
 	#endif
 	if (!Ok)
 		return OpenError;
 
 	Prof.Add("Insert");
 
 	d->App->GetTree()->Insert(this);
 	Expanded(true);
 
 	Prof.Add("Serialize");
 	
 	d->Settings.Serialize(&r, false /* read */);
 	return OpenOk;
 }
 
 bool IdeProject::SaveFile()
 {
 	auto Full = GetFullPath();
 
 	if (ValidStr(Full) && d->Dirty)
 	{
 		LFile f;
 		if (f.Open(Full, O_WRITE))
 		{
 			f.SetSize(0);
 
 			LXmlTree x;
 			d->Settings.Serialize(this, true /* write */);
 
 			if (x.Write(this, &f))
 				d->Dirty = false;
 			else
 				LgiTrace("%s:%i - Failed to write XML.\n", _FL);
 		}
 		else LgiTrace("%s:%i - Couldn't open '%s' for writing.\n", _FL, Full.Get());
 	}
 
 	if (d->UserFileDirty)
 	{
 		LFile f;
 		LAssert(d->UserFile.Get());
 		if (f.Open(d->UserFile, O_WRITE))
 		{
 			f.SetSize(0);
 
 			// Save user file details..
 			// int Id;
 			// for (int Flags = d->UserNodeFlags.First(&Id); Flags >= 0; Flags = d->UserNodeFlags.Next(&Id))
 			for (auto i : d->UserNodeFlags)
 			{
 				f.Print("%i,%x\n", i.key, i.value);
 			}
 
 			d->UserFileDirty = false;
 		}
 	}
 
 	printf("\tIdeProject::SaveFile %i %i\n", d->Dirty, d->UserFileDirty);
 
 	return	!d->Dirty &&
 			!d->UserFileDirty;
 }
 
 void IdeProject::SetDirty()
 {
 	d->Dirty = true;
 	d->App->OnProjectChange();
 }
 
 void IdeProject::SetUserFileDirty()
 {
 	d->UserFileDirty = true;
 }
 
 bool IdeProject::GetExpanded(int Id)
 {
 	int f = d->UserNodeFlags.Find(Id);
 	return f >= 0 ? f : false;
 }
 
 void IdeProject::SetExpanded(int Id, bool Exp)
 {
 	if (d->UserNodeFlags.Find(Id) != (int)Exp)
 	{
 		d->UserNodeFlags.Add(Id, Exp);
 		SetUserFileDirty();
 	}
 }
 
 int IdeProject::AllocateId()
 {
 	return d->NextNodeId++;
 }
 
 template<typename T, typename Fn>
 bool CheckExists(LAutoString Base, T &p, Fn Setter, bool Debug)
 {
 	LFile::Path Full;
 	bool WasRel = LIsRelativePath(p);
 	if (WasRel)
 	{
 		Full = Base.Get();
 		Full += p.Get();
 	}
 	else Full = p.Get();
 	
 	bool Ret = Full.Exists();
 	if (!Ret)
 	{
 		// Is the case wrong?
 		for (int i=1; i<Full.Length(); i++)
 		{
 			LFile::Path t;
 			t = Full.Slice(0, i);
 			if (!t.Exists())
 			{
 				LDirectory dir;
 				bool Matched = false;
 				auto &Leaf = Full[i-1];
 				auto Parent = t.GetParent();
 				
 				if (Debug)
 					printf("Searching '%s' for missing '%s'\n", Parent.GetFull().Get(), Leaf.Get());
 				
 				for (auto b=dir.First(Parent); b; b = dir.Next())
 				{
 					if (!Stricmp(dir.GetName(), t.Last().Get()))
 					{
 						if (Debug)
 							printf("t[%i]: %s->%s\n", i, Leaf.Get(), dir.GetName());
 						Leaf = dir.GetName();
 						Matched = true;
 						break;
 					}
 				}
 				if (!Matched)					
 					break;
 			}
 		}
 		
 		if ((Ret = Full.Exists()))
 		{
 			LString Old = p.Get();
 			if (WasRel)
 			{
 				auto r = LMakeRelativePath(Base, Full);
 				Setter(p, r);
 			}
 			else
 			{
 				Setter(p, Full.GetFull());
 			}
 			
 			if (Debug)
 				printf("%s -> %s\n", Old.Get(), p.Get());
 		}
 	}
 
 	if (Debug)
 		printf("CheckExists '%s' = %i\n", Full.GetFull().Get(), Ret);		
 
 	return Ret;
 }
 
 bool IdeProject::CheckExists(LString &p, bool Debug)
 {
 	return ::CheckExists(GetBasePath(), p, [](LString &o, const char *i) {
 			o = i;
 		}, Debug);
 }
 
 bool IdeProject::CheckExists(LAutoString &p, bool Debug)
 {
 	return ::CheckExists(GetBasePath(), p, [](LAutoString &o, const char *i) {
 			o.Reset(NewStr(i));
 		}, Debug);
 }
 
 bool IdeProject::GetClean()
 {
 	for (auto i: *this)
 	{
 		ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 		if (p && !p->GetClean())
 			return false;
 	}
 	
 	return !d->Dirty && !d->UserFileDirty;
 }
 
 void IdeProject::SetClean(std::function<void(bool)> OnDone)
 {
-	auto CleanNodes = [&]()
+	auto CleanNodes = [this, OnDone]()
 	{
+		printf("IdeProject.SetClean.CleanNodes\n");
 		for (auto i: *this)
 		{
 			ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 			if (!p) break;
 			p->SetClean();
 		}
 
 		if (OnDone)
 			OnDone(true);
 	};
 
+	printf("IdeProject.SetClean dirty=%i,%i validfile=%i\n", d->Dirty, d->UserFileDirty, ValidStr(d->FileName));
 	if (d->Dirty || d->UserFileDirty)
 	{
 		if (ValidStr(d->FileName))
 			SaveFile();
 		else
 		{
-			LFileSelect s;
-			s.Parent(Tree);
-			s.Name("Project.xml");
-			s.Save([&](auto s, auto ok)
+			auto s = new LFileSelect;
+			s->Parent(Tree);
+			s->Name("Project.xml");
+			s->Save([this, OnDone, CleanNodes](auto s, auto ok)
 			{
-				if (!ok)
+				printf("IdeProject.SetClean.FileSelect ok=%i\n", ok);
+				if (ok)
+				{
+					d->FileName = s->Name();
+					d->UserFile = d->FileName + "." + LCurrentUserName();
+					d->App->OnFile(d->FileName, true);
+					Update();
+
+					CleanNodes();
+				}
+				else
 				{
 					if (OnDone)
 						OnDone(false);
-					return;
 				}
-
-				d->FileName = s->Name();
-				d->UserFile = d->FileName + "." + LCurrentUserName();
-				d->App->OnFile(d->FileName, true);
-				Update();
-
-				CleanNodes();
+				
+				delete s;
 			});
 			return;
 		}
 	}
 	
 	CleanNodes();
 }
 
 
 const char *IdeProject::GetText(int Col)
 {
 	if (d->FileName)
 	{
 		char *s = strrchr(d->FileName, DIR_CHAR);
 		return s ? s + 1 : d->FileName.Get();
 	}
 
 	return Untitled;
 }
 
 int IdeProject::GetImage(int Flags)
 {
 	return 0;
 }
 
 void IdeProject::Empty()
 {
 	LXmlTag *t;
 	while (Children.Length() > 0 &&
 		(t = Children[0]))
 	{
 		ProjectNode *n = dynamic_cast<ProjectNode*>(t);
 		if (n)
 		{
 			n->Remove();
 		}
 		DeleteObj(t);
 	}
 }
 
 LXmlTag *IdeProject::Create(char *Tag)
 {
 	if (!stricmp(Tag, TagSettings))
 		return NULL;
 
 	return new ProjectNode(this);
 }
 
 void IdeProject::OnMouseClick(LMouse &m)
 {
 	if (m.IsContextMenu())
 	{
 		LSubMenu Sub;
 		Sub.AppendItem("New Folder", IDM_NEW_FOLDER);
 		Sub.AppendItem("New Web Folder", IDM_WEB_FOLDER);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Build", IDM_BUILD);
 		Sub.AppendItem("Clean Project", IDM_CLEAN_PROJECT);
 		Sub.AppendItem("Clean All", IDM_CLEAN_ALL);
 		Sub.AppendItem("Rebuild Project", IDM_REBUILD_PROJECT);
 		Sub.AppendItem("Rebuild All", IDM_REBUILD_ALL);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Sort Children", IDM_SORT_CHILDREN);
 		Sub.AppendSeparator();
 		Sub.AppendItem("Settings", IDM_SETTINGS, true);
 		Sub.AppendItem("Insert Dependency", IDM_INSERT_DEP);
 
 		m.ToScreen();
 		auto c = _ScrollPos();
 		m.x -= c.x;
 		m.y -= c.y;
 		switch (Sub.Float(Tree, m.x, m.y))
 		{
 			case IDM_NEW_FOLDER:
 			{
 				auto Name = new LInput(Tree, "", "Name:", AppName);
 				Name->DoModal([this, Name](auto d, auto code)
 				{
 					if (code)
 						GetSubFolder(this, Name->GetStr(), true);
 					delete d;
 				});
 				break;
 			}
 			case IDM_WEB_FOLDER:
 			{
 				WebFldDlg *Dlg = new WebFldDlg(Tree, 0, 0, 0);
 				Dlg->DoModal([&](auto d, auto code)
 				{
 					if (Dlg->Ftp && Dlg->Www)
 					{
 						IdeCommon *f = GetSubFolder(this, Dlg->Name, true);
 						if (f)
 						{
 							f->SetAttr(OPT_Ftp, Dlg->Ftp);
 							f->SetAttr(OPT_Www, Dlg->Www);
 						}
 					}
 					delete Dlg;
 				});
 				break;
 			}
 			case IDM_BUILD:
 			{
 				StopBuild();
 				Build(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_CLEAN_PROJECT:
 			{
 				Clean(false, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_CLEAN_ALL:
 			{
 				Clean(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_REBUILD_PROJECT:
 			{
 				StopBuild();
 				Clean(false, d->App->GetBuildMode());
 				Build(false, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_REBUILD_ALL:
 			{
 				StopBuild();
 				Clean(true, d->App->GetBuildMode());
 				Build(true, d->App->GetBuildMode());
 				break;
 			}
 			case IDM_SORT_CHILDREN:
 			{
 				SortChildren();
 				Project->SetDirty();
 				break;
 			}
 			case IDM_SETTINGS:
 			{
 				d->Settings.Edit(Tree, [&]()
 				{
 					SetDirty();
 				});
 				break;
 			}
 			case IDM_INSERT_DEP:
 			{
 				LFileSelect *s = new LFileSelect;
 				s->Parent(Tree);
 				s->Type("Project", "*.xml");
 				s->Open([&](auto s, bool ok)
 				{
 					if (!ok)
 						return;
 					ProjectNode *New = new ProjectNode(this);
 					if (New)
 					{
 						New->SetFileName(s->Name());
 						New->SetType(NodeDependancy);
 						InsertTag(New);
 						SetDirty();
 					}
 					delete s;
 				});
 				break;
 			}
 		}
 	}
 }
 
 char *IdeProject::FindFullPath(const char *File, ProjectNode **Node)
 {
 	char *Full = 0;
 	
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		ProjectNode *n = c->FindFile(File, &Full);
 		if (n)
 		{
 			if (Node)
 				*Node = n;
 			break;
 		}
 	}
 	
 	return Full;
 }
 
 bool IdeProject::HasNode(ProjectNode *Node)
 {
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		if (c->HasNode(Node))
 			return true;
 	}
 	return false;
 }
 
 bool IdeProject::GetAllNodes(LArray<ProjectNode*> &Nodes)
 {
 	for (auto i:*this)
 	{
 		ProjectNode *c = dynamic_cast<ProjectNode*>(i);
 		if (!c) break;
 
 		c->AddNodes(Nodes);
 	}
 	return true;
 }
 
 bool IdeProject::InProject(bool FuzzyMatch, const char *Path, bool Open, IdeDoc **Doc)
 {
 	if (!Path)
 		return false;
 		
 	// Search complete path first...
 	ProjectNode *n = d->Nodes.Find(Path);	
 	if (!n && FuzzyMatch)
 	{
 		// No match, do partial matching.
 		const char *Leaf = LGetLeaf(Path);
 		auto PathLen = strlen(Path);
 		auto LeafLen = strlen(Leaf);
 		uint32_t MatchingScore = 0;
 
 		// Traverse all nodes and try and find the best fit.
 		// const char *p;
 		// for (ProjectNode *Cur = d->Nodes.First(&p); Cur; Cur = d->Nodes.Next(&p))
 		for (auto Cur : d->Nodes)
 		{
 			int CurPlatform = Cur.value->GetPlatforms();
 			uint32_t Score = 0;
 
 			if (stristr(Cur.key, Path))
 			{
 				Score += PathLen;
 			}
 			else if (stristr(Cur.key, Leaf))
 			{
 				Score += LeafLen;
 			}
 
 			const char *pLeaf = LGetLeaf(Cur.key);
 			if (pLeaf && !stricmp(pLeaf, Leaf))
 			{
 				Score |= 0x40000000;
 			}
 			if (Score && (CurPlatform & PLATFORM_CURRENT) != 0)
 			{
 				Score |= 0x80000000;
 			}
 
 			if (Score > MatchingScore)
 			{
 				MatchingScore = Score;
 				n = Cur.value;
 			}
 		}
 	}
 	
 	if (n && Doc)
 	{
 		*Doc = n->Open();
 	}
 	
 	return n != 0;
 }
 
 char *GetQuotedStr(char *Str)
 {
 	char *s = strchr(Str, '\"');
 	if (s)
 	{
 		s++;
 		char *e = strchr(s, '\"');
 		if (e)
 		{
 			return NewStr(s, e - s);
 		}
 	}
 
 	return 0;
 }
 
 void IdeProject::ImportDsp(const char *File)
 {
 	if (File && LFileExists(File))
 	{
 		char Base[256];
 		strcpy(Base, File);
 		LTrimDir(Base);
 		
 		char *Dsp = LReadTextFile(File);
 		if (Dsp)
 		{
 			LToken Lines(Dsp, "\r\n");
 			IdeCommon *Current = this;
 			bool IsSource = false;
 			for (int i=0; i<Lines.Length(); i++)
 			{
 				char *L = Lines[i];
 				if (strnicmp(L, "# Begin Group", 13) == 0)
 				{
 					char *Folder = GetQuotedStr(L);
 					if (Folder)
 					{
 						IdeCommon *Sub = Current->GetSubFolder(this, Folder, true);
 						if (Sub)
 						{
 							Current = Sub;
 						}
 						DeleteArray(Folder);
 					}
 				}
 				else if (strnicmp(L, "# End Group", 11) == 0)
 				{
 					IdeCommon *Parent = dynamic_cast<IdeCommon*>(Current->GetParent());
 					if (Parent)
 					{
 						Current = Parent;
 					}
 				}
 				else if (strnicmp(L, "# Begin Source", 14) == 0)
 				{
 					IsSource = true;
 				}
 				else if (strnicmp(L, "# End Source", 12) == 0)
 				{
 					IsSource = false;
 				}
 				else if (Current && IsSource && strncmp(L, "SOURCE=", 7) == 0)
 				{
 					ProjectNode *New = new ProjectNode(this);
 					if (New)
 					{
 						char *Src = 0;
 						if (strchr(L, '\"'))
 						{
 							Src = GetQuotedStr(L);
 						}
 						else
 						{
 							Src = NewStr(L + 7);
 						}						
 						if (Src)
 						{
 							// Make absolute path
 							char Abs[256];
 							LMakePath(Abs, sizeof(Abs), Base, ToUnixPath(Src));
 							
 							// Make relitive path
 							New->SetFileName(Src);
 							DeleteArray(Src);
 						}
 
 						Current->InsertTag(New);
 						SetDirty();
 					}
 				}
 			}
 			
 			DeleteArray(Dsp);
 		}
 	}
 }
 
 IdeProjectSettings *IdeProject::GetSettings()
 {
 	return &d->Settings;
 }
 
 bool IdeProject::BuildIncludePaths(LArray<LString> &Paths, bool Recurse, bool IncludeSystem, IdePlatform Platform)
 {
 	List<IdeProject> Projects;
 	if (Recurse)
 		GetChildProjects(Projects);
 	Projects.Insert(this, 0);
 
 	LHashTbl<StrKey<char>, bool> Map;
 	
 	for (auto p: Projects)
 	{
 		LString ProjInclude = d->Settings.GetStr(ProjIncludePaths, NULL, Platform);
 		LAutoString Base = p->GetBasePath();
 		
 		const char *Delim = ",;\r\n";
 		LString::Array In, Out;
 		LString::Array a = ProjInclude.SplitDelimit(Delim);
 		In = a;
 		
 		if (IncludeSystem)
 		{
 			LString SysInclude = d->Settings.GetStr(ProjSystemIncludes, NULL, Platform);
 			a = SysInclude.SplitDelimit(Delim);
 			In.SetFixedLength(false);
 			In.Add(a);
 		}
 		
 		for (unsigned i=0; i<In.Length(); i++)
 		{
 			auto p = ToPlatformPath(In[i], Platform);
 
 			char *Path = p;
 			if (*Path == '`')
 			{
 				// Run config app to get the full path list...
 				p = p.Strip("`");
 				LString::Array a = p.Split(" ", 1);
 				LSubProcess Proc(a[0], a.Length() > 1 ? a[1].Get() : NULL);
 				LStringPipe Buf;
 				if (Proc.Start())
 				{
 					Proc.Communicate(&Buf);
 
 					LString result = Buf.NewLStr();
 					a = result.Split(" \t\r\n");
 					for (int i=0; i<a.Length(); i++)
 					{
 						char *inc = a[i];
 						if (inc[0] == '-' &&
 							inc[1] == 'I')
 						{
 							Out.New() = a[i](2,-1);
 						}
 					}
 				}
 				else LgiTrace("%s:%i - Error: failed to run process for '%s'\n", _FL, p.Get());
 			}
 			else
 			{
 				// Add path literal
 				Out.New() = Path;
 			}
 		}
 			
 		for (int i=0; i<Out.Length(); i++)
 		{
 			char *Path = Out[i];
 			char *Full = 0, Buf[MAX_PATH_LEN];
 			if
 			(
 				*Path != '/'
 				&&
 				!(
 					IsAlpha(*Path)
 					&&
 					Path[1] == ':'
 				)
 			)
 			{
 				LMakePath(Buf, sizeof(Buf), Base, Path);
 				Full = Buf;
 			}
 			else
 			{
 				Full = Out[i];
 			}
 			
 			if (!Map.Find(Full))
 				Map.Add(Full, true);
 		}
 
 		// Add paths for the headers in the project... bit of a hack but it'll
 		// help it find them if the user doesn't specify the paths in the project.
 		LArray<ProjectNode*> Nodes;
 		if (p->GetAllNodes(Nodes))
 		{
 			auto Base = p->GetFullPath();
 			if (Base)
 			{
 				LTrimDir(Base);
 
 				for (auto &n: Nodes)
 				{
 					if (n->GetType() == NodeHeader &&				// Only look at headers.
 						(n->GetPlatforms() & (1 << Platform)) != 0)	// Exclude files not on this platform.
 					{
 						auto f = n->GetFileName();
 						char p[MAX_PATH_LEN];
 						if (f &&
 							LMakePath(p, sizeof(p), Base, f))
 						{
 							char *l = strrchr(p, DIR_CHAR);
 							if (l)
 								*l = 0;
 							if (!Map.Find(p))
 							{
 								Map.Add(p, true);
 							}
 						}
 					}
 				}
 			}
 		}
 	}
 
 	// char *p;
 	// for (bool b = Map.First(&p); b; b = Map.Next(&p))
 	for (auto p : Map)
 		Paths.Add(p.key);
 
 	return true;
 }
 
 void IdeProjectPrivate::CollectAllFiles(LTreeNode *Base, LArray<ProjectNode*> &Files, bool SubProjects, int Platform)
 {
 	for (auto i:*Base)
 	{
 		IdeProject *Proj = dynamic_cast<IdeProject*>(i);
 		if (Proj)
 		{
 			if (Proj->GetParentProject() && !SubProjects)
 			{
 				continue;
 			}
 		}
 		else
 		{
 			ProjectNode *p = dynamic_cast<ProjectNode*>(i);
 			if (p)
 			{
 				if (p->GetType() == NodeSrc ||
 					p->GetType() == NodeHeader)
 				{
 					if (p->GetPlatforms() & Platform)
 					{
 						Files.Add(p);
 					}
 				}
 			}
 		}
 
 		CollectAllFiles(i, Files, SubProjects, Platform);
 	}
 }
 
 LString IdeProject::GetTargetName(IdePlatform Platform)
 {
 	LString Status;
 	const char *t = d->Settings.GetStr(ProjTargetName, NULL, Platform);
 	if (ValidStr(t))
 	{
 		// Take target name from the settings
 		Status = t;
 	}
 	else
 	{
 		char *s = strrchr(d->FileName, DIR_CHAR);
 		if (s)
 		{
 			// Generate the target executable name
 			char Target[MAX_PATH_LEN];
 			strcpy_s(Target, sizeof(Target), s + 1);
 			s = strrchr(Target, '.');
 			if (s) *s = 0;
 			strlwr(Target);
 			s = Target;
 			for (char *i = Target; *i; i++)
 			{
 				if (*i != '.' && *i != ' ')
 				{
 					*s++ = *i;
 				}
 			}
 			*s = 0;
 			Status = Target;
 		}
 	}
 	
 	return Status;
 }
 
 LString IdeProject::GetTargetFile(IdePlatform Platform)
 {
 	LString Target = GetTargetName(PlatformCurrent);
 	if (!Target)
 	{
 		LAssert(!"No target?");
 		return LString();
 	}
 
 	const char *TargetType = d->Settings.GetStr(ProjTargetType);
 	if (!TargetType)
 	{
 		LAssert(!"Needs a target type.");
 		return LString();
 	}
 
 	if (!stricmp(TargetType, "Executable"))
 	{
 		return Target;
 	}
 	else if (!stricmp(TargetType, "DynamicLibrary"))
 	{
 		char t[MAX_PATH_LEN];
 		auto DefExt = PlatformDynamicLibraryExt(Platform);
 		strcpy_s(t, sizeof(t), Target);
 		char *ext = LGetExtension(t);
 		if (!ext)
 			sprintf(t + strlen(t), ".%s", DefExt);
 		else if (stricmp(ext, DefExt))
 			strcpy(ext, DefExt);
 		return t;
 	}
 	else if (!stricmp(TargetType, "StaticLibrary"))
 	{
 		LString Ret;
 		Ret.Printf("%s.%s", Target.Get(), PlatformSharedLibraryExt(Platform));
 		return Ret;
 	}
 	
 	return LString();
 }
 
 struct ProjDependency
 {
 	bool Scanned;
 	LAutoString File;
 	
 	ProjDependency(const char *f)
 	{
 		Scanned = false;
 		File.Reset(NewStr(f));
 	}
 };
 
 bool IdeProject::GetAllDependencies(LArray<char*> &Files, IdePlatform Platform)
 {
 	if (!GetTree()->Lock(_FL))
 		return false;
 		
 	LHashTbl<StrKey<char>, ProjDependency*> Deps;
 	LAutoString Base = GetBasePath();
 	
 	// Build list of all the source files...
 	LArray<LString> Src;
 	CollectAllSource(Src, Platform);
 	
 	// Get all include paths
 	LArray<LString> IncPaths;
 	BuildIncludePaths(IncPaths, false, false, Platform);
 	
 	// Add all source to dependencies
 	for (int i=0; i<Src.Length(); i++)
 	{
 		char *f = Src[i];
 		ProjDependency *dep = Deps.Find(f);
 		if (!dep)
 			Deps.Add(f, new ProjDependency(f));
 	}
 	
 	// Scan all dependencies for includes
 	LArray<ProjDependency*> Unscanned;
 	do
 	{
 		// Find all the unscanned dependencies
 		Unscanned.Length(0);
 		// for (ProjDependency *d = Deps.First(); d; d = Deps.Next())
 		for (auto d : Deps)
 		{
 			if (!d.value->Scanned)
 				Unscanned.Add(d.value);
 		}		
 
 		for (int i=0; i<Unscanned.Length(); i++)
 		{
 			// Then scan source for includes...
 			ProjDependency *d = Unscanned[i];
 			d->Scanned = true;
 			
 			char *Src = d->File;
 			char Full[MAX_PATH_LEN];
 			if (LIsRelativePath(d->File))
 			{
 				LMakePath(Full, sizeof(Full), Base, d->File);
 				Src = Full;
 			}
 
 			LArray<char*> SrcDeps;
 			if (GetDependencies(Src, IncPaths, SrcDeps, Platform))
 			{
 				for (int n=0; n<SrcDeps.Length(); n++)
 				{
 					// Add include to dependencies...
 					char *File = SrcDeps[n];
 
 					if (LIsRelativePath(File))
 					{
 						LMakePath(Full, sizeof(Full), Base, File);
 						File = Full;
 					}
 
 					if (!Deps.Find(File))
 					{						
 						Deps.Add(File, new ProjDependency(File));
 					}
 				}
 				SrcDeps.DeleteArrays();
 			}
 		}
 	}
 	while (Unscanned.Length() > 0);
 	
 	// for (ProjDependency *d = Deps.First(); d; d = Deps.Next())
 	for (auto d : Deps)
 	{
 		Files.Add(d.value->File.Release());
 	}
 	
 	Deps.DeleteObjects();
 	GetTree()->Unlock();
 	
 	return true;
 }
 
 bool IdeProject::GetDependencies(const char *InSourceFile, LArray<LString> &IncPaths, LArray<char*> &Files, IdePlatform Platform)
 {
 	LString SourceFile = InSourceFile;
 	if (!CheckExists(SourceFile))
 	{
 		LgiTrace("%s:%i - can't read '%s'\n", _FL, SourceFile.Get());
 		return false;
 	}
 
 	LAutoString c8(LReadTextFile(SourceFile));
 	if (!c8)
 		return false;
 
 	LArray<char*> Headers;
 	if (!BuildHeaderList(c8, Headers, IncPaths, false))
 		return false;
 	
 	for (int n=0; n<Headers.Length(); n++)
 	{
 		char *i = Headers[n];
 		LString p;
 		if (!RelativePath(p, i))
 			p = i;
 		ToUnixPath(p);
 		Files.Add(NewStr(p));
 	}
 	Headers.DeleteArrays();
 	
 	return true;
 }
 
 int MakefileThread::Instances = 0;
 
 bool IdeProject::CreateMakefile(IdePlatform Platform, bool BuildAfterwards)
 {
 	if (d->CreateMakefile)
 	{
 		if (d->CreateMakefile->IsExited())
 			d->CreateMakefile.Reset();
 		else
 		{
 			d->App->GetBuildLog()->Print("%s:%i - Makefile thread still running.\n", _FL);
 			return false;
 		}
 	}
 	
 	if (Platform == PlatformCurrent)
 		Platform = GetCurrentPlatform();
 
 	return d->CreateMakefile.Reset(new MakefileThread(d, Platform, BuildAfterwards));
 }
 
 void IdeProject::OnMakefileCreated()
 {
 	if (d->CreateMakefile)
 	{
 		d->CreateMakefile.Reset();
 		if (MakefileThread::Instances == 0)
 			GetApp()->PostEvent(M_LAST_MAKEFILE_CREATED);
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////
 IdeTree::IdeTree() : LTree(IDC_PROJECT_TREE, 0, 0, 100, 100)
 {
 	Hit = 0;
 	MultiSelect(true);
 }
 
 void IdeTree::OnCreate()
 {
 	SetWindow(this);
 }
 
 void IdeTree::OnDragExit()
 {
 	SelectDropTarget(0);
 }
 
 int IdeTree::WillAccept(LDragFormats &Formats, LPoint p, int KeyState)
 {
 	static bool First = true;
 	
 	Formats.SupportsFileDrops();
 	Formats.Supports(NODE_DROP_FORMAT);
 	First = false;
 		
 	if (Formats.Length() == 0)
 	{
 		LgiTrace("%s:%i - No valid drop formats.\n", _FL);
 		return DROPEFFECT_NONE;
 	}
 
 	Hit = ItemAtPoint(p.x, p.y);
 	if (!Hit)
 	{
 		SelectDropTarget(NULL);
 		return DROPEFFECT_NONE;
 	}
 
 	if (Formats.HasFormat(LGI_FileDropFormat))
 	{
 		SelectDropTarget(Hit);
 		return DROPEFFECT_LINK;
 	}
 
 	IdeCommon *Src = dynamic_cast<IdeCommon*>(Selection());
 	IdeCommon *Dst = dynamic_cast<IdeCommon*>(Hit);
 	if (Src && Dst)
 	{
 		// Check this folder is not a child of the src
 		for (IdeCommon *n=Dst; n; n=dynamic_cast<IdeCommon*>(n->GetParent()))
 		{
 			if (n == Src)
 				return DROPEFFECT_NONE;
 		}
 	}
 
 	// Valid target
 	SelectDropTarget(Hit);
 	return DROPEFFECT_MOVE;
 }
 
 int IdeTree::OnDrop(LArray<LDragData> &Data, LPoint p, int KeyState)
 {
 	int Ret = DROPEFFECT_NONE;
 	SelectDropTarget(NULL);
 	if (!(Hit = ItemAtPoint(p.x, p.y)))
 		return Ret;
 	
 	for (unsigned n=0; n<Data.Length(); n++)
 	{
 		LDragData &dd = Data[n];
 		LVariant *Data = &dd.Data[0];
 		if (dd.IsFormat(NODE_DROP_FORMAT))
 		{
 			if (Data->Type == GV_BINARY && Data->Value.Binary.Length == sizeof(ProjectNode*))
 			{
 				ProjectNode *Src = ((ProjectNode**)Data->Value.Binary.Data)[0];
 				if (Src)
 				{
 					ProjectNode *Folder = dynamic_cast<ProjectNode*>(Hit);
 					while (Folder && Folder->GetType() != NodeDir)
 						Folder = dynamic_cast<ProjectNode*>(Folder->GetParent());
 
 					IdeCommon *Dst = dynamic_cast<IdeCommon*>(Folder?Folder:Hit);
 					if (Dst)
 					{
 						// Check this folder is not a child of the src
 						for (IdeCommon *n=Dst; n; n=dynamic_cast<IdeCommon*>(n->GetParent()))
 						{
 							if (n == Src)
 								return DROPEFFECT_NONE;
 						}
 
 						// Detach
 						LTreeItem *i = dynamic_cast<LTreeItem*>(Src);
 						i->Detach();
 						if (Src->LXmlTag::Parent)
 						{
 							LAssert(Src->LXmlTag::Parent->Children.HasItem(Src));
 							Src->LXmlTag::Parent->Children.Delete(Src);
 						}
 						
 						// Attach
 						Src->LXmlTag::Parent = Dst;
 						Dst->Children.SetFixedLength(false);
 						Dst->Children.Add(Src);
 						Dst->Children.SetFixedLength(true);
 						Dst->Insert(Src);
 						
 						// Dirty
 						Src->GetProject()->SetDirty();
 					}
 				
 					Ret = DROPEFFECT_MOVE;
 				}
 			}
 		}
 		else if (dd.IsFileDrop())
 		{
 			ProjectNode *Folder = dynamic_cast<ProjectNode*>(Hit);
 			while (Folder && Folder->GetType() > NodeDir)
 				Folder = dynamic_cast<ProjectNode*>(Folder->GetParent());
 			
 			IdeCommon *Dst = dynamic_cast<IdeCommon*>(Folder?Folder:Hit);
 			if (Dst)
 			{
 				AddFilesProgress Prog(this);
 				LDropFiles Df(dd);
 				for (int i=0; i<Df.Length() && !Prog.Cancel; i++)
 				{
 					if (Dst->AddFiles(&Prog, Df[i]))
 						Ret = DROPEFFECT_LINK;
 				}
 			}
 		}
 		else LgiTrace("%s:%i - Unknown drop format: %s.\n", _FL, dd.Format.Get());
 	}
 
 	return Ret;
 }
 
 /////////////////////////////////////////////////////////////////////////////////////////////////
 AddFilesProgress::AddFilesProgress(LViewI *par)
 {
 	v = 0;
 	Cancel = false;
 	Msg = NULL;
 	SetParent(par);
 	Ts = LCurrentTime();
 	LRect r(0, 0, 140, 100);
 	SetPos(r);
 	MoveSameScreen(par);
 	Name("Importing files...");
 
 	LString::Array a = LString(DefaultExt).SplitDelimit(",");
 	for (unsigned i=0; i<a.Length(); i++)
 	{
 		Exts.Add(a[i], true);
 	}
 
 	LTableLayout *t = new LTableLayout(100);
 	AddView(t);
 		
 	auto *c = t->GetCell(0, 0);
 	c->Add(new LTextLabel(-1, 0, 0, -1, -1, "Loaded:"));
 		
 	c = t->GetCell(1, 0);
 	c->Add(Msg = new LTextLabel(-1, 0, 0, -1, -1, "..."));
 		
 	c = t->GetCell(0, 1, true, 2);
 	c->TextAlign(LCss::Len(LCss::AlignRight));
 	c->Add(new LButton(IDCANCEL, 0, 0, -1, -1, "Cancel"));
 }
 
 int64 AddFilesProgress::Value()
 {
 	return v;
 }
 
 void AddFilesProgress::Value(int64 val)
 {
 	v = val;
 
 	uint64 Now = LCurrentTime();
 	if (Visible())
 	{
 		if (Now - Ts > 200)
 		{
 			if (Msg)
 			{
 				Msg->Value(v);
 				Msg->SendNotify(LNotifyTableLayoutRefresh);
 			}
 			Ts = Now;
 		}
 	}
 	else if (Now - Ts > 1000)
 	{
 		DoModeless();
 		SetAlwaysOnTop(true);
 	}
 }
 
 int AddFilesProgress::OnNotify(LViewI *c, LNotification n)
 {
 	if (c->GetId() == IDCANCEL)
 		Cancel = true;
 	return 0;
 }
diff --git a/Ide/Code/LgiIde.cpp b/Ide/Code/LgiIde.cpp
--- a/Ide/Code/LgiIde.cpp
+++ b/Ide/Code/LgiIde.cpp
@@ -1,4740 +1,4743 @@
 #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 OPT_PLATFORM			"Platform"
 
 #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, App->GetPlatform());
 
 		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;
 	}
 };
 
 //////////////////////////////////////////////////////////////////////////////////////////
 const 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(NULL);
 	}
 	
 	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;
 	int Platform = 0;
 	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 = NULL;
 	LString::Array RecentProjects;
 	LSubMenu *RecentProjectsMenu = NULL;
 
 	// 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;
 
 		Icons = LLoadImageList("icons.png", 16, 16);
 
 		Options.SerializeFile(false);
 		App->SerializeState(&Options, "WndPos", true);
 
 		SerializeStringList("RecentFiles", &RecentFiles, false);
 		SerializeStringList("RecentProjects", &RecentProjects, false);
 	}
 	
 	~AppWndPrivate()
 	{
 		FindSym.Reset();
 		Finder.Reset();
 		if (Output)
 			Output->Save();
 		App->SerializeState(&Options, "WndPos", false);
 		SerializeStringList("RecentFiles", &RecentFiles, true);
 		SerializeStringList("RecentProjects", &RecentProjects, true);
 		Options.SerializeFile(true);
 		
 		while (Docs.Length())
 		{
 			auto len = Docs.Length();
 			delete Docs[0];
 			LAssert(Docs.Length() != len); // doc must delete itself...
 		}
 
 		auto root = App->RootProject();
 		if (root)
 		{
 			// printf("Deleting proj %s\n", root->GetFileName());
 			delete root;
 		}
 		LAssert(!Projects.Length());
 			
 		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 (!a[n] || stricmp(a[n], File) == 0)
 						a.DeleteAt(n--);
 				}
 			}
 
 			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, 1000, 760);
 	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 SplitPx = 270, OutPx = 250, v;
 	d->Options.GetValue(OPT_SPLIT_PX, SplitPx);
 	d->Options.GetValue(OPT_OUTPUT_PX, OutPx);
 
 	if (d->Options.GetValue(OPT_PLATFORM, v))
 		SetPlatform(v.CastInt32());
 	else
 		SetPlatform(PLATFORM_CURRENT);
 
 	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(SplitPx.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
 
 	OnCommand(IDM_NEW, 0, NULL);
 }
 
 AppWnd::~AppWnd()
 {
 	LAssert(IsClean());
 	#ifdef HAIKU
 	WaitThread();
 	#endif
 
 	LVariant v;
 	if (d->HBox)
 		d->Options.SetValue(OPT_SPLIT_PX, v = d->HBox->Value());
 	if (d->Output)
 		d->Options.SetValue(OPT_OUTPUT_PX, v = d->Output->Y());
 	d->Options.SetValue(OPT_PLATFORM, v = d->Platform);
 
 	ShutdownFtpThread();
 
 	LAppInst->AppWnd = NULL;
 	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();
 	}
 	
 	for (auto n: NeedsPulse)
 		n->OnPulse();
 }
 
 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.NewLStr().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.NewLStr().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.NewLStr().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("");
 	}
 }
 
 int AppWnd::GetPlatform()
 {
 	return d->Platform;
 }
 
 bool AppWnd::SetPlatform(int p)
 {
 	if (p == 0)
 		p = PLATFORM_CURRENT;
 
 	if (d->Platform == p)
 		return false;
 
 	d->Platform = p;
 
 	if (auto m = GetMenu())
 	{
 		bool all = d->Platform == PLATFORM_ALL;
 		#define SET_CHK(id, flag) \
 			{ auto mi = m->FindItem(id); \
 			if (mi) mi->Checked((d->Platform & flag) && !all); }
 
 		SET_CHK(IDM_WIN, PLATFORM_WIN32);
 		SET_CHK(IDM_LINUX, PLATFORM_LINUX);
 		SET_CHK(IDM_MAC, PLATFORM_MAC);
 		SET_CHK(IDM_HAIKU, PLATFORM_HAIKU);
 		auto mi = m->FindItem(IDM_ALL_OS);
 		if (mi) mi->Checked(all);
 	}
 	
 	return true;
 }
 
 bool AppWnd::IsClean()
 {
 	for (auto Doc: d->Docs)
 	{
 		if (!Doc->GetClean())
 			return false;
 	}
 
 	for (auto Proj: d->Projects)
 	{
 		if (!Proj->GetClean())
 			return false;
 	}
 	
 	return true;
 }
 
 struct SaveState
 {
 	AppWndPrivate *d = NULL;
 	LArray<IdeDoc*> Docs;
 	LArray<IdeProject*> Projects;
 	std::function<void(bool)> Callback;
 	bool Status = true;
 	bool CloseDirty = false;
 
 	void Iterate()
 	{
 		if (Docs.Length())
 		{
 			auto doc = Docs[0];
 			Docs.DeleteAt(0);
 			// printf("Saving doc...\n");
 			doc->SetClean([this, doc](bool ok)
 			{
 				// printf("SetClean cb ok=%i\n", ok);
 				if (ok)
 					d->OnFile(doc->GetFileName());
 				else
 				{
 					if (CloseDirty)
 						delete doc;
 					Status = false;
 				}
 				// printf("SetClean cb iter\n", ok);
 				Iterate();
 			});
 		}
 		else if (Projects.Length())
 		{
 			auto proj = Projects[0];
 			Projects.DeleteAt(0);
-			// printf("Saving proj...\n");
+			
+			printf("Saving proj...\n");
 			proj->SetClean([this, proj](bool ok)
 			{
+				printf("save.proj.cb ok=%i\n", ok);
+				
 				if (ok)
 					d->OnFile(proj->GetFileName(), true);
 				else
 				{
 					if (CloseDirty)
 						delete proj;
 					Status = false;
 				}
 				Iterate();
 			});
 		}
 		else
 		{
 			// printf("Doing callback...\n");
 			if (Callback)
 				Callback(Status);
 
 			// printf("Deleting...\n");
 			delete this;
 		}
 	}
 };
 
 void AppWnd::SaveAll(std::function<void(bool)> Callback, bool CloseDirty)
 {
 	auto ss = new SaveState;	
 	ss->d = d;
 	ss->Callback = Callback;
 	ss->CloseDirty = CloseDirty;
 	for (auto Doc: d->Docs)
 	{
 		if (!Doc->GetClean())
 			ss->Docs.Add(Doc);
 	}	
 	for (auto Proj: d->Projects)
 	{
 		if (!Proj->GetClean())
 			ss->Projects.Add(Proj);
 	}	
 	ss->Iterate();
 }
 
 void AppWnd::CloseAll()
 {
 	SaveAll([&](auto status)
 	{	
 		if (!status)
 		{
 			LgiTrace("%s:%i - status=%i\n", _FL, status);
 			return;
 		}
 			
 		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 IsOsQuit)
 {
 	if (!IsClean())
 	{
 		SaveAll([](bool status)
 		{
 			LCloseApp();
 		},	true);	
 	
 		return false;
 	}
 	else
 	{
 		return LWindow::OnRequestClose(IsOsQuit);
 	}
 }
 
 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()
 {
 	for (auto p: d->Projects)
 		if (!p->GetParentProject())
 			return p;
 	
 	return NULL;
 }
 
 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;
 
 	if (d->FindSym)
 		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);
 		}
 	}
 	
 	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));
 				// Fall through..
 			}
 			case IDCANCEL:
 			{
 				EndModal(c->GetId());
 				break;
 			}
 			case IDC_SET_FONT:
 			{
 				Font.DoUI(this, [&](auto ui)
 				{
 					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([&](bool status)
 	{	
 		if (!status)
 		{
 			LgiTrace("%s:%i - status=%i\n", _FL);
 			return;
 		}
 		
 		IdeDoc *Top;
 		IdeProject *p = RootProject();
 		if (p)
 		{		
 			UpdateState(-1, true);
 
 			p->Build(false, GetBuildMode());
 		}
 		else if ((Top = TopDoc()))
 		{
 			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:
 		{
 			auto dlg = new Options(this);
 			dlg->DoModal(NULL);
 			break;
 		}
 		case IDM_HELP:
 		{
 			LExecute(APP_URL);
 			break;
 		}
 		case IDM_ABOUT:
 		{
 			auto dlg = new LAbout(	this,
 									AppName, APP_VER,
 									"\nLGI Integrated Development Environment",
 									"icon128.png",
 									APP_URL,
 									"fret@memecode.com");
 			dlg->DoModal(NULL);
 			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 = new LFileSelect;
 			s->Parent(this);
 			
 			// printf("File open dlg from thread=%u\n", GetCurrentThreadId());
 			s->Open([&](auto s, auto ok)
 			{
 				// printf("open handler start... ok=%i thread=%u\n", ok, GetCurrentThreadId());
 				if (ok)
 					OpenFile(s->Name());
 				// printf("open handler deleting...\n");
 				delete s;
 				// printf("open handler deleted...\n");
 			});
 			break;
 		}
 		case IDM_SAVE_ALL:
 		{
 			SaveAll(NULL);
 			break;
 		}
 		case IDM_SAVE:
 		{
 			IdeDoc *Top = TopDoc();
 			if (Top)
 				Top->SetClean(NULL);
 			break;
 		}
 		case IDM_SAVEAS:
 		{
 			IdeDoc *Top = TopDoc();
 			if (Top)
 			{
 				LFileSelect *s = new LFileSelect;
 				s->Parent(this);
 				s->Save([&](auto s, auto ok)
 				{
 					Top->SetFileName(s->Name(), true);
 					d->OnFile(s->Name());
 					delete s;
 				});
 			}
 			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(NULL);
 			}
 			else LgiTrace("%s:%i - No focus doc.\n", _FL);
 			break;
 		}
 		case IDM_FIND_NEXT:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 			{
 				Doc->DoFindNext(NULL);
 			}
 			else LgiTrace("%s:%i - No focus doc.\n", _FL);
 			break;
 		}
 		case IDM_REPLACE:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 			{
 				Doc->DoReplace(NULL);
 			}
 			else LgiTrace("%s:%i - No focus doc.\n", _FL);
 			break;
 		}
 		case IDM_GOTO:
 		{
 			LTextView3 *Doc = FocusEdit();
 			if (Doc)
 				Doc->DoGoto(NULL);
 			else
 			{
 				LInput *Inp = new LInput(this, NULL, LLoadString(L_TEXTCTRL_GOTO_LINE, "Goto [file:]line:"), "Goto");
 				Inp->DoModal([Inp,this](auto dlg, auto code)
 				{
 					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);
 					
 					delete dlg;
 				});
 			}
 			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;
 				}		
 
 				auto Dlg = new FindInFiles(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;
 				}
 
 				Dlg->DoModal([this, Dlg, p](auto dlg, auto code)
 				{
 					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();
 					
 					if (d->FindParameters->Text)
 						d->Finder->PostEvent(FindInFilesThread::M_START_SEARCH, (LMessage::Param) new FindParams(d->FindParameters));
 					
 					delete Dlg;
 				});
 			}
 			break;
 		}
 		case IDM_FIND_SYMBOL:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (Doc)
 			{
 				Doc->GotoSearch(IDC_SYMBOL_SEARCH);
 			}
 			else
 			{
 				d->FindSym->OpenSearchDlg(this, [&](auto r)
 				{
 					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
 			{
 				auto d = new FindInProject(this);
 				d->DoModal([](auto dlg, auto ctrlId){
 					delete dlg;
 				});
 			}
 			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 = new LFileSelect;
 			s->Parent(this);
 			s->Type("Projects", "*.xml");
 			s->Open([&](auto s, auto ok)
 			{
 				if (ok)
 				{
 					CloseAll();
 					OpenProject(s->Name(), NULL, Cmd == IDM_NEW_PROJECT);
 					if (d->Tree)
 					{
 						d->Tree->Focus(true);
 					}
 				}
 				delete s;
 			});
 			break;
 		}
 		case IDM_IMPORT_DSP:
 		{
 			IdeProject *p = RootProject();
 			if (p)
 			{
 				LFileSelect *s = new LFileSelect;
 				s->Parent(this);
 				s->Type("Developer Studio Project", "*.dsp");
 				s->Open([&](auto s, auto ok)
 				{
 					if (ok)
 						p->ImportDsp(s->Name());
 					delete s;
 				});
 			}
 			break;
 		}
 		case IDM_RUN:
 		{
 			SaveAll([&](bool status)
 			{
 				if (!status)
 				{
 					LgiTrace("%s:%i - status=%i\n", _FL, status);
 					return;
 				}
 				
 				IdeProject *p = RootProject();
 				if (p)
 					p->Execute();
 			});
 			break;
 		}
 		case IDM_VALGRIND:
 		{
 			SaveAll([&](bool status)
 			{
 				if (!status)
 				{
 					LgiTrace("%s:%i - status=%i\n", _FL, status);
 					return;
 				}
 				
 				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([&](bool status)
 			{
 				if (!status)
 				{
 					LgiTrace("%s:%i - status=%i\n", _FL, status);
 					return;
 				}
 				
 				IdeProject *p = RootProject();
 				if (!p)
 				{
 					LgiMsg(this, "No project loaded.", "Error");
 					return;
 				}
 
 				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([&](bool status)
 			{
 				if (!status)
 				{
 					LgiTrace("%s:%i - status=%i\n", _FL, status);
 					return;
 				}
 				
 				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;
 		}
 
 		//
 		// OS Platform
 		//
 		#define HANDLE_PLATFORM_ITEM(id, flag) \
 		case id: \
 		{ \
 			auto mi = GetMenu()->FindItem(id); \
 			if (!mi) break; \
 			if (d->Platform == PLATFORM_ALL) d->Platform = 0; \
 			if (mi->Checked()) SetPlatform(d->Platform & ~flag); \
 			else               SetPlatform(d->Platform | flag); \
 			break; \
 		}
 		HANDLE_PLATFORM_ITEM(IDM_WIN, PLATFORM_WIN32)
 		HANDLE_PLATFORM_ITEM(IDM_LINUX, PLATFORM_LINUX)
 		HANDLE_PLATFORM_ITEM(IDM_MAC, PLATFORM_MAC)
 		HANDLE_PLATFORM_ITEM(IDM_HAIKU, PLATFORM_HAIKU)
 		case IDM_ALL_OS:
 		{
 			SetPlatform(PLATFORM_ALL);
 			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 = new LInput(this, "", "Separator:", AppName);
 			i->DoModal([&](auto dlg, auto ok)
 			{
 				if (ok)
 					Doc->SplitSelection(i->GetStr());
 				delete i;
 			});
 			break;
 		}
 		case IDM_JOIN:
 		{
 			IdeDoc *Doc = FocusDoc();
 			if (!Doc)
 				break;
 
 			LInput *i = new LInput(this, "", "Separator:", AppName);
 			i->DoModal([&](auto dlg, auto ok)
 			{
 				if (ok)
 					Doc->JoinSelection(i->GetStr());
 				delete i;
 			});
 			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:
 		{
 			int index = Cmd - IDM_RECENT_FILE;
 			auto r = d->RecentFiles.IdxCheck(index)? d->RecentFiles[index] : LString();
 			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);
 			}
 
 			index = Cmd - IDM_RECENT_PROJECT;
 			auto p = d->RecentProjects.IdxCheck(index) ? d->RecentProjects[index] : LString();
 			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)
 {
 	if (d)
 	{
 		auto locked = Lock(_FL);
 		// printf("OnProjectDestroy(%s) %i\n", Proj->GetFileName(), locked);
 		d->Projects.Delete(Proj);
 		if (locked) Unlock();
 	}
 	else LAssert(!"No priv");
 }
 
 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)
 	{
 		auto locked = Lock(_FL);
 		d->Docs.Delete(Doc);
 		d->UpdateMenus();
 		if (locked) Unlock();
 	}
 	else
 	{
 		LAssert(!"OnDocDestroy no priv...\n");
 	}
 }
 
 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)
 {
 	d->FindSym->Search(ResultsSinkHnd, Sym, d->Platform);
 }
 
 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, 210);
 		SetPos(r);
 		Sunken(true);
 		printf("_BorderSize=%i\n", _BorderSize);
 	}
 
 	void OnPaint(LSurface *pdc)
 	{
 		auto c = GetClient();
 		
 		pdc->Colour(LColour::Red);
 		pdc->Line(c.x1, c.y1, c.x2, c.y2);		
 		pdc->Ellipse(c.x1+(c.X()/2)+10, c.y1+(c.Y()/2), c.X()/2, c.Y()/2);
 	}
 };
 
 #include "lgi/common/Tree.h"
 #include "lgi/common/List.h"
 
 class Test : public LWindow
 {
 public:
 	Test()
 	{
 		LRect r(100, 100, 800, 700);
 		SetPos(r);
 		Name("Test");
 		SetQuitOnClose(true);
 
 		if (Attach(0))
 		{
 			// AddView(new TestView);
 			
 			// auto t = new LTree(10, 10, 10, 100, 200);
 			auto t = new LTextLabel(10, 10, 10, 100, 35, "Text");
 			AddView(t);			
 			
 			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/LgiIdeProj.xml b/Ide/LgiIdeProj.xml
--- a/Ide/LgiIdeProj.xml
+++ b/Ide/LgiIdeProj.xml
@@ -1,290 +1,288 @@
 <?xml version="1.0" encoding="UTF-8" ?>
 <Project TabSize="4" IndentSize="4" UseTabs="1" Makefile="./Makefile.linux" Exe="./lgiide" ShowWhitespace="0" BuildType="0" TargetType="0" TargetName="lgiide" Compiler="0">
 	<Node Name="Source Files" Type="1" Platforms="15" Open="1" Id="1">
 		<Node Name="Debugger" Type="1" Platforms="15" Open="0" Id="2">
 			<Node File=".\Code\DebugContext.cpp" Type="2" Platforms="15" />
 			<Node File=".\Code\DebugContext.h" Type="3" Platforms="15" />
 			<Node File=".\Code\Debugger.cpp" Type="2" Platforms="7" />
 			<Node File=".\Code\Debugger.h" Type="3" Platforms="7" />
 		</Node>
 		<Node Name="Dialogs" Type="1" Platforms="15" Open="0" Id="3">
 			<Node File="./Code/AddFtpFile.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/AddFtpFile.h" Type="3" Platforms="15" />
 			<Node File="..\src\common\Lgi\About.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/WebFldDlg.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/WebFldDlg.h" Type="3" Platforms="15" />
 		</Node>
 		<Node Name="Docs" Type="1" Platforms="15" Id="1">
 			<Node File="./Code/DocEdit.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/DocEdit.h" Type="3" Platforms="15" />
 			<Node File="./Code/DocEditStyling.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/IdeDoc.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/IdeDoc.h" Type="3" Platforms="15" />
 			<Node File="./Code/IdeDocPrivate.h" Type="3" Platforms="15" />
 		</Node>
 		<Node Name="Ftp" Type="1" Platforms="15" Open="0" Id="4">
 			<Node File="./Code/FtpThread.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/FtpThread.h" Type="3" Platforms="15" />
 			<Node File="../src/common/Net/Ftp.cpp" Type="2" Platforms="15" />
 			<Node File="..\include\lgi\common\Ftp.h" Type="3" Platforms="15" />
 		</Node>
 		<Node Name="Projects" Type="1" Platforms="15" Id="1">
 			<Node File="./Code/IdeProject.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/IdeProject.h" Type="3" Platforms="15" />
 			<Node File="./Code/IdeProjectSettings.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/IdeProjectSettings.h" Type="3" Platforms="15" />
 			<Node File="./Code/levenshtein.c" Type="2" Platforms="15" />
 			<Node File="./Code/levenshtein.h" Type="3" Platforms="15" />
 			<Node File="./Code/MissingFiles.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/NewProjectFromTemplate.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/ProjectNode.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/ProjectNode.h" Type="3" Platforms="15" />
 		</Node>
 		<Node Name="Search" Type="1" Platforms="15" Open="1" Id="5">
 			<Node File="./Code/FindInFiles.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/FindInFiles.h" Type="3" Platforms="15" />
 			<Node File="./Code/FindSymbol.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/FindSymbol.h" Type="3" Platforms="15" />
 			<Node File="./Code/History.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/History.h" Type="3" Platforms="15" />
 			<Node File="./Code/JavascriptParser.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/ParserCommon.h" Type="3" Platforms="15" />
 			<Node File="./Code/PythonParser.cpp" Type="2" Platforms="15" />
 			<Node File="./Code/SimpleCppParser.cpp" Type="2" Platforms="15" />
 		</Node>
 		<Node Name="Source Code" Type="1" Platforms="15" Open="1" Id="6">
 			<Node File="../src/common/Coding/LexCpp.cpp" Type="2" Platforms="15" />
 			<Node File="../src/common/Coding/ParseCpp.cpp" Type="2" Platforms="15" />
 			<Node File=".\Code\SysCharSupport.cpp" Type="2" Platforms="15" />
 		</Node>
 		<Node File="./Code/IdeCommon.cpp" Type="2" Platforms="15" />
 		<Node File="./Code/LgiIde.cpp" Type="2" Platforms="15" />
 		<Node File="./Code/LgiIde.h" Type="3" Platforms="15" />
 		<Node File="./Code/LgiUtils.cpp" Type="2" Platforms="15" />
 		<Node File="./Code/MemDumpViewer.cpp" Type="2" Platforms="15" />
 		<Node File="./Code/SpaceTabConv.h" Type="3" Platforms="15" />
 		<Node File="./Code/SpaceTabConv.cpp" Type="2" Platforms="15" />
 	</Node>
 	<Node Name="Lgi" Type="1" Platforms="15" Open="1" Id="7">
 		<Node Name="Html" Type="1" Platforms="15" Id="1">
 			<Node File="../src/common/Text/Html.cpp" Type="2" Platforms="15" />
 			<Node File="../src/common/Text/HtmlCommon.cpp" Type="2" Platforms="15" />
 			<Node File="../src/common/Text/HtmlParser.cpp" Type="2" Platforms="15" />
 		</Node>
 		<Node File="../src/common/Text/DocView.cpp" Type="2" Platforms="15" />
 		<Node File="../src/common/Text/Homoglyphs/Homoglyphs.cpp" Type="2" Platforms="15" />
 		<Node File="../src/common/Text/Homoglyphs/HomoglyphsTable.cpp" Type="2" Platforms="15" />
 		<Node File="../src/common/Net/Http.cpp" Type="2" Platforms="15" />
 		<Node File="../src/common/Lgi/LgiMain.cpp" Type="2" Platforms="15" />
 		<Node File="../src/common/Lgi/Mdi.cpp" Type="2" Platforms="15" />
 		<Node File="../include/lgi/common/Mdi.h" Type="3" Platforms="15" />
 		<Node File="../src/common/Net/OpenSSLSocket.cpp" Type="2" Platforms="15" />
 		<Node File="../src/common/Gdc2/Filters/Png.cpp" Type="2" Platforms="15" />
 		<Node File="../include/lgi/common/PopupList.h" Type="3" Platforms="15" />
 		<Node File="../src/common/Text/TextConvert.cpp" Type="2" Platforms="15" />
 		<Node File="../include/lgi/common/TextLog.h" Type="3" Platforms="15" />
 		<Node File="../include/lgi/common/TrayIcon.h" Type="3" Platforms="15" />
 	</Node>
 	<Node Name="Resources" Type="1" Platforms="15" Open="1" Id="8">
 		<Node Name="Test" Type="1" Platforms="15" Id="1" />
 		<Node File="./buildHaiku.py" Type="8" Platforms="15" />
 		<Node File="./CMakeLists.txt" Type="8" Platforms="15" />
 		<Node File="./Makefile.haiku" Type="9" Platforms="15" />
 		<Node File="./Makefile.linux" Type="9" Platforms="15" />
 		<Node File="./Resources/resource.h" Type="3" Platforms="15" />
 	</Node>
 	<Node File="../Lgi.xml" Type="4" Platforms="15" LinkAgainst="1" />
 	<Settings>
 		<General>
 			<Makefile>
 				<Windows>.\buildHaiku.py</Windows>
 				<Linux>./Makefile.linux</Linux>
 				<Mac>./MacCocoa/LgiIde.xcodeproj</Mac>
 				<Haiku>Makefile.haiku</Haiku>
 			</Makefile>
 			<Executable>
 				<Linux>
 					<Debug>./lgiide</Debug>
 					<Release>./lgiide</Release>
 				</Linux>
 				<Windows>
 					<Debug>LgiIde.exe</Debug>
 					<Release>LgiIde.exe</Release>
 				</Windows>
 			</Executable>
 			<Defines>
 				<Windows>
 					<Debug>WINDOWS
 WINNATIVE</Debug>
 					<Release>WINDOWS
 WINNATIVE</Release>
 				</Windows>
 				<Haiku>
 					<Debug>POSIX</Debug>
 					<Release>POSIX</Release>
 				</Haiku>
 				<Linux>
 					<Debug>LIBPNG_VERSION=\&quot;1.2\&quot;</Debug>
 					<Release>LIBPNG_VERSION=\&quot;1.2\&quot;</Release>
 				</Linux>
 			</Defines>
 			<Compiler>
 				<Windows>MingW</Windows>
 			</Compiler>
 			<Arguments>
 				<All>
 					<Debug>/home/matthew/Code/Lgi/trunk/Ide/Code/IdeProjectSettings.cpp</Debug>
 				</All>
 			</Arguments>
 			<CCrossCompiler />
 			<CppCrossCompiler />
 		</General>
 		<Build>
 			<IncludePaths>
 				<All>
 					<Debug>./Code
 ./Resources
 ../include</Debug>
 					<Release>./Code
 ./Resources
 ../include</Release>
 				</All>
 				<Windows>
 					<Debug>..\include\lgi\win
 /local/include</Debug>
 					<Release>..\include\lgi\win
 /local/include</Release>
 				</Windows>
 				<Linux>
 					<Debug>../include/lgi/linux
 ../include/lgi/linux/Gtk
 ../../../../codelib/openssl/include</Debug>
 					<Release>../include/lgi/linux
 ../include/lgi/linux/Gtk
 ../../../../codelib/openssl/include
 </Release>
 				</Linux>
 				<Haiku>
 					<Debug>../include/lgi/haiku</Debug>
 					<Release>../include/lgi/haiku</Release>
 				</Haiku>
 				<Mac>
 					<Debug>../include/lgi/mac/cocoa</Debug>
 					<Release>../include/lgi/mac/cocoa</Release>
 				</Mac>
 			</IncludePaths>
 			<Libraries>
 				<Windows>
 					<Debug>imm32</Debug>
 					<Release>imm32</Release>
 				</Windows>
 				<Linux>
 					<Debug>magic
 pthread
 `pkg-config --libs gtk+-3.0`
 -static-libgcc</Debug>
 					<Release>magic
 pthread
 `pkg-config --libs gtk+-3.0`
 -static-libgcc</Release>
 				</Linux>
 				<Haiku>
 					<Debug>-static-libgcc
 gnu
 network
 be</Debug>
 					<Release>-static-libgcc
 gnu
 network
 be</Release>
 				</Haiku>
 				<All />
 			</Libraries>
 			<LibraryPaths>
 				<All>
 					<Debug>..\Debug</Debug>
 					<Release>..\Release</Release>
 				</All>
 				<Linux />
 			</LibraryPaths>
 			<TargetType>
 				<All>Executable</All>
 			</TargetType>
 			<TargetName>
 				<Haiku>
 					<Debug>lgiide</Debug>
 					<Release>lgiide</Release>
 				</Haiku>
 				<Windows>
 					<Debug>LgiIde.exe</Debug>
 					<Release>LgiIde.exe</Release>
 				</Windows>
 				<Linux>
 					<Debug>lgiide</Debug>
 					<Release>lgiide</Release>
 				</Linux>
 			</TargetName>
 			<SystemIncludes>
 				<Windows>
 					<Debug>C:\Data\CodeLib\Gtk\include\gtk-2.0\gtk
 C:\Data\CodeLib\Gtk\include\gtk-2.0\gdk</Debug>
 					<Release>C:\Data\CodeLib\Gtk\include\gtk-2.0\gtk
 C:\Data\CodeLib\Gtk\include\gtk-2.0\gdk</Release>
 				</Windows>
 				<Linux>
 					<Debug>`pkg-config --cflags gtk+-3.0`</Debug>
 					<Release>`pkg-config --cflags gtk+-3.0`</Release>
 				</Linux>
 			</SystemIncludes>
 			<Defines>
 				<All />
 				<Haiku>
 					<Debug>POSIX
 _GNU_SOURCE</Debug>
 					<Release>POSIX
 _GNU_SOURCE</Release>
 				</Haiku>
 				<Linux />
 			</Defines>
 			<ApplicationIcon />
 		</Build>
 		<Editor>
 			<TabSize>
 				<All>4</All>
 			</TabSize>
 			<IndentSize>
 				<All>4</All>
 			</IndentSize>
 			<ShowWhiteSpace>
 				<All>0</All>
 			</ShowWhiteSpace>
 			<UseHardTabs>
 				<All>1</All>
 			</UseHardTabs>
 			<CommentFile />
 			<CommentFunction />
 		</Editor>
 		<Debug>
 			<Environment>
 				<All>SOME_TEST=testing</All>
 			</Environment>
 			<Arguments>
-				<All>
-					<Debug>/home/matthew/code/scribe/trunk_os/Linux/ScribeProj.xml</Debug>
-				</All>
+				<All />
 			</Arguments>
 			<DebugAdmin />
 			<InitialDir />
 		</Debug>
 		<Remote>
 			<RemoteUri />
 			<RemotePass />
 		</Remote>
 		<Advanced>
 			<PostBuildCommands>
 				<Linux />
 			</PostBuildCommands>
 			<OtherMakefileRules />
 		</Advanced>
 	</Settings>
 </Project>
diff --git a/include/lgi/common/AudioView.h b/include/lgi/common/AudioView.h
--- a/include/lgi/common/AudioView.h
+++ b/include/lgi/common/AudioView.h
@@ -1,937 +1,940 @@
 /// Audio waveform display control
 #pragma once
 
 #include "lgi/common/Layout.h"
 #include "lgi/common/DisplayString.h"
 #include "lgi/common/Menu.h"
 #include "lgi/common/ClipBoard.h"
 #include "lgi/common/FileSelect.h"
 
 #define CC(code) LgiSwap32(code)
 
 struct int24_t
 {
 	int32_t s : 24;
 };
 
 union sample_t
 {
 	int8_t *i8;
 	int16_t *i16;
 	int24_t *i24;
 	int32_t *i32;
 	float *f;
 
 	sample_t(void *ptr = NULL)
 	{
 		*this = ptr;
 	}
 
 	sample_t &operator=(void *ptr)
 	{
 		i8 = (int8_t*)ptr;
 		return *this;
 	}
 };
 
 typedef int32_t (*ConvertFn)(sample_t &ptr);
 
 class LAudioView : public LLayout
 {
 public:
 	enum LFileType
 	{
 		AudioUnknown,
 		AudioRaw,
 		AudioWav,
 	};
 	enum LSampleType
 	{
 		AudioS8,
 		AudioS16LE,
 		AudioS16BE,
 		AudioS24LE,
 		AudioS24BE,
 		AudioS32LE,
 		AudioS32BE,
 		AudioFloat32,
 	};
 
 protected:
 	enum LCmds
 	{
 		IDC_COPY_CURSOR,
 		
 		IDC_LOAD_WAV,
 		IDC_LOAD_RAW,
 		IDC_SAVE_WAV,
 		IDC_SAVE_RAW,
 		
 		IDC_DRAW_AUTO,
 		IDC_DRAW_LINE,
 		IDC_SCAN_SAMPLES,
 		IDC_SCAN_GROUPS,
 		
 		IDC_44K,
 		IDC_48K,
 		IDC_88K,
 		IDC_96K,
 		
 		IDC_MONO,
 		IDC_STEREO,
 		IDC_2pt1_CHANNELS,
 		IDC_5pt1_CHANNELS,
 	};
 	enum LDrawMode
 	{
 		DrawAutoSelect,
 		DrawSamples,
 		ScanSamples,
 		ScanGroups,
 	};
 
 	LArray<int8_t> Audio;
 	LFileType Type = AudioUnknown;
 	LSampleType SampleType = AudioS16LE;
 	int SampleBits = 0;
 	int SampleRate = 0;
 	int Channels = 0;
 	size_t DataStart = 0;
 	size_t CursorSample = 0;
 	LRect Data;
 	LArray<LRect> ChData;
 	double XZoom = 1.0;
 	LString Msg, ErrorMsg;
 	LDrawMode DrawMode = DrawAutoSelect;
 
 	template<typename T>
 	struct Grp
 	{
 		T Min = 0, Max = 0;
 	};
 
 	LArray<LArray<Grp<int32_t>>> IntGrps;
 	LArray<LArray<Grp<float>>> FloatGrps;
 
 	LArray<LArray<void*>> PixelAddr;
 
 	void MouseToCursor(LMouse &m)
 	{
 		auto idx = ViewToSample(m.x);
 		if (idx != CursorSample)
 		{
 			CursorSample = idx;
 			UpdateMsg();
 			Invalidate();
 		}
 	}
 
 	void SetData(LRect &r)
 	{
 		Data = r;
 		ChData.Length(Channels);
 
 		int Dy = Data.Y() - 1;
 		for (int i=0; i<Channels; i++)
 		{
 			auto &r = ChData[i];
 			r = Data;
 			r.y1 = Data.y1 + (i * Dy / Channels);
 			r.y2 = Data.y1 + ((i + 1) * Dy / Channels) - 1;
 		}
 	}
 
 public:
 	LColour cGrid, cMax, cMin, cCursorMin, cCursorMax;
 
 	LAudioView(const char *file = NULL)
 	{
 		cGrid.Rgb(200, 200, 200);
 		cMax = LColour::Blue;
 		cMin = cMax.Mix(cGrid);
 		cCursorMax = LColour::Red;
 		cCursorMin = cCursorMax.Mix(cGrid);
 
 		Empty();
 		if (file)
 			Load(file);
 	}
 
 	~LAudioView()
 	{
 	}
 
 	bool Empty()
 	{
 		Audio.Length(0);
 		Type = AudioUnknown;
 		SampleType = AudioS16LE;
 		SampleRate = 0;
 		SampleBits = 0;
 		DataStart = 0;
 		Channels = 0;
 		CursorSample = 0;
 		Data.ZOff(-1, -1);
 
 		return false;
 	}
 
 	bool Load(const char *FileName, int rate = 0, int bitDepth = 0, int channels = 0)
 	{
 		LFile f(FileName, O_READ);
 		if (!f.IsOpen())
 		{
 			ErrorMsg.Printf("Can't open '%s' for reading.", FileName);
 			return false;
 		}
 		
 		if (!Audio.Length(f.GetSize()))
 		{
 			ErrorMsg.Printf("Can't allocate %s.", LFormatSize(f.GetSize()).Get());
 			return Empty();
 		}
 
 		auto rd = f.Read(Audio.AddressOf(), f.GetSize());
 		if (rd > 0 && rd != f.GetSize())
 			Audio.Length(rd);
 
 		auto Ext = LGetExtension(FileName);
 		if (!Stricmp(Ext, "wav"))
 			Type = AudioWav;
 		else if (!Stricmp(Ext, "raw"))
 			Type = AudioRaw;
 		else
 		{
 			ErrorMsg.Printf("Unknown format: %s", Ext);
 			return Empty();
 		}
 			
 		if (rate)
 			SampleRate = rate;
 
 		DataStart = 0;
 		SampleBits = bitDepth;
 		Channels = channels;
 		if (bitDepth == 16)
 		{
 			SampleType = AudioS16LE;
 		}
 		else if (bitDepth == 32)
 		{
 			SampleType = AudioS32LE;
 		}
 		else if (Type == AudioWav)
 		{
 			// Parse the wave file...
 			LPointer p;
 			p.s8 = Audio.AddressOf();
 			auto end = p.s8 + Audio.Length();
 
 			if (*p.u32++ != CC('RIFF'))
 				return Empty();
 			auto ChunkSz = *p.u32++;
 			auto Fmt = *p.u32++;
 			
 			while (p.s8 < end)
 			{
 				auto SubChunkId = *p.u32++;
 				auto SubChunkSz = *p.u32++;
 				auto NextChunk = p.u8 + SubChunkSz;
 
 				if (SubChunkId == CC('fmt '))
 				{
 					auto AudioFmt = *p.u16++;
 					Channels = *p.u16++;
 					SampleRate = *p.u32++;
 					auto ByteRate = *p.u32++;
 					auto BlockAlign = *p.u16++;
 					SampleBits = *p.u16++;
 
 					if (SampleBits == 16)
 						SampleType = AudioS16LE;
 					else if (SampleBits == 24)
 						SampleType = AudioS24LE;
 					else if (SampleBits == 32)
 						SampleType = AudioS32LE;
 				}
 				else if (SubChunkId == CC('data'))
 				{
 					DataStart = p.s8 - Audio.AddressOf();
 					break;
 				}
 				
 				p.u8 = NextChunk;
 			}
 
 			if (!DataStart)
 			{
 				ErrorMsg = "No 'data' element found.";
 				return Empty();
 			}
 		}
 		else if (Type == AudioRaw)
 		{
 			// Assume 32bit
 			SampleType = AudioS32LE;
 			SampleBits = 32;
 		}
 
 		if (!SampleRate)
 			SampleRate = 44100;
 		if (!Channels)
 			Channels = 2;
 
 		Invalidate();
 		return true;
 	}
 
 	LRect DefaultPos()
 	{
 		auto c = GetClient();
 		c.Inset(20, 20);
 		return c;
 	}
 
 	size_t GetSamples()
 	{
 		return (Audio.Length() - DataStart) / (SampleBits >> 3) / Channels;
 	}
 
 	int SampleToView(size_t idx)
 	{
 		return Data.x1 + (int)((idx * Data.X()) / GetSamples());
 	}
 
 	size_t ViewToSample(int x /*px*/)
 	{
 		int offset = x - Data.x1;
 		ssize_t samples = GetSamples();
 		ssize_t idx = offset * samples / Data.X();
 		if (idx < 0)
 			idx = 0;
 		else if (idx >= samples)
 			idx = samples - 1;
 		return idx;
 	}
 
 	void OnPosChange()
 	{
 		auto def = DefaultPos();
 		LRect d = Data;
 		d.y1 = def.y1;
 		d.y2 = def.y2;
 		SetData(d);
 	}
 
 	#define CheckItem(Sub, Name, Id, Chk) \
 	{ \
 		auto item = Sub->AppendItem(Name, Id); \
 		if (item && Chk) item->Checked(true); \
 	}
 
 	void OnMouseClick(LMouse &m)
 	{
 		if (m.IsContextMenu())
 		{
 			LSubMenu s;
 			s.AppendItem("Copy Cursor Address", IDC_COPY_CURSOR);
 			s.AppendSeparator();
 
 			auto File = s.AppendSub("File");
 			File->AppendItem("Load Wav", IDC_LOAD_WAV);
 			File->AppendItem("Load Raw", IDC_LOAD_RAW);
 			File->AppendItem("Save Wav", IDC_SAVE_WAV);
 			File->AppendItem("Save Raw", IDC_SAVE_RAW);
 
 			auto Draw = s.AppendSub("Draw Mode");
 			CheckItem(Draw, "Auto", IDC_DRAW_AUTO, DrawMode == DrawAutoSelect);
 			CheckItem(Draw, "Line", IDC_DRAW_LINE, DrawMode == DrawSamples);
 			CheckItem(Draw, "Scan Samples", IDC_SCAN_SAMPLES, DrawMode == ScanSamples);
 			CheckItem(Draw, "Scan Groups", IDC_SCAN_GROUPS, DrawMode == ScanGroups);
 
 			auto Rate = s.AppendSub("Sample Rate");
 			CheckItem(Rate, "44.1k", IDC_44K, SampleRate == 44100);
 			CheckItem(Rate, "48k", IDC_48K, SampleRate == 4800);
 			CheckItem(Rate, "88.2k", IDC_88K, SampleRate == 44100*2);
 			CheckItem(Rate, "96k", IDC_96K, SampleRate == 48000*2);
 
 			auto Ch = s.AppendSub("Channels");
 			CheckItem(Ch, "Mono", IDC_MONO, Channels == 1);
 			CheckItem(Ch, "Stereo", IDC_STEREO, Channels == 2);
 			CheckItem(Ch, "2.1", IDC_2pt1_CHANNELS, Channels == 3);
 			CheckItem(Ch, "5.1", IDC_5pt1_CHANNELS, Channels == 6);
 
 			bool Update = false;
 			switch (s.Float(this, m))
 			{
 				case IDC_COPY_CURSOR:
 				{
 					LClipBoard clip(this);
 					size_t addrVal = DataStart + (CursorSample * Channels * SampleBits / 8);
 					LString addr;
 					addr.Printf(LPrintfSizeT, addrVal);
 					clip.Text(addr);
 					break;
 				}
 				case IDC_SAVE_RAW:
 				{
 					auto s = new LFileSelect;
 					s->Parent(this);
 					s->Save([this](auto s, auto ok)
 					{
 						if (ok)
 						{
 							LFile out(s->Name(), O_WRITE);
 							if (out)
 							{
 								out.SetSize(0);
 
 								auto ptr = Audio.AddressOf(DataStart);
 								out.Write(ptr, Audio.Length() - DataStart);
 							}
 							else
 								LgiMsg(this, "Can't open '%s' for writing.", "Error", MB_OK, s->Name());
 						}
 						delete s;
 					});
 					break;
 				}
 				case IDC_DRAW_AUTO:
 					DrawMode = DrawAutoSelect;
 					Update = true;
 					break;
 				case IDC_DRAW_LINE:
 					DrawMode = DrawSamples;
 					Update = true;
 					break;
 				case IDC_SCAN_SAMPLES:
 					DrawMode = ScanSamples;
 					Update = true;
 					break;
 				case IDC_SCAN_GROUPS:
 					DrawMode = ScanGroups;
 					Update = true;
 					break;
 				case IDC_44K:
 					SampleRate = 44100;
 					Update = true;
 					break;
 				case IDC_48K:
 					SampleRate = 48000;
 					Update = true;
 					break;
 				case IDC_88K:
 					SampleRate = 44100*2;
 					Update = true;
 					break;
 				case IDC_96K:
 					SampleRate = 48000*2;
 					Update = true;
 					break;
 				case IDC_MONO:
 					Channels = 1;
 					Update = true;
 					break;
 				case IDC_STEREO:
 					Channels = 2;
 					Update = true;
 					break;
 				case IDC_2pt1_CHANNELS:
 					Channels = 3;
 					Update = true;
 					break;
 				case IDC_5pt1_CHANNELS:
 					Channels = 6;
 					Update = true;
 					break;
 				default:
 					break;
 			}
 
 			if (Update)
 			{
 				IntGrps.Length(0);
 				FloatGrps.Length(0);
 				SetData(Data);
 				Invalidate();
 			}
 		}
 		else if (m.Left())
 		{
 			Focus(true);
 			MouseToCursor(m);
 		}
 	}
 
 	void OnMouseMove(LMouse &m)
 	{
 		if (m.Down())
 			MouseToCursor(m);
 	}
 
 	LPointer AddressOf(size_t Sample)
 	{
 		LPointer p;
 		int SampleBytes = SampleBits >> 3;
 		p.s8 = Audio.AddressOf(DataStart + (Sample * Channels * SampleBytes));
 		return p;
 	}
 
 	void UpdateMsg()
 	{
 		ssize_t Samples = GetSamples();
 		auto Addr = AddressOf(CursorSample);
 		size_t AddrOffset = Addr.s8 - Audio.AddressOf();
 		LString::Array Val;
 		size_t GraphLen = 0;
 		for (int ch=0; ch<Channels; ch++)
 		{
 			/*
 			switch (SampleType)
 			{
 				case AudioS16LE:
 				case AudioS16BE:
 					Val.New().Printf("%i", Native(Addr.s16[ch]));
 					GraphLen = Int16Grps.Length() ? Int16Grps[0].Length() : 0;
 					break;
 				case AudioS32LE:
 				case AudioS32BE:
 					Val.New().Printf("%i", Native(Addr.s32[ch]));
 					GraphLen = Int32Grps.Length() ? Int32Grps[0].Length() : 0;
 					break;
 			}
 			*/
 		}
 
 		Msg.Printf("Channels=%i SampleRate=%i BitDepth=%i XZoom=%g Samples=" LPrintfSSizeT " Cursor=" LPrintfSizeT " @ " LPrintfSizeT " (%s) Graph=" LPrintfSizeT "\n",
 			Channels, SampleRate, SampleBits,
 			XZoom, Samples, CursorSample, AddrOffset, LString(",").Join(Val).Get(), GraphLen);
 	}
 
 	bool OnMouseWheel(double Lines)
 	{
 		LMouse m;
 		GetMouse(m);
 
 		ssize_t Samples = GetSamples();
 		if (m.System() && m.Alt())
 		{
 			auto DefPos = DefaultPos();
 			auto change = (double)Lines / 3;
 			XZoom *= 1.0 + (-change / 10);
 
 			int OldX = Data.X();
 			int x = (int)(DefPos.X() * XZoom);
 			int CursorX = SampleToView(CursorSample);
 			LRect d = Data;
 			d.x1 = (int) (CursorX - (CursorSample * x / Samples));
 			d.x2 = d.x1 + x - 1;
 			SetData(d);
 
 			Invalidate();
 		}
 		else
 		{
 			int change = (int)(Lines * -6);
 			LRect d = Data;
 			d.x1 += change;
 			d.x2 += change;
 			SetData(d);
 
 			Invalidate();
 		}
 
 		UpdateMsg();
 
 		return true;
 	}
 
 	#define PROFILE_PAINT_SAMPLES 0
 	#if PROFILE_PAINT_SAMPLES
 		#define PROF(name) Prof.Add(name)
 	#else
 		#define PROF(name)
 	#endif
 
 	ConvertFn GetConvert()
 	{
 		switch (SampleType)
 		{
 			case AudioS8:
 				return [](sample_t &s) -> int32_t
 				{
 					return *s.i8++;
 				};
 			case AudioS16LE:
 				return [](sample_t &s) -> int32_t
 				{					
 					return *s.i16++;
 				};
 			case AudioS16BE:
 				return [](sample_t &s) -> int32_t
 				{
 					int16_t i = LgiSwap16(*s.i16);
 					s.i16++;
 					return i;
 				};
 			case AudioS24LE:
 				return [](sample_t &s) -> int32_t
 				{
 					int32_t i = s.i24->s;
 					s.i8 += 3;
 					return i;
 				};
 			case AudioS24BE:
 				return [](sample_t &s) -> int32_t
 				{
 					int24_t i;
 					int8_t *p = (int8_t*)&i;
 					p[0] = s.i8[2];
 					p[1] = s.i8[1];
 					p[2] = s.i8[0];
 					s.i8 += 3;
 					return i.s;
 				};
 			case AudioS32LE:
 				return [](sample_t &s) -> int32_t
 				{
 					return *s.i32++;
 				};
 			case AudioS32BE:
 				return [](sample_t &s) -> int32_t
 				{
 					int32_t i = *s.i32++;
 					return LgiSwap32(i);
 				};
 		}
 
 		return NULL;
 	}
 
 	void PaintSamples(LSurface *pDC, int ChannelIdx, LArray<LArray<Grp<int32_t>>> *Grps)
 	{
 		#if PROFILE_PAINT_SAMPLES
 		LProfile Prof("PaintSamples", 10);
 		#endif
 
 		int32_t MaxT = 0;
 		ConvertFn Convert = GetConvert();
 
 		if (SampleBits == 8)
 			MaxT = 0x7f;
 		else if (SampleBits == 16)
 			MaxT = 0x7fff;
 		else if (SampleBits == 24)
 			MaxT = 0x7fffff;
 		else
 			MaxT = 0x7fffffff;
 
 		auto sampleBytes = SampleBits / 8;
 		auto Client = GetClient();
 		auto &c = ChData[ChannelIdx];
 		auto start = Audio.AddressOf(DataStart);
 		size_t samples = GetSamples();
 		auto end = start + (samples * Channels);
 		int cy = c.y1 + (c.Y() / 2);
 
 		pDC->Colour(cGrid);
 		pDC->Box(&c);
 
 		int blk = 64;
 		if (Grps->Length() == 0)
 		{
 			// Initialize the graph
 			PROF("GraphGen");
 			Grps->Length(Channels);
 			for (int ch = 0; ch < Channels; ch++)
 			{
 				auto &GraphArr = (*Grps)[ch];
 				GraphArr.SetFixedLength(false);
 				GraphArr.Length(0);
 
 				int BlkChannels = blk * Channels;
 				size_t BlkIndex = 0;
 				int byteOffsetToSample = ch * (SampleRate >> 3);
 				sample_t s;
 				s.i8 = start+byteOffsetToSample;
 
 				// For each block...
 				for (; s.i8 < end; s.i8 += BlkChannels)
 				{
 					int remain = MIN( (int)(end - s.i8), BlkChannels );
 					auto &b = GraphArr[BlkIndex++];
 
 					// For all samples in the block...
 					int8_t *blkEnd = s.i8 + (remain * sampleBytes);
 					b.Min = b.Max = Convert(s); // init min/max with first sample
 					while (s.i8 < blkEnd)
 					{
 						auto n = Convert(s);
 						if (n < b.Min)
 							b.Min = n;
 						if (n > b.Max)
 							b.Max = n;
 					}
 				}
 
 				GraphArr.SetFixedLength(true);
 			}
 		}
 
 		PROF("PrePaint");
 
 		int YScale = c.Y() / 2;
 		int CursorX = SampleToView(CursorSample);
 		double blkScale = Grps->Length() > 0 ? (double) (*Grps)[0].Length() / c.X() : 1.0;
 		LDrawMode EffectiveMode = DrawMode;
 		auto StartSample = ViewToSample(Client.x1);
 		auto EndSample = ViewToSample(Client.x2);
 		auto SampleRange = EndSample - StartSample;
 
 		if (EffectiveMode == DrawAutoSelect)
 		{
 			if (SampleRange < (Client.X() << 2))
 				EffectiveMode = DrawSamples;
 			else if (blkScale < 1.0)
 				EffectiveMode = ScanSamples;
 			else
 				EffectiveMode = ScanGroups;
 		}
 	
 		// LgiTrace("DrawRange: " LPrintfSizeT "->" LPrintfSizeT " (" LPrintfSizeT ") mode=%i\n", StartSample, EndSample, SampleRange, (int)EffectiveMode);
 		if (EffectiveMode == DrawSamples)
 		{
 			sample_t pSample;
 			pSample.i8 = start + (StartSample * Channels) + ChannelIdx;
 
 			if (CursorX >= Client.x1 && CursorX <= Client.x2)
 			{
 				pDC->Colour(L_BLACK);
 				pDC->VLine(CursorX, c.y1, c.y2);
 			}
 			pDC->Colour(cGrid);
 			pDC->HLine(c.x1, c.x2, cy);
 
 			// LgiTrace("	ptr=%i\n", (int)((char*)pSample-(char*)start));
 
 			// For all samples in the view space...
 			pDC->Colour(cMax);
 			LPoint Prev(-1, -1);
 			for (auto idx = StartSample; idx <= EndSample + 1; idx++, pSample.i8 += Channels)
 			{
 				auto n = Convert(pSample);
 				auto x = SampleToView(idx);
 				auto y = (uint32_t) (cy - ((uint64_t)n * YScale / MaxT));
 				if (idx != StartSample)
 					pDC->Line(Prev.x, Prev.y, (int)x, (int)y);
 				Prev.Set((int)x, (int)y);
 			}
 		}
 		else
 		{
 			// For all x coordinates in the view space..
 			for (int Vx=Client.x1; Vx<=Client.x2; Vx++)
 			{
 				if (Vx % 100 == 0)
 				{
 					PROF("Pixels");
 				}
 
 				if (Vx < c.x1 || Vx > c.x2)
 					continue;
 
 				auto isCursor = CursorX == Vx;
 				if (isCursor)
 				{
 					pDC->Colour(L_BLACK);
 					pDC->VLine(Vx, c.y1, c.y2);
 				}
 
 				Grp<int32_t> Min, Max;
 				StartSample = ViewToSample(Vx);
 				EndSample = ViewToSample(Vx+1);
 				if (EffectiveMode == ScanSamples)
 				{
 					// Scan individual samples
 					sample_t pStart;
 					pStart.i8 = start + (StartSample * Channels) + ChannelIdx;
 					auto pEnd = start + (EndSample * Channels) + ChannelIdx;
 
 					#if 0
 					if (Vx==Client.x1)
 					{
 						auto PosX = SampleToView((pStart - ChannelIdx - start) / Channels);
 						LgiTrace("	ptr=%i " LPrintfSizeT "-" LPrintfSizeT " x=%i pos=%i\n", (int)((char*)pStart-(char*)start), StartSample, EndSample, Vx, PosX);
 					}
 					#endif
 					
 					for (auto i = pStart; i.i8 < pEnd; i.i8 += Channels)
 					{
 						auto n = Convert(i);
 						Min.Min = MIN(Min.Min, n);
 						Max.Max = MAX(Max.Max, n);
 					}
 				}
 				else
 				{
 					// Scan the buckets
 					auto &Graph = (*Grps)[ChannelIdx];
 					double blkStart = (double)StartSample * Graph.Length() / samples;
 					double blkEnd = (double)EndSample * Graph.Length() / samples;
 				
 					#if 0
 					if (isCursor)
 						LgiTrace("Blk %g-%g of " LPrintfSizeT "\n", blkStart, blkEnd, Graph.Length());
 					#endif
 
 					for (int i=(int)floor(blkStart); i<(int)ceil(blkEnd); i++)
 					{
 						auto &b = Graph[i];
 						Min.Min = MIN(Min.Min, b.Min);
 						Min.Max = MAX(Min.Max, b.Min);
 						Max.Min = MIN(Max.Min, b.Max);
 						Max.Max = MAX(Max.Max, b.Max);
 					}
 				}
 			
 				auto y1 = (cy - (Min.Min * YScale / MaxT));
 				auto y2 = (cy - (Max.Max * YScale / MaxT));
 				pDC->Colour(isCursor ? cCursorMax : cMax);
 				pDC->VLine(Vx, (int)y1, (int)y2);
 
 				if (EffectiveMode == ScanGroups)
 				{
 					y1 = (cy - (Min.Max * YScale / MaxT));
 					y2 = (cy - (Max.Min * YScale / MaxT));
 					pDC->Colour(isCursor ? cCursorMin : cMin);
 					pDC->VLine(Vx, (int)y1, (int)y2);
 				}
 			}
 		}
 	}
 
 	void OnPaint(LSurface *pDC)
 	{
 		#ifdef WINDOWS
 		LDoubleBuffer DblBuf(pDC);
 		#endif
 		pDC->Colour(L_WORKSPACE);
 		pDC->Rectangle();
 
 		if (!Data.Valid())
-			SetData(DefaultPos());
+		{
+			auto r = DefaultPos();
+			SetData(r);
+		}
 
 		auto Fnt = GetFont();
 		LDisplayString ds(Fnt, ErrorMsg ? ErrorMsg : Msg);
 		Fnt->Transparent(true);
 		Fnt->Fore(ErrorMsg ? LColour::Red : LColour(L_LOW));
 		ds.Draw(pDC, 4, 4);
 		if (ErrorMsg)
 			return;
 
 		switch (SampleType)
 		{
 			case AudioS16LE:
 			case AudioS16BE:
 			{
 				for (int ch = 0; ch < Channels; ch++)
 					PaintSamples(pDC, ch, &IntGrps);
 				break;
 			}
 			case AudioS24LE:
 			case AudioS24BE:
 			{
 				for (int ch = 0; ch < Channels; ch++)
 					PaintSamples(pDC, ch, &IntGrps);
 				break;
 			}
 			case AudioS32LE:
 			case AudioS32BE:
 			{
 				for (int ch = 0; ch < Channels; ch++)
 					PaintSamples(pDC, ch, &IntGrps);
 				break;
 			}
 			case AudioFloat32:
 			{
 				/*
 				for (int ch = 0; ch < Channels; ch++)
 					PaintSamples(pDC, ch, &FloatGrps);
 				*/
 				break;
 			}
 		}
 	}
 
 	bool UnitTests()
 	{		
 		SampleType = AudioS16LE;
 		auto c = GetConvert();
 		int16_t le16 = (2 << 8) | (1);
 		sample_t ptr(&le16);
 		auto out = c(ptr);
 		if (out != 0x201)
 		{
 			LAssert(0);
 			return false;
 		}
 
 		SampleType = AudioS16BE;
 		c = GetConvert();
 		int16_t be16 = (1 << 8) | (2);
 		ptr = &be16;
 		out = c(ptr);
 		if (out != 0x201)
 		{
 			LAssert(0);
 			return false;
 		}
 
 		SampleType = AudioS24LE;
 		c = GetConvert();
 		uint8_t le24[] = {1, 2, 3};
 		ptr = &le24;
 		out = c(ptr);
 		if (out != 0x30201)
 		{
 			LAssert(0);
 			return false;
 		}
 
 		SampleType = AudioS24BE;
 		c = GetConvert();
 		uint8_t be24[] = {3, 2, 1};
 		ptr = &be24;
 		out = c(ptr);
 		if (out != 0x30201)
 		{
 			LAssert(0);
 			return false;
 		}
 
 		SampleType = AudioS32LE;
 		c = GetConvert();
 		uint8_t le32[] = {1, 2, 3, 4};
 		ptr = &le32;
 		out = c(ptr);
 		if (out != 0x4030201)
 		{
 			LAssert(0);
 			return false;
 		}
 
 		SampleType = AudioS32BE;
 		c = GetConvert();
 		uint8_t be32[] = {4, 3, 2, 1};
 		ptr = &be32;
 		out = c(ptr);
 		if (out != 0x4030201)
 		{
 			LAssert(0);
 			return false;
 		}
 
 		return true;
 	}
 };
 
diff --git a/src/common/Lgi/FileSelect.cpp b/src/common/Lgi/FileSelect.cpp
--- a/src/common/Lgi/FileSelect.cpp
+++ b/src/common/Lgi/FileSelect.cpp
@@ -1,2256 +1,2256 @@
 /*hdr
 **      FILE:           LFileSelect.cpp
 **      AUTHOR:         Matthew Allen
 **      DATE:           20/5/2002
 **      DESCRIPTION:    Common file/directory selection dialog
 **
 **      Copyright (C) 1998-2002, Matthew Allen
 **              fret@memecode.com
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include "lgi/common/Lgi.h"
 #include "lgi/common/Popup.h"
 #include "lgi/common/List.h"
 #include "lgi/common/TextLabel.h"
 #include "lgi/common/Edit.h"
 #include "lgi/common/Button.h"
 #include "lgi/common/CheckBox.h"
 #include "lgi/common/Combo.h"
 #include "lgi/common/Tree.h"
 #include "lgi/common/TableLayout.h"
 #include "lgi/common/Box.h"
 #include "lgi/common/FileSelect.h"
 #include "lgi/common/Menu.h"
 
 #define FSI_FILE			0
 #define FSI_DIRECTORY		1
 #define FSI_BACK			2
 #define FSI_UPDIR			3
 #define FSI_NEWDIR			4
 #define FSI_DESKTOP			5
 #define FSI_HARDDISK		6
 #define FSI_CDROM			7
 #define FSI_FLOPPY			8
 #define FSI_NETWORK			9
 
 enum DlgType
 {
 	TypeNone,
 	TypeOpenFile,
 	TypeOpenFolder,
 	TypeSaveFile
 };
 
 class LFileSelectDlg;
 
 char ModuleName[] = "File Select";
 
 uint32_t IconBits[] = {
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xC980FA8A, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x738E738E, 0xF81F738E, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F,
 0xF81FF81F, 0x8430F81F, 0x84308430, 0x84308430, 0xF81F8430, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x9CE09CE0, 0x9CE09CE0, 0x00009CE0, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCCE0F81F, 0x9800FCF9, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F,
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x738E738E, 0xCE6C9E73, 0x738EC638, 0xF81F738E, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x9FFF738E, 0x9FFF9FFF, 0x9FFF9FFF, 0x00009FFF, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x9CE0F81F, 0xFFF9F7BE, 0xFFF3FFF9, 0x9CE0FFF3, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x9CE09CE0, 0x9CE09CE0, 0x00009CE0, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0xF81FF81F, 0xF81FF81F, 0x04F904F9,
 0x04F904F9, 0xAD720313, 0xAD72AD72, 0xAD72AD72, 0xFE60CCE0, 0x00009B00, 0x0000AD72, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x738EF81F, 0x667334F3, 0xCE6C9E73, 0xC638B5B6, 0x3186C638, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFFF738E, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0xF81FF81F, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0xF81F738E, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFF0000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCE6C9CE0, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0x9CE09CE0, 0x9CE09CE0, 0x9CE09CE0, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x9CE0F81F, 0xFFF9F7BE, 0xFFF3FFF9, 0x9CE0FFF3,
 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81F0000, 0x667F04F9, 0x031304F9, 0xFFFFCE73, 0xFFF9FFFF, 0xCCE0FFFF, 0x9B00FFF3, 0x04F90000, 0x00000313, 0xF81FF81F, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0xF81F738E, 0xF81FF81F, 0xF81FF81F, 0x6673738E, 0x34F36673, 0xCE736673, 0xB5B6C638, 0xB5B6DEFB, 0xF81F3186, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFFF738E, 0xFFFFFFFF, 0xCFFFCFFF, 0x0000CFFF, 0x738EF81F, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0x0000738E, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFF0000, 0x0000FFFF, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF9FFF9, 0xFFF9FFF9, 0xFFF9FFF9, 0xFFF9FFF9, 0xFFF9FFF9, 0xCE6CFFF3,
 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCE6C9CE0, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0x9CE09CE0, 0x9CE09CE0, 0x9CE09CE0, 0xF81FF81F, 0xF81FF81F, 0x9CE09CE0, 0x9CE09CE0, 0xF81F0000, 0x0000F81F, 0x0000F81F, 0x0000F81F, 0xF81FF81F, 0x04F904F9, 0xCE730313, 0xFFFFFFFF, 0xFFF9FFF9, 0xFE60CCE0, 0x00009B00, 0x667F3313, 0x00000313, 0x738EF81F, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0x0000738E, 0xF81FF81F, 0xF81FF81F, 0x34F98430, 0x667364F9, 0x84306679, 0xD6BAB5B6, 0xB5B6C638, 0xF81F3186, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCFFF738E, 0xCFFFCFFF, 0xCFFFCFFF, 0x0000CFFF, 0xFFFF738E, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x9CF3FFFF, 0x0000738E, 0xFFFF0000, 0xFFFFFFFF,
 0xFFFFFFFF, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xCE6CFE73, 0xF81F0000, 0xF81FF81F, 0x0000F81F, 0x000007FF, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF9FFF9, 0xFFF9FFF9, 0xFFF9FFF9, 0xFFF9FFF9, 0xFFF9FFF9, 0xCE6CFFF3, 0xF81F0000, 0x9CE0F81F, 0xFFF9F7BE, 0xFFF3FFF3, 0x00009CE0, 0xF81FF81F, 0xF81F0000, 0xF81F0000, 0xF81FF81F, 0x031304F9, 0xFFFFCE73, 0x94B294B2, 0xCCE094B2, 0x9B00FFF3, 0xAD720000, 0x3313FFF9, 0x00000313, 0xFFFF738E, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x9CF3FFFF, 0x0000738E, 0xF81FF81F, 0x738EF81F, 0xA53494B2, 0x667964F3, 0x00008430, 0xA5348430, 0xCE79B5B6, 0x3186CE79, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCE79738E,
 0xCE79C638, 0xC638B5B6, 0x0000B5B6, 0xD6BA738E, 0xC638C638, 0xC638C638, 0xC638C638, 0xB5B6C638, 0x04200660, 0x94B2B5B6, 0x0000738E, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xD699FFFF, 0xD699D699, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFE73FFF3, 0xFE73FFF3, 0xCE6CFFF3, 0xF81F0000, 0xF81FF81F, 0x07FF0000, 0x000007FF, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0x0000FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xCE6CFE73, 0xF81F0000, 0xCE6C9CE0, 0xCE6CCE6C, 0xCE6CCE6C, 0x9CE0CE6C, 0x9CE09CE0, 0xF81F9CE0, 0x0000F81F, 0x0000F81F, 0xCE730313, 0xFFFFFFFF, 0xFFFF94B2, 0xFE60CCE0, 0x00009B00, 0xFFF9AD72, 0xCE73CE73, 0x00003313, 0xD6BA738E, 0xC638C638, 0xC638C638, 0xC638C638, 0xB5B6C638, 0x04200660, 0x94B2B5B6, 0x0000738E,
 0xF81FF81F, 0x738EF81F, 0xB5B6B5B6, 0x8430CE79, 0xF81F0000, 0x84300000, 0xCE79CE79, 0x3186CE79, 0xF81FF81F, 0x84308430, 0x84308430, 0x84308430, 0xC638738E, 0x84308430, 0x84308430, 0x0000C638, 0xDEFB738E, 0xC638B5B6, 0xC638C638, 0xC638C638, 0xB5B6B5B6, 0xB5B6B5B6, 0x94B2B5B6, 0x0000738E, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xD699FFFF, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FE73, 0xCE6CFE73, 0xF81F0000, 0x0000F81F, 0x07FF07FF, 0x07FF07FF, 0x07FF07FF, 0x07FF07FF, 0x07FF07FF, 0xF81F0000, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0x00000000, 0xFFF30000, 0xFE73FFF3, 0xFE73FFF3, 0xCE6CFFF3, 0xF81F0000, 0xFFF99CE0, 0xFFF9FFF9, 0xFFF9FFF9, 0xFFF9FFF9, 0xFFF3FFF9, 0x0000CE6C, 0xF81F0000, 0xF81FF81F, 0xFFFFAD72, 0xFFF9FFFF, 0xFFFF94B2,
 0x9B009CEC, 0x00000000, 0xCE73FFF9, 0xAD72FFF9, 0x000094B2, 0xDEFB738E, 0xC638B5B6, 0xC638C638, 0xC638C638, 0xB5B6B5B6, 0xB5B6B5B6, 0x94B2B5B6, 0x0000738E, 0xF81FF81F, 0x738EF81F, 0xF7BEE73C, 0xB5B6E73C, 0x00008430, 0xB5B68430, 0xF7BEEF7D, 0x3186CE79, 0x8430F81F, 0xC638C638, 0xC638C638, 0xC638C638, 0xCE79738E, 0x0000738E, 0xFFFF738E, 0x0000B5B6, 0xDEFB738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x94B2B5B6, 0x0000738E, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xD699FFFF, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FFF3, 0xFE73FFF3, 0xFE73FFF3, 0xFE73FFF3, 0xCE6CFFF3, 0xF81F0000, 0x0000F81F, 0x07FF07FF, 0x07FF07FF, 0x07FF07FF, 0x07FF07FF, 0x07FF07FF, 0xF81F0000, 0xF81FF81F, 0xFFF99CE0, 0x0000FFF3, 0x00000000, 0x00000000, 0xFFF3FFF3, 0xFFF3FE73,
 0xCE6CFE73, 0xF81F0000, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFE73FFF3, 0x0000CE6C, 0x0000F81F, 0xF81FF81F, 0xFFFFAD72, 0xFFF9FFF9, 0xFFFF94B2, 0xFFFF0000, 0x0000FFF9, 0xFFF9CE73, 0xCE73AD72, 0x000094B2, 0xDEFB738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x94B2B5B6, 0x0000738E, 0x8430F81F, 0x84308430, 0xA5348430, 0xA534B5B6, 0x8430A534, 0xDEFB34F3, 0xFFFFE73C, 0xF81F3186, 0xFFFF8430, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000FFFF, 0x00000000, 0x00000000, 0xF81F0000, 0xD6BA738E, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x94B2B5B6, 0x0000738E, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xD699FFFF, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FE73, 0xFFF3FE73, 0xCE6CFE73, 0xF81F0000, 0xF81FF81F,
 0x07FF0000, 0x000007FF, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0x0000FFF3, 0xFE73FFF3, 0xFE73FFF3, 0xFE73FFF3, 0xCE6CFFF3, 0xF81F0000, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FFF3, 0xFFF3FE73, 0x0000CE6C, 0xF81FF81F, 0xF81F0000, 0xFFF9AD72, 0xFFF9FFF9, 0xFFFF94B2, 0xFFFFFFFF, 0x0000FFF9, 0xCE73FFF9, 0xAD72CE73, 0x000094B2, 0xD6BA738E, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x94B2B5B6, 0x0000738E, 0xFFFF8430, 0xFFFFFFFF, 0xA534738E, 0xB5B6A534, 0xCE73D6BA, 0x34F96673, 0xB5B6CFFF, 0xF81F3186, 0xC6388430, 0xC638C638, 0xC638C638, 0xC638C638, 0xC638C638, 0xC638F800, 0x738E8430, 0xF81F0000, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0xF81F0000, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 0xD699FFFF, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0xFE73FFF3, 0xFE73FFF3, 0xFE73FFF3, 0xFE73FFF3, 0xCE6CFE73, 0xF81F0000, 0xF81FF81F, 0x0000F81F, 0x000007FF, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0x0000FFF3, 0xFFF3FFF3, 0xFFF3FE73, 0xFFF3FE73, 0xCE6CFE73, 0xF81F0000, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FFF3, 0xFE73FFF3, 0xFE73FFF3, 0x0000CE6C, 0xF81FF81F, 0xF81FF81F, 0xFFF9AD72, 0xFFF9FFF9, 0xFFFF94B2, 0xFFFFFFFF, 0x0000FFF9, 0xCE73CE73, 0xCE73AD72, 0x000094B2, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0x738E738E, 0xF81F0000, 0xFFFF8430, 0xC638C638, 0x738EC638, 0xB5B6A534, 0xCE73CE79, 0x04F99E73, 0x000004F9, 0xF81FF81F, 0xC6388430, 0xC638C638, 0x84308430, 0x84308430, 0xC638C638, 0xC638C638, 0x738E8430,
 0xF81F0000, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81FF81F, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xD699FFFF, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FE73, 0xFFF3FE73, 0xFFF3FE73, 0xFFF3FE73, 0xFE73FE73, 0xCE6CFE73, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FFF3, 0x0000FFF3, 0x00000000, 0x00000000, 0xFE730000, 0xCE6CFE73, 0xF81F0000, 0xFFF99CE0, 0xFFF3FFF3, 0xFFF3FE73, 0xFFF3FE73, 0xFFF3FE73, 0x0000CE6C, 0xF81FF81F, 0xF81FF81F, 0xFFF904F9, 0xFFF9FFF9, 0xFFF994B2, 0xFFF9FFF9, 0x0000FFF9, 0xAD72CE73, 0xAD72CE73, 0x00003313, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81FF81F, 0xFFFF8430, 0x31863186,
 0x31863186, 0x84308430, 0xCE73CE79, 0x31869E73, 0x00003186, 0xF81FF81F, 0xC6388430, 0x84308430, 0x00000000, 0x00000000, 0x84308430, 0xC6388430, 0x738E8430, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xB5B6F81F, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xD699FFFF, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xCE6C9CE0, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFF99CE0, 0xFFF3FE73, 0xFFF3FE73, 0xFFF3FE73, 0xFFF3FE73, 0xFE73FE73, 0xCE6CFE73, 0xF81F0000, 0xFFF99CE0, 0xFFF3FE73, 0xFE73FFF3, 0xFE73FFF3, 0xFE73FFF3, 0x0000CE6C, 0xF81FF81F, 0xF81FF81F, 0x04F904F9, 0xFFF9FFF9, 0x00000000, 0x00000000, 0x00000000,
 0xCE73AD72, 0x3313AD72, 0x00003313, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFFF8430, 0x042007E0, 0xFFFFFFFF, 0xC638C638, 0x31863186, 0xC6383186, 0x0000738E, 0xF81FF81F, 0xC6388430, 0xC638C638, 0xFFFFFFFF, 0xFFFFFFFF, 0xC638C638, 0xC638C638, 0x738E8430, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xB5B6F81F, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xFFFF0000, 0xD699D699, 0xD699D699, 0xD699D699, 0xD699D699, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xCE6C9CE0, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xF81F0000,
 0xCE6C9CE0, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0xCE6CCE6C, 0x0000CE6C, 0xF81FF81F, 0xF81FF81F, 0x667F04F9, 0xFFF904F9, 0xCE73FFF9, 0xCE73FFF9, 0xAD72CE73, 0xAD72CE73, 0x667F3313, 0x00003313, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x8430738E, 0x84308430, 0x84308430, 0x84308430, 0x84308430, 0x84308430, 0x00008430, 0xF81FF81F, 0x84308430, 0x84308430, 0x84308430, 0x84308430, 0x84308430, 0x84308430, 0x00008430, 0xF81FF81F, 0xB5B6F81F, 0xB5B6F81F, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0xB5B6B5B6, 0xF81FB5B6, 0xF81FB5B6, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F,
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81FF81F, 0xF81FF81F, 0x03130313, 0x04F90313, 0x94B294B2, 0x94B294B2, 0x94B294B2, 0x331394B2, 0x33133313, 0x00003313, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81FF81F, 0x0000F81F, 0x0000F81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81F0000, 0xF81F0000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F,
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F,
 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F, 0xF81FF81F};
 
 LInlineBmp FileSelectIcons = { 160, 16, 16, IconBits };
 
 enum Icons2Idx
 {
 	IcoApps,
 	IcoHome,
 	IcoDesktop,
 	IcoDocuments,
 	IcoDownloads,
 	IcoMovies,
 	IcoMusic,
 	IcoPhotos,
 	IcoFolder,
 	IcoComputer,
 	IcoCDROM,
 	IcoDrive,	
 };
 
 uint32_t Icons2[] = {
 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xF7FFFFFF, 0xFFF56264, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000FFFF, 0x0E000000, 0xFFFFFF93, 0xFFFFFFFF, 0xFFFFFFFF, 0xC3FFFFFF, 0x04042368, 0xFFB86421, 0xFFFFFFFF, 0xFFFFFFFF, 0x000000FF, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x5487BCEF, 0xFFFF1821, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xBFFFFFFF, 0x06062568, 0xFFBF6825, 0xFFFFFFFF, 0xFFFFFFFF, 0x43B0FFFF, 0x31313131, 0x31313131, 0xB0413131, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x62A4F8FF, 0xA8664D45, 0xFFFFFFF8, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x180089FF, 0xFFFFFFF5, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x31DEFFFF, 0xDD2F0000, 0xFF0000FF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x9800FFFF, 0x02319498, 0xFFFF8029, 0xFFFFFFFF, 0xFFFFFFFF, 0x0445DFFF, 0x1616120C, 0x3D040C14, 0xFFFFFFD5, 0xFFFFFFFF, 0x00FF00FF, 0xCFCFCFCF, 0xCFCFCFCF, 0xFF00CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0x23568CCF, 0x00000000,
 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0060FFFF, 0x88000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x4141D9FF, 0xB2B2A483, 0x414180A4, 0xFFFFFFD7, 0xFFFFFFFF, 0xBA35F6FF, 0xD9D9D9D9, 0xD9D9D9D9, 0x35BAD9D9, 0xFFFFFFF3, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x5E1F0E92, 0x2C4D4D76, 0xFFFF900F, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0000D4FF, 0xFFFFFF7C, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x0010B5FF, 0x0E000000, 0xFF0000B4, 0xFFFFFFFF, 0x1DC3FFFF, 0x00000000, 0x00000000, 0x00000000, 0xC11A0000, 0xFFFFFFFF, 0xFEFEFFFF, 0x9800FFFF, 0x00969898, 0xFF7E1AE3, 0xFFFFFFFF, 0xFFFFFFFF, 0x160C10C9, 0x16161616, 0x0C161616, 0xFFFFBC09,
 0xFFFFFFFF, 0x000000FF, 0xCFCFCFCF, 0xCFCFCFCF, 0x0000CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000004, 0x00000000, 0xFFFF0000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xE500FFFF, 0x00CBE5E5, 0xFFFFFF98, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xC9900CC5, 0xB4B4B4C5, 0x78B4B4B4, 0xFFFFC30B, 0xFFFFFFFF, 0xD937D3FF, 0x1212127C, 0xD5701212, 0x37D9BAB2, 0xFFFFFFD3, 0x087EFFFF, 0x00000000, 0x00000000, 0x00000000, 0x7E080000, 0xFFFFFFFF, 0x3FF3FFFF, 0x94C15A16, 0x73C17070, 0xF442285B, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x006899A9, 0xFFFFE006, 0xFFFFFFFF, 0xFFFFFFFF, 0xFDFFFFFF, 0x0E000080, 0x000EABAB, 0xFF000000, 0xFFFFFFFF, 0xC321FFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x1FC1FFFF, 0xFFFFFFFF,
 0x000000FF, 0x47000000, 0x00989898, 0x7E18D6FF, 0xFFFFFFFF, 0xDFFFFFFF, 0x16160E12, 0x00000008, 0x16160800, 0xFFD7090E, 0xFFFFFFFF, 0x00FF00FF, 0xCFCFCFCF, 0xCFCFCFCF, 0xFF00CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x00000000, 0xFFFF0000, 0xFFFFFFFF, 0x0200F3FF, 0x0014BCFF, 0x14000000, 0xFFFFFFBE, 0xFFFFFFFF, 0xE500FFFF, 0xBAE5E5E5, 0x00000060, 0x00000000, 0x64000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xD9FFFFFF, 0xE7FFAC0E, 0xB4B4B6C3, 0xB4B4B4B4, 0xFFD70D81, 0xFFFFFFFF, 0xD943C3FF, 0xD9D9D9D9, 0xA2CBD9D9, 0x43D9B2C7, 0xFFFFFFBF, 0xCD0AFFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x0ACDCDCD, 0xFFFFFFFF, 0x2339FCFF, 0x6A92AA68, 0x6BBA6B6B, 0x3C249298, 0xFFFFFFFE, 0xFFFFFFFF, 0xDCFFFFFF, 0x0E9D0004, 0xFFFF5800, 0xFFFFFFFF, 0xFFFFFFFF, 0x49ECFFFF,
 0xD22D0000, 0x2BD1F2F2, 0xEB000000, 0xFFFFFFFF, 0x0800FFFF, 0x08080808, 0x08080808, 0x06060606, 0x00060606, 0xFFFFFFFF, 0xE3E300FF, 0x04025CD9, 0x0098983D, 0x25DDFFFF, 0xFFFFFF8C, 0x45FFFFFF, 0x1616160A, 0xFFFFFF00, 0x161600FF, 0xFF340B16, 0xFFFFFFFF, 0x000000FF, 0xCFCFCFCF, 0xCFCFCFCF, 0x0000CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0x00000000, 0x62270000, 0xFFFF007E, 0xFFFFFFFF, 0xFFFFFFFF, 0x66431FCF, 0x43666666, 0xFFFFD723, 0xFFFFFFFF, 0xE500FFFF, 0xE5E5E5E5, 0xE5E5E5E5, 0xE5E5E5E5, 0x00E5E5E5, 0xFFFFFFFF, 0x020274FF, 0x02020202, 0x02020202, 0x02020202, 0xFFFFFF74, 0x39FFFFFF, 0xFFFFFF8A, 0x76769CD5, 0xB2B4B494, 0xFF3877B2, 0xFFFFFFFF, 0xD954A8FF, 0xAAC3DBD9, 0xC7989E9E, 0x54D9AAF3, 0xFFFFFFAA, 0xCD00FFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x00CDCDCD, 0xFFFFFFFF, 0x641691FF, 0x6666B47A,
 0x9CB66C66, 0x176365A6, 0xFFFFFF94, 0xFFFFFFFF, 0xA5FFFFFF, 0x8DEE1F7E, 0xFFC80000, 0xFFFFFFFF, 0xFFFFFFFF, 0x001FCCFF, 0x91EC5C00, 0xEB854343, 0x1D00005A, 0xFFFFFFCB, 0x9800FFFF, 0x97979798, 0x97979797, 0x96969696, 0x00969696, 0xFFFFFFFF, 0xE3E300FF, 0x8700DDE3, 0x00982502, 0x02000000, 0xFFFFFF0C, 0x02CDFFFF, 0x16161616, 0xFFFFFF00, 0x161600FF, 0xB8031616, 0xFFFFFFFF, 0x00FF00FF, 0xCFCFCFCF, 0xCFCFCFCF, 0xFF00CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0x763B0400, 0xFFFFEBB0, 0xFFFF00FF, 0xFFFFFFFF, 0x00000035, 0x2D583D12, 0x582D1212, 0x00000E39, 0xFFFF3D00, 0x1000FFFF, 0x00000000, 0x00000000, 0x00000000, 0x00100000, 0xFFFFFFFF, 0xD1D102FF, 0xD1D1D1D1, 0xD1D1D1D1, 0xCDD1D1D1, 0xFFFFFF04, 0x41BCFFFF, 0xF6FCDBC9, 0x8A8A6074, 0xB2AE5A5E, 0xBA40B2B2, 0xFFFFFFFF, 0xD96698FF, 0xDBB2AAD5, 0xF3E5EDED,
 0x66D9A6F3, 0xFFFFFF94, 0xCD00FFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x00CDCDCD, 0xFFFFFFFF, 0x604F10FB, 0x606068B4, 0x96FCD160, 0x92A66E60, 0xFFFFF611, 0xFFFFFFFF, 0x0AF7FFFF, 0xFDFFDE1F, 0xFF6A002F, 0xFFFFFFFF, 0xFFFFFFFF, 0x0400069B, 0x43F2F291, 0xF133DEDE, 0x00028EF1, 0xFFFF9C04, 0xA000FFFF, 0x97979798, 0x97979797, 0x96969696, 0x009E9696, 0xFFFFFFFF, 0xE3E300FF, 0xFE00E3E3, 0x98250AC5, 0x2D949898, 0xFFFFFF00, 0x0C74FFFF, 0x16161616, 0xFFFFFF00, 0x161600FF, 0x620C1616, 0xFFFFFFFF, 0x000000FF, 0xCFCFCFCF, 0xCFCFCFCF, 0x0000CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFE700, 0xFFFFFFFF, 0xFFFF00FF, 0xFFFFFFFF, 0x66666600, 0x8C143966, 0x148CCFCD, 0x122F5239, 0xFFFF005E, 0x9C00FFFF, 0xB2B2B2B2, 0xB2B2B2B2, 0xB2B2B2B2, 0x009CB2B2, 0xFFFFFFFF, 0xD1D102FF, 0xD1D1D1D1, 0xD1D1D1D1, 0xD1D1D1D1,
 0xFFFFFF02, 0x8366FFFF, 0x70C9BABA, 0xE7E7E794, 0xB25990E7, 0x6581B2B2, 0xFFFFFFFF, 0xD9767EFF, 0xCDF3BFB6, 0xF3CD8585, 0x76D99AF1, 0xFFFFFF7C, 0xCD00FFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x00CDCDCD, 0xFFFFFFFF, 0xC9B125AC, 0x8C6060E5, 0x60DBC5B8, 0x5868A4AC, 0xFFFFA61B, 0xFFFFFFFF, 0x0082FFFF, 0xFFFFFF31, 0xE30000E1, 0xFFFFFFFF, 0xFFFFFFFF, 0xC20E0068, 0x43F2F2F2, 0xF133FFFF, 0x0AC1F1F1, 0xFFFF6600, 0xA000FFFF, 0x97979798, 0x97979797, 0x96969696, 0x009E9696, 0xFFFFFFFF, 0xE3E300FF, 0xFE00E3E3, 0x2B0EC9FE, 0x92969898, 0xFFFFFF00, 0x1231FFFF, 0x16161616, 0xFFFFFF00, 0x161600FF, 0x1F141616, 0xFFFFFFFF, 0x00FF00FF, 0xCFCFCFCF, 0xCFCFCFCF, 0xFF00CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFF00FF, 0xFFFFFFFF, 0x66666600, 0x62DB1F49, 0xD7620A0A, 0x12314721, 0xFFFF005E,
 0xB200FFFF, 0xB2B2B2B2, 0xB2B2B2B2, 0xB2B2B2B2, 0x00B2B2B2, 0xFFFFFFFF, 0xD1D102FF, 0xD1D1D1D1, 0xD1D1D1D1, 0xD1D1D1D1, 0xFFFFFF02, 0xA823FFFF, 0x5E94B4B4, 0x5E5EBFE7, 0x925FE7BF, 0x22A6B2B2, 0xFFFFFFFF, 0xD98C68FF, 0x6CF3EDA0, 0xF370D1D5, 0x8CD9A0ED, 0xFFFFFF68, 0xCD00FFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x00CDCDCD, 0xFFFFFFFF, 0xFF622B66, 0x7EA2B6FF, 0xBCC35254, 0x5252526C, 0xFFFF642B, 0x0818FFFF, 0x0000E231, 0x0A0A23D8, 0x35006A7E, 0x166A78B0, 0xFFFFFFFF, 0xF2007AFE, 0x43F2F2F2, 0xF1334747, 0x00F1F1F1, 0xFFFFFE78, 0xA000FFFF, 0x97979798, 0x97979797, 0x96969696, 0x009E9696, 0xFFFFFFFF, 0xE3E300FF, 0x0000E3E3, 0x00060000, 0x96969898, 0xFFFFFF00, 0x1414FFFF, 0x00081216, 0xFFFFFF00, 0x080000FF, 0x04161612, 0xFFFFFFFF, 0x000000FF, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFF00, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFF00FF, 0xFFFFFFFF, 0x66666600, 0x394BAE1F, 0x4B396060, 0x5E521DB0, 0xFFFF0066, 0xB200FFFF, 0xB2B2B2B2, 0xB2B2B2B2, 0xB2B2B2B2, 0x00B2B2B2, 0xFFFFFFFF, 0xD1D102FF, 0xD1D1D1D1, 0xD1D1D1D1, 0xD1D1D1D1, 0xFFFFFF02, 0xB206FFFF, 0x8A76B4B4, 0xF6F65EE7, 0x7588E75E, 0x05B0B2B2, 0xFFFFFFFF, 0xD99E52FF, 0xAAF3EDA0, 0xF3A86E6E, 0x9CD9A0ED, 0xFFFFFF50, 0xCD00FFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x00CDCDCD, 0xFFFFFFFF, 0xB8492F4D, 0x49494994, 0xA8FF7E49, 0x49494949, 0xFFFF4531, 0x0000FFFF, 0x640043AB, 0x00000064, 0x0002CD00, 0x0008A8C1, 0xFFFFFFFF, 0xF200FFFF, 0xE2F2F2F2, 0xF1DFD2D2, 0x00F1F1F1, 0xFFFFFFFF, 0xA000FFFF, 0x97979798, 0x97979797, 0x96969696, 0x009E9696, 0xFFFFFFFF, 0xE3E300FF, 0xE3E3E3E3, 0x005ADDE3, 0x96969898, 0xFFFFFF00, 0x141AFFFF, 0xFF980816,
 0xFFFFFFFF, 0x98FFFFFF, 0x04161608, 0xFFFFFFFF, 0x00FF00FF, 0xCFCFCFCF, 0xCFCFCFCF, 0xFF00CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFF00FF, 0xFFFFFFFF, 0x64666600, 0x660ADF00, 0x0A666666, 0x666402DF, 0xFFFF0066, 0xB200FFFF, 0xB2B2B2B2, 0xB2B2B2B2, 0xB2B2B2B2, 0x00B2B2B2, 0xFFFFFFFF, 0xD1D102FF, 0xD1D1D1D1, 0xD1D1D1D1, 0xD1D1D1D1, 0xFFFFFF02, 0xAC0CFFFF, 0x8A76B4B4, 0xF6F65EE7, 0x7588E55E, 0x05B2B2B2, 0xFFFFFFFF, 0xD9AC39FF, 0xF3F6C3B6, 0xF6F3EDED, 0xAED9B6C3, 0xFFFFFF39, 0xCD00FFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x00CDCDCD, 0xFFFFFFFF, 0xA8413F49, 0x41414141, 0x83C98841, 0x41414141, 0xFFFF452B, 0x4308FFFF, 0xD20200C6, 0x0A0A0A0A, 0x8AB25A00, 0x1808C383, 0xFFFFFFFF, 0xF200FFFF, 0xF2F2F2F2, 0xF1F1F2F2, 0x00F1F1F1, 0xFFFFFFFF, 0xA000FFFF, 0x97979798, 0x97979797,
 0x96969696, 0x009E9696, 0xFFFFFFFF, 0xE3E300FF, 0xE3E3E3E3, 0x00D9E3E3, 0x96969898, 0xFFFFFF00, 0x1235FFFF, 0xBC001216, 0xFFFFFFFF, 0x02BCFFFF, 0x21141612, 0xFFFFFFFF, 0x000000FF, 0xCFCFCFCF, 0xCFCFCFCF, 0x0000CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFF00FF, 0xFFFFFFFF, 0x64666600, 0x660CDD04, 0x0C666666, 0x666204DD, 0xFFFF0066, 0xB200FFFF, 0xB2B2B2B2, 0xB2B2B2B2, 0xB2B2B2B2, 0x00B2B2B2, 0xFFFFFFFF, 0xD1D102FF, 0xD1D1D1D1, 0xD1D1D1D1, 0xD1D1D1D1, 0xFFFFFF02, 0xA227FFFF, 0x6094B4B4, 0x605EBFE7, 0x925FE5BF, 0x21A8B2B2, 0xFFFFFFFF, 0xD9C123FF, 0xE5BAAAD5, 0xBAE3F8FA, 0xC1D9D5AA, 0xFFFFFF23, 0xCD00FFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x00CDCDCD, 0xFFFFFFFF, 0xA8435A5E, 0x3B3B3B3B, 0xB43FA83B, 0x3B3B3B3D, 0xFFFF702B, 0xF9FFFFFF, 0xFF9F0012, 0xFFFFFFFF, 0x47FFFFFF,
 0xFFFF7E00, 0xFFFFFFFF, 0xF200FFFF, 0x00F2F2F2, 0xF1000000, 0x00F1F1F1, 0xFFFFFFFF, 0xA000FFFF, 0x97979798, 0x97979797, 0x96969696, 0x009E9696, 0xFFFFFFFF, 0xE3E300FF, 0xE3E3E3E3, 0x00DDE3E3, 0x9696989A, 0xFFFFFF00, 0x0C6CFFFF, 0x0C0E1616, 0xFFFFFFDB, 0x0E0EDBFF, 0x640C1616, 0xFFFFFFFF, 0x00FF00FF, 0xCFCFCFCF, 0xCFCFCFCF, 0xFF00CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFF00F5, 0xFFFFFFFF, 0x66666600, 0x392DC716, 0x2D396666, 0x666614C9, 0xFFFF0066, 0xB200FFFF, 0xB2B2B2B2, 0xB2B2B2B2, 0xB2B2B2B2, 0x00B2B2B2, 0xFFFFFFFF, 0xD1D102FF, 0xD1D1D1D1, 0xD1D1D1D1, 0xD1D1D1D1, 0xFFFFFF02, 0x885EFFFF, 0x5AB4B4B4, 0xE7E7E790, 0xC76F92E5, 0x5C85B8B8, 0xFFFFFFFF, 0xD9D30AFF, 0xAAC3DBD9, 0xC3AA9E9E, 0xD5D9D9DB, 0xFFFFFF08, 0xCD0AFFFF, 0xCDCDCDCD, 0xCDCDCDCD, 0xCDCDCDCD, 0x0ACDCDCD,
 0xFFFFFFFF, 0xE1A814AC, 0x33333388, 0x56337C54, 0x70416EA2, 0xFFFFA62B, 0x51FFFFFF, 0xFFFB1200, 0xFFFFFFFF, 0xCBFFFFFF, 0xFFDBB03F, 0xFFFFFFFF, 0xF200FFFF, 0x00F2F2F2, 0xF1000000, 0x00F1F1F1, 0xFFFFFFFF, 0xA000FFFF, 0x4B4B9798, 0x4B4B4B4B, 0x49494949, 0x009E9696, 0xFFFFFFFF, 0xE3E300FF, 0xE3E3E3E3, 0x00DDE3E3, 0x9696989A, 0xFFFFFF00, 0x02C7FFFF, 0x0C161616, 0xFFFFF323, 0x160C23F3, 0xB9041616, 0xFFFFFFFF, 0x000000FF, 0xCFCFCFCF, 0xCFCFCFCF, 0x0000CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0xFAFFFFFF, 0xFFFFFF00, 0x8EDDFFFF, 0xFFFF0035, 0xFFFFFFFF, 0x66666600, 0x2FD93741, 0xD92F0E0E, 0x66663F39, 0xFFFF0066, 0xB002FFFF, 0xB2B2B2B2, 0xB2B2B2B2, 0xB2B2B2B2, 0x00B0B2B2, 0xFFFFFFFF, 0xD1D102FF, 0xD1D1D1D1, 0xD1D1D1D1, 0xD1D1D1D1, 0xFFFFFF02, 0x43BAFFFF, 0xAEB4B4B4, 0x888A5E5A, 0xFAF4735F, 0xB841C7D9, 0xFFFFFFFF,
 0xD18C2FFF, 0xD9D9D9D9, 0xD9D9D9D9, 0x8ED1D9D9, 0xFFFFFF2F, 0x087EFFFF, 0x00000000, 0x00000000, 0x00000000, 0x7C080000, 0xFFFFFFFF, 0xFF720CFC, 0x2B2B49ED, 0x2B2B458E, 0x62EDFF9A, 0xFFFFF80C, 0x76F0FFFF, 0xFFFF9702, 0xFFFFFFFF, 0xFFFFFFFF, 0xE50C0094, 0xFFFFFFFF, 0xF200FFFF, 0x00F2F2F2, 0xF1006A00, 0x00F1F1F1, 0xFFFFFFFF, 0xA000FFFF, 0xFF4B9798, 0xFFFF4BFF, 0x49FFFF4B, 0x009E9696, 0xFFFFFFFF, 0xE3E300FF, 0xE3E3E3E3, 0x00E3E3E3, 0x00000000, 0xFFFFFF00, 0x45FFFFFF, 0x1616160A, 0xFFFF410A, 0x16160A41, 0xFF350C16, 0xFFFFFFFF, 0x00FF00FF, 0xCFCFCFCF, 0xCFCFCFCF, 0xFF00CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0x398CDBFF, 0xFFFFFF00, 0x000085FF, 0xFFFF0000, 0xFFFFFFFF, 0x66666600, 0xBC353966, 0x35BCDBDB, 0x66666639, 0xFFFF0066, 0xB302FFFF, 0xB2B2B2B2, 0xB2B2B2B2, 0xB2B2B2B2, 0x00B2B2B2, 0xFFFFFFFF, 0x02020202,
 0x02020202, 0x02020202, 0x02020202, 0xFFFF0202, 0x39FFFFFF, 0xB4B4B478, 0x757594B4, 0xFFFFD39A, 0xFF378CFF, 0xFFFFFFFF, 0x165000FF, 0x16161616, 0x16161616, 0x50161616, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0x787878FF, 0xFFFFFF78, 0xFFFFFFFF, 0xFFFFFFFF, 0xA40A90FF, 0xAA947892, 0x9E98C9FF, 0x21BFFAAC, 0xFFFFFF96, 0x376EFFFF, 0xFFFFFEB7, 0xFFFFFFFF, 0xFFFFFFFF, 0x7C000083, 0xFFFFFFFF, 0xF300FFFF, 0x00F2F2F2, 0xF1005800, 0x00F1F1F1, 0xFFFFFFFF, 0x7421FFFF, 0xFF4B9798, 0xFFFF4BFF, 0x49FFFF4B, 0x1F749696, 0xFFFFFFFF, 0xE3E300FF, 0xE3E3E3E3, 0x00E3E3E3, 0xFEFEFFFE, 0xFFFFFFFF, 0xDFFFFFFF, 0x16160E12, 0x6A680816, 0x16161608, 0xFFD9080E, 0xFFFFFFFF, 0x000000FF, 0xCFCFCFCF, 0xCFCFCFCF, 0x0000CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0x0000008A, 0xFFFFFF00, 0x00000CFF, 0xFFFF0C00, 0xFFFFFFFF, 0x66666600, 0x18436666,
 0x43180000, 0x66666666, 0xFFFF0066, 0x9902FFFF, 0x98989899, 0x98989898, 0x98989898, 0x00989898, 0xFFFFFFFF, 0x02020280, 0x02020202, 0x02020202, 0x02020202, 0xFFFF7F02, 0xD9FFFFFF, 0xB4B4830E, 0xB2B2B2B4, 0xFFE5C1B4, 0xFFD90CAA, 0xFFFFFFFF, 0x1D9800FF, 0x98989898, 0x984B984B, 0x9898984B, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0x9E9E9ED3, 0xFFFFD39E, 0xFFFFFFFF, 0xFFFFFFFF, 0x0A3BFFFF, 0x2F1D1DA4, 0x1D1D50D1, 0x3F081D1D, 0xFFFFFFFF, 0x2129FFFF, 0xFFFFFFE2, 0xFFFFFFFF, 0xFFFFFFFF, 0x450039F1, 0xFFFFFFFF, 0xF300FFFF, 0x00F2F2F2, 0xF1000000, 0x00F1F1F1, 0xFFFFFFFF, 0x10C3FFFF, 0x00000000, 0x00000000, 0x00000000, 0xBE100000, 0xFFFFFFFF, 0xE3E300FF, 0xE3E3E3E3, 0x00E3E3E3, 0xFFFFFFFE, 0xFFFFFFFF, 0xFFFFFFFF, 0x160C0EC9, 0x0C0C1616, 0x0C161616, 0xFFFFBE0A, 0xFFFFFFFF, 0x00FF00FF, 0xCFCFCFCF, 0xCFCFCFCF,
 0xFF00CFCF, 0xFFFFFF00, 0xFFFFFFFF, 0x0000000C, 0xFFFFFF04, 0x00001AFF, 0xFFFF4D00, 0xFFFFFFFF, 0x00000045, 0x00000000, 0x00000000, 0x00000000, 0xFFFF4300, 0x0235FFFF, 0x00020202, 0x00000000, 0x00000000, 0x31000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xB4780CC5, 0xB2B2B2B2, 0x8CC7C3B2, 0xFFFFC30A, 0xFFFFFFFF, 0x1D9800FF, 0x98989898, 0x984B984B, 0x9800984B, 0xFFFFFF00, 0xFFFFFFFF, 0xFFFFFFFF, 0x64646464, 0xFFFF6464, 0xFFFFFFFF, 0xFFFFFFFF, 0x39F6FFFF, 0x1616391D, 0x16161694, 0xF63D0610, 0xFFFFFFFF, 0xE82BFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x665CFEFF, 0xFFFFFFFF, 0x0000FFFF, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x000000FF, 0x00000000, 0x00000000, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFFFF, 0x043DDDFF, 0x1616120C, 0x35040C14, 0xFFFFFFD5, 0xFFFFFFFF, 0x000000FF, 0x00000000, 0x00000000, 0x00000000, 0xFFFFFF00, 0xFFFFFFFF, 0x0000001F, 0xFFFFFF43, 0x181DB8FF, 0xFFFFED5C, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x4239D9FF, 0xACB0A481, 0x374180A0, 0xFFFFFFD7, 0xFFFFFFFF, 0x1D7810FF, 0x98989898, 0x984B984B, 0x7898984B, 0xFFFFFF10, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x080C1088, 0x08080C62, 0xFFFE880A, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xBEFFFFFF, 0x020A2766, 0xFFB6621F, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x6E2521B8, 0xFFFFFFF1, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xB8FFFFFF, 0x08022164, 0xFFB86427, 0xFFFFFFFF, 0xFFFFFFFF, 0x00028CFF, 0x00000000, 0x00000000, 0x02000000, 0xFFFFFF8C, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0x62A8FAFF, 0xAC624349, 0xFFFFFFFA, 0xFFFFFFFF, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
 };
 
 LInlineBmp TreeIconsImg = { 308, 22, 8, Icons2 };
 
 
 //////////////////////////////////////////////////////////////////////////
 char *LFileType::DefaultExtension()
 {
 	char *Status = 0;
 	auto T = LString(Extension()).SplitDelimit(";");
 	if (T.Length())
 	{
 		char s[256];
 		strcpy(s, T[0]);
 		char *Dir = strchr(s, '.');
 		if (Dir)
 		{
 			Status = NewStr(Dir+1);
 			if (Status) strlwr(Status);
 		}
 	}
 	return Status;
 }
 
 //////////////////////////////////////////////////////////////////////////
 class LFolderItem : public LListItem
 {
 	LFileSelectDlg *Dlg;
 	LString Path;
 
 public:
 	char *File;
 	bool IsDir;
 
 	LFolderItem(LFileSelectDlg *dlg, char *FullPath, LDirectory *Dir);
 	~LFolderItem();
 
 	void OnActivate();
 	const char *GetText(int i);
 	int GetImage(int Flags);
 	void OnSelect();
 	void OnDelete(bool Ask = true);
 	void OnRename();
 	void OnMouseClick(LMouse &m);
 };
 
 
 //////////////////////////////////////////////////////////////////////////
 // This is just a private data container to make it easier to change the
 // implementation of this class without effecting headers and applications.
 class LFileSelectPrivate
 {
 	friend class LFileSelect;
 	friend class LFileSelectDlg;
 	friend class LFolderList;
 
 	LView *Parent = NULL;
 	LFileSelect *Select = NULL;
 
 	DlgType Type = TypeNone;
 	LString Title;
 	LString DefExt;
 	bool MultiSelect = false;
 	List<char> Files;
 	int CurrentType = -1;
 	List<LFileType> Types;
 	List<char> History;
 	bool ShowReadOnly = false;
 	bool ReadOnly = false;	
 	bool EatClose = false;
 
 public:
 	static LImageList *BtnIcons, *TreeIcons;
 	static LString InitPath;
 	static bool InitShowHiddenFiles;
 	static LRect InitSize;
 
 	LFileSelectPrivate(LFileSelect *select)
 	{
 		Select = select;
 
 		if (!BtnIcons)
 			BtnIcons = new LImageList(16, 16, FileSelectIcons.Create(0xF81F));
 		if (!TreeIcons)
 		{
 			LAutoPtr<LSurface> a(TreeIconsImg.Create(0xF81F));
 			LAutoPtr<LMemDC> m(new LMemDC(a->X(), a->Y(), System32BitColourSpace));
 			if (a && m)
 			{
 				LColour fore(128, 128, 128);
 				for (int y=0; y<a->Y(); y++)
 				{
 					uint8_t *i = (uint8_t*)(*a)[y];
 					auto *e = i + a->X();
 					System32BitPixel *o = (System32BitPixel*)(*m)[y];
 					while (i < e)
 					{
 						o->r = (int)fore.r() * *i / 255;
 						o->g = (int)fore.g() * *i / 255;
 						o->b = (int)fore.b() * *i / 255;
 						o->a = *i;
 						i++;
 						o++;
 					}
 				}
 				
 				TreeIcons = new LImageList(22, 22, m.Release());
 			}
 		}
 	}
 
 	virtual ~LFileSelectPrivate()
 	{
 		Types.DeleteObjects();
 		Files.DeleteArrays();
 		History.DeleteArrays();
 	}
 };
 
 LImageList *LFileSelectPrivate::BtnIcons = NULL;
 LImageList *LFileSelectPrivate::TreeIcons = NULL;
 LString LFileSelectPrivate::InitPath;
 bool LFileSelectPrivate::InitShowHiddenFiles = false;
 LRect LFileSelectPrivate::InitSize(0, 0, -1, -1);
 
 //////////////////////////////////////////////////////////////////////////
 // This class implements the UI for the selector.
 class LFileSelectDlg;
 
 class LFolderView
 {
 protected:
 	LFileSelectDlg *Dlg;
 
 public:
 	LFolderView(LFileSelectDlg *dlg)
 	{
 		Dlg = dlg;
 	}
 
 	virtual void OnFolder() {}
 };
 
 class LFolderDrop : public LDropDown, public LFolderView
 {
 public:
 	LFolderDrop(LFileSelectDlg *dlg, int Id, int x, int y, int cx, int cy);
 
 	void OnFolder();
 
 	bool OnLayout(LViewLayoutInfo &Inf)
 	{
 		Inf.Width.Min = 
 			Inf.Width.Max = 18;
 		return true;
 	}
 };
 
 class LIconButton : public LLayout
 {
 	LImageList *Icons;
 	int Icon;
 	bool Down;
 
 public:
 	LIconButton(int Id, int x, int y, int cx, int cy, LImageList *icons, int icon)
 	{
 		Icons = icons;
 		Icon = icon;
 		SetId(Id);
 		LRect r(x, y, x+cx, y+cy);
 		SetPos(r);
 		Down = false;
 		SetTabStop(true);
 	}
 
 	void OnPaint(LSurface *pDC)
 	{
 		LRect c = GetClient();
 		LColour Background(L_MED);
 		c.Offset(-c.x1, -c.y1);
 		LWideBorder(pDC, c, Down ? DefaultSunkenEdge : DefaultRaisedEdge);
 		pDC->Colour(Background);
 		pDC->Rectangle(&c);
 		
 		int x = (c.X()-Icons->TileX()) / 2;
 		int y = (c.Y()-Icons->TileY()) / 2;
 
 		if (Focus())
 		{
 			#if WINNATIVE
 			RECT r = c;
 			DrawFocusRect(pDC->Handle(), &r);
 			#endif
 		}
 
 		Icons->Draw(pDC, c.x1+x+Down, c.y1+y+Down, Icon, Background, !Enabled());
 	}
 
 	void OnFocus(bool f)
 	{
 		Invalidate();
 	}
 
 	void OnMouseClick(LMouse &m)
 	{
 		if (Enabled())
 		{
 			bool Trigger = Down && !m.Down();
 
 			Capture(Down = m.Down());
 			if (Down) Focus(true);
 			Invalidate();		
 
 			if (Trigger)
 			{
 				LViewI *n=GetNotify()?GetNotify():GetParent();
 				if (n)
 					n->OnNotify(this, LNotification(m));
 			}
 		}
 	}
 
 	void OnMouseEnter(LMouse &m)
 	{
 		if (IsCapturing())
 		{
 			Down = true;
 			Invalidate();
 		}
 	}
 
 	void OnMouseExit(LMouse &m)
 	{
 		if (IsCapturing())
 		{
 			Down = false;
 			Invalidate();
 		}
 	}
 
 	bool OnKey(LKey &k)
 	{
 		if (k.c16 == ' ' || k.c16 == LK_RETURN)
 		{
 			if (Enabled() && Down ^ k.Down())
 			{
 				Down = k.Down();
 				Invalidate();
 
 				if (!Down)
 				{
 					LViewI *n=GetNotify()?GetNotify():GetParent();
 					if (n) n->OnNotify(this, LNotifyActivate);
 				}
 			}
 			
 			return true;
 		}
 		
 		return false;
 	}
 	
 	bool OnLayout(LViewLayoutInfo &Inf)
 	{
 		Inf.Width.Min = Inf.Width.Max = Icons->TileX() + 4;
 		Inf.Width.Max += 4;
 		Inf.Height.Min = Inf.Height.Max = Icons->TileY() + 4;
 		Inf.Height.Max += 4;
 		return true;
 	}
 };
 
 class LFolderList : public LList, public LFolderView
 {
 	LString FilterKey;
 
 public:
 	LFolderList(LFileSelectDlg *dlg, int Id, int x, int y, int cx, int cy);
 
 	void OnFolder();
 	bool OnKey(LKey &k);
 	void SetFilterKey(LString s) { FilterKey = s; OnFolder(); }
 };
 
 enum Ctrls
 {
 	IDC_STATIC = -1,
 	IDD_FILE_SELECT = 1000,
 	IDC_PATH,
 	IDC_DROP,
 	IDC_BACK,
 	IDC_UP,
 	IDC_NEW,
 	IDC_VIEW,
 	IDC_FILE,
 	IDC_TYPE,
 	IDC_SHOWHIDDEN,
 	IDC_SUB_TBL,
 	IDC_BOOKMARKS,
 	IDC_FILTER,
 	IDC_FILTER_CLEAR,
 };
 
 #if 1
 #define USE_FOLDER_CTRL				1
 
 enum FolderCtrlMessages
 {
 	M_DELETE_EDIT				=	M_USER + 100,
 	M_NOTIFY_VALUE_CHANGED,
 	M_LOST_FOCUS,
 };
 
 class FolderCtrlEdit : public LEdit
 {
 public:
 	FolderCtrlEdit(int id, LRect c) :
 		LEdit(id, c.x1, c.y1, c.X()-1, c.Y()-1)
 	{
 	}
 
 	void OnFocus(bool f)
 	{
 		printf("OnFocus(%i)\n", f);
 		if (!f && GetParent())
 			GetParent()->PostEvent(M_LOST_FOCUS);
 	}
 };
 
 class FolderCtrl : public LView
 {
 	struct Part
 	{
 		LAutoPtr<LDisplayString> ds;
 		LRect Arrow;
 		LRect Text;
 	};
 	
 	LEdit *e;
 	LArray<Part> p;
 	Part *Over;
 	ssize_t Cursor;
 
 	Part *HitPart(int x, int y, int *Sub = NULL)
 	{
 		for (unsigned i=0; i<p.Length(); i++)
 		{
 			if (p[i].Arrow.Overlap(x, y))
 			{
 				if (Sub) *Sub = 1;
 				return p.AddressOf(i);
 			}
 			if (p[i].Text.Overlap(x, y))
 			{
 				if (Sub) *Sub = 0;
 				return p.AddressOf(i);
 			}
 		}
 
 		return NULL;
 	}
 	
 public:
 	FolderCtrl(int id)
 	{
 		e = NULL;
 		Cursor = 0;
 		SetId(id);
 	}
 	
 	~FolderCtrl()
 	{
 	}
 	
 	const char *GetClass() { return "FolderCtrl"; }
 	
 	bool OnLayout(LViewLayoutInfo &Inf)
 	{
 		if (Inf.Width.Min == 0)
 		{
 			Inf.Width.Min = -1;
 			Inf.Width.Max = -1;
 		}
 		else
 		{
 			Inf.Height.Min = GetFont()->GetHeight() + 4;
 			Inf.Height.Max = Inf.Height.Min;
 		}
 		return true;
 	}
 
 	LString NameAt(ssize_t Level)
 	{
 		LString n;
 		#ifndef WINDOWS
 		n += "/";
 		#endif
 		for (unsigned i=0; i<=Level && i<p.Length(); i++)
 		{
 			n += (const char16*) *(p[i].ds.Get());
 			n += DIR_STR;
 		}
 
 		return n;		
 	}
 
 	const char *Name()
 	{
 		LString n = NameAt(Cursor);
 		LBase::Name(n);
 		return LBase::Name();
 	}
 	
 	bool Name(const char *n)
 	{
 		if (n && LView::Name() && !strcmp(n, LView::Name()))
 			return true;
 
 		bool b = LView::Name(n);
 		
 		Over = NULL;
 		LString Nm(n);
 		LString::Array a = Nm.SplitDelimit(DIR_STR);
 		p.Length(0);
 		for (size_t i=0; i<a.Length(); i++)
 		{
 			Part &n = p.New();
 			n.ds.Reset(new LDisplayString(GetFont(), a[i]));
 		}
 
 		Cursor = p.Length() - 1;
 		Invalidate();
 		return b;
 	}
 	
 	void OnPaint(LSurface *pDC)
 	{
 		LRect c = GetClient();
 		LThinBorder(pDC, c, EdgeWin7Sunken);
 		
 		LFont *f = GetFont();
 		f->Transparent(false);
 		
 		LDisplayString Arrow(f, ">");
 		for (unsigned i=0; i<p.Length(); i++)
 		{
 			Part *n = p.AddressOf(i);
 			LColour Fore(Cursor == i ? L_FOCUS_SEL_FORE : L_TEXT);
 			LColour Bk(	Cursor == i
 						?
 						LColour(L_FOCUS_SEL_BACK)
 						:
 						(
 							n == Over
 							?
 							GdcMixColour(LColour(L_FOCUS_SEL_BACK), LColour(L_WORKSPACE), 0.15f)
 							:
 							LColour(L_WORKSPACE)
 						)
 					);
 			
 			// Layout and draw arrow
 			n->Arrow.ZOff(Arrow.X()+1, c.Y()-1);
 			n->Arrow.Offset(c.x1, c.y1);
 			f->Colour(LColour(192,192,192), Bk);
 			Arrow.DrawCenter(pDC, &n->Arrow);
 			c.x1 = n->Arrow.x2 + 1;
 
 			if (n->ds)
 			{
 				// Layout and draw text
 				n->Text.ZOff(n->ds->X() + 4, c.Y()-1);
 				n->Text.Offset(c.x1, c.y1);
 				f->Colour(Fore, Bk);
 				n->ds->DrawCenter(pDC, &n->Text);
 				c.x1 = n->Text.x2 + 1;
 			}
 		}
 		if (p.Length() == 0)
 		{
 			// Layout and draw arrow for the "root folder"
 			f->Colour(LColour(192,192,192), L_WORKSPACE);
 			LRect a;
 			a.ZOff(Arrow.X()+1, c.Y()-1);
 			a.Offset(c.x1, c.y1);
 			Arrow.DrawCenter(pDC, &a);
 			c.x1 = a.x2 + 1;
 		}
 		
 		pDC->Colour(L_WORKSPACE);
 		pDC->Rectangle(&c);
 	}
 	
 	void ExitEditMode()
 	{
 		if (e)
 		{
 			Name(e->Name());
 			DeleteObj(e);
 
 			PostEvent(M_DELETE_EDIT);
 			PostEvent(M_NOTIFY_VALUE_CHANGED);
 			
 			Invalidate();
 		}
 	}
 
 	void OnMouseClick(LMouse &m)
 	{
 		if (m.IsContextMenu())
 		{
 		}
 		else if (m.Left())
 		{
 			if (m.Down())
 			{
 				Over = HitPart(m.x, m.y);
 				if (p.PtrCheck(Over))
 				{
 					// Over a path node...
 					Cursor = Over - p.AddressOf(0);
 					Part &o = p[Cursor];
 					Invalidate();
 					SendNotify(LNotifyValueChanged);
 
 					if (o.Arrow.Overlap(m.x, m.y))
 					{
 						// Show sub-menu at this level
 						ShowMenu(Cursor);
 					}
 				}
 				else if (!e)
 				{
 					// In empty space
 					LRect c = GetClient();
 					e = new FolderCtrlEdit(GetId()+1, c);
 					if (e)
 					{
 						e->Attach(this);
 
 						LString s = Name();
 						e->Name(s);
 						e->SetCaret(s.Length());
 						e->Focus(true);
 					}
 				}
 			}
 		}
 	}
 
 	void OnMouseMove(LMouse &m)
 	{
 		Part *o = Over;
 		Over = HitPart(m.x, m.y);
 		if (o != Over)
 			Invalidate();
 	}
 	
 	void OnMouseExit(LMouse &m)
 	{
 		if (Over)
 		{
 			Over = NULL;
 			Invalidate();
 		}
 	}
 
 	int OnNotify(LViewI *c, LNotification n)
 	{
 		if (e != NULL &&
 			c->GetId() == e->GetId())
 		{
 			if (n.Type == LNotifyReturnKey)
 			{
 				ExitEditMode();
 			}
 		}
 
 		return 0;
 	}
 
 	LMessage::Result OnEvent(LMessage *m)
 	{
 		switch (m->Msg())
 		{
 			case M_LOST_FOCUS:
 			{
 				ExitEditMode();
 				break;
 			}
 			case M_DELETE_EDIT:
 			{
 				DeleteObj(e);
 				break;
 			}
 			case M_NOTIFY_VALUE_CHANGED:
 			{
 				SendNotify(LNotifyValueChanged);
 				break;			
 			}
 		}
 
 		return LView::OnEvent(m);
 	}
 
 	virtual bool ShowMenu(ssize_t Level)
 	{
 		if (Level <= 0)
 			return false;
 
 		LString dir = NameAt(Level-1);
 		LSubMenu s;
 		LDirectory d;
 
 		LString::Array Opts;
 		for (int b = d.First(dir); b; b = d.Next())
 		{
 			if (d.IsDir())
 			{
 				Opts.New() = d.GetName();
 				s.AppendItem(d.GetName(), (int)Opts.Length());
 			}
 		}
 
 		Part &i = p[Level];
 		LPoint pt(i.Arrow.x1, i.Arrow.y2+1);
 		PointToScreen(pt);
 		int Cmd = s.Float(this, pt.x, pt.y, true);
 		if (Cmd)
 		{
 			LString np;
 			np = dir + DIR_STR + Opts[Cmd-1];
 			Name(np);
 			PostEvent(M_NOTIFY_VALUE_CHANGED);
 		}
 		else return false;
 
 		return true;
 	}
 };
 
 #else
 #define USE_FOLDER_CTRL				0
 #endif
 
 
 class LFileSelectDlg :
 	public LDialog
 {
 	LRect OldPos;
 	LRect MinSize;
 	LArray<LString> Links;
 	LArray<LFolderItem*> Hidden;
 	
 public:
 	LFileSelectPrivate *d = NULL;
 
 	LTableLayout *Tbl = NULL;
 	LBox *Sub = NULL;
 
 	LTree *Bookmarks = NULL;
 	LTextLabel *Ctrl1 = NULL;
 
 	#if USE_FOLDER_CTRL
 	FolderCtrl *Ctrl2 = NULL;
 	#else
 	LEdit *Ctrl2 = NULL;
 	#endif
 	
 	LFolderDrop *Ctrl3 = NULL;
 	LIconButton *BackBtn = NULL;
 	LIconButton *UpBtn = NULL;
 	LIconButton *NewDirBtn = NULL;
 	LFolderList *FileLst = NULL;
 	LTextLabel *Ctrl8 = NULL;
 	LTextLabel *Ctrl9 = NULL;
 	LEdit *FileNameEdit = NULL;
 	LCombo *FileTypeCbo = NULL;
 	LButton *SaveBtn = NULL;
 	LButton *CancelBtn = NULL;
 	LCheckBox *ShowHidden = NULL;
 	LEdit *FilterEdit = NULL;
 
 	LFileSelectDlg(LFileSelectPrivate *Select);
 	~LFileSelectDlg();
 
 	const char *GetClass() override { return "LFileSelectDlg"; }
 
 	int OnNotify(LViewI *Ctrl, LNotification n) override;
 	void OnUpFolder();
 	void SetFolder(char *f);
 	void OnFolder();
 	void OnFile(char *f);
 	void OnFilter(const char *Key);
 
 	bool OnViewKey(LView *v, LKey &k) override
 	{
 		if (k.vkey == LK_UP && k.Alt())
 		{
 			if (k.Down())
 			{
 				UpBtn->SendNotify();
 			}
 			
 			return true;
 		}
 
 		return false;
 	}
 	
 	void Add(LTreeItem *i, LVolume *v)
 	{
 		if (!i || !v)
 			return;
 		
 		auto Path = v->Path();
 		i->SetText(v->Name());
 		i->SetText(Path, 1);
 		
 		for (unsigned n=0; n<Links.Length(); n++)
 		{
 			if (Path && !Stricmp(Path, Links[n].Get()))
 			{
 				Links.DeleteAt(n--);
 				break;
 			}
 		}
 		
 		for (LVolume *cv = v->First(); cv; cv = cv->Next())
 		{
 			LTreeItem *ci = new LTreeItem;
 			if (ci)
 			{
 				i->Insert(ci);
 				Add(ci, cv);
 			}
 		}
 
 		i->Expanded(true);
 	}
 };
 
 LFileSelectDlg::LFileSelectDlg(LFileSelectPrivate *select)
 {
 	d = select;
 	SetParent(d->Parent);
 	MinSize.ZOff(450, 300);
 
 	if (!d->InitSize.Valid())
 	{
 		auto Dpi = LScreenDpi();
 		auto Scale = (float)Dpi.x / 96.0;	
 		d->InitSize.Set(0, 0, (int)(650*Scale), (int)(450*Scale) + LAppInst->GetMetric(LGI_MET_DECOR_Y) );
 	}
 
 	SetPos(d->InitSize);
 
 	int x = 0, y = 0;
 	AddView(Tbl = new LTableLayout);
 
 	// Top Row
 	auto *c = Tbl->GetCell(x++, y);
 	c->Add(Ctrl1 = new LTextLabel(IDC_STATIC, 0, 0, -1, -1, "Look in:"));
 	c->VerticalAlign(LCss::Len(LCss::VerticalMiddle));
 	c = Tbl->GetCell(x++, y);
 	#if USE_FOLDER_CTRL
 	c->Add(Ctrl2 = new FolderCtrl(IDC_PATH));
 	#else
 	c->Add(Ctrl2 = new LEdit(IDC_PATH, 0, 0, 245, 21, ""));
 	#endif
 	c = Tbl->GetCell(x++, y);
 	c->Add(Ctrl3 = new LFolderDrop(this, IDC_DROP, 336, 7, 16, 21));
 	c = Tbl->GetCell(x++, y);
 	c->Add(BackBtn = new LIconButton(IDC_BACK, 378, 7, 27, 21, d->BtnIcons, FSI_BACK));
 	c = Tbl->GetCell(x++, y);
 	c->Add(UpBtn = new LIconButton(IDC_UP, 406, 7, 27, 21, d->BtnIcons, FSI_UPDIR));
 	c = Tbl->GetCell(x++, y);
 	c->Add(NewDirBtn = new LIconButton(IDC_NEW, 434, 7, 27, 21, d->BtnIcons, FSI_NEWDIR));
 
 	// Folders/items row
 	x = 0; y++;
 	c = Tbl->GetCell(x, y, true, 6, 1);
 	c->Add(Sub = new LBox(IDC_SUB_TBL));
 	Sub->AddView(Bookmarks = new LTree(IDC_BOOKMARKS, 0, 0, -1, -1));
 	Bookmarks->GetCss(true)->Width(LCss::Len(LCss::LenPx, 150.0f));
 	Bookmarks->SetImageList(d->TreeIcons, false);
 	
 	LTableLayout *t;
 	Sub->AddView(t = new LTableLayout(11));
 	
 	// Filter / search row
 	c = t->GetCell(0, 0);
 	c->Add(new LCheckBox(IDC_FILTER_CLEAR, 0, 0, -1, -1, "Filter items:"));
 	c->VerticalAlign(LCss::Len(LCss::VerticalMiddle));
 	c = t->GetCell(1, 0);
 	c->Add(FilterEdit = new LEdit(IDC_FILTER, 0, 0, 60, 20));
 	c = t->GetCell(0, 1, true, 2);
 	c->Add(FileLst = new LFolderList(this, IDC_VIEW, 14, 35, 448, 226));
 	
 	// File name row
 	x = 0; y++;
 	c = Tbl->GetCell(x++, y);
 	c->Add(Ctrl8 = new LTextLabel(IDC_STATIC, 14, 275, -1, -1, "File name:"));
 	c = Tbl->GetCell(x, y, true, 2);
 	x += 2;
 	c->Add(FileNameEdit = new LEdit(IDC_FILE, 100, 268, 266, 21, ""));
 	c = Tbl->GetCell(x, y, true, 3);
 	c->Add(SaveBtn = new LButton(IDOK, 392, 268, 70, 21, "Ok"));
 
 	// 4th row
 	x = 0; y++;
 	c = Tbl->GetCell(x++, y);
 	c->Add(Ctrl9 = new LTextLabel(IDC_STATIC, 14, 303, -1, -1, "Files of type:"));
 	c = Tbl->GetCell(x, y, true, 2);
 	x += 2;
 	c->Add(FileTypeCbo = new LCombo(IDC_TYPE, 100, 296, 266, 21, ""));
 	c = Tbl->GetCell(x++, y, true, 3);
 	c->Add(CancelBtn = new LButton(IDCANCEL, 392, 296, 70, 21, "Cancel"));
 
 	// 5th row
 	x = 0; y++;
 	c = Tbl->GetCell(x++, y, true, 6);
 	c->Add(ShowHidden = new LCheckBox(IDC_SHOWHIDDEN, 14, 326, -1, -1, "Show hidden files."));
 
 	// Init
 	if (BackBtn)
 		BackBtn->Enabled(false);
 	if (SaveBtn)
 		SaveBtn->Enabled(false);
 	if (FileLst)
 		FileLst->MultiSelect(d->MultiSelect);
 	if (ShowHidden)
 		ShowHidden->Value(d->InitShowHiddenFiles);
 
 	// Load types
 	if (!d->Types.Length())
 	{
 		LFileType *t = new LFileType;
 		if (t)
 		{
 			t->Description("All Files");
 			t->Extension(LGI_ALL_FILES);
 			d->Types.Insert(t);
 		}
 	}
 	for (auto t: d->Types)
 	{
 		char s[256];
 		sprintf(s, "%s (%s)", t->Description(), t->Extension());
 		if (FileTypeCbo)
 			FileTypeCbo->Insert(s);
 	}
 	d->CurrentType = 0;
 
 	// File + Path
 	char *File = d->Files[0];
 	if (File)
 	{
 		char *Dir = strrchr(File, DIR_CHAR);
 		if (Dir)
 		{
 			OnFile(Dir + 1);
 		}
 		else
 		{
 			OnFile(File);
 		}
 	}
 	
 	if (d->InitPath)
 	{
 		SetFolder(d->InitPath);
 	}
 	else
 	{
 		SetFolder(LGetExePath());
 	}
 	OnFolder();
 
 	// Size/layout
 	SetPos(d->InitSize);
 	MoveToCenter();
 
 	RegisterHook(this, LKeyEvents);
 	FileLst->Focus(true);
 	
 	LgiGetUsersLinks(Links);
 
 	auto v = FileDev->GetRootVolume();
 	if (v)
 	{
 		for (auto vol = v; vol; vol = vol->Next())
 		{
 			if (auto *ti = new LTreeItem)
 			{
 				Bookmarks->Insert(ti);
 				Add(ti, vol);
 				ti->Expanded(true);
 			}
 		}
 	}
 	
 	if (Links.Length())
 	{
 		if (auto *ti = new LTreeItem)
 		{
 			ti->SetText("Bookmarks");
 			Bookmarks->Insert(ti);
 			
 			for (unsigned n=0; n<Links.Length(); n++)
 			{
 				LTreeItem *ci = new LTreeItem;
 				if (ci)
 				{
 					char *p = Links[n];
 					char *leaf = strrchr(p, DIR_CHAR);
 					ci->SetText(leaf?leaf+1:p, 0);
 					ci->SetText(p, 1);
 					ti->Insert(ci);
 				}
 			}
 
 			ti->Expanded(true);
 		}
 	}
 }
 
 LFileSelectDlg::~LFileSelectDlg()
 {
 	UnregisterHook(this);
 	d->InitShowHiddenFiles = ShowHidden ? ShowHidden->Value() : false;
 	d->InitSize = GetPos();
 
 	auto CurPath = GetCtrlName(IDC_PATH);
 	if (ValidStr(CurPath))
 		d->InitPath = CurPath;
 }
 
 void LFileSelectDlg::OnFile(char *f)
 {
 	if (d->Type != TypeOpenFolder)
 	{
 		FileNameEdit->Name(f ? f : (char*)"");
 		SaveBtn->Enabled(ValidStr(f));
 	}
 }
 
 void LFileSelectDlg::SetFolder(char *f)
 {
 	auto CurPath = GetCtrlName(IDC_PATH);
 	if (CurPath)
 	{
 		d->History.Insert(NewStr(CurPath));
 		SetCtrlEnabled(IDC_BACK, true);
 	}
 	
 	SetCtrlName(IDC_PATH, f);
 }
 
 void LFileSelectDlg::OnFolder()
 {
 	if (Ctrl3)
 		Ctrl3->OnFolder();
 	if (FileLst)
 		FileLst->OnFolder();
 
 	auto CurPath = GetCtrlName(IDC_PATH);
 	if (CurPath && UpBtn)
 		UpBtn->Enabled(strlen(CurPath)>3);
 }
 
 void LFileSelectDlg::OnUpFolder()
 {
 	auto Cur = GetCtrlName(IDC_PATH);
 	if (Cur)
 	{
 		char Dir[MAX_PATH_LEN];
 		strcpy(Dir, Cur);
 		if (strlen(Dir) > 3)
 		{
 			LTrimDir(Dir);
 
 			if (!strchr(Dir, DIR_CHAR))
 				strcat(Dir, DIR_STR);
 
 			SetFolder(Dir);
 			OnFolder();
 		}
 	}
 }
 
 void LFileSelectDlg::OnFilter(const char *Key)
 {
 	if (FileLst)
 		FileLst->SetFilterKey(Key);
 }
 
 int LFileSelectDlg::OnNotify(LViewI *Ctrl, LNotification n)
 {
 	switch (Ctrl->GetId())
 	{
 		case IDC_BOOKMARKS:
 		{
 			if (n.Type == LNotifyItemSelect && Bookmarks)
 			{
 				LTreeItem *s = Bookmarks->Selection();
 				if (s)
 				{
 					const char *p = s->GetText(1);
 					if (LDirExists(p))
 					{
 						SetCtrlName(IDC_PATH, p);
 						OnFolder();
 					}
 				}
 			}
 			break;
 		}
 		case IDC_PATH:
 		{
 			if (n.Type == LNotifyValueChanged)
 				OnFolder();
 			break;
 		}
 		case IDC_VIEW:
 		{
 			if (FileLst)
 			{
 				/*	These functions are handled by the list 
 					control's OnKey implementation
 					
 				if (Flags == GLIST_NOTIFY_RETURN)
 				{
 					List<LListItem> s;
 					if (FileLst->GetSelection(s))
 					{
 						LFolderItem *i = dynamic_cast<LFolderItem*>(s.First());
 						if (i)
 						{
 							i->OnActivate();
 						}
 					}
 				}
 				else if (Flags == GLIST_NOTIFY_BACKSPACE)
 				{
 					OnUpFolder();
 				}
 				*/
 			}
 			break;
 		}
 		case IDC_FILE:
 		{
 			auto f = Ctrl->Name();
 			if (!f)
 				break;
 
 			if (n.Type == LNotifyReturnKey)
 			{
 				// allow user to insert new type by typing the pattern into the file name edit box and
 				// hitting enter
 				if (strchr(f, '?') || strchr(f, '*'))
 				{
 					// it's a mask, push the new type on the the type stack and
 					// refilter the content
 					int TypeIndex = -1;
 					
 					int n = 0;
 					for (auto t: d->Types)
 					{
 						if (t->Extension() &&
 							stricmp(t->Extension(), f) == 0)
 						{
 							TypeIndex = n;
 							break;
 						}
 						n++;
 					}
 					
 					// insert the new type if not already there
 					if (TypeIndex < 0)
 					{
 						LFileType *n = new LFileType;
 						if (n)
 						{
 							n->Description(f);
 							n->Extension(f);							
 							TypeIndex = (int)d->Types.Length();
 							d->Types.Insert(n);
 							FileTypeCbo->Insert(f);
 						}
 					}
 					
 					// select the new type
 					if (TypeIndex >= 0)
 					{
 						FileTypeCbo->Value(d->CurrentType = TypeIndex);
 					}
 					
 					// clear the edit box
 					Ctrl->Name("");
 					
 					// Update and don't do normal save btn processing.
 					OnFolder();
 					
 					// Skip the IDOK message generated by the default button
 					d->EatClose = true;
 					printf("%s:%i - eat close true\n", _FL);
 					break;
 				}
 				
 				if (LDirExists(f))
 				{
 					// Switch to the folder...
 					SetCtrlName(IDC_PATH, f);
 					OnFolder();
 					Ctrl->Name(NULL);
 					d->EatClose = true;
 				}
 				else if (LFileExists(f))
 				{
 					// Select the file...
 					d->Files.Insert(NewStr(f));
 					EndModal(IDOK);
 					break;
 				}
 			}
 			
 			bool HasFile = ValidStr(f);
 			bool BtnEnabled = SaveBtn->Enabled();
 			if (HasFile ^ BtnEnabled)
 			{
 				SaveBtn->Enabled(HasFile);
 			}
 			break;
 		}
 		case IDC_BACK:
 		{
 			auto It = d->History.rbegin();
 			char *Dir = *It;
 			if (Dir)
 			{
 				d->History.Delete(Dir);
 				SetCtrlName(IDC_PATH, Dir);
 				OnFolder();
 				DeleteArray(Dir);
 
 				if (!d->History[0])
 				{
 					SetCtrlEnabled(IDC_BACK, false);
 				}
 			}
 			break;
 		}
 		case IDC_SHOWHIDDEN:
 		{
 			FileLst->OnFolder();
 			break;
 		}
 		case IDC_TYPE:
 		{
 			d->CurrentType = (int)FileTypeCbo->Value();
 			FileLst->OnFolder();
 
 			if (d->Type == TypeSaveFile)
 			{
 				// change extension of current file
 				LFileType *Type = d->Types.ItemAt(d->CurrentType);
 				auto File = FileNameEdit->Name();
 				if (Type && File)
 				{
 					char *Ext = strchr(File, '.');
 					if (Ext)
 					{
 						char *DefExt = Type->DefaultExtension();
 						if (DefExt)
 						{
 							Ext++;
 							char s[256];
 							ZeroObj(s);
 							memcpy(s, File, Ext-File);
 							strcat(s, DefExt);
 
 							OnFile(s);
 
 							DeleteArray(DefExt);
 						}
 					}
 				}
 			}
 			break;
 		}
 		case IDC_UP:
 		{
 			OnUpFolder();
 			break;
 		}
 		case IDC_FILTER:
 		{
 			const char *n = Ctrl->Name();
 			SetCtrlValue(IDC_FILTER_CLEAR, ValidStr(n));
 			OnFilter(n);
 			break;
 		}
 		case IDC_FILTER_CLEAR:
 		{
 			if (!Ctrl->Value())
 			{
 				SetCtrlName(IDC_FILTER, NULL);
 				OnFilter(NULL);
 			}
 			break;
 		}
 		case IDC_NEW:
 		{
 			LInput Dlg(this, "", "Create new folder:", "New Folder");
 			Dlg.DoModal([&](auto d, auto code)
 			{
 				char New[MAX_PATH_LEN];
 				strcpy(New, GetCtrlName(IDC_PATH));
 				if (New[strlen(New)-1] != DIR_CHAR) strcat(New, DIR_STR);
 				strcat(New, Dlg.GetStr());
 
 				FileDev->CreateFolder(New);
 				OnFolder();
 			});
 			break;
 		}
 		case IDOK:
 		{
 			if (d->EatClose)
 			{
 				printf("%s:%i - SKIPPING eat close false\n", _FL);
 				d->EatClose = false;
 				break;
 			}
 			
 			auto Path = GetCtrlName(IDC_PATH);
 			auto File = GetCtrlName(IDC_FILE);
 			if (Path)
 			{
 				char f[MAX_PATH_LEN];
 				d->Files.DeleteArrays();
 
 				if (d->Type == TypeOpenFolder)
 				{
 					d->Files.Insert(NewStr(Path));
 				}
 				else
 				{
 					List<LListItem> Sel;
 					if (d->Type != TypeSaveFile &&
 						FileLst &&
 						FileLst->GetSelection(Sel) &&
 						Sel.Length() > 1)
 					{
 						for (auto i: Sel)
 						{
 							LMakePath(f, sizeof(f), Path, i->GetText(0));
 							d->Files.Insert(NewStr(f));
 						}
 					}
 					else if (ValidStr(File))
 					{
 						if (strchr(File, DIR_CHAR))
 							strcpy_s(f, sizeof(f), File);
 						else
 							LMakePath(f, sizeof(f), Path, File);
 						d->Files.Insert(NewStr(f));
 					}
 				}
 			}
 
 			// fall thru
 		}
 		case IDCANCEL:
 		{
 			EndModal(Ctrl->GetId());
 			break;
 		}
 	}
 
 	return 0;
 }
 
 //////////////////////////////////////////////////////////////////////////
 class LFileSystemItem : public LTreeItem
 {
 	class LFileSystemPopup *Popup;
 	LString Path;
 
 public:
 	LFileSystemItem(LFileSystemPopup *popup, LVolume *vol, char *path = 0);
 
 	char *GetPath()
 	{
 		return Path;
 	}
 
 	void OnPath(const char *p);
 	void OnMouseClick(LMouse &m);
 	bool OnKey(LKey &k);
 };
 
 #define IDC_TREE 100
 class LFileSystemPopup : public LPopup
 {
 	friend class LFileSystemItem;
 
 	LFileSelectDlg *Dlg;
 	LTree *Tree;
 	LFileSystemItem *Root;
 
 public:
 	LFileSystemPopup(LView *owner, LFileSelectDlg *dlg, int x) : LPopup(owner)
 	{
 		Dlg = dlg;
 		LRect r(0, 0, x, 150);
 		SetPos(r);
 		Children.Insert(Tree = new LTree(IDC_TREE, 1, 1, X()-3, Y()-3));
 		if (Tree)
 		{
 			Tree->Sunken(false);
 
 			LVolume *v = FileDev->GetRootVolume();
 			if (v)
 			{
 				Tree->SetImageList(Dlg->d->BtnIcons, false);
 				Tree->Insert(Root = new LFileSystemItem(this, v));
 				
 				for (auto next = v->Next(); next; next = next->Next())
 				{
 					Tree->SetImageList(Dlg->d->BtnIcons, false);
 					Tree->Insert(Root = new LFileSystemItem(this, next));
 				}
 			}
 		}
 	}
 
 	~LFileSystemPopup()
 	{
 	}
 
 	void Visible(bool i)
 	{
 		if (i && Root)
 		{
 			Root->OnPath(Dlg->GetCtrlName(IDC_PATH));
 		}
 
 		LPopup::Visible(i);
 	}
 
 	void OnPaint(LSurface *pDC)
 	{
 		// Draw border
 		LRect c = GetClient();
 		c.Offset(-c.x1, -c.y1);
 		pDC->Colour(L_BLACK);
 		pDC->Box(&c);
 		c.Inset(1, 1);
 	}
 
 	void OnActivate(LFileSystemItem *i)
 	{
 		if (i)
 		{
 			Dlg->SetFolder(i->GetPath());
 			Dlg->OnFolder();
 			Visible(false);
 		}
 	}
 };
 
 LFileSystemItem::LFileSystemItem(LFileSystemPopup *popup, LVolume *Vol, char *path)
 {
 	Popup = popup;
 	Expanded(true);
 
 	if (Vol)
 	{
 		Path = Vol->Path();
 		SetText(Vol->Name());
 		
 		switch (Vol->Type())
 		{
 			case VT_FLOPPY:
 				SetImage(FSI_FLOPPY);
 				break;
 			case VT_HARDDISK:
 			case VT_RAMDISK:
 				SetImage(FSI_HARDDISK);
 				break;
 			case VT_CDROM:
 				SetImage(FSI_CDROM);
 				break;
 			case VT_NETWORK_SHARE:
 				SetImage(FSI_NETWORK);
 				break;
 			case VT_DESKTOP:
 				SetImage(FSI_DESKTOP);
 				break;
 			default:
 				SetImage(FSI_DIRECTORY);
 				break;
 		}
 
 		for (LVolume *v=Vol->First(); v; v=v->Next())
 		{
 			Insert(new LFileSystemItem(Popup, v));
 		}
 	}
 	else
 	{
 		Path = NewStr(path);
 		SetText(strrchr(Path, DIR_CHAR)+1);
 		SetImage(FSI_DIRECTORY);
 	}
 }
 
 void LFileSystemItem::OnPath(const char *p)
 {
 	switch (GetImage())
 	{
 		case FSI_DESKTOP:
 		{
 			if (p &&
 				Path &&
 				stricmp(Path, p) == 0)
 			{
 				Select(true);
 				p = 0;
 			}
 			break;
 		}
 		case FSI_DIRECTORY:
 		{
 			return;
 		}
 		default:
 		{
 			LTreeItem *Old = Items[0];
 			if (Old)
 			{
 				Old->Remove();
 				DeleteObj(Old);
 			}
 			break;
 		}
 	}
 
 	if (p)
 	{
 		auto PathLen = strlen(Path);
 		if (Path &&
 			strnicmp(Path, p, PathLen) == 0 &&
 			(p[PathLen] == DIR_CHAR || p[PathLen] == 0)
 			#ifdef LINUX
 			&& strcmp(Path, "/") != 0
 			#endif
 			)
 		{
 			LTreeItem *Item = this;
 
 			if (GetImage() != FSI_DESKTOP &&
 				strlen(p) > 3)
 			{
 				auto Start = p + strlen(Path);
 				if (Start)
 				{
 					char s[256];
 					strcpy(s, Path);
 
 					auto T = LString(Start).SplitDelimit(DIR_STR);
 					for (int i=0; i<T.Length(); i++)
 					{
 						if (s[strlen(s)-1] != DIR_CHAR) strcat(s, DIR_STR);
 						strcat(s, T[i]);
 
 						LFileSystemItem *New = new LFileSystemItem(Popup, 0, s);
 						if (New)
 						{
 							Item->Insert(New);
 							Item = New;
 						}
 					}
 				}
 			}
 
 			if (Item)
 			{
 				Item->Select(true);
 			}
 		}
 	}
 
 	for (auto item: Items)
 	{
 		LFileSystemItem *i = dynamic_cast<LFileSystemItem*>(item);
 		if (i)
 			i->OnPath(p);
 	}
 }
 
 void LFileSystemItem::OnMouseClick(LMouse &m)
 {
 	if (m.Left() && m.Down())
 	{
 		Popup->OnActivate(this);
 	}
 }
 
 bool LFileSystemItem::OnKey(LKey &k)
 {
 	if ((k.c16 == ' ' || k.c16 == LK_RETURN))
 	{
 		if (k.Down() && k.IsChar)
 		{
 			Popup->OnActivate(this);
 		}
 		
 		return true;
 	}
 	
 	return false;
 }
 
 LFolderDrop::LFolderDrop(LFileSelectDlg *dlg, int Id, int x, int y, int cx, int cy) :
 	LDropDown(Id, x, y, cx, cy, 0),
 	LFolderView(dlg)
 {
 	SetPopup(new LFileSystemPopup(this, dlg, cx + (dlg->Ctrl2 ? dlg->Ctrl2->X() : 0) ));
 }
 
 void LFolderDrop::OnFolder()
 {
 }
 
 //////////////////////////////////////////////////////////////////////////
 #define IDM_OPEN				1000
 #define IDM_CUT					1001
 #define IDM_COPY				1002
 #define IDM_RENAME				1003
 #define IDM_PROPERTIES			1004
 #define IDM_CREATE_SHORTCUT		1005
 #define IDM_DELETE				1006
 
 LFolderItem::LFolderItem(LFileSelectDlg *dlg, char *FullPath, LDirectory *Dir)
 {
 	Dlg = dlg;
 	Path = FullPath;
 	File = strrchr(Path, DIR_CHAR);
 	if (File) File++;
 	IsDir = Dir->IsDir();
 }
 
 LFolderItem::~LFolderItem()
 {
 }
 
 const char *LFolderItem::GetText(int i)
 {
 	return File;
 }
 
 int LFolderItem::GetImage(int Flags)
 {
 	return IsDir ? 1 : 0;
 }
 
 void LFolderItem::OnSelect()
 {
 	if (!IsDir && File)
 	{
 		Dlg->OnFile(Select() ? File : 0);
 	}
 }
 
 void LFolderItem::OnDelete(bool Ask)
 {
 	if (!Ask || LgiMsg(Parent, "Do you want to delete '%s'?", ModuleName, MB_YESNO, Path.Get()) == IDYES)
 	{
 		bool Status = false;
 
 		if (IsDir)
 		{
 			Status = FileDev->RemoveFolder(Path, true);
 		}
 		else
 		{
 			Status = FileDev->Delete(Path);
 		}
 
 		if (Status)
 		{
 			Parent->Remove(this);
 			delete this;
 		}
 	}
 }
 
 void LFolderItem::OnRename()
 {
 	LInput *Inp = new LInput(Dlg, File, "New name:", Dlg->Name());
 	Inp->DoModal([&](auto d, auto code)
 	{
 		if (!code)
 			return;
 			
 		char Old[MAX_PATH_LEN];
 		strcpy_s(Old, sizeof(Old), Path);
 
 		char New[MAX_PATH_LEN];
 		File[0] = 0;
 		LMakePath(New, sizeof(New), Path, Inp->GetStr());
 		
 		if (FileDev->Move(Old, New))
 		{
 			DeleteArray(Path);
 			Path = NewStr(New);
 			File = strrchr(Path, DIR_CHAR);
 			if (File) File++;
 			Update();
 		}
 		else
 		{
 			LgiMsg(Dlg, "Renaming '%s' failed.", Dlg->Name(), MB_OK);
 		}
 		
 		delete Inp;
 	});
 }
 
 void LFolderItem::OnActivate()
 {
 	if (File)
 	{
 		if (IsDir)
 		{
 			char Dir[256];
 			strcpy(Dir, Dlg->GetCtrlName(IDC_PATH));
 			if (Dir[strlen(Dir)-1] != DIR_CHAR) strcat(Dir, DIR_STR);
 			strcat(Dir, File);
 			Dlg->SetFolder(Dir);
 			Dlg->OnFolder();
 		}
 		else // Is file
 		{
 			Dlg->OnNotify(Dlg->SaveBtn, LNotifyActivate);
 		}
 	}
 }
 
 void LFolderItem::OnMouseClick(LMouse &m)
 {
 	if (m.Down())
 	{
 		if (m.Left())
 		{
 			if (m.Double())
 			{
 				OnActivate();
 			}
 		}
 		else if (m.Right())
 		{
 			LSubMenu *RClick = new LSubMenu;
 			if (RClick)
 			{
 				RClick->AppendItem("Select", IDM_OPEN, true);
 				RClick->AppendSeparator();
 				RClick->AppendItem("Cut", IDM_CUT, false);
 				RClick->AppendItem("Copy", IDM_COPY, false);
 				RClick->AppendSeparator();
 				RClick->AppendItem("Create Shortcut", IDM_CREATE_SHORTCUT, false);
 				RClick->AppendItem("Delete", IDM_DELETE, true);
 				RClick->AppendItem("Rename", IDM_RENAME, true);
 				RClick->AppendSeparator();
 				RClick->AppendItem("Properties", IDM_PROPERTIES, false);
 
 				if (Parent->GetMouse(m, true))
 				{
 					switch (RClick->Float(Parent, m.x, m.y))
 					{
 						case IDM_OPEN:
 						{
 							break;
 						}
 						case IDM_DELETE:
 						{
 							OnDelete();
 							break;
 						}
 						case IDM_RENAME:
 						{
 							OnRename();
 							break;
 						}
 					}
 				}
 
 				DeleteObj(RClick);
 			}
 		}
 	}
 }
 
 int LFolderItemCompare(LListItem *A, LListItem *B, NativeInt Data)
 {
 	LFolderItem *a = dynamic_cast<LFolderItem*>(A);
 	LFolderItem *b = dynamic_cast<LFolderItem*>(B);
 	if (a && b)
 	{
 		if (a->IsDir ^ b->IsDir)
 		{
 			if (a->IsDir) return -1;
 			else return 1;
 		}
 		else if (a->File && b->File)
 		{
 			return stricmp(a->File, b->File);
 		}
 	}
 
 	return 0;
 }
 
 LFolderList::LFolderList(LFileSelectDlg *dlg, int Id, int x, int y, int cx, int cy) :
 	LList(Id, x, y, cx, cy),
 	LFolderView(dlg)
 {
 	SetImageList(Dlg->d->BtnIcons, false);
 	ShowColumnHeader(false);
 	AddColumn("Name", cx-20);
 	SetMode(LListColumns);
 }
 
 bool LFolderList::OnKey(LKey &k)
 {
 	bool Status = LList::OnKey(k);
 	
 	switch (k.vkey)
 	{
 		case LK_BACKSPACE:
 		{
 			if (k.Down() && GetWindow())
 			{
 				// Go up a directory
 				LViewI *v = GetWindow()->FindControl(IDC_UP);
 				if (v)
 				{
 					GetWindow()->OnNotify(v, LNotifyBackspaceKey);
 				}
 			}
 			Status = true;
 			break;
 		}
 		case LK_RETURN:
 		#ifdef LK_KP_ENTER
 		case LK_KP_ENTER:
 		#endif
 		{
 			if (k.Down() && GetWindow())
 			{
 				LFolderItem *Sel = dynamic_cast<LFolderItem*>(GetSelected());
 				if (Sel)
 				{
 					if (Sel->IsDir)
 					{
 						auto Cur = GetWindow()->GetCtrlName(IDC_PATH);
 						if (Cur)
 						{
 							char Path[256];
 							LMakePath(Path, sizeof(Path), Cur, Sel->GetText(0));
 							if (LDirExists(Path))
 							{
 								GetWindow()->SetCtrlName(IDC_PATH, Path);
 								Dlg->OnFolder();
 							}
 						}
 					}
 					else
 					{
 						LViewI *Ok = GetWindow()->FindControl(IDOK);
 						if (Ok)
 						{
 							GetWindow()->SetCtrlName(IDC_FILE, Sel->GetText(0));
 							GetWindow()->OnNotify(Ok, LNotification(k));
 						}
 					}
 				}
 			}
 			Status = true;
 			break;
 		}
 		case LK_DELETE:
 		{
 			if (k.Down() && !k.IsChar && GetWindow())
 			{
 				List<LListItem> Sel;
 				if (GetSelection(Sel))
 				{
 					LStringPipe Msg;
 					Msg.Push("Do you want to delete:\n\n");
 					
 					List<LFolderItem> Delete;
 					for (auto i: Sel)
 					{
 						LFolderItem *s = dynamic_cast<LFolderItem*>(i);
 						if (s)
 						{
 							Delete.Insert(s);
 							Msg.Push("\t");
 							Msg.Push(s->GetText(0));
 							Msg.Push("\n");
 						}
 					}
 					
 					char *Mem = Msg.NewStr();
 					if (Mem)
 					{
 						if (LgiMsg(this, Mem, ModuleName, MB_YESNO) == IDYES)
 						{
 							for (auto d: Delete)
 							{
 								d->OnDelete(false);
 							}
 						}
 						DeleteArray(Mem);
 					}
 				}
 			}
 			Status = true;
 			break;
 		}
 	}
 
 	// LgiTrace("%s:%i LFolderList::OnKey, key=%i down=%i status=%i\n", _FL, k.vkey, k.Down(), Status);
 	
 	return Status;
 }
 
 void LFolderList::OnFolder()
 {
 	Empty();
 
 	LDirectory Dir;
 	List<LListItem> New;
 
 	// Get current type
 	LFileType *Type = Dlg->d->Types.ItemAt(Dlg->d->CurrentType);
 	List<char> Ext;
 	if (Type)
 	{
 		auto T = LString(Type->Extension()).SplitDelimit(";");
 		for (size_t i=0; i<T.Length(); i++)
 			Ext.Insert(NewStr(T[i]));
 	}
 
 	// Get items
 	if (!Dlg->Ctrl2)
 		return;
 		
 	bool ShowHiddenFiles = Dlg->ShowHidden ? Dlg->ShowHidden->Value() : false;
 	for (auto Found = Dir.First(Dlg->Ctrl2->Name()); Found; Found = Dir.Next())
 	{
 		char Name[LDirectory::MaxPathLen];
 		Dir.Path(Name, sizeof(Name));
 		
 		bool Match = true;
 		if (!ShowHiddenFiles && Dir.IsHidden())
 		{
 			Match = false;
 		}
 		else if (!Dir.IsDir() &&
 				Ext.Length() > 0)
 		{
 			Match = false;
 			for (auto e: Ext)
 			{
 				bool m = MatchStr(e, Name);
 				if (m)
 				{
 					Match = true;
 					break;
 				}
 			}
 		}
 		
 		if (FilterKey && Match)
 			Match = stristr(Dir.GetName(), FilterKey) != NULL;
 
 		if (Match)
 			New.Insert(new LFolderItem(Dlg, Name, &Dir));
 	}
 
 	// Sort items...
 	New.Sort(LFolderItemCompare);
 
 	// Display items...
 	Insert(New);
 }
 
 //////////////////////////////////////////////////////////////////////////
 LFileSelect::LFileSelect(LViewI *Window)
 {
 	d = new LFileSelectPrivate(this);
 	if (Window)
 		Parent(Window);
 }
 
 LFileSelect::~LFileSelect()
 {
 	DeleteObj(d);
 }
 
 void LFileSelect::ShowReadOnly(bool b)
 {
 	d->ShowReadOnly = b;;
 }
 
 bool LFileSelect::ReadOnly()
 {
 	return d->ReadOnly;
 }
 
 const char *LFileSelect::Name()
 {
 	return d->Files[0];
 }
 
 bool LFileSelect::Name(const char *n)
 {
 	d->Files.DeleteArrays();
 	if (n)
 	{
 		d->Files.Insert(NewStr(n));
 	}
 
 	return true;
 }
 
 const char *LFileSelect::operator [](size_t i)
 {
 	return d->Files.ItemAt(i);
 }
 
 size_t LFileSelect::Length()
 {
 	return d->Files.Length();
 }
 
 size_t LFileSelect::Types()
 {
 	return d->Types.Length();
 }
 
 void LFileSelect::ClearTypes()
 {
 	d->Types.DeleteObjects();
 }
 
 LFileType *LFileSelect::TypeAt(ssize_t n)
 {
 	return d->Types.ItemAt(n);
 }
 
 bool LFileSelect::Type(const char *Description, const char *Extension, int Data)
 {
 	LFileType *Type = new LFileType;
 	if (Type)
 	{
 		Type->Description(Description);
 		Type->Extension(Extension);
 		d->Types.Insert(Type);
 	}
 
 	return Type != 0;
 }
 
 ssize_t LFileSelect::SelectedType()
 {
 	return d->CurrentType;
 }
 
 LViewI *LFileSelect::Parent()
 {
 	return d->Parent;
 }
 
 void LFileSelect::Parent(LViewI *Window)
 {
 	d->Parent = dynamic_cast<LView*>(Window);
 }
 
 bool LFileSelect::MultiSelect()
 {
 	return d->MultiSelect;
 }
 
 void LFileSelect::MultiSelect(bool Multi)
 {
 	d->MultiSelect = Multi;
 }
 
 #define CharPropImpl(Func, Var)				\
 	const char *LFileSelect::Func()			\
 	{										\
 		return Var;							\
 	}										\
 	void LFileSelect::Func(const char *i)	\
 	{										\
 		Var = i;							\
 	}
 
 CharPropImpl(InitialDir, d->InitPath);
 CharPropImpl(Title, d->Title);
 CharPropImpl(DefaultExtension, d->DefExt);
 
 void LFileSelect::Open(SelectCb Cb)
 {
 	LFileSelectDlg *Dlg = new LFileSelectDlg(d);
 
 	d->Type = TypeOpenFile;
 	Dlg->Name("Open");
 	if (Dlg->SaveBtn)
 		Dlg->SaveBtn->Name("Open");
 
 	// printf("LFileSelect domodal.. thread=%p\n", LGetCurrentThread());
 	Dlg->DoModal([select=this, cb=Cb](auto dlg, auto code)
 	{
 		// printf("LFileSelect cb.. thread=%u lock=%u\n", GetCurrentThreadId(), dlg->WindowHandle()->LockingThread());
 		if (cb)
 			cb(select, code == IDOK);
 		// printf("LFileSelect deleting.. lock=%u\n", dlg->WindowHandle()->LockingThread());
 		delete dlg;
 		// printf("LFileSelect deleted..\n");
 	});
 }
 
 void LFileSelect::OpenFolder(SelectCb Cb)
 {
 	auto Dlg = new LFileSelectDlg(d);
 
 	d->Type = TypeOpenFolder;
 	Dlg->SaveBtn->Enabled(true);
 	Dlg->FileNameEdit->Enabled(false);
 	Dlg->Name("Open Folder");
 	Dlg->SaveBtn->Name("Open");
 
 	printf("LFileSelect::OpenFolder domodal...\n");
 	Dlg->DoModal([this,Cb](auto d, auto code)
 	{
 		printf("LFileSelect::OpenFolder cb, code=%i\n", code);
 		if (Cb)
-			Cb(this, code != IDOK);
+			Cb(this, code == IDOK);
 		delete d;
 	});
 }
 
 void LFileSelect::Save(SelectCb Cb)
 {
 	auto *Dlg = new LFileSelectDlg(d);
 	
 	d->Type = TypeSaveFile;
 	Dlg->Name("Save As");
 	Dlg->SaveBtn->Name("Save As");
 
 	// printf("LFileSelect domodal.. thread=%u\n", GetCurrentThreadId());
-	Dlg->DoModal([FileSelect=this,Cb](auto dlg, auto code)
+	Dlg->DoModal([this, Cb](auto dlg, auto code)
 	{
-		// printf("LFileSelect cb.. thread=%u lock=%u\n", GetCurrentThreadId(), dlg->WindowHandle()->LockingThread());
+		// printf("LFileSelect cb.. thread=%u, code=%i\n", GetCurrentThreadId(), code); // dlg->WindowHandle()->LockingThread());
 		if (Cb)
-			Cb(FileSelect, code != IDOK);
+			Cb(this, code == IDOK);
 		// printf("LFileSelect deleting.. lock=%u\n", dlg->WindowHandle()->LockingThread());
 		delete dlg;
 		// printf("LFileSelect deleted..\n");
 	});
 }
 
 ///////////////////////////////////////////////////////////////////////////////////
 #if defined(LINUX)
 #include "lgi/common/Net.h"
 #endif
 bool LgiGetUsersLinks(LArray<LString> &Links)
 {
 	LString Folder = LGetSystemPath(LSP_USER_LINKS);
 	if (!Folder)
 		return false;
 	
 	#if defined(WINDOWS)
 		LDirectory d;
 		for (int b = d.First(Folder); b; b = d.Next())
 		{
 			char *s = d.GetName();
 			if (s && stristr(s, ".lnk"))
 			{
 				char lnk[MAX_PATH_LEN];
 				if (d.Path(lnk, sizeof(lnk)) &&
 					LResolveShortcut(lnk, lnk, sizeof(lnk)))
 				{
 					Links.New() = lnk;
 				}
 			}
 		}		
 	#elif defined(LINUX)
 		char p[MAX_PATH_LEN];
 		if (!LMakePath(p, sizeof(p), Folder, "bookmarks"))
 		{
 			LgiTrace("%s:%i - Failed to make path '%s'\n", _FL, Folder.Get());
 			return false;
 		}
 
 		if (!LFileExists(p))
 			return false;
 			
 		LAutoString Txt(LReadTextFile(p));
 		if (!Txt)
 		{
 			LgiTrace("%s:%i - failed to read '%s'\n", _FL, p);
 			return false;
 		}
 
 		LString s = Txt.Get();
 		LString::Array a = s.Split("\n");
 		for (unsigned i=0; i<a.Length(); i++)
 		{
 			LUri u(a[i]);
 			if (u.sProtocol.Equals("file"))
 				Links.New() = u.sPath;
 		}
 	#else
 		LAssert(!"Not impl yet.");
 		return false;
 	#endif
 	
 	return true;
 }